|
// ------------------------------------------------------------------------------
// <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
{
[Guid("0000000F-0000-0000-C000-000000000046")]
[SupportedOSPlatform("windows5.0")]
[global::System.CodeDom.Compiler.GeneratedCode("Microsoft.Windows.CsWin32", "0.3.151+58e949951d.RR")]
internal unsafe partial struct IMoniker
:IVTable<IMoniker,IMoniker.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]<IMoniker*,global::System.Guid* ,void** ,winmdroot.Foundation.HRESULT>)lpVtbl[0])((IMoniker*)Unsafe.AsPointer(ref this), riid, ppvObject);
}
public uint AddRef()
{
return ((delegate *unmanaged [Stdcall]<IMoniker*,uint>)lpVtbl[1])((IMoniker*)Unsafe.AsPointer(ref this));
}
public uint Release()
{
return ((delegate *unmanaged [Stdcall]<IMoniker*,uint>)lpVtbl[2])((IMoniker*)Unsafe.AsPointer(ref this));
}
/// <inheritdoc cref="GetClassID(global::System.Guid*)"/>
internal unsafe winmdroot.Foundation.HRESULT GetClassID(out global::System.Guid pClassID)
{
fixed (global::System.Guid* pClassIDLocal = &pClassID)
{
winmdroot.Foundation.HRESULT __result = this.GetClassID(pClassIDLocal);
return __result;
}
}
[UnmanagedCallersOnly(CallConvs = new []{
typeof(CallConvStdcall)}
)]
private static winmdroot.Foundation.HRESULT GetClassID(IMoniker* 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 winmdroot.Foundation.HRESULT GetClassID(global::System.Guid* pClassID)
{
return ((delegate *unmanaged [Stdcall]<IMoniker*,global::System.Guid* ,winmdroot.Foundation.HRESULT>)lpVtbl[3])((IMoniker*)Unsafe.AsPointer(ref this), pClassID);
}
[UnmanagedCallersOnly(CallConvs = new []{
typeof(CallConvStdcall)}
)]
private static winmdroot.Foundation.HRESULT IsDirty(IMoniker* 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;
}
}
public winmdroot.Foundation.HRESULT IsDirty()
{
return ((delegate *unmanaged [Stdcall]<IMoniker*,winmdroot.Foundation.HRESULT>)lpVtbl[4])((IMoniker*)Unsafe.AsPointer(ref this));
}
[UnmanagedCallersOnly(CallConvs = new []{
typeof(CallConvStdcall)}
)]
private static winmdroot.Foundation.HRESULT Load(IMoniker* pThis, winmdroot.System.Com.IStream* pStm)
{
try
{
winmdroot.Foundation.HRESULT __hr = ComHelpers.UnwrapCCW(pThis, out Interface __object);
if (__hr.Failed)
{
return __hr;
}
return __object.Load(pStm);
}
catch (Exception ex)
{
return (winmdroot.Foundation.HRESULT)ex.HResult;
}
}
public unsafe winmdroot.Foundation.HRESULT Load(winmdroot.System.Com.IStream* pStm)
{
return ((delegate *unmanaged [Stdcall]<IMoniker*,winmdroot.System.Com.IStream* ,winmdroot.Foundation.HRESULT>)lpVtbl[5])((IMoniker*)Unsafe.AsPointer(ref this), pStm);
}
[UnmanagedCallersOnly(CallConvs = new []{
typeof(CallConvStdcall)}
)]
private static winmdroot.Foundation.HRESULT Save(IMoniker* pThis, winmdroot.System.Com.IStream* pStm, winmdroot.Foundation.BOOL fClearDirty)
{
try
{
winmdroot.Foundation.HRESULT __hr = ComHelpers.UnwrapCCW(pThis, out Interface __object);
if (__hr.Failed)
{
return __hr;
}
return __object.Save(pStm, fClearDirty);
}
catch (Exception ex)
{
return (winmdroot.Foundation.HRESULT)ex.HResult;
}
}
public unsafe winmdroot.Foundation.HRESULT Save(winmdroot.System.Com.IStream* pStm, winmdroot.Foundation.BOOL fClearDirty)
{
return ((delegate *unmanaged [Stdcall]<IMoniker*,winmdroot.System.Com.IStream* ,winmdroot.Foundation.BOOL ,winmdroot.Foundation.HRESULT>)lpVtbl[6])((IMoniker*)Unsafe.AsPointer(ref this), pStm, fClearDirty);
}
/// <inheritdoc cref="GetSizeMax(ulong*)"/>
internal unsafe winmdroot.Foundation.HRESULT GetSizeMax(out ulong pcbSize)
{
fixed (ulong* pcbSizeLocal = &pcbSize)
{
winmdroot.Foundation.HRESULT __result = this.GetSizeMax(pcbSizeLocal);
return __result;
}
}
[UnmanagedCallersOnly(CallConvs = new []{
typeof(CallConvStdcall)}
)]
private static winmdroot.Foundation.HRESULT GetSizeMax(IMoniker* pThis, ulong* pcbSize)
{
try
{
winmdroot.Foundation.HRESULT __hr = ComHelpers.UnwrapCCW(pThis, out Interface __object);
if (__hr.Failed)
{
return __hr;
}
return __object.GetSizeMax(pcbSize);
}
catch (Exception ex)
{
return (winmdroot.Foundation.HRESULT)ex.HResult;
}
}
public unsafe winmdroot.Foundation.HRESULT GetSizeMax(ulong* pcbSize)
{
return ((delegate *unmanaged [Stdcall]<IMoniker*,ulong* ,winmdroot.Foundation.HRESULT>)lpVtbl[7])((IMoniker*)Unsafe.AsPointer(ref this), pcbSize);
}
/// <inheritdoc cref="BindToObject(winmdroot.System.Com.IBindCtx*, winmdroot.System.Com.IMoniker*, global::System.Guid*, void**)"/>
internal unsafe winmdroot.Foundation.HRESULT BindToObject(winmdroot.System.Com.IBindCtx* pbc, winmdroot.System.Com.IMoniker* pmkToLeft, in global::System.Guid riidResult, out void* ppvResult)
{
fixed (void** ppvResultLocal = &ppvResult)
{
fixed (global::System.Guid* riidResultLocal = &riidResult)
{
winmdroot.Foundation.HRESULT __result = this.BindToObject(pbc, pmkToLeft, riidResultLocal, ppvResultLocal);
return __result;
}
}
}
[UnmanagedCallersOnly(CallConvs = new []{
typeof(CallConvStdcall)}
)]
private static winmdroot.Foundation.HRESULT BindToObject(IMoniker* pThis, winmdroot.System.Com.IBindCtx* pbc, [Optional] winmdroot.System.Com.IMoniker* pmkToLeft, global::System.Guid* riidResult, void** ppvResult)
{
try
{
winmdroot.Foundation.HRESULT __hr = ComHelpers.UnwrapCCW(pThis, out Interface __object);
if (__hr.Failed)
{
return __hr;
}
return __object.BindToObject(pbc, pmkToLeft, riidResult, ppvResult);
}
catch (Exception ex)
{
return (winmdroot.Foundation.HRESULT)ex.HResult;
}
}
/// <summary>Binds to the specified object. The binding process involves finding the object, putting it into the running state if necessary, and providing the caller with a pointer to a specified interface on the identified object.</summary>
/// <param name="pbc">A pointer to the <a href="https://docs.microsoft.com/windows/desktop/api/objidl/nn-objidl-ibindctx">IBindCtx</a> interface on the bind context object, which is used in this binding operation. The bind context caches objects bound during the binding process, contains parameters that apply to all operations using the bind context, and provides the means by which the moniker implementation should retrieve information about its environment.</param>
/// <param name="pmkToLeft">If the moniker is part of a composite moniker, pointer to the moniker to the left of this moniker. This parameter is primarily used by moniker implementers to enable cooperation between the various components of a composite moniker. Moniker clients should use <b>NULL</b>.</param>
/// <param name="riidResult">The IID of the interface the client wishes to use to communicate with the object that the moniker identifies.</param>
/// <param name="ppvResult">The address of pointer variable that receives the interface pointer requested in <i>riid</i>. Upon successful return, *<i>ppvResult</i> contains the requested interface pointer to the object the moniker identifies. When successful, the implementation must call <a href="https://docs.microsoft.com/windows/desktop/api/unknwn/nf-unknwn-iunknown-addref">AddRef</a> on the moniker. It is the caller's responsibility to call <a href="https://docs.microsoft.com/windows/desktop/api/unknwn/nf-unknwn-iunknown-release">Release</a>. If an error occurs, *<i>ppvResult</i> should be <b>NULL</b>.</param>
/// <returns>
/// <para>This method can return the standard return values E_OUTOFMEMORY and E_UNEXPECTED, as well as the following values. </para>
/// <para>This doc was truncated.</para>
/// </returns>
/// <remarks>
/// <para><b>BindToObject</b> implements the primary function of a moniker, which is to locate the object identified by the moniker and return a pointer to one of its interfaces. <h3><a id="Notes_to_Callers"></a><a id="notes_to_callers"></a><a id="NOTES_TO_CALLERS"></a>Notes to Callers</h3> If you are using a moniker as a persistent connection between two objects, you activate the connection by calling <b>BindToObject</b>. You typically call <b>BindToObject</b> during the following process: </para>
/// <para>This doc was truncated.</para>
/// <para><see href="https://learn.microsoft.com/windows/win32/api/objidl/nf-objidl-imoniker-bindtoobject#">Read more on docs.microsoft.com</see>.</para>
/// </remarks>
public unsafe winmdroot.Foundation.HRESULT BindToObject(winmdroot.System.Com.IBindCtx* pbc, [Optional] winmdroot.System.Com.IMoniker* pmkToLeft, global::System.Guid* riidResult, void** ppvResult)
{
return ((delegate *unmanaged [Stdcall]<IMoniker*,winmdroot.System.Com.IBindCtx* ,winmdroot.System.Com.IMoniker* ,global::System.Guid* ,void** ,winmdroot.Foundation.HRESULT>)lpVtbl[8])((IMoniker*)Unsafe.AsPointer(ref this), pbc, pmkToLeft, riidResult, ppvResult);
}
/// <inheritdoc cref="BindToStorage(winmdroot.System.Com.IBindCtx*, winmdroot.System.Com.IMoniker*, global::System.Guid*, void**)"/>
internal unsafe winmdroot.Foundation.HRESULT BindToStorage(winmdroot.System.Com.IBindCtx* pbc, winmdroot.System.Com.IMoniker* pmkToLeft, in global::System.Guid riid, out void* ppvObj)
{
fixed (void** ppvObjLocal = &ppvObj)
{
fixed (global::System.Guid* riidLocal = &riid)
{
winmdroot.Foundation.HRESULT __result = this.BindToStorage(pbc, pmkToLeft, riidLocal, ppvObjLocal);
return __result;
}
}
}
[UnmanagedCallersOnly(CallConvs = new []{
typeof(CallConvStdcall)}
)]
private static winmdroot.Foundation.HRESULT BindToStorage(IMoniker* pThis, winmdroot.System.Com.IBindCtx* pbc, [Optional] winmdroot.System.Com.IMoniker* pmkToLeft, global::System.Guid* riid, void** ppvObj)
{
try
{
winmdroot.Foundation.HRESULT __hr = ComHelpers.UnwrapCCW(pThis, out Interface __object);
if (__hr.Failed)
{
return __hr;
}
return __object.BindToStorage(pbc, pmkToLeft, riid, ppvObj);
}
catch (Exception ex)
{
return (winmdroot.Foundation.HRESULT)ex.HResult;
}
}
/// <summary>Binds to the storage for the specified object. Unlike the IMoniker::BindToObject method, this method does not activate the object identified by the moniker.</summary>
/// <param name="pbc">A pointer to the <a href="https://docs.microsoft.com/windows/desktop/api/objidl/nn-objidl-ibindctx">IBindCtx</a> interface on the bind context object, which is used in this binding operation. The bind context caches objects bound during the binding process, contains parameters that apply to all operations using the bind context, and provides the means by which the moniker implementation should retrieve information about its environment.</param>
/// <param name="pmkToLeft">If the moniker is part of a composite moniker, pointer to the moniker to the left of this moniker. This parameter is primarily used by moniker implementers to enable cooperation between the various components of a composite moniker. Moniker clients should use <b>NULL</b>.</param>
/// <param name="riid">A reference to the identifier of the storage interface requested, whose pointer will be returned in <i>ppvObj</i>. Storage interfaces commonly requested include <a href="https://docs.microsoft.com/windows/desktop/api/objidl/nn-objidl-istorage">IStorage</a>, <a href="https://docs.microsoft.com/windows/desktop/api/objidl/nn-objidl-istream">IStream</a>, and <a href="https://docs.microsoft.com/windows/desktop/api/objidl/nn-objidl-ilockbytes">ILockBytes</a>.</param>
/// <param name="ppvObj">The address of pointer variable that receives the interface pointer requested in <i>riid</i>. Upon successful return, *<i>ppvObj</i> contains the requested interface pointer to the storage of the object the moniker identifies. When successful, the implementation must call <a href="https://docs.microsoft.com/windows/desktop/api/unknwn/nf-unknwn-iunknown-addref">AddRef</a> on the storage. It is the caller's responsibility to call <a href="https://docs.microsoft.com/windows/desktop/api/unknwn/nf-unknwn-iunknown-release">Release</a>. If an error occurs, *<i>ppvObj</i> should be <b>NULL</b>.</param>
/// <returns>
/// <para>This method can return the standard return values E_UNEXPECTED, as well as the following values. </para>
/// <para>This doc was truncated.</para>
/// </returns>
/// <remarks>
/// <para>There is an important difference between the <a href="https://docs.microsoft.com/windows/desktop/api/objidl/nf-objidl-imoniker-bindtoobject">BindToObject</a> and <b>BindToStorage</b> methods. If, for example, you have a moniker that identifies a spreadsheet object, calling <b>BindToObject</b> provides access to the spreadsheet object itself, while calling <b>BindToStorage</b> provides access to the storage object in which the spreadsheet resides. <h3><a id="Notes_to_Callers"></a><a id="notes_to_callers"></a><a id="NOTES_TO_CALLERS"></a>Notes to Callers</h3> Although none of the COM moniker classes call this method in their binding operations, it might be appropriate to call it in the implementation of a new moniker class. You could call this method in an implementation of <a href="https://docs.microsoft.com/windows/desktop/api/objidl/nf-objidl-imoniker-bindtoobject">BindToObject</a> that requires information from the object identified by the <i>pmkToLeft</i> parameter and can get it from the persistent storage of the object without activation. For example, if your monikers are used to identify objects that can be activated without activating their containers, you may find this method useful. A client that can read the storage of the object its moniker identifies could also call this method. <h3><a id="Notes_to_Implementers"></a><a id="notes_to_implementers"></a><a id="NOTES_TO_IMPLEMENTERS"></a>Notes to Implementers</h3> Your implementation should locate the persistent storage for the object identified by the current moniker and return the desired interface pointer. Some types of monikers represent pseudo-objects, which are objects that do not have their own persistent storage. Such objects comprise some portion of the internal state of its container, for example, a range of cells in a spreadsheet. If your moniker class identifies this type of object, your implementation of <b>BindToStorage</b> should return the error MK_E_NOSTORAGE. If the bind context's <a href="https://docs.microsoft.com/windows/desktop/api/objidl/ns-objidl-bind_opts">BIND_OPTS</a> structure specifies the BINDFLAGS_JUSTTESTEXISTENCE flag, your implementation has the option of returning <b>NULL</b> in <i>ppvObj</i> (although you can also ignore the flag and perform the complete binding operation). <h3><a id="Implementation-specific_Notes"></a><a id="implementation-specific_notes"></a><a id="IMPLEMENTATION-SPECIFIC_NOTES"></a>Implementation-specific Notes</h3> </para>
/// <para>This doc was truncated.</para>
/// <para><see href="https://learn.microsoft.com/windows/win32/api/objidl/nf-objidl-imoniker-bindtostorage#">Read more on docs.microsoft.com</see>.</para>
/// </remarks>
public unsafe winmdroot.Foundation.HRESULT BindToStorage(winmdroot.System.Com.IBindCtx* pbc, [Optional] winmdroot.System.Com.IMoniker* pmkToLeft, global::System.Guid* riid, void** ppvObj)
{
return ((delegate *unmanaged [Stdcall]<IMoniker*,winmdroot.System.Com.IBindCtx* ,winmdroot.System.Com.IMoniker* ,global::System.Guid* ,void** ,winmdroot.Foundation.HRESULT>)lpVtbl[9])((IMoniker*)Unsafe.AsPointer(ref this), pbc, pmkToLeft, riid, ppvObj);
}
[UnmanagedCallersOnly(CallConvs = new []{
typeof(CallConvStdcall)}
)]
private static winmdroot.Foundation.HRESULT Reduce(IMoniker* pThis, winmdroot.System.Com.IBindCtx* pbc, uint dwReduceHowFar, winmdroot.System.Com.IMoniker** ppmkToLeft, winmdroot.System.Com.IMoniker** ppmkReduced)
{
try
{
winmdroot.Foundation.HRESULT __hr = ComHelpers.UnwrapCCW(pThis, out Interface __object);
if (__hr.Failed)
{
return __hr;
}
return __object.Reduce(pbc, dwReduceHowFar, ppmkToLeft, ppmkReduced);
}
catch (Exception ex)
{
return (winmdroot.Foundation.HRESULT)ex.HResult;
}
}
/// <summary>Reduces a moniker to its simplest form.</summary>
/// <param name="pbc">A pointer to the <a href="https://docs.microsoft.com/windows/desktop/api/objidl/nn-objidl-ibindctx">IBindCtx</a> interface on the bind context to be used in this binding operation. The bind context caches objects bound during the binding process, contains parameters that apply to all operations using the bind context, and provides the means by which the moniker implementation should retrieve information about its environment.</param>
/// <param name="dwReduceHowFar">Specifies how far this moniker should be reduced. This parameter must be one of the values from the <a href="https://docs.microsoft.com/windows/win32/api/objidl/ne-objidl-mkrreduce">MKRREDUCE</a> enumeration.</param>
/// <param name="ppmkToLeft">
/// <para>On entry, a pointer to an <a href="https://docs.microsoft.com/windows/desktop/api/objidl/nn-objidl-imoniker">IMoniker</a> pointer variable that contains the interface pointer to moniker to the left of this moniker. This parameter is used primarily by moniker implementers to enable cooperation between the various components of a composite moniker; moniker clients can usually pass <b>NULL</b>. On return, *<i>ppmkToLeft</i> is usually set to <b>NULL</b>, indicating no change in the original moniker to the left. In rare situations, *<i>ppmkToLeft</i> indicates a moniker, indicating that the previous moniker to the left should be disregarded and the moniker returned through *<i>ppmkToLeft</i> is the replacement. In such a situation, the implementation must call <a href="https://docs.microsoft.com/windows/desktop/api/unknwn/nf-unknwn-iunknown-release">Release</a> on the old moniker to the left of this moniker and must call <a href="https://docs.microsoft.com/windows/desktop/api/unknwn/nf-unknwn-iunknown-addref">AddRef</a> on the new returned moniker; the caller must release it later. If an error occurs, the implementation can either leave the interface pointer unchanged or set it to <b>NULL</b>.</para>
/// <para><see href="https://learn.microsoft.com/windows/win32/api/objidl/nf-objidl-imoniker-reduce#parameters">Read more on docs.microsoft.com</see>.</para>
/// </param>
/// <param name="ppmkReduced">A pointer to an <a href="https://docs.microsoft.com/windows/desktop/api/objidl/nn-objidl-imoniker">IMoniker</a> pointer variable that receives the interface pointer to the reduced form of this moniker, which can be <b>NULL</b> if an error occurs or if this moniker is reduced to nothing. If this moniker cannot be reduced, *<i>ppmkReduced</i> is simply set to this moniker and the return value is MK_S_REDUCED_TO_SELF. If *<i>ppmkReduced</i> is non-<b>NULL</b>, the implementation must call <a href="https://docs.microsoft.com/windows/desktop/api/unknwn/nf-unknwn-iunknown-addref">AddRef</a> on the new moniker; it is the caller's responsibility to call <a href="https://docs.microsoft.com/windows/desktop/api/unknwn/nf-unknwn-iunknown-release">Release</a>. (This is true even if *<i>ppmkReduced</i> is set to this moniker.)</param>
/// <returns>
/// <para>This method can return the standard return values E_OUTOFMEMORY and E_UNEXPECTED, as well as the following values. </para>
/// <para>This doc was truncated.</para>
/// </returns>
/// <remarks>
/// <para>This method is intended for the following uses: </para>
/// <para>This doc was truncated.</para>
/// <para><see href="https://learn.microsoft.com/windows/win32/api/objidl/nf-objidl-imoniker-reduce#">Read more on docs.microsoft.com</see>.</para>
/// </remarks>
public unsafe winmdroot.Foundation.HRESULT Reduce(winmdroot.System.Com.IBindCtx* pbc, uint dwReduceHowFar, winmdroot.System.Com.IMoniker** ppmkToLeft, winmdroot.System.Com.IMoniker** ppmkReduced)
{
return ((delegate *unmanaged [Stdcall]<IMoniker*,winmdroot.System.Com.IBindCtx* ,uint ,winmdroot.System.Com.IMoniker** ,winmdroot.System.Com.IMoniker** ,winmdroot.Foundation.HRESULT>)lpVtbl[10])((IMoniker*)Unsafe.AsPointer(ref this), pbc, dwReduceHowFar, ppmkToLeft, ppmkReduced);
}
[UnmanagedCallersOnly(CallConvs = new []{
typeof(CallConvStdcall)}
)]
private static winmdroot.Foundation.HRESULT ComposeWith(IMoniker* pThis, winmdroot.System.Com.IMoniker* pmkRight, winmdroot.Foundation.BOOL fOnlyIfNotGeneric, winmdroot.System.Com.IMoniker** ppmkComposite)
{
try
{
winmdroot.Foundation.HRESULT __hr = ComHelpers.UnwrapCCW(pThis, out Interface __object);
if (__hr.Failed)
{
return __hr;
}
return __object.ComposeWith(pmkRight, fOnlyIfNotGeneric, ppmkComposite);
}
catch (Exception ex)
{
return (winmdroot.Foundation.HRESULT)ex.HResult;
}
}
/// <summary>Creates a new composite moniker by combining the current moniker with the specified moniker.</summary>
/// <param name="pmkRight">A pointer to the <a href="https://docs.microsoft.com/windows/desktop/api/objidl/nn-objidl-imoniker">IMoniker</a> interface on the moniker to compose onto the end of this moniker.</param>
/// <param name="fOnlyIfNotGeneric">If <b>TRUE</b>, the caller requires a nongeneric composition, so the operation should proceed only if <i>pmkRight</i> is a moniker class that this moniker can compose with in some way other than forming a generic composite. If <b>FALSE</b>, the method can create a generic composite if necessary. Most callers should set this parameter to <b>FALSE</b>.</param>
/// <param name="ppmkComposite">A pointer to an <a href="https://docs.microsoft.com/windows/desktop/api/objidl/nn-objidl-imoniker">IMoniker</a> pointer variable that receives the composite moniker pointer. When successful, the implementation must call <a href="https://docs.microsoft.com/windows/desktop/api/unknwn/nf-unknwn-iunknown-addref">AddRef</a> on the resulting moniker; it is the caller's responsibility to call <a href="https://docs.microsoft.com/windows/desktop/api/unknwn/nf-unknwn-iunknown-release">Release</a>. If an error occurs or if the monikers compose to nothing (for example, composing an anti-moniker with an item moniker or a file moniker), *<i>ppmkComposite</i> should be set to <b>NULL</b>.</param>
/// <returns>
/// <para>This method can return the standard return values E_OUTOFMEMORY and E_UNEXPECTED, as well as the following values. </para>
/// <para>This doc was truncated.</para>
/// </returns>
/// <remarks>
/// <para>Joining two monikers together is called <i>composition</i>. Sometimes two monikers of the same class can be combined in what is called nongeneric composition. For example, a file moniker representing an incomplete path and another file moniker representing a relative path can be combined to form a single file moniker representing the complete path. Nongeneric composition for a given moniker class can be handled only in the implementation of <b>ComposeWith</b> for that moniker class. Combining two monikers of any class is called <i>generic composition</i>, which can be accomplished through a call to the <a href="https://docs.microsoft.com/windows/desktop/api/objbase/nf-objbase-creategenericcomposite">CreateGenericComposite</a> function. Composition of monikers is an associative operation. That is, if A, B, and C are monikers, then, where Comp() represents the composition operation, Comp( Comp( A, B ), C ) is always equal to Comp( A, Comp( B, C ) ). <h3><a id="Notes_to_Callers"></a><a id="notes_to_callers"></a><a id="NOTES_TO_CALLERS"></a>Notes to Callers</h3> To combine two monikers, you should call <b>ComposeWith</b> rather than calling the <a href="https://docs.microsoft.com/windows/desktop/api/objbase/nf-objbase-creategenericcomposite">CreateGenericComposite</a> function to give the first moniker a chance to perform a nongeneric composition. An object that provides item monikers to identify its objects would call <b>ComposeWith</b> to provide a moniker that completely identifies the location of the object. This would apply, for example, to a server that supports linking to portions of a document, or to a container that supports linking to embedded objects within its documents. In such a situation, you would do the following: </para>
/// <para>This doc was truncated.</para>
/// <para><see href="https://learn.microsoft.com/windows/win32/api/objidl/nf-objidl-imoniker-composewith#">Read more on docs.microsoft.com</see>.</para>
/// </remarks>
public unsafe winmdroot.Foundation.HRESULT ComposeWith(winmdroot.System.Com.IMoniker* pmkRight, winmdroot.Foundation.BOOL fOnlyIfNotGeneric, winmdroot.System.Com.IMoniker** ppmkComposite)
{
return ((delegate *unmanaged [Stdcall]<IMoniker*,winmdroot.System.Com.IMoniker* ,winmdroot.Foundation.BOOL ,winmdroot.System.Com.IMoniker** ,winmdroot.Foundation.HRESULT>)lpVtbl[11])((IMoniker*)Unsafe.AsPointer(ref this), pmkRight, fOnlyIfNotGeneric, ppmkComposite);
}
[UnmanagedCallersOnly(CallConvs = new []{
typeof(CallConvStdcall)}
)]
private static winmdroot.Foundation.HRESULT Enum(IMoniker* pThis, winmdroot.Foundation.BOOL fForward, winmdroot.System.Com.IEnumMoniker** ppenumMoniker)
{
try
{
winmdroot.Foundation.HRESULT __hr = ComHelpers.UnwrapCCW(pThis, out Interface __object);
if (__hr.Failed)
{
return __hr;
}
return __object.Enum(fForward, ppenumMoniker);
}
catch (Exception ex)
{
return (winmdroot.Foundation.HRESULT)ex.HResult;
}
}
/// <summary>Retrieves a pointer to an enumerator for the components of a composite moniker.</summary>
/// <param name="fForward">If <b>TRUE</b>, enumerates the monikers from left to right. If <b>FALSE</b>, enumerates from right to left.</param>
/// <param name="ppenumMoniker">A pointer to an <a href="https://docs.microsoft.com/windows/desktop/api/objidl/nn-objidl-ienummoniker">IEnumMoniker</a> pointer variable that receives the interface pointer to the enumerator object for the moniker. When successful, the implementation must call <a href="https://docs.microsoft.com/windows/desktop/api/unknwn/nf-unknwn-iunknown-addref">AddRef</a> on the enumerator object. It is the caller's responsibility to call <a href="https://docs.microsoft.com/windows/desktop/api/unknwn/nf-unknwn-iunknown-release">Release</a>. If an error occurs or if the moniker has no enumerable components, the implementation sets *<i>ppenumMoniker</i> to <b>NULL</b>.</param>
/// <returns>This method can return the standard return values E_OUTOFMEMORY, E_UNEXPECTED, and S_OK.</returns>
/// <remarks>
/// <para>This method must supply an <a href="https://docs.microsoft.com/windows/desktop/api/objidl/nn-objidl-ienummoniker">IEnumMoniker</a> pointer to an enumerator that can enumerate the components of a moniker. For example, the implementation of the <b>IMoniker::Enum</b> method for a generic composite moniker creates an enumerator that can determine the individual monikers that make up the composite, while the <b>IMoniker::Enum</b> method for a file moniker creates an enumerator that returns monikers representing each of the components in the path. <h3><a id="Notes_to_Callers"></a><a id="notes_to_callers"></a><a id="NOTES_TO_CALLERS"></a>Notes to Callers</h3> Call this method to examine the components that make up a composite moniker. <h3><a id="Notes_to_Implementers"></a><a id="notes_to_implementers"></a><a id="NOTES_TO_IMPLEMENTERS"></a>Notes to Implementers</h3> If the new moniker class has no discernible internal structure, your implementation of this method can simply return S_OK and set <i>ppenumMoniker</i> to <b>NULL</b>. <h3><a id="Implementation-specific_Notes"></a><a id="implementation-specific_notes"></a><a id="IMPLEMENTATION-SPECIFIC_NOTES"></a>Implementation-specific Notes</h3> </para>
/// <para>This doc was truncated.</para>
/// <para><see href="https://learn.microsoft.com/windows/win32/api/objidl/nf-objidl-imoniker-enum#">Read more on docs.microsoft.com</see>.</para>
/// </remarks>
public unsafe winmdroot.Foundation.HRESULT Enum(winmdroot.Foundation.BOOL fForward, winmdroot.System.Com.IEnumMoniker** ppenumMoniker)
{
return ((delegate *unmanaged [Stdcall]<IMoniker*,winmdroot.Foundation.BOOL ,winmdroot.System.Com.IEnumMoniker** ,winmdroot.Foundation.HRESULT>)lpVtbl[12])((IMoniker*)Unsafe.AsPointer(ref this), fForward, ppenumMoniker);
}
[UnmanagedCallersOnly(CallConvs = new []{
typeof(CallConvStdcall)}
)]
private static winmdroot.Foundation.HRESULT IsEqual(IMoniker* pThis, winmdroot.System.Com.IMoniker* pmkOtherMoniker)
{
try
{
winmdroot.Foundation.HRESULT __hr = ComHelpers.UnwrapCCW(pThis, out Interface __object);
if (__hr.Failed)
{
return __hr;
}
return __object.IsEqual(pmkOtherMoniker);
}
catch (Exception ex)
{
return (winmdroot.Foundation.HRESULT)ex.HResult;
}
}
/// <summary>Determines whether this moniker is identical to the specified moniker.</summary>
/// <param name="pmkOtherMoniker">A pointer to the <a href="https://docs.microsoft.com/windows/desktop/api/objidl/nn-objidl-imoniker">IMoniker</a> interface on the moniker to be used for comparison with this one (the one from which this method is called).</param>
/// <returns>This method returns S_OK to indicate that the two monikers are identical, and S_FALSE otherwise.</returns>
/// <remarks>
/// <para>Previous implementations of the running object table (ROT) called this method. The current implementation of the ROT uses the <a href="https://docs.microsoft.com/windows/desktop/api/objidl/nn-objidl-irotdata">IROTData</a> interface instead. <h3><a id="Notes_to_Callers"></a><a id="notes_to_callers"></a><a id="NOTES_TO_CALLERS"></a>Notes to Callers</h3> Call this method to determine whether two monikers are identical. The reduced form of a moniker is considered different from the unreduced form. You should call the <a href="https://docs.microsoft.com/windows/desktop/api/objidl/nf-objidl-imoniker-reduce">IMoniker::Reduce</a> method before calling <b>IsEqual</b>, because a reduced moniker is in its most specific form. <b>IsEqual</b> may return S_FALSE on two monikers before they are reduced, and S_OK after they are reduced. <h3><a id="Notes_to_Implementers"></a><a id="notes_to_implementers"></a><a id="NOTES_TO_IMPLEMENTERS"></a>Notes to Implementers</h3> Your implementation should not reduce the current moniker before performing the comparison. It is the caller's responsibility to call <a href="https://docs.microsoft.com/windows/desktop/api/objidl/nf-objidl-imoniker-reduce">IMoniker::Reduce</a> to compare reduced monikers. Two monikers that compare as equal must hash to the same value using <a href="https://docs.microsoft.com/windows/desktop/api/objidl/nf-objidl-imoniker-hash">IMoniker::Hash</a>. <h3><a id="Implementation-specific_Notes"></a><a id="implementation-specific_notes"></a><a id="IMPLEMENTATION-SPECIFIC_NOTES"></a>Implementation-specific Notes</h3> </para>
/// <para>This doc was truncated.</para>
/// <para><see href="https://learn.microsoft.com/windows/win32/api/objidl/nf-objidl-imoniker-isequal#">Read more on docs.microsoft.com</see>.</para>
/// </remarks>
public unsafe winmdroot.Foundation.HRESULT IsEqual(winmdroot.System.Com.IMoniker* pmkOtherMoniker)
{
return ((delegate *unmanaged [Stdcall]<IMoniker*,winmdroot.System.Com.IMoniker* ,winmdroot.Foundation.HRESULT>)lpVtbl[13])((IMoniker*)Unsafe.AsPointer(ref this), pmkOtherMoniker);
}
/// <inheritdoc cref="Hash(uint*)"/>
internal unsafe winmdroot.Foundation.HRESULT Hash(out uint pdwHash)
{
fixed (uint* pdwHashLocal = &pdwHash)
{
winmdroot.Foundation.HRESULT __result = this.Hash(pdwHashLocal);
return __result;
}
}
[UnmanagedCallersOnly(CallConvs = new []{
typeof(CallConvStdcall)}
)]
private static winmdroot.Foundation.HRESULT Hash(IMoniker* pThis, uint* pdwHash)
{
try
{
winmdroot.Foundation.HRESULT __hr = ComHelpers.UnwrapCCW(pThis, out Interface __object);
if (__hr.Failed)
{
return __hr;
}
return __object.Hash(pdwHash);
}
catch (Exception ex)
{
return (winmdroot.Foundation.HRESULT)ex.HResult;
}
}
/// <summary>Creates a hash value using the internal state of the moniker.</summary>
/// <param name="pdwHash">A pointer to a variable that receives the hash value.</param>
/// <returns>This method returns S_OK to indicate that the hash value was retrieved successfully.</returns>
/// <remarks>
/// <para><h3><a id="Notes_to_Callers"></a><a id="notes_to_callers"></a><a id="NOTES_TO_CALLERS"></a>Notes to Callers</h3> You can use the value returned by this method to maintain a hash table of monikers. The hash value determines a hash bucket in the table. To search such a table for a specified moniker, calculate its hash value and then compare it to the monikers in that hash bucket using <a href="https://docs.microsoft.com/windows/desktop/api/objidl/nf-objidl-imoniker-isequal">IMoniker::IsEqual</a>. <h3><a id="Notes_to_Implementers"></a><a id="notes_to_implementers"></a><a id="NOTES_TO_IMPLEMENTERS"></a>Notes to Implementers</h3> The hash value must be constant for the lifetime of the moniker. Two monikers that compare as equal using <a href="https://docs.microsoft.com/windows/desktop/api/objidl/nf-objidl-imoniker-isequal">IMoniker::IsEqual</a> must hash to the same value. Marshaling and then unmarshaling a moniker should have no effect on its hash value. Consequently, your implementation of <b>IMoniker::Hash</b> should rely only on the internal state of the moniker, not on its memory address. <h3><a id="Implementation-specific_Notes"></a><a id="implementation-specific_notes"></a><a id="IMPLEMENTATION-SPECIFIC_NOTES"></a>Implementation-specific Notes</h3> </para>
/// <para>This doc was truncated.</para>
/// <para><see href="https://learn.microsoft.com/windows/win32/api/objidl/nf-objidl-imoniker-hash#">Read more on docs.microsoft.com</see>.</para>
/// </remarks>
public unsafe winmdroot.Foundation.HRESULT Hash(uint* pdwHash)
{
return ((delegate *unmanaged [Stdcall]<IMoniker*,uint* ,winmdroot.Foundation.HRESULT>)lpVtbl[14])((IMoniker*)Unsafe.AsPointer(ref this), pdwHash);
}
[UnmanagedCallersOnly(CallConvs = new []{
typeof(CallConvStdcall)}
)]
private static winmdroot.Foundation.HRESULT IsRunning(IMoniker* pThis, winmdroot.System.Com.IBindCtx* pbc, winmdroot.System.Com.IMoniker* pmkToLeft, winmdroot.System.Com.IMoniker* pmkNewlyRunning)
{
try
{
winmdroot.Foundation.HRESULT __hr = ComHelpers.UnwrapCCW(pThis, out Interface __object);
if (__hr.Failed)
{
return __hr;
}
return __object.IsRunning(pbc, pmkToLeft, pmkNewlyRunning);
}
catch (Exception ex)
{
return (winmdroot.Foundation.HRESULT)ex.HResult;
}
}
/// <summary>Determines whether the object identified by this moniker is currently loaded and running.</summary>
/// <param name="pbc">A pointer to the <a href="https://docs.microsoft.com/windows/desktop/api/objidl/nn-objidl-ibindctx">IBindCtx</a> interface on the bind context to be used in this binding operation. The bind context caches objects bound during the binding process, contains parameters that apply to all operations using the bind context, and provides the means by which the moniker implementation should retrieve information about its environment.</param>
/// <param name="pmkToLeft">A pointer to the <a href="https://docs.microsoft.com/windows/desktop/api/objidl/nn-objidl-imoniker">IMoniker</a> interface on the moniker to the left of this moniker if this moniker is part of a composite. This parameter is used primarily by moniker implementers to enable cooperation between the various components of a composite moniker; moniker clients can usually pass <b>NULL</b>.</param>
/// <param name="pmkNewlyRunning">A pointer to the <a href="https://docs.microsoft.com/windows/desktop/api/objidl/nn-objidl-imoniker">IMoniker</a> interface on the moniker most recently added to the running object table (ROT). This can be <b>NULL</b>. If non-<b>NULL</b>, the implementation can return the results of calling <a href="https://docs.microsoft.com/windows/desktop/api/objidl/nf-objidl-imoniker-isequal">IMoniker::IsEqual</a> on the <i>pmkNewlyRunning</i> parameter, passing the current moniker. This parameter is intended to enable <b>IsRunning</b> implementations that are more efficient than just searching the ROT, but the implementation can choose to ignore <i>pmkNewlyRunning</i> without causing any harm.</param>
/// <returns>
/// <para>This method can return the standard return values E_UNEXPECTED, as well as the following values. </para>
/// <para>This doc was truncated.</para>
/// </returns>
/// <remarks>
/// <para><h3><a id="Notes_to_Callers"></a><a id="notes_to_callers"></a><a id="NOTES_TO_CALLERS"></a>Notes to Callers</h3> If speed is important when you're requesting services from the object identified by the moniker, you may want those services only if the object is already running (because loading an object into the running state may be time-consuming). In such a situation, you should call <b>IsRunning</b> to determine whether the object is running. For the monikers stored within linked objects, <b>IsRunning</b> is primarily called by the default handler's implementation of <a href="https://docs.microsoft.com/windows/desktop/api/oleidl/nf-oleidl-iolelink-bindifrunning">IOleLink::BindIfRunning</a>. <h3><a id="Notes_to_Implementers"></a><a id="notes_to_implementers"></a><a id="NOTES_TO_IMPLEMENTERS"></a>Notes to Implementers</h3> To get a pointer to the ROT, your implementation should call <a href="https://docs.microsoft.com/windows/desktop/api/objidl/nf-objidl-ibindctx-getrunningobjecttable">IBindCtx::GetRunningObjectTable</a> on the <i>pbc</i> parameter. Your implementation can then call <a href="https://docs.microsoft.com/windows/desktop/api/objidl/nf-objidl-irunningobjecttable-isrunning">IRunningObjectTable::IsRunning</a> to determine whether the object identified by the moniker is running. The object identified by the moniker must have registered itself with the ROT when it first began running. <h3><a id="Implementation-specific_Notes"></a><a id="implementation-specific_notes"></a><a id="IMPLEMENTATION-SPECIFIC_NOTES"></a>Implementation-specific Notes</h3> </para>
/// <para>This doc was truncated.</para>
/// <para><see href="https://learn.microsoft.com/windows/win32/api/objidl/nf-objidl-imoniker-isrunning#">Read more on docs.microsoft.com</see>.</para>
/// </remarks>
public unsafe winmdroot.Foundation.HRESULT IsRunning(winmdroot.System.Com.IBindCtx* pbc, winmdroot.System.Com.IMoniker* pmkToLeft, winmdroot.System.Com.IMoniker* pmkNewlyRunning)
{
return ((delegate *unmanaged [Stdcall]<IMoniker*,winmdroot.System.Com.IBindCtx* ,winmdroot.System.Com.IMoniker* ,winmdroot.System.Com.IMoniker* ,winmdroot.Foundation.HRESULT>)lpVtbl[15])((IMoniker*)Unsafe.AsPointer(ref this), pbc, pmkToLeft, pmkNewlyRunning);
}
/// <inheritdoc cref="GetTimeOfLastChange(winmdroot.System.Com.IBindCtx*, winmdroot.System.Com.IMoniker*, global::System.Runtime.InteropServices.ComTypes.FILETIME*)"/>
internal unsafe winmdroot.Foundation.HRESULT GetTimeOfLastChange(winmdroot.System.Com.IBindCtx* pbc, winmdroot.System.Com.IMoniker* pmkToLeft, out global::System.Runtime.InteropServices.ComTypes.FILETIME pFileTime)
{
fixed (global::System.Runtime.InteropServices.ComTypes.FILETIME* pFileTimeLocal = &pFileTime)
{
winmdroot.Foundation.HRESULT __result = this.GetTimeOfLastChange(pbc, pmkToLeft, pFileTimeLocal);
return __result;
}
}
[UnmanagedCallersOnly(CallConvs = new []{
typeof(CallConvStdcall)}
)]
private static winmdroot.Foundation.HRESULT GetTimeOfLastChange(IMoniker* pThis, winmdroot.System.Com.IBindCtx* pbc, winmdroot.System.Com.IMoniker* pmkToLeft, global::System.Runtime.InteropServices.ComTypes.FILETIME* pFileTime)
{
try
{
winmdroot.Foundation.HRESULT __hr = ComHelpers.UnwrapCCW(pThis, out Interface __object);
if (__hr.Failed)
{
return __hr;
}
return __object.GetTimeOfLastChange(pbc, pmkToLeft, pFileTime);
}
catch (Exception ex)
{
return (winmdroot.Foundation.HRESULT)ex.HResult;
}
}
/// <summary>Retrieves the time at which the object identified by this moniker was last changed.</summary>
/// <param name="pbc">A pointer to the bind context to be used in this binding operation. The bind context caches objects bound during the binding process, contains parameters that apply to all operations using the bind context, and provides the means by which the moniker implementation should retrieve information about its environment. For more information, see <a href="https://docs.microsoft.com/windows/desktop/api/objidl/nn-objidl-ibindctx">IBindCtx</a>.</param>
/// <param name="pmkToLeft">If the moniker is part of a composite moniker, pointer to the moniker to the left of this moniker. This parameter is primarily used by moniker implementers to enable cooperation between the various components of a composite moniker. Moniker clients should pass <b>NULL</b>.</param>
/// <param name="pFileTime">A pointer to the <a href="https://docs.microsoft.com/windows/desktop/api/minwinbase/ns-minwinbase-filetime">FILETIME</a> structure that receives the time of last change. A value of {0xFFFFFFFF,0x7FFFFFFF} indicates an error (for example, exceeded time limit, information not available).</param>
/// <returns>
/// <para>This method can return the standard return values E_OUTOFMEMORY, as well as the following values. </para>
/// <para>This doc was truncated.</para>
/// </returns>
/// <remarks>
/// <para>To be precise, the time returned is the earliest time COM can identify after which no change has occurred, so this time may be later than the time of the last change to 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> If you're caching information returned by the object identified by the moniker, you may want to ensure that your information is up-to-date. To do so, you would call <b>GetTimeOfLastChange</b> and compare the time returned with the time you last retrieved information from the object.</para>
/// <para>For the monikers stored within linked objects, <b>GetTimeOfLastChange</b> is primarily called by the default handler's implementation of <a href="https://docs.microsoft.com/windows/desktop/api/oleidl/nf-oleidl-ioleobject-isuptodate">IOleObject::IsUpToDate</a>. Container applications call <b>IOleObject::IsUpToDate</b> to determine if a linked object (or an embedded object containing linked objects) is up-to-date without actually binding to the object. This enables an application to determine quickly which linked objects require updating when the end user opens a document. The application can then bind only those linked objects that need updating (after prompting the end user to determine whether they should be updated) instead of binding every linked object in the document. <h3><a id="Notes_to_Implementers"></a><a id="notes_to_implementers"></a><a id="NOTES_TO_IMPLEMENTERS"></a>Notes to Implementers</h3> It is important to perform this operation quickly because, for linked objects, this method is called when a user first opens a compound document. Consequently, your <b>GetTimeOfLastChange</b> implementation should not bind to any objects. In addition, your implementation should check the deadline parameter in the bind context and return MK_E_EXCEEDEDDEADLINE if the operation cannot be completed by the specified time. Following are some strategies you can use in your implementations:</para>
/// <para></para>
/// <para>This doc was truncated.</para>
/// <para><see href="https://learn.microsoft.com/windows/win32/api/objidl/nf-objidl-imoniker-gettimeoflastchange#">Read more on docs.microsoft.com</see>.</para>
/// </remarks>
public unsafe winmdroot.Foundation.HRESULT GetTimeOfLastChange(winmdroot.System.Com.IBindCtx* pbc, winmdroot.System.Com.IMoniker* pmkToLeft, global::System.Runtime.InteropServices.ComTypes.FILETIME* pFileTime)
{
return ((delegate *unmanaged [Stdcall]<IMoniker*,winmdroot.System.Com.IBindCtx* ,winmdroot.System.Com.IMoniker* ,global::System.Runtime.InteropServices.ComTypes.FILETIME* ,winmdroot.Foundation.HRESULT>)lpVtbl[16])((IMoniker*)Unsafe.AsPointer(ref this), pbc, pmkToLeft, pFileTime);
}
[UnmanagedCallersOnly(CallConvs = new []{
typeof(CallConvStdcall)}
)]
private static winmdroot.Foundation.HRESULT Inverse(IMoniker* pThis, winmdroot.System.Com.IMoniker** ppmk)
{
try
{
winmdroot.Foundation.HRESULT __hr = ComHelpers.UnwrapCCW(pThis, out Interface __object);
if (__hr.Failed)
{
return __hr;
}
return __object.Inverse(ppmk);
}
catch (Exception ex)
{
return (winmdroot.Foundation.HRESULT)ex.HResult;
}
}
/// <summary>Creates a moniker that is the inverse of this moniker. When composed to the right of this moniker or one of similar structure, the moniker will compose to nothing.</summary>
/// <param name="ppmk">The address of an <a href="https://docs.microsoft.com/windows/desktop/api/objidl/nn-objidl-imoniker">IMoniker</a> pointer variable that receives the interface pointer to a moniker that is the inverse of this moniker. When successful, the implementation must call <a href="https://docs.microsoft.com/windows/desktop/api/unknwn/nf-unknwn-iunknown-addref">AddRef</a> on the new inverse moniker. It is the caller's responsibility to call <a href="https://docs.microsoft.com/windows/desktop/api/unknwn/nf-unknwn-iunknown-release">Release</a>. If an error occurs, the implementation should set *<i>ppmk</i> to <b>NULL</b>.</param>
/// <returns>
/// <para>This method can return the standard return values E_OUTOFMEMORY, as well as the following values. </para>
/// <para>This doc was truncated.</para>
/// </returns>
/// <remarks>
/// <para>The inverse of a moniker is analogous to the ".." directory in MS-DOS file systems; the ".." directory acts as the inverse to any other directory name, because appending ".." to a directory name results in an empty path. In the same way, the inverse of a moniker typically is also the inverse of all monikers in the same class. However, it is not necessarily the inverse of a moniker of a different class. The inverse of a composite moniker is a composite consisting of the inverses of the components of the original moniker, arranged in reverse order. For example, if the inverse of A is Inv( A ) and the composite of A, B, and C is Comp( A, B, C ), then Inv( Comp( A, B, C ) ) is equal to Comp( Inv( C ), Inv( B ), Inv( A ) ). Not all monikers have inverses. Most monikers that are themselves inverses, such as anti-monikers, do not have inverses. Monikers that have no inverse cannot have relative monikers formed from inside the objects they identify to other objects outside. <h3><a id="Notes_to_Callers"></a><a id="notes_to_callers"></a><a id="NOTES_TO_CALLERS"></a>Notes to Callers</h3> An object that is using a moniker to locate another object usually does not know the class of the moniker it is using. To get the inverse of a moniker, you should always call <b>IMoniker::Inverse</b> rather than the <a href="https://docs.microsoft.com/windows/desktop/api/objbase/nf-objbase-createantimoniker">CreateAntiMoniker</a> function, because you cannot be certain that the moniker you're using considers an anti-moniker to be its inverse.</para>
/// <para>The <b>Inverse</b> method is also called by the implementation of the <a href="https://docs.microsoft.com/windows/desktop/api/objidl/nf-objidl-imoniker-relativepathto">IMoniker::RelativePathTo</a> method, to assist in constructing a relative moniker. <h3><a id="Notes_to_Implementers"></a><a id="notes_to_implementers"></a><a id="NOTES_TO_IMPLEMENTERS"></a>Notes to Implementers</h3> If your monikers have no internal structure, you can call the <a href="https://docs.microsoft.com/windows/desktop/api/objbase/nf-objbase-createantimoniker">CreateAntiMoniker</a> function in to get an anti-moniker in your implementation of <b>IMoniker::Inverse</b>. In your implementation of <a href="https://docs.microsoft.com/windows/desktop/api/objidl/nf-objidl-imoniker-composewith">IMoniker::ComposeWith</a>, you need to check for the inverse you supply in the implementation of <b>Inverse</b>. <h3><a id="Implementation-specific_Notes"></a><a id="implementation-specific_notes"></a><a id="IMPLEMENTATION-SPECIFIC_NOTES"></a>Implementation-specific Notes</h3> </para>
/// <para>This doc was truncated.</para>
/// <para><see href="https://learn.microsoft.com/windows/win32/api/objidl/nf-objidl-imoniker-inverse#">Read more on docs.microsoft.com</see>.</para>
/// </remarks>
public unsafe winmdroot.Foundation.HRESULT Inverse(winmdroot.System.Com.IMoniker** ppmk)
{
return ((delegate *unmanaged [Stdcall]<IMoniker*,winmdroot.System.Com.IMoniker** ,winmdroot.Foundation.HRESULT>)lpVtbl[17])((IMoniker*)Unsafe.AsPointer(ref this), ppmk);
}
[UnmanagedCallersOnly(CallConvs = new []{
typeof(CallConvStdcall)}
)]
private static winmdroot.Foundation.HRESULT CommonPrefixWith(IMoniker* pThis, winmdroot.System.Com.IMoniker* pmkOther, winmdroot.System.Com.IMoniker** ppmkPrefix)
{
try
{
winmdroot.Foundation.HRESULT __hr = ComHelpers.UnwrapCCW(pThis, out Interface __object);
if (__hr.Failed)
{
return __hr;
}
return __object.CommonPrefixWith(pmkOther, ppmkPrefix);
}
catch (Exception ex)
{
return (winmdroot.Foundation.HRESULT)ex.HResult;
}
}
/// <summary>Creates a new moniker based on the prefix that this moniker has in common with the specified moniker.</summary>
/// <param name="pmkOther">A pointer to the <a href="https://docs.microsoft.com/windows/desktop/api/objidl/nn-objidl-imoniker">IMoniker</a> interface on another moniker to be compared with this one to determine whether there is a common prefix.</param>
/// <param name="ppmkPrefix">The address of an <a href="https://docs.microsoft.com/windows/desktop/api/objidl/nn-objidl-imoniker">IMoniker</a>* pointer variable that receives the interface pointer to the moniker that is the common prefix of this moniker and pmkOther. When successful, the implementation must call <a href="https://docs.microsoft.com/windows/desktop/api/unknwn/nf-unknwn-iunknown-addref">AddRef</a> on the resulting moniker; it is the caller's responsibility to call <a href="https://docs.microsoft.com/windows/desktop/api/unknwn/nf-unknwn-iunknown-release">Release</a>. If an error occurs or if there is no common prefix, the implementation should set *<i>ppmkPrefix</i> to <b>NULL</b>.</param>
/// <returns>
/// <para>This method can return the standard return values E_OUTOFMEMORY, as well as the following values. </para>
/// <para>This doc was truncated.</para>
/// </returns>
/// <remarks>
/// <para><b>CommonPrefixWith</b> creates a new moniker that consists of the common prefixes of the moniker on this moniker object and another moniker. For example, if one moniker represents the path "c:\projects\secret\art\pict1.bmp" and another moniker represents the path "c:\projects\secret\docs\chap1.txt", the common prefix of these two monikers would be a moniker representing the path "c:\projects\secret". <h3><a id="Notes_to_Callers"></a><a id="notes_to_callers"></a><a id="NOTES_TO_CALLERS"></a>Notes to Callers</h3> The <b>CommonPrefixWith</b> method is primarily called in the implementation of the <a href="https://docs.microsoft.com/windows/desktop/api/objidl/nf-objidl-imoniker-relativepathto">IMoniker::RelativePathTo</a> method. Clients using a moniker to locate an object rarely need to call this method.</para>
/// <para>Call this method only if <i>pmkOther</i> and this moniker are both absolute monikers. An absolute moniker is either a file moniker or a generic composite whose leftmost component is a file moniker that represents an absolute path. Do not call this method on relative monikers because it would not produce meaningful results.</para>
/// <para><h3><a id="Notes_to_Implementers"></a><a id="notes_to_implementers"></a><a id="NOTES_TO_IMPLEMENTERS"></a>Notes to Implementers</h3> Your implementation should first determine whether <i>pmkOther</i> is a moniker of a class that you recognize and for which you can provide special handling (for example, if it is of the same class as this moniker). If so, your implementation should determine the common prefix of the two monikers. Otherwise, it should pass both monikers in a call to the <a href="https://docs.microsoft.com/windows/desktop/api/objbase/nf-objbase-monikercommonprefixwith">MonikerCommonPrefixWith</a> function, which correctly handles the generic case.</para>
/// <para><h3><a id="Implementation-specific_Notes"></a><a id="implementation-specific_notes"></a><a id="IMPLEMENTATION-SPECIFIC_NOTES"></a>Implementation-specific Notes</h3> </para>
/// <para>This doc was truncated.</para>
/// <para><see href="https://learn.microsoft.com/windows/win32/api/objidl/nf-objidl-imoniker-commonprefixwith#">Read more on docs.microsoft.com</see>.</para>
/// </remarks>
public unsafe winmdroot.Foundation.HRESULT CommonPrefixWith(winmdroot.System.Com.IMoniker* pmkOther, winmdroot.System.Com.IMoniker** ppmkPrefix)
{
return ((delegate *unmanaged [Stdcall]<IMoniker*,winmdroot.System.Com.IMoniker* ,winmdroot.System.Com.IMoniker** ,winmdroot.Foundation.HRESULT>)lpVtbl[18])((IMoniker*)Unsafe.AsPointer(ref this), pmkOther, ppmkPrefix);
}
[UnmanagedCallersOnly(CallConvs = new []{
typeof(CallConvStdcall)}
)]
private static winmdroot.Foundation.HRESULT RelativePathTo(IMoniker* pThis, winmdroot.System.Com.IMoniker* pmkOther, winmdroot.System.Com.IMoniker** ppmkRelPath)
{
try
{
winmdroot.Foundation.HRESULT __hr = ComHelpers.UnwrapCCW(pThis, out Interface __object);
if (__hr.Failed)
{
return __hr;
}
return __object.RelativePathTo(pmkOther, ppmkRelPath);
}
catch (Exception ex)
{
return (winmdroot.Foundation.HRESULT)ex.HResult;
}
}
/// <summary>Creates a relative moniker between this moniker and the specified moniker.</summary>
/// <param name="pmkOther">A pointer to the <a href="https://docs.microsoft.com/windows/desktop/api/objidl/nn-objidl-imoniker">IMoniker</a> interface on the moniker to which a relative path should be taken.</param>
/// <param name="ppmkRelPath">A pointer to an <a href="https://docs.microsoft.com/windows/desktop/api/objidl/nn-objidl-imoniker">IMoniker</a> pointer variable that receives the interface pointer to the relative moniker. When successful, the implementation must call <a href="https://docs.microsoft.com/windows/desktop/api/unknwn/nf-unknwn-iunknown-addref">AddRef</a> on the new moniker; it is the caller's responsibility to call <a href="https://docs.microsoft.com/windows/desktop/api/unknwn/nf-unknwn-iunknown-release">Release</a>. If an error occurs, the implementation sets *<i>ppmkRelPath</i> to <b>NULL</b>.</param>
/// <returns>
/// <para>This method can return the standard return values E_OUTOFMEMORY and E_UNEXPECTED, as well as the following values. </para>
/// <para>This doc was truncated.</para>
/// </returns>
/// <remarks>
/// <para>A relative moniker is analogous to a relative path (such as "..\backup"). For example, suppose you have one moniker that represents the path "c:\projects\secret\art\pict1.bmp" and another moniker that represents the path "c:\projects\secret\docs\chap1.txt". Calling <b>RelativePathTo</b> on the first moniker, passing the second one as the <i>pmkOther</i> parameter, would create a relative moniker representing the path "..\docs\chap1.txt". <h3><a id="Notes_to_Callers"></a><a id="notes_to_callers"></a><a id="NOTES_TO_CALLERS"></a>Notes to Callers</h3> Moniker clients typically do not need to call <b>RelativePathTo</b>. This method is called primarily by the default handler for linked objects. Linked objects contain both an absolute and a relative moniker to identify the link source. (This enables link tracking if the user moves a directory tree containing both the container and source files.) The default handler calls this method to create a relative moniker from the container document to the link source. (That is, it calls <b>RelativePathTo</b> on the moniker identifying the container document, passing the moniker identifying the link source as the <i>pmkOther</i> parameter.) If you do call <b>RelativePathTo</b>, call it only on absolute monikers, for example, a file moniker or a composite moniker whose leftmost component is a file moniker, where the file moniker represents an absolute path. Do not call this method on relative monikers. <h3><a id="Notes_to_Implementers"></a><a id="notes_to_implementers"></a><a id="NOTES_TO_IMPLEMENTERS"></a>Notes to Implementers</h3> Your implementation of <b>RelativePathTo</b> should first determine whether <i>pmkOther</i> is a moniker of a class that you recognize and for which you can provide special handling (for example, if it is of the same class as this moniker). If so, your implementation should determine the relative path. Otherwise, it should pass both monikers in a call to the <a href="https://docs.microsoft.com/windows/desktop/api/objbase/nf-objbase-monikerrelativepathto">MonikerRelativePathTo</a> function, which correctly handles the generic case. The first step in determining a relative path is determining the common prefix of this moniker and <i>pmkOther</i>. The next step is to break this moniker and <i>pmkOther</i> into two parts each, say (P, myTail) and (P, otherTail) respectively, where P is the common prefix. The correct relative path is then the inverse of myTail composed with otherTail: Comp( Inv( myTail ), otherTail ) where Comp() represents the composition operation and Inv() represents the inverse operation. For certain types of monikers, you cannot use your <a href="https://docs.microsoft.com/windows/desktop/api/objidl/nf-objidl-imoniker-inverse">IMoniker::Inverse</a> method to construct the inverse of myTail. For example, a file moniker returns an anti-moniker as an inverse, while its <b>RelativePathTo</b> method must use one or more file monikers that each represent the path ".." to construct the inverse of myTail. <h3><a id="Implementation-specific_Notes"></a><a id="implementation-specific_notes"></a><a id="IMPLEMENTATION-SPECIFIC_NOTES"></a>Implementation-specific Notes</h3> </para>
/// <para>This doc was truncated.</para>
/// <para><see href="https://learn.microsoft.com/windows/win32/api/objidl/nf-objidl-imoniker-relativepathto#">Read more on docs.microsoft.com</see>.</para>
/// </remarks>
public unsafe winmdroot.Foundation.HRESULT RelativePathTo(winmdroot.System.Com.IMoniker* pmkOther, winmdroot.System.Com.IMoniker** ppmkRelPath)
{
return ((delegate *unmanaged [Stdcall]<IMoniker*,winmdroot.System.Com.IMoniker* ,winmdroot.System.Com.IMoniker** ,winmdroot.Foundation.HRESULT>)lpVtbl[19])((IMoniker*)Unsafe.AsPointer(ref this), pmkOther, ppmkRelPath);
}
/// <inheritdoc cref="GetDisplayName(winmdroot.System.Com.IBindCtx*, winmdroot.System.Com.IMoniker*, winmdroot.Foundation.PWSTR*)"/>
internal unsafe winmdroot.Foundation.HRESULT GetDisplayName(winmdroot.System.Com.IBindCtx* pbc, winmdroot.System.Com.IMoniker* pmkToLeft, out winmdroot.Foundation.PWSTR ppszDisplayName)
{
fixed (winmdroot.Foundation.PWSTR* ppszDisplayNameLocal = &ppszDisplayName)
{
winmdroot.Foundation.HRESULT __result = this.GetDisplayName(pbc, pmkToLeft, ppszDisplayNameLocal);
return __result;
}
}
[UnmanagedCallersOnly(CallConvs = new []{
typeof(CallConvStdcall)}
)]
private static winmdroot.Foundation.HRESULT GetDisplayName(IMoniker* pThis, winmdroot.System.Com.IBindCtx* pbc, winmdroot.System.Com.IMoniker* pmkToLeft, winmdroot.Foundation.PWSTR* ppszDisplayName)
{
try
{
winmdroot.Foundation.HRESULT __hr = ComHelpers.UnwrapCCW(pThis, out Interface __object);
if (__hr.Failed)
{
return __hr;
}
return __object.GetDisplayName(pbc, pmkToLeft, ppszDisplayName);
}
catch (Exception ex)
{
return (winmdroot.Foundation.HRESULT)ex.HResult;
}
}
/// <summary>Retrieves the display name for the moniker.</summary>
/// <param name="pbc">A pointer to the <a href="https://docs.microsoft.com/windows/desktop/api/objidl/nn-objidl-ibindctx">IBindCtx</a> interface on the bind context to be used in this operation. The bind context caches objects bound during the binding process, contains parameters that apply to all operations using the bind context, and provides the means by which the moniker implementation should retrieve information about its environment.</param>
/// <param name="pmkToLeft">If the moniker is part of a composite moniker, pointer to the moniker to the left of this moniker. This parameter is used primarily by moniker implementers to enable cooperation between the various components of a composite moniker. Moniker clients should pass <b>NULL</b>.</param>
/// <param name="ppszDisplayName">The address of a pointer variable that receives a pointer to the display name string for the moniker. The implementation must use <a href="https://docs.microsoft.com/windows/desktop/api/objidl/nf-objidl-imalloc-alloc">IMalloc::Alloc</a> to allocate the string returned in <i>ppszDisplayName</i>, and the caller is responsible for calling <a href="https://docs.microsoft.com/windows/desktop/api/objidl/nf-objidl-imalloc-free">IMalloc::Free</a> to free it. Both the caller and the implementation of this method use the COM task allocator returned by <a href="https://docs.microsoft.com/windows/desktop/api/combaseapi/nf-combaseapi-cogetmalloc">CoGetMalloc</a>. If an error occurs, the implementation must set *<i>ppszDisplayName</i> should be set to <b>NULL</b>.</param>
/// <returns>
/// <para>This method can return the standard return values E_OUTOFMEMORY, as well as the following values. </para>
/// <para>This doc was truncated.</para>
/// </returns>
/// <remarks>
/// <para><b>GetDisplayName</b> provides a string that is a displayable representation of the moniker. A display name is not a complete representation of a moniker's internal state; it is simply a form that can be read by users. As a result, it is possible (though rare) for two different monikers to have the same display name. While there is no guarantee that the display name of a moniker can be parsed back into that moniker when calling the <a href="https://docs.microsoft.com/windows/desktop/api/objbase/nf-objbase-mkparsedisplayname">MkParseDisplayName</a> function with it, failure to do so is rare. <h3><a id="Notes_to_Callers"></a><a id="notes_to_callers"></a><a id="NOTES_TO_CALLERS"></a>Notes to Callers</h3> It is possible that retrieving a moniker's display name may be an expensive operation. For efficiency, you may want to cache the results of the first successful call to <b>GetDisplayName</b>, rather than making repeated calls. <h3><a id="Notes_to_Implementers"></a><a id="notes_to_implementers"></a><a id="NOTES_TO_IMPLEMENTERS"></a>Notes to Implementers</h3> If you are writing a moniker class in which the display name does not change, simply cache the display name and supply the cached name when requested. If the display name can change over time, getting the current display name might mean that the moniker has to access the object's storage or bind to the object, either of which can be expensive operations. If this is the case, your implementation of <b>GetDisplayName</b> should return MK_E_EXCEEDEDDEADLINE if the name cannot be retrieved by the time specified in the bind context's <a href="https://docs.microsoft.com/windows/desktop/api/objidl/ns-objidl-bind_opts">BIND_OPTS</a> structure. A moniker that is intended to be part of a generic composite moniker should include any preceding delimiter (such as '\') as part of its display name. For example, the display name returned by an item moniker includes the delimiter specified when it was created with the <a href="https://docs.microsoft.com/windows/desktop/api/objbase/nf-objbase-createitemmoniker">CreateItemMoniker</a> function. The display name for a file moniker does not include a delimiter because file monikers are always expected to be the leftmost component of a composite. <h3><a id="Implementation-specific_Notes"></a><a id="implementation-specific_notes"></a><a id="IMPLEMENTATION-SPECIFIC_NOTES"></a>Implementation-specific Notes</h3> </para>
/// <para>This doc was truncated.</para>
/// <para><see href="https://learn.microsoft.com/windows/win32/api/objidl/nf-objidl-imoniker-getdisplayname#">Read more on docs.microsoft.com</see>.</para>
/// </remarks>
public unsafe winmdroot.Foundation.HRESULT GetDisplayName(winmdroot.System.Com.IBindCtx* pbc, winmdroot.System.Com.IMoniker* pmkToLeft, winmdroot.Foundation.PWSTR* ppszDisplayName)
{
return ((delegate *unmanaged [Stdcall]<IMoniker*,winmdroot.System.Com.IBindCtx* ,winmdroot.System.Com.IMoniker* ,winmdroot.Foundation.PWSTR* ,winmdroot.Foundation.HRESULT>)lpVtbl[20])((IMoniker*)Unsafe.AsPointer(ref this), pbc, pmkToLeft, ppszDisplayName);
}
/// <inheritdoc cref="ParseDisplayName(winmdroot.System.Com.IBindCtx*, winmdroot.System.Com.IMoniker*, winmdroot.Foundation.PWSTR, uint*, winmdroot.System.Com.IMoniker**)"/>
internal unsafe winmdroot.Foundation.HRESULT ParseDisplayName(winmdroot.System.Com.IBindCtx* pbc, winmdroot.System.Com.IMoniker* pmkToLeft, winmdroot.Foundation.PWSTR pszDisplayName, out uint pchEaten, winmdroot.System.Com.IMoniker** ppmkOut)
{
fixed (uint* pchEatenLocal = &pchEaten)
{
winmdroot.Foundation.HRESULT __result = this.ParseDisplayName(pbc, pmkToLeft, pszDisplayName, pchEatenLocal, ppmkOut);
return __result;
}
}
[UnmanagedCallersOnly(CallConvs = new []{
typeof(CallConvStdcall)}
)]
private static winmdroot.Foundation.HRESULT ParseDisplayName(IMoniker* pThis, winmdroot.System.Com.IBindCtx* pbc, winmdroot.System.Com.IMoniker* pmkToLeft, winmdroot.Foundation.PWSTR pszDisplayName, uint* pchEaten, winmdroot.System.Com.IMoniker** ppmkOut)
{
try
{
winmdroot.Foundation.HRESULT __hr = ComHelpers.UnwrapCCW(pThis, out Interface __object);
if (__hr.Failed)
{
return __hr;
}
return __object.ParseDisplayName(pbc, pmkToLeft, pszDisplayName, pchEaten, ppmkOut);
}
catch (Exception ex)
{
return (winmdroot.Foundation.HRESULT)ex.HResult;
}
}
/// <summary>Converts a display name into a moniker.</summary>
/// <param name="pbc">A pointer to the <a href="https://docs.microsoft.com/windows/desktop/api/objidl/nn-objidl-ibindctx">IBindCtx</a> interface on the bind context to be used in this binding operation. The bind context caches objects bound during the binding process, contains parameters that apply to all operations using the bind context, and provides the means by which the moniker implementation should retrieve information about its environment.</param>
/// <param name="pmkToLeft">A pointer to the <a href="https://docs.microsoft.com/windows/desktop/api/objidl/nn-objidl-imoniker">IMoniker</a> interface on the moniker that has been built out of the display name up to this point.</param>
/// <param name="pszDisplayName">The remaining display name to be parsed.</param>
/// <param name="pchEaten">A pointer to a variable that receives the number of characters in <i>pszDisplayName</i> that were consumed in this step.</param>
/// <param name="ppmkOut">A pointer to an <a href="https://docs.microsoft.com/windows/desktop/api/objidl/nn-objidl-imoniker">IMoniker</a> pointer variable that receives the interface pointer to the moniker that was built from <i>pszDisplayName</i>. When successful, the implementation must call <a href="https://docs.microsoft.com/windows/desktop/api/unknwn/nf-unknwn-iunknown-addref">AddRef</a> on the new moniker; it is the caller's responsibility to call <a href="https://docs.microsoft.com/windows/desktop/api/unknwn/nf-unknwn-iunknown-release">Release</a>. If an error occurs, the implementation sets *<i>ppmkOut</i> to <b>NULL</b>.</param>
/// <returns>
/// <para>This method can return the standard return valuesE_OUTOFMEMORY and E_UNEXPECTED, as well as the following values. </para>
/// <para>This doc was truncated.</para>
/// </returns>
/// <remarks>
/// <para><h3><a id="Notes_to_Callers"></a><a id="notes_to_callers"></a><a id="NOTES_TO_CALLERS"></a>Notes to Callers</h3> Moniker clients do not typically call <b>ParseDisplayName</b> directly. Instead, they call the <a href="https://docs.microsoft.com/windows/desktop/api/objbase/nf-objbase-mkparsedisplayname">MkParseDisplayName</a> function when they want to convert a display name into a moniker (for example, in implementing the <b>Links</b> dialog box for a container application, or for implementing a macro language that supports references to objects outside the document). That function first parses the initial portion of the display name itself. It then calls <b>ParseDisplayName</b> on the moniker it has just created, passing the remainder of the display name and getting a new moniker in return; this step is repeated until the entire display name has been parsed. <h3><a id="Notes_to_Implementers"></a><a id="notes_to_implementers"></a><a id="NOTES_TO_IMPLEMENTERS"></a>Notes to Implementers</h3> Your implementation may be able to perform this parsing by itself if your moniker class is designed to designate only certain kinds of objects. Otherwise, you must get an <a href="https://docs.microsoft.com/windows/desktop/api/oleidl/nn-oleidl-iparsedisplayname">IParseDisplayName</a> interface pointer for the object identified by the moniker-so-far (that is, the composition of <i>pmkToLeft</i> and this moniker) and then return the results of calling <a href="https://docs.microsoft.com/windows/desktop/api/oleidl/nf-oleidl-iparsedisplayname-parsedisplayname">IParseDisplayName::ParseDisplayName</a>. There are different strategies for getting an <a href="https://docs.microsoft.com/windows/desktop/api/oleidl/nn-oleidl-iparsedisplayname">IParseDisplayName</a> pointer, as follows: </para>
/// <para>This doc was truncated.</para>
/// <para><see href="https://learn.microsoft.com/windows/win32/api/objidl/nf-objidl-imoniker-parsedisplayname#">Read more on docs.microsoft.com</see>.</para>
/// </remarks>
public unsafe winmdroot.Foundation.HRESULT ParseDisplayName(winmdroot.System.Com.IBindCtx* pbc, winmdroot.System.Com.IMoniker* pmkToLeft, winmdroot.Foundation.PWSTR pszDisplayName, uint* pchEaten, winmdroot.System.Com.IMoniker** ppmkOut)
{
return ((delegate *unmanaged [Stdcall]<IMoniker*,winmdroot.System.Com.IBindCtx* ,winmdroot.System.Com.IMoniker* ,winmdroot.Foundation.PWSTR ,uint* ,winmdroot.System.Com.IMoniker** ,winmdroot.Foundation.HRESULT>)lpVtbl[21])((IMoniker*)Unsafe.AsPointer(ref this), pbc, pmkToLeft, pszDisplayName, pchEaten, ppmkOut);
}
/// <inheritdoc cref="IsSystemMoniker(uint*)"/>
internal unsafe winmdroot.Foundation.HRESULT IsSystemMoniker(out uint pdwMksys)
{
fixed (uint* pdwMksysLocal = &pdwMksys)
{
winmdroot.Foundation.HRESULT __result = this.IsSystemMoniker(pdwMksysLocal);
return __result;
}
}
[UnmanagedCallersOnly(CallConvs = new []{
typeof(CallConvStdcall)}
)]
private static winmdroot.Foundation.HRESULT IsSystemMoniker(IMoniker* pThis, uint* pdwMksys)
{
try
{
winmdroot.Foundation.HRESULT __hr = ComHelpers.UnwrapCCW(pThis, out Interface __object);
if (__hr.Failed)
{
return __hr;
}
return __object.IsSystemMoniker(pdwMksys);
}
catch (Exception ex)
{
return (winmdroot.Foundation.HRESULT)ex.HResult;
}
}
/// <summary>Determines whether this moniker is one of the system-provided moniker classes.</summary>
/// <param name="pdwMksys">A pointer to a variables that receives one of the values from the <a href="https://docs.microsoft.com/windows/desktop/api/objidl/ne-objidl-mksys">MKSYS</a> enumeration and refers to one of the COM moniker classes. This parameter cannot be <b>NULL</b>.</param>
/// <returns>This method returns S_OK to indicate that the moniker is a system moniker, and S_FALSE otherwise.</returns>
/// <remarks>
/// <para><h3><a id="Notes_to_Callers"></a><a id="notes_to_callers"></a><a id="NOTES_TO_CALLERS"></a>Notes to Callers</h3> New values of the <a href="https://docs.microsoft.com/windows/desktop/api/objidl/ne-objidl-mksys">MKSYS</a> enumeration may be defined in the future; therefore, you should explicitly test for each value you are interested in. <h3><a id="Notes_to_Implementers"></a><a id="notes_to_implementers"></a><a id="NOTES_TO_IMPLEMENTERS"></a>Notes to Implementers</h3> Your implementation of this method must return MKSYS_NONE. You cannot use this function to identify your own monikers (for example, in your implementation of <a href="https://docs.microsoft.com/windows/desktop/api/objidl/nf-objidl-imoniker-composewith">IMoniker::ComposeWith</a>). Instead, you should use your moniker's implementation of <a href="https://docs.microsoft.com/windows/desktop/api/objidl/nf-objidl-ipersist-getclassid">IPersist::GetClassID</a> or use <a href="https://docs.microsoft.com/windows/desktop/api/unknwn/nf-unknwn-iunknown-queryinterface(q)">QueryInterface</a> to test for your own private interface. <h3><a id="Implementation-specific_Notes"></a><a id="implementation-specific_notes"></a><a id="IMPLEMENTATION-SPECIFIC_NOTES"></a>Implementation-specific Notes</h3> </para>
/// <para>This doc was truncated.</para>
/// <para><see href="https://learn.microsoft.com/windows/win32/api/objidl/nf-objidl-imoniker-issystemmoniker#">Read more on docs.microsoft.com</see>.</para>
/// </remarks>
public unsafe winmdroot.Foundation.HRESULT IsSystemMoniker(uint* pdwMksys)
{
return ((delegate *unmanaged [Stdcall]<IMoniker*,uint* ,winmdroot.Foundation.HRESULT>)lpVtbl[22])((IMoniker*)Unsafe.AsPointer(ref this), pdwMksys);
}
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]<IMoniker*,global::System.Guid* ,void** ,winmdroot.Foundation.HRESULT> QueryInterface_1;
internal delegate *unmanaged [Stdcall]<IMoniker*,uint> AddRef_2;
internal delegate *unmanaged [Stdcall]<IMoniker*,uint> Release_3;
internal delegate *unmanaged [Stdcall]<IMoniker*,global::System.Guid* ,winmdroot.Foundation.HRESULT> GetClassID_4;
internal delegate *unmanaged [Stdcall]<IMoniker*,winmdroot.Foundation.HRESULT> IsDirty_5;
internal delegate *unmanaged [Stdcall]<IMoniker*,winmdroot.System.Com.IStream* ,winmdroot.Foundation.HRESULT> Load_6;
internal delegate *unmanaged [Stdcall]<IMoniker*,winmdroot.System.Com.IStream* ,winmdroot.Foundation.BOOL ,winmdroot.Foundation.HRESULT> Save_7;
internal delegate *unmanaged [Stdcall]<IMoniker*,ulong* ,winmdroot.Foundation.HRESULT> GetSizeMax_8;
internal delegate *unmanaged [Stdcall]<IMoniker*,winmdroot.System.Com.IBindCtx* ,winmdroot.System.Com.IMoniker* ,global::System.Guid* ,void** ,winmdroot.Foundation.HRESULT> BindToObject_9;
internal delegate *unmanaged [Stdcall]<IMoniker*,winmdroot.System.Com.IBindCtx* ,winmdroot.System.Com.IMoniker* ,global::System.Guid* ,void** ,winmdroot.Foundation.HRESULT> BindToStorage_10;
internal delegate *unmanaged [Stdcall]<IMoniker*,winmdroot.System.Com.IBindCtx* ,uint ,winmdroot.System.Com.IMoniker** ,winmdroot.System.Com.IMoniker** ,winmdroot.Foundation.HRESULT> Reduce_11;
internal delegate *unmanaged [Stdcall]<IMoniker*,winmdroot.System.Com.IMoniker* ,winmdroot.Foundation.BOOL ,winmdroot.System.Com.IMoniker** ,winmdroot.Foundation.HRESULT> ComposeWith_12;
internal delegate *unmanaged [Stdcall]<IMoniker*,winmdroot.Foundation.BOOL ,winmdroot.System.Com.IEnumMoniker** ,winmdroot.Foundation.HRESULT> Enum_13;
internal delegate *unmanaged [Stdcall]<IMoniker*,winmdroot.System.Com.IMoniker* ,winmdroot.Foundation.HRESULT> IsEqual_14;
internal delegate *unmanaged [Stdcall]<IMoniker*,uint* ,winmdroot.Foundation.HRESULT> Hash_15;
internal delegate *unmanaged [Stdcall]<IMoniker*,winmdroot.System.Com.IBindCtx* ,winmdroot.System.Com.IMoniker* ,winmdroot.System.Com.IMoniker* ,winmdroot.Foundation.HRESULT> IsRunning_16;
internal delegate *unmanaged [Stdcall]<IMoniker*,winmdroot.System.Com.IBindCtx* ,winmdroot.System.Com.IMoniker* ,global::System.Runtime.InteropServices.ComTypes.FILETIME* ,winmdroot.Foundation.HRESULT> GetTimeOfLastChange_17;
internal delegate *unmanaged [Stdcall]<IMoniker*,winmdroot.System.Com.IMoniker** ,winmdroot.Foundation.HRESULT> Inverse_18;
internal delegate *unmanaged [Stdcall]<IMoniker*,winmdroot.System.Com.IMoniker* ,winmdroot.System.Com.IMoniker** ,winmdroot.Foundation.HRESULT> CommonPrefixWith_19;
internal delegate *unmanaged [Stdcall]<IMoniker*,winmdroot.System.Com.IMoniker* ,winmdroot.System.Com.IMoniker** ,winmdroot.Foundation.HRESULT> RelativePathTo_20;
internal delegate *unmanaged [Stdcall]<IMoniker*,winmdroot.System.Com.IBindCtx* ,winmdroot.System.Com.IMoniker* ,winmdroot.Foundation.PWSTR* ,winmdroot.Foundation.HRESULT> GetDisplayName_21;
internal delegate *unmanaged [Stdcall]<IMoniker*,winmdroot.System.Com.IBindCtx* ,winmdroot.System.Com.IMoniker* ,winmdroot.Foundation.PWSTR ,uint* ,winmdroot.System.Com.IMoniker** ,winmdroot.Foundation.HRESULT> ParseDisplayName_22;
internal delegate *unmanaged [Stdcall]<IMoniker*,uint* ,winmdroot.Foundation.HRESULT> IsSystemMoniker_23;
}
public static void PopulateVTable(Vtbl* vtable)
{
vtable->GetClassID_4 = &GetClassID;
vtable->IsDirty_5 = &IsDirty;
vtable->Load_6 = &Load;
vtable->Save_7 = &Save;
vtable->GetSizeMax_8 = &GetSizeMax;
vtable->BindToObject_9 = &BindToObject;
vtable->BindToStorage_10 = &BindToStorage;
vtable->Reduce_11 = &Reduce;
vtable->ComposeWith_12 = &ComposeWith;
vtable->Enum_13 = &Enum;
vtable->IsEqual_14 = &IsEqual;
vtable->Hash_15 = &Hash;
vtable->IsRunning_16 = &IsRunning;
vtable->GetTimeOfLastChange_17 = &GetTimeOfLastChange;
vtable->Inverse_18 = &Inverse;
vtable->CommonPrefixWith_19 = &CommonPrefixWith;
vtable->RelativePathTo_20 = &RelativePathTo;
vtable->GetDisplayName_21 = &GetDisplayName;
vtable->ParseDisplayName_22 = &ParseDisplayName;
vtable->IsSystemMoniker_23 = &IsSystemMoniker;
}
private void** lpVtbl;
/// <summary>The IID guid for this interface.</summary>
/// <value>{0000000f-0000-0000-c000-000000000046}</value>
internal static readonly Guid IID_Guid = new Guid(0x0000000F, 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[] {
0x0F,0x00,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("0000000F-0000-0000-C000-000000000046"),InterfaceType(ComInterfaceType.InterfaceIsIUnknown),ComImport()]
[SupportedOSPlatform("windows5.0")]
internal interface Interface
:winmdroot.System.Com.IPersist.Interface,winmdroot.System.Com.IPersistStream.Interface {
[PreserveSig()]
unsafe new winmdroot.Foundation.HRESULT GetClassID(global::System.Guid* pClassID);
[PreserveSig()]
new winmdroot.Foundation.HRESULT IsDirty();
[PreserveSig()]
unsafe new winmdroot.Foundation.HRESULT Load(winmdroot.System.Com.IStream* pStm);
[PreserveSig()]
unsafe new winmdroot.Foundation.HRESULT Save(winmdroot.System.Com.IStream* pStm, winmdroot.Foundation.BOOL fClearDirty);
[PreserveSig()]
unsafe new winmdroot.Foundation.HRESULT GetSizeMax(ulong* pcbSize);
[PreserveSig()]
unsafe winmdroot.Foundation.HRESULT BindToObject(winmdroot.System.Com.IBindCtx* pbc, [Optional] winmdroot.System.Com.IMoniker* pmkToLeft, global::System.Guid* riidResult, void** ppvResult);
[PreserveSig()]
unsafe winmdroot.Foundation.HRESULT BindToStorage(winmdroot.System.Com.IBindCtx* pbc, [Optional] winmdroot.System.Com.IMoniker* pmkToLeft, global::System.Guid* riid, void** ppvObj);
[PreserveSig()]
unsafe winmdroot.Foundation.HRESULT Reduce(winmdroot.System.Com.IBindCtx* pbc, uint dwReduceHowFar, winmdroot.System.Com.IMoniker** ppmkToLeft, winmdroot.System.Com.IMoniker** ppmkReduced);
[PreserveSig()]
unsafe winmdroot.Foundation.HRESULT ComposeWith(winmdroot.System.Com.IMoniker* pmkRight, winmdroot.Foundation.BOOL fOnlyIfNotGeneric, winmdroot.System.Com.IMoniker** ppmkComposite);
[PreserveSig()]
unsafe winmdroot.Foundation.HRESULT Enum(winmdroot.Foundation.BOOL fForward, winmdroot.System.Com.IEnumMoniker** ppenumMoniker);
[PreserveSig()]
unsafe winmdroot.Foundation.HRESULT IsEqual(winmdroot.System.Com.IMoniker* pmkOtherMoniker);
[PreserveSig()]
unsafe winmdroot.Foundation.HRESULT Hash(uint* pdwHash);
[PreserveSig()]
unsafe winmdroot.Foundation.HRESULT IsRunning(winmdroot.System.Com.IBindCtx* pbc, winmdroot.System.Com.IMoniker* pmkToLeft, winmdroot.System.Com.IMoniker* pmkNewlyRunning);
[PreserveSig()]
unsafe winmdroot.Foundation.HRESULT GetTimeOfLastChange(winmdroot.System.Com.IBindCtx* pbc, winmdroot.System.Com.IMoniker* pmkToLeft, global::System.Runtime.InteropServices.ComTypes.FILETIME* pFileTime);
[PreserveSig()]
unsafe winmdroot.Foundation.HRESULT Inverse(winmdroot.System.Com.IMoniker** ppmk);
[PreserveSig()]
unsafe winmdroot.Foundation.HRESULT CommonPrefixWith(winmdroot.System.Com.IMoniker* pmkOther, winmdroot.System.Com.IMoniker** ppmkPrefix);
[PreserveSig()]
unsafe winmdroot.Foundation.HRESULT RelativePathTo(winmdroot.System.Com.IMoniker* pmkOther, winmdroot.System.Com.IMoniker** ppmkRelPath);
[PreserveSig()]
unsafe winmdroot.Foundation.HRESULT GetDisplayName(winmdroot.System.Com.IBindCtx* pbc, winmdroot.System.Com.IMoniker* pmkToLeft, winmdroot.Foundation.PWSTR* ppszDisplayName);
[PreserveSig()]
unsafe winmdroot.Foundation.HRESULT ParseDisplayName(winmdroot.System.Com.IBindCtx* pbc, winmdroot.System.Com.IMoniker* pmkToLeft, winmdroot.Foundation.PWSTR pszDisplayName, uint* pchEaten, winmdroot.System.Com.IMoniker** ppmkOut);
[PreserveSig()]
unsafe winmdroot.Foundation.HRESULT IsSystemMoniker(uint* pdwMksys);
}
}
}
}
|