|
// ------------------------------------------------------------------------------
// <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 UI.Accessibility
{
[Guid("618736E0-3C3D-11CF-810C-00AA00389B71")]
[SupportedOSPlatform("windows5.0")]
[global::System.CodeDom.Compiler.GeneratedCode("Microsoft.Windows.CsWin32", "0.3.151+58e949951d.RR")]
internal unsafe partial struct IAccessible
:IVTable<IAccessible,IAccessible.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]<IAccessible*,global::System.Guid* ,void** ,winmdroot.Foundation.HRESULT>)lpVtbl[0])((IAccessible*)Unsafe.AsPointer(ref this), riid, ppvObject);
}
public uint AddRef()
{
return ((delegate *unmanaged [Stdcall]<IAccessible*,uint>)lpVtbl[1])((IAccessible*)Unsafe.AsPointer(ref this));
}
public uint Release()
{
return ((delegate *unmanaged [Stdcall]<IAccessible*,uint>)lpVtbl[2])((IAccessible*)Unsafe.AsPointer(ref this));
}
/// <inheritdoc cref="GetTypeInfoCount(uint*)"/>
internal unsafe void GetTypeInfoCount(out uint pctinfo)
{
fixed (uint* pctinfoLocal = &pctinfo)
{
this.GetTypeInfoCount(pctinfoLocal);
}
}
/// <summary>Retrieves the number of type information interfaces that an object provides (either 0 or 1).</summary>
/// <param name="pctinfo">The number of type information interfaces provided by the object. If the object provides type information, this number is 1; otherwise the number is 0.</param>
/// <returns>
/// <para>This method can return one of these values. </para>
/// <para>This doc was truncated.</para>
/// </returns>
/// <remarks>The method may return zero, which indicates that the object does not provide any type information. In this case, the object may still be programmable through <b>IDispatch</b> or a VTBL, but does not provide run-time type information for browsers, compilers, or other programming tools that access type information. This can be useful for hiding an object from browsers.</remarks>
public unsafe void GetTypeInfoCount(uint* pctinfo)
{
((delegate *unmanaged [Stdcall]<IAccessible*,uint* ,winmdroot.Foundation.HRESULT>)lpVtbl[3])((IAccessible*)Unsafe.AsPointer(ref this), pctinfo).ThrowOnFailure();
}
public unsafe void GetTypeInfo(uint iTInfo, uint lcid, winmdroot.System.Com.ITypeInfo** ppTInfo)
{
((delegate *unmanaged [Stdcall]<IAccessible*,uint ,uint ,winmdroot.System.Com.ITypeInfo** ,winmdroot.Foundation.HRESULT>)lpVtbl[4])((IAccessible*)Unsafe.AsPointer(ref this), iTInfo, lcid, ppTInfo).ThrowOnFailure();
}
/// <inheritdoc cref="GetIDsOfNames(global::System.Guid*, winmdroot.Foundation.PWSTR*, uint, uint, int*)"/>
internal unsafe void GetIDsOfNames(in global::System.Guid riid, ReadOnlySpan<winmdroot.Foundation.PWSTR> rgszNames, uint lcid, Span<int> rgDispId)
{
fixed (int* rgDispIdLocal = rgDispId)
{
fixed (winmdroot.Foundation.PWSTR* rgszNamesLocal = rgszNames)
{
fixed (global::System.Guid* riidLocal = &riid)
{
if (rgszNames.Length != rgDispId.Length) throw new ArgumentException();
this.GetIDsOfNames(riidLocal, rgszNamesLocal, (uint )rgDispId.Length, lcid, rgDispIdLocal);
}
}
}
}
public unsafe void GetIDsOfNames(global::System.Guid* riid, winmdroot.Foundation.PWSTR* rgszNames, uint cNames, uint lcid, int* rgDispId)
{
((delegate *unmanaged [Stdcall]<IAccessible*,global::System.Guid* ,winmdroot.Foundation.PWSTR* ,uint ,uint ,int* ,winmdroot.Foundation.HRESULT>)lpVtbl[5])((IAccessible*)Unsafe.AsPointer(ref this), riid, rgszNames, cNames, lcid, rgDispId).ThrowOnFailure();
}
/// <inheritdoc cref="Invoke(int, global::System.Guid*, uint, winmdroot.System.Com.DISPATCH_FLAGS, winmdroot.System.Com.DISPPARAMS*, winmdroot.System.Variant.VARIANT*, winmdroot.System.Com.EXCEPINFO*, uint*)"/>
internal unsafe void Invoke(int dispIdMember, in global::System.Guid riid, uint lcid, winmdroot.System.Com.DISPATCH_FLAGS wFlags, in winmdroot.System.Com.DISPPARAMS pDispParams, winmdroot.System.Variant.VARIANT* pVarResult, winmdroot.System.Com.EXCEPINFO* pExcepInfo, uint* puArgErr)
{
fixed (winmdroot.System.Com.DISPPARAMS* pDispParamsLocal = &pDispParams)
{
fixed (global::System.Guid* riidLocal = &riid)
{
this.Invoke(dispIdMember, riidLocal, lcid, wFlags, pDispParamsLocal, pVarResult, pExcepInfo, puArgErr);
}
}
}
public unsafe void Invoke(int dispIdMember, global::System.Guid* riid, uint lcid, winmdroot.System.Com.DISPATCH_FLAGS wFlags, winmdroot.System.Com.DISPPARAMS* pDispParams, [Optional] winmdroot.System.Variant.VARIANT* pVarResult, [Optional] winmdroot.System.Com.EXCEPINFO* pExcepInfo, [Optional] uint* puArgErr)
{
((delegate *unmanaged [Stdcall]<IAccessible*,int ,global::System.Guid* ,uint ,winmdroot.System.Com.DISPATCH_FLAGS ,winmdroot.System.Com.DISPPARAMS* ,winmdroot.System.Variant.VARIANT* ,winmdroot.System.Com.EXCEPINFO* ,uint* ,winmdroot.Foundation.HRESULT>)lpVtbl[6])((IAccessible*)Unsafe.AsPointer(ref this), dispIdMember, riid, lcid, wFlags, pDispParams, pVarResult, pExcepInfo, puArgErr).ThrowOnFailure();
}
[UnmanagedCallersOnly(CallConvs = new []{
typeof(CallConvStdcall)}
)]
private static winmdroot.Foundation.HRESULT get_accParent(IAccessible* pThis, winmdroot.System.Com.IDispatch** ppdispParent)
{
try
{
winmdroot.Foundation.HRESULT __hr = ComHelpers.UnwrapCCW(pThis, out Interface __object);
if (__hr.Failed)
{
return __hr;
}
return __object.get_accParent(ppdispParent);
}
catch (Exception ex)
{
return (winmdroot.Foundation.HRESULT)ex.HResult;
}
}
/// <summary>The IAccessible::get_accParent method retrieves the IDispatch of the object's parent. All objects support this property.</summary>
/// <param name="ppdispParent">
/// <para>Type: <b>IDispatch**</b> Receives the address of the parent object's <a href="https://docs.microsoft.com/windows/desktop/WinAuto/idispatch-interface">IDispatch</a> interface. If no parent exists or if the child cannot access its parent, the variable is set to <b>NULL</b>.</para>
/// <para><see href="https://learn.microsoft.com/windows/win32/api/oleacc/nf-oleacc-iaccessible-get_accparent#parameters">Read more on docs.microsoft.com</see>.</para>
/// </param>
/// <returns>
/// <para>Type: <b><a href="https://docs.microsoft.com/windows/desktop/WinProg/windows-data-types">HRESULT</a></b> If successful, returns S_OK. If not successful, returns one of the values in the table that follows, or another standard <a href="https://docs.microsoft.com/windows/desktop/WinAuto/return-values">COM error code</a>. Servers return these values, but clients must always check output parameters to ensure that they contain valid values. For more information, see <a href="https://docs.microsoft.com/windows/desktop/WinAuto/checking-iaccessible-return-values">Checking IAccessible Return Values</a>. </para>
/// <para>This doc was truncated.</para>
/// </returns>
/// <remarks>
/// <para><see href="https://learn.microsoft.com/windows/win32/api/oleacc/nf-oleacc-iaccessible-get_accparent">Learn more about this API from docs.microsoft.com</see>.</para>
/// </remarks>
public unsafe winmdroot.Foundation.HRESULT get_accParent(winmdroot.System.Com.IDispatch** ppdispParent)
{
return ((delegate *unmanaged [Stdcall]<IAccessible*,winmdroot.System.Com.IDispatch** ,winmdroot.Foundation.HRESULT>)lpVtbl[7])((IAccessible*)Unsafe.AsPointer(ref this), ppdispParent);
}
/// <inheritdoc cref="get_accChildCount(int*)"/>
internal unsafe winmdroot.Foundation.HRESULT get_accChildCount(out int pcountChildren)
{
fixed (int* pcountChildrenLocal = &pcountChildren)
{
winmdroot.Foundation.HRESULT __result = this.get_accChildCount(pcountChildrenLocal);
return __result;
}
}
[UnmanagedCallersOnly(CallConvs = new []{
typeof(CallConvStdcall)}
)]
private static winmdroot.Foundation.HRESULT get_accChildCount(IAccessible* pThis, int* pcountChildren)
{
try
{
winmdroot.Foundation.HRESULT __hr = ComHelpers.UnwrapCCW(pThis, out Interface __object);
if (__hr.Failed)
{
return __hr;
}
return __object.get_accChildCount(pcountChildren);
}
catch (Exception ex)
{
return (winmdroot.Foundation.HRESULT)ex.HResult;
}
}
/// <summary>The IAccessible::get_accChildCount method retrieves the number of children that belong to this object. All objects must support this property.</summary>
/// <param name="pcountChildren">
/// <para>Type: <b>long*</b> Address of a variable that receives the number of children that belong to this object. The children are accessible objects or child elements. If the object has no children, this value is zero.</para>
/// <para><see href="https://learn.microsoft.com/windows/win32/api/oleacc/nf-oleacc-iaccessible-get_accchildcount#parameters">Read more on docs.microsoft.com</see>.</para>
/// </param>
/// <returns>
/// <para>Type: <b><a href="https://docs.microsoft.com/windows/desktop/WinProg/windows-data-types">HRESULT</a></b> If successful, returns S_OK. If not successful, returns a standard <a href="https://docs.microsoft.com/windows/desktop/WinAuto/return-values">COM error code</a>. Servers return these values, but clients must always check output parameters to ensure that they contain valid values. For more information, see <a href="https://docs.microsoft.com/windows/desktop/WinAuto/checking-iaccessible-return-values">Checking IAccessible Return Values</a>.</para>
/// </returns>
/// <remarks>
/// <para>The number of children in an object can change. An application tracks the changes to the child count by watching for <a href="https://docs.microsoft.com/windows/desktop/WinAuto/event-constants">EVENT_OBJECT_CREATE</a> and <a href="https://docs.microsoft.com/windows/desktop/WinAuto/event-constants">EVENT_OBJECT_DESTROY</a> events generated by this object. <b>Note to server developers: </b>If the object does not have any children, return S_OK and set <i>pcountChildren</i> to zero.</para>
/// <para><see href="https://learn.microsoft.com/windows/win32/api/oleacc/nf-oleacc-iaccessible-get_accchildcount#">Read more on docs.microsoft.com</see>.</para>
/// </remarks>
public unsafe winmdroot.Foundation.HRESULT get_accChildCount(int* pcountChildren)
{
return ((delegate *unmanaged [Stdcall]<IAccessible*,int* ,winmdroot.Foundation.HRESULT>)lpVtbl[8])((IAccessible*)Unsafe.AsPointer(ref this), pcountChildren);
}
[UnmanagedCallersOnly(CallConvs = new []{
typeof(CallConvStdcall)}
)]
private static winmdroot.Foundation.HRESULT get_accChild(IAccessible* pThis, winmdroot.System.Variant.VARIANT varChild, winmdroot.System.Com.IDispatch** ppdispChild)
{
try
{
winmdroot.Foundation.HRESULT __hr = ComHelpers.UnwrapCCW(pThis, out Interface __object);
if (__hr.Failed)
{
return __hr;
}
return __object.get_accChild(varChild, ppdispChild);
}
catch (Exception ex)
{
return (winmdroot.Foundation.HRESULT)ex.HResult;
}
}
/// <summary>The IAccessible::get_accChild method retrieves an IDispatch for the specified child, if one exists. All objects must support this property.</summary>
/// <param name="varChild">
/// <para>Type: <b>VARIANT</b> Identifies the child whose <a href="https://docs.microsoft.com/windows/desktop/WinAuto/idispatch-interface">IDispatch</a> interface is retrieved. For more information about initializing the <a href="https://docs.microsoft.com/windows/desktop/WinAuto/variant-structure">VARIANT</a>, see <a href="https://docs.microsoft.com/windows/desktop/WinAuto/how-child-ids-are-used-in-parameters">How Child IDs Are Used in Parameters</a>.</para>
/// <para><see href="https://learn.microsoft.com/windows/win32/api/oleacc/nf-oleacc-iaccessible-get_accchild#parameters">Read more on docs.microsoft.com</see>.</para>
/// </param>
/// <param name="ppdispChild">
/// <para>Type: <b>IDispatch**</b> [out, retval] Receives the address of the child object's <a href="https://docs.microsoft.com/windows/desktop/WinAuto/idispatch-interface">IDispatch</a> interface.</para>
/// <para><see href="https://learn.microsoft.com/windows/win32/api/oleacc/nf-oleacc-iaccessible-get_accchild#parameters">Read more on docs.microsoft.com</see>.</para>
/// </param>
/// <returns>
/// <para>Type: <b><a href="https://docs.microsoft.com/windows/desktop/WinProg/windows-data-types">HRESULT</a></b> If successful, returns S_OK. If not successful, returns one of the values in the table that follows, or another standard <a href="https://docs.microsoft.com/windows/desktop/WinAuto/return-values">COM error code</a>. Servers return these values, but clients must always check output parameters to ensure that they contain valid values. For more information, see <a href="https://docs.microsoft.com/windows/desktop/WinAuto/checking-iaccessible-return-values">Checking IAccessible Return Values</a>. </para>
/// <para>This doc was truncated.</para>
/// </returns>
/// <remarks>
/// <para>Servers expose elements as either elements (child IDs) or full objects (<a href="https://docs.microsoft.com/windows/desktop/api/oleacc/nn-oleacc-iaccessible">IAccessible</a> interface pointers). If a child is an element, <b>get_accChild</b> returns S_FALSE, and the parent will provide information for that child. If the child is a full object, <b>get_accChild</b> will return the <b>IAccessible</b> interface pointer and the parent will not provide information about that child. If <b>get_accChild</b> fails because the server application cannot create an accessible object due to a temporary system error (such as an out-of-memory error), the server should return a suitable failure code. <b>Note to server developers: </b>If <i>varChildID</i> contains VT_EMPTY, you should return E_INVALIDARG.</para>
/// <para><h3><a id="Server_Example"></a><a id="server_example"></a><a id="SERVER_EXAMPLE"></a>Server Example</h3> The following example code shows an implementation for an object that does not have any children, or whose children are elements rather than objects.</para>
/// <para></para>
/// <para>This doc was truncated.</para>
/// <para><see href="https://learn.microsoft.com/windows/win32/api/oleacc/nf-oleacc-iaccessible-get_accchild#">Read more on docs.microsoft.com</see>.</para>
/// </remarks>
public unsafe winmdroot.Foundation.HRESULT get_accChild(winmdroot.System.Variant.VARIANT varChild, winmdroot.System.Com.IDispatch** ppdispChild)
{
return ((delegate *unmanaged [Stdcall]<IAccessible*,winmdroot.System.Variant.VARIANT ,winmdroot.System.Com.IDispatch** ,winmdroot.Foundation.HRESULT>)lpVtbl[9])((IAccessible*)Unsafe.AsPointer(ref this), varChild, ppdispChild);
}
[UnmanagedCallersOnly(CallConvs = new []{
typeof(CallConvStdcall)}
)]
private static winmdroot.Foundation.HRESULT get_accName(IAccessible* pThis, winmdroot.System.Variant.VARIANT varChild, winmdroot.Foundation.BSTR* pszName)
{
try
{
winmdroot.Foundation.HRESULT __hr = ComHelpers.UnwrapCCW(pThis, out Interface __object);
if (__hr.Failed)
{
return __hr;
}
return __object.get_accName(varChild, pszName);
}
catch (Exception ex)
{
return (winmdroot.Foundation.HRESULT)ex.HResult;
}
}
/// <summary>The IAccessible::get_accName method retrieves the name of the specified object. All objects support this property.</summary>
/// <param name="varChild">
/// <para>Type: <b>VARIANT</b> Specifies whether the retrieved name belongs to the object or one of the object's child elements. This parameter is either CHILDID_SELF (to obtain information about the object) or a child ID (to obtain information about the object's child element). For more information about initializing the <a href="https://docs.microsoft.com/windows/desktop/WinAuto/variant-structure">VARIANT structure</a>, see <a href="https://docs.microsoft.com/windows/desktop/WinAuto/how-child-ids-are-used-in-parameters">How Child IDs Are Used in Parameters</a>.</para>
/// <para><see href="https://learn.microsoft.com/windows/win32/api/oleacc/nf-oleacc-iaccessible-get_accname#parameters">Read more on docs.microsoft.com</see>.</para>
/// </param>
/// <param name="pszName">
/// <para>Type: <b>BSTR*</b> Address of a <b>BSTR</b> that receives a string that contains the specified object's name.</para>
/// <para><see href="https://learn.microsoft.com/windows/win32/api/oleacc/nf-oleacc-iaccessible-get_accname#parameters">Read more on docs.microsoft.com</see>.</para>
/// </param>
/// <returns>
/// <para>Type: <b><a href="https://docs.microsoft.com/windows/desktop/WinProg/windows-data-types">HRESULT</a></b> If successful, returns S_OK. If not successful, returns one of the values in the table that follows, or another standard <a href="https://docs.microsoft.com/windows/desktop/WinAuto/return-values">COM error code</a>. Servers return these values, but clients must always check output parameters to ensure that they contain valid values. For more information, see <a href="https://docs.microsoft.com/windows/desktop/WinAuto/checking-iaccessible-return-values">Checking IAccessible Return Values</a>. </para>
/// <para>This doc was truncated.</para>
/// </returns>
/// <remarks>
/// <para>Many objects such as icons, menus, check boxes, combo boxes, and other controls have labels that are displayed to users. Any label that is displayed to users is used for the object's name property. For more information, see the <a href="https://docs.microsoft.com/windows/desktop/WinAuto/name-property">Name Property</a>. <b>Note to server developers: </b>If you are using menu or button text for the Name property, remove any ampersands (&) marking the keyboard access keys. Provide the access key to the client in response to <a href="https://docs.microsoft.com/windows/desktop/api/oleacc/nf-oleacc-iaccessible-get_acckeyboardshortcut">IAccessible::get_accKeyboardShortcut</a>. Localize the string returned from this property.</para>
/// <para><h3><a id="Server_Example"></a><a id="server_example"></a><a id="SERVER_EXAMPLE"></a>Server Example</h3> The following example shows a possible implementation of this method for a custom list box control that manages its own child elements.</para>
/// <para></para>
/// <para>This doc was truncated.</para>
/// <para><see href="https://learn.microsoft.com/windows/win32/api/oleacc/nf-oleacc-iaccessible-get_accname#">Read more on docs.microsoft.com</see>.</para>
/// </remarks>
public unsafe winmdroot.Foundation.HRESULT get_accName(winmdroot.System.Variant.VARIANT varChild, winmdroot.Foundation.BSTR* pszName)
{
return ((delegate *unmanaged [Stdcall]<IAccessible*,winmdroot.System.Variant.VARIANT ,winmdroot.Foundation.BSTR* ,winmdroot.Foundation.HRESULT>)lpVtbl[10])((IAccessible*)Unsafe.AsPointer(ref this), varChild, pszName);
}
[UnmanagedCallersOnly(CallConvs = new []{
typeof(CallConvStdcall)}
)]
private static winmdroot.Foundation.HRESULT get_accValue(IAccessible* pThis, winmdroot.System.Variant.VARIANT varChild, winmdroot.Foundation.BSTR* pszValue)
{
try
{
winmdroot.Foundation.HRESULT __hr = ComHelpers.UnwrapCCW(pThis, out Interface __object);
if (__hr.Failed)
{
return __hr;
}
return __object.get_accValue(varChild, pszValue);
}
catch (Exception ex)
{
return (winmdroot.Foundation.HRESULT)ex.HResult;
}
}
/// <summary>The IAccessible::get_accValue method retrieves the value of the specified object. Not all objects have a value.</summary>
/// <param name="varChild">
/// <para>Type: <b>VARIANT</b> Specifies whether the retrieved value information belongs to the object or one of the object's child elements. This parameter is either CHILDID_SELF (to obtain information about the object) or a child ID (to obtain information about the object's child element). For more information about initializing the <a href="https://docs.microsoft.com/windows/desktop/WinAuto/variant-structure">VARIANT structure</a>, see <a href="https://docs.microsoft.com/windows/desktop/WinAuto/how-child-ids-are-used-in-parameters">How Child IDs Are Used in Parameters</a>.</para>
/// <para><see href="https://learn.microsoft.com/windows/win32/api/oleacc/nf-oleacc-iaccessible-get_accvalue#parameters">Read more on docs.microsoft.com</see>.</para>
/// </param>
/// <param name="pszValue">
/// <para>Type: <b>BSTR*</b> Address of the <b>BSTR</b> that receives a localized string that contains the object's current value.</para>
/// <para><see href="https://learn.microsoft.com/windows/win32/api/oleacc/nf-oleacc-iaccessible-get_accvalue#parameters">Read more on docs.microsoft.com</see>.</para>
/// </param>
/// <returns>
/// <para>Type: <b><a href="https://docs.microsoft.com/windows/desktop/WinProg/windows-data-types">HRESULT</a></b> If successful, returns S_OK. If not successful, returns one of the values in the table that follows, or another standard <a href="https://docs.microsoft.com/windows/desktop/WinAuto/return-values">COM error code</a>. Servers return these values, but clients must always check output parameters to ensure that they contain valid values. For more information, see <a href="https://docs.microsoft.com/windows/desktop/WinAuto/checking-iaccessible-return-values">Checking IAccessible Return Values</a>. </para>
/// <para>This doc was truncated.</para>
/// </returns>
/// <remarks>
/// <para>Numeric values returned from scroll bar and trackbar accessible objects indicate percentages. They are integers between zero (0) and one hundred (100), inclusive, but might also be a limited range for example, between one (1) and sixteen (16). Also, some scroll bar and trackbar objects return strings that correspond to settings such as screen size or Internet security. <b>Note to server developers: </b>Localize the string returned from this property.</para>
/// <para><see href="https://learn.microsoft.com/windows/win32/api/oleacc/nf-oleacc-iaccessible-get_accvalue#">Read more on docs.microsoft.com</see>.</para>
/// </remarks>
public unsafe winmdroot.Foundation.HRESULT get_accValue(winmdroot.System.Variant.VARIANT varChild, winmdroot.Foundation.BSTR* pszValue)
{
return ((delegate *unmanaged [Stdcall]<IAccessible*,winmdroot.System.Variant.VARIANT ,winmdroot.Foundation.BSTR* ,winmdroot.Foundation.HRESULT>)lpVtbl[11])((IAccessible*)Unsafe.AsPointer(ref this), varChild, pszValue);
}
[UnmanagedCallersOnly(CallConvs = new []{
typeof(CallConvStdcall)}
)]
private static winmdroot.Foundation.HRESULT get_accDescription(IAccessible* pThis, winmdroot.System.Variant.VARIANT varChild, winmdroot.Foundation.BSTR* pszDescription)
{
try
{
winmdroot.Foundation.HRESULT __hr = ComHelpers.UnwrapCCW(pThis, out Interface __object);
if (__hr.Failed)
{
return __hr;
}
return __object.get_accDescription(varChild, pszDescription);
}
catch (Exception ex)
{
return (winmdroot.Foundation.HRESULT)ex.HResult;
}
}
/// <summary>The IAccessible::get_accDescription method retrieves a string that describes the visual appearance of the specified object. Not all objects have a description.</summary>
/// <param name="varChild">
/// <para>Type: <b>VARIANT</b> Specifies whether the retrieved description belongs to the object or one of the object's child elements. This parameter is either CHILDID_SELF (to obtain information about the object) or a child ID (to obtain information about the object's child element). For more information about initializing the <a href="https://docs.microsoft.com/windows/desktop/WinAuto/variant-structure">VARIANT structure</a>, see <a href="https://docs.microsoft.com/windows/desktop/WinAuto/how-child-ids-are-used-in-parameters">How Child IDs Are Used in Parameters</a>.</para>
/// <para><see href="https://learn.microsoft.com/windows/win32/api/oleacc/nf-oleacc-iaccessible-get_accdescription#parameters">Read more on docs.microsoft.com</see>.</para>
/// </param>
/// <param name="pszDescription">
/// <para>Type: <b>BSTR*</b> Address of a <b>BSTR</b> that receives a localized string that describes the specified object, or <b>NULL</b> if this object has no description.</para>
/// <para><see href="https://learn.microsoft.com/windows/win32/api/oleacc/nf-oleacc-iaccessible-get_accdescription#parameters">Read more on docs.microsoft.com</see>.</para>
/// </param>
/// <returns>
/// <para>Type: <b><a href="https://docs.microsoft.com/windows/desktop/WinProg/windows-data-types">HRESULT</a></b> If successful, returns S_OK. If not successful, returns one of the values in the table that follows, or another standard <a href="https://docs.microsoft.com/windows/desktop/WinAuto/return-values">COM error code</a>. Servers return these values, but clients must always check output parameters to ensure that they contain valid values. For more information, see <a href="https://docs.microsoft.com/windows/desktop/WinAuto/checking-iaccessible-return-values">Checking IAccessible Return Values</a>. </para>
/// <para>This doc was truncated.</para>
/// </returns>
/// <remarks>
/// <para>An Microsoft Active Accessibility server can add support for UI Automation by using Direct Annotation, using the <a href="https://docs.microsoft.com/windows/desktop/api/uiautomationcore/nn-uiautomationcore-iaccessibleex">IAccessibleEx</a> interface, or by implementing Microsoft Active Accessibility and UI Automation side-by-side with both implementations handling the [WM_GETOBJECT](/windows/win32/winauto/wm-getobject) message. This property provides a textual equivalent of the object for the user. The description should be similar to the text supplied with the ALT attribute in HTML, which is the text that is displayed to describe images for people using text-only browsers. However, some controls use this property to store extra information about the control that is not related to a textual equivalent. For more information about this property, see <a href="https://docs.microsoft.com/windows/desktop/WinAuto/description-property">Description Property</a>. <b>Note to server developers: </b>Localize the string returned from this property.</para>
/// <para><h3><a id="Server_Example"></a><a id="server_example"></a><a id="SERVER_EXAMPLE"></a>Server Example</h3> The following example code shows one possible implementation of this method for a custom list box that maintains its own child elements. The example demonstrates the syntax, but remember that a real text-only list box would probably not need to support this property. For simplicity, the strings in the example are not localized.</para>
/// <para></para>
/// <para>This doc was truncated.</para>
/// <para><see href="https://learn.microsoft.com/windows/win32/api/oleacc/nf-oleacc-iaccessible-get_accdescription#">Read more on docs.microsoft.com</see>.</para>
/// </remarks>
public unsafe winmdroot.Foundation.HRESULT get_accDescription(winmdroot.System.Variant.VARIANT varChild, winmdroot.Foundation.BSTR* pszDescription)
{
return ((delegate *unmanaged [Stdcall]<IAccessible*,winmdroot.System.Variant.VARIANT ,winmdroot.Foundation.BSTR* ,winmdroot.Foundation.HRESULT>)lpVtbl[12])((IAccessible*)Unsafe.AsPointer(ref this), varChild, pszDescription);
}
/// <inheritdoc cref="get_accRole(winmdroot.System.Variant.VARIANT, winmdroot.System.Variant.VARIANT*)"/>
internal unsafe winmdroot.Foundation.HRESULT get_accRole(winmdroot.System.Variant.VARIANT varChild, out winmdroot.System.Variant.VARIANT pvarRole)
{
fixed (winmdroot.System.Variant.VARIANT* pvarRoleLocal = &pvarRole)
{
winmdroot.Foundation.HRESULT __result = this.get_accRole(varChild, pvarRoleLocal);
return __result;
}
}
[UnmanagedCallersOnly(CallConvs = new []{
typeof(CallConvStdcall)}
)]
private static winmdroot.Foundation.HRESULT get_accRole(IAccessible* pThis, winmdroot.System.Variant.VARIANT varChild, winmdroot.System.Variant.VARIANT* pvarRole)
{
try
{
winmdroot.Foundation.HRESULT __hr = ComHelpers.UnwrapCCW(pThis, out Interface __object);
if (__hr.Failed)
{
return __hr;
}
return __object.get_accRole(varChild, pvarRole);
}
catch (Exception ex)
{
return (winmdroot.Foundation.HRESULT)ex.HResult;
}
}
/// <summary>The IAccessible::get_accRole method retrieves information that describes the role of the specified object. All objects support this property.</summary>
/// <param name="varChild">
/// <para>Type: <b>VARIANT</b> Specifies whether the retrieved role information belongs to the object or one of the object's child elements. This parameter is either CHILDID_SELF (to obtain information about the object) or a child ID (to obtain information about the object's child element). For more information about initializing the <a href="https://docs.microsoft.com/windows/desktop/WinAuto/variant-structure">VARIANT</a>, see <a href="https://docs.microsoft.com/windows/desktop/WinAuto/how-child-ids-are-used-in-parameters">How Child IDs Are Used in Parameters</a>.</para>
/// <para><see href="https://learn.microsoft.com/windows/win32/api/oleacc/nf-oleacc-iaccessible-get_accrole#parameters">Read more on docs.microsoft.com</see>.</para>
/// </param>
/// <param name="pvarRole">
/// <para>Type: <b>VARIANT*</b> Address of a <a href="https://docs.microsoft.com/windows/desktop/WinAuto/variant-structure">VARIANT</a> that receives an <a href="https://docs.microsoft.com/windows/desktop/WinAuto/object-roles">object role</a> constant. The <b>vt</b> member must be VT_I4. The <b>lVal</b> member receives an object role constant.</para>
/// <para><see href="https://learn.microsoft.com/windows/win32/api/oleacc/nf-oleacc-iaccessible-get_accrole#parameters">Read more on docs.microsoft.com</see>.</para>
/// </param>
/// <returns>
/// <para>Type: <b><a href="https://docs.microsoft.com/windows/desktop/WinProg/windows-data-types">HRESULT</a></b> If successful, returns S_OK. If not successful, returns one of the values in the table that follows, or another standard <a href="https://docs.microsoft.com/windows/desktop/WinAuto/return-values">COM error code</a>. Servers return these values, but clients must always check output parameters to ensure that they contain valid values. For more information, see <a href="https://docs.microsoft.com/windows/desktop/WinAuto/checking-iaccessible-return-values">Checking IAccessible Return Values</a>. </para>
/// <para>This doc was truncated.</para>
/// </returns>
/// <remarks>
/// <para>Clients call <a href="https://docs.microsoft.com/windows/desktop/api/oleacc/nf-oleacc-getroletexta">GetRoleText</a> to retrieve a localized string that describes the object's role. <b>Note to server developers: </b>You must use the predefined role constants.</para>
/// <para><h3><a id="Server_Example"></a><a id="server_example"></a><a id="SERVER_EXAMPLE"></a>Server Example</h3> The following example code is a possible implementation of this method for a custom list box that maintains its own list items.</para>
/// <para></para>
/// <para>This doc was truncated.</para>
/// <para><see href="https://learn.microsoft.com/windows/win32/api/oleacc/nf-oleacc-iaccessible-get_accrole#">Read more on docs.microsoft.com</see>.</para>
/// </remarks>
public unsafe winmdroot.Foundation.HRESULT get_accRole(winmdroot.System.Variant.VARIANT varChild, winmdroot.System.Variant.VARIANT* pvarRole)
{
return ((delegate *unmanaged [Stdcall]<IAccessible*,winmdroot.System.Variant.VARIANT ,winmdroot.System.Variant.VARIANT* ,winmdroot.Foundation.HRESULT>)lpVtbl[13])((IAccessible*)Unsafe.AsPointer(ref this), varChild, pvarRole);
}
/// <inheritdoc cref="get_accState(winmdroot.System.Variant.VARIANT, winmdroot.System.Variant.VARIANT*)"/>
internal unsafe winmdroot.Foundation.HRESULT get_accState(winmdroot.System.Variant.VARIANT varChild, out winmdroot.System.Variant.VARIANT pvarState)
{
fixed (winmdroot.System.Variant.VARIANT* pvarStateLocal = &pvarState)
{
winmdroot.Foundation.HRESULT __result = this.get_accState(varChild, pvarStateLocal);
return __result;
}
}
[UnmanagedCallersOnly(CallConvs = new []{
typeof(CallConvStdcall)}
)]
private static winmdroot.Foundation.HRESULT get_accState(IAccessible* pThis, winmdroot.System.Variant.VARIANT varChild, winmdroot.System.Variant.VARIANT* pvarState)
{
try
{
winmdroot.Foundation.HRESULT __hr = ComHelpers.UnwrapCCW(pThis, out Interface __object);
if (__hr.Failed)
{
return __hr;
}
return __object.get_accState(varChild, pvarState);
}
catch (Exception ex)
{
return (winmdroot.Foundation.HRESULT)ex.HResult;
}
}
/// <summary>The IAccessible::get_accState method retrieves the current state of the specified object. All objects support this property.</summary>
/// <param name="varChild">
/// <para>Type: <b>VARIANT</b> Specifies whether the retrieved state information belongs to the object or of one of the object's child elements. This parameter is either CHILDID_SELF (to obtain information about the object) or a child ID (to obtain information about the object's child element). For more information about initializing the <a href="https://docs.microsoft.com/windows/desktop/WinAuto/variant-structure">VARIANT</a>, see <a href="https://docs.microsoft.com/windows/desktop/WinAuto/how-child-ids-are-used-in-parameters">How Child IDs Are Used in Parameters</a>.</para>
/// <para><see href="https://learn.microsoft.com/windows/win32/api/oleacc/nf-oleacc-iaccessible-get_accstate#parameters">Read more on docs.microsoft.com</see>.</para>
/// </param>
/// <param name="pvarState">
/// <para>Type: <b>VARIANT*</b> Address of a <a href="https://docs.microsoft.com/windows/desktop/WinAuto/variant-structure">VARIANT structure</a> that receives information that describes the object's state. The <b>vt</b> member is VT_I4, and the <b>lVal</b> member is one or more of the <a href="https://docs.microsoft.com/windows/desktop/WinAuto/object-state-constants">object state constants</a>.</para>
/// <para><see href="https://learn.microsoft.com/windows/win32/api/oleacc/nf-oleacc-iaccessible-get_accstate#parameters">Read more on docs.microsoft.com</see>.</para>
/// </param>
/// <returns>
/// <para>Type: <b><a href="https://docs.microsoft.com/windows/desktop/WinProg/windows-data-types">HRESULT</a></b> If successful, returns S_OK. If not successful, returns one of the values in the table that follows, or another standard <a href="https://docs.microsoft.com/windows/desktop/WinAuto/return-values">COM error code</a>. Servers return these values, but clients must always check output parameters to ensure that they contain valid values. For more information, see <a href="https://docs.microsoft.com/windows/desktop/WinAuto/checking-iaccessible-return-values">Checking IAccessible Return Values</a>. </para>
/// <para>This doc was truncated.</para>
/// </returns>
/// <remarks>
/// <para>If predefined state values are returned, clients call <a href="https://docs.microsoft.com/windows/desktop/api/oleacc/nf-oleacc-getstatetexta">GetStateText</a> to retrieve a localized string that describes the object's state. The actual state of a child often depends on the state of its ancestors. For example, controls in an application's main window are not focusable when a modal dialog box is open, but the controls may not report this state. To verify the state information of a child object, call <b>get_accState</b> for the parent object. <b>Note to server developers: </b>You must use the predefined state constants.</para>
/// <para><h3><a id="Server_Example"></a><a id="server_example"></a><a id="SERVER_EXAMPLE"></a>Server Example</h3> The following example code shows a possible implementation of this method for a custom list box that maintains its own child elements (list items), only one of which can be selected at a time. If the client requests the state of the list box itself, the method passes the call to the standard accessible object that serves the control window. For child items, different flags are returned depending on whether the item is selected or not.</para>
/// <para></para>
/// <para>This doc was truncated.</para>
/// <para><see href="https://learn.microsoft.com/windows/win32/api/oleacc/nf-oleacc-iaccessible-get_accstate#">Read more on docs.microsoft.com</see>.</para>
/// </remarks>
public unsafe winmdroot.Foundation.HRESULT get_accState(winmdroot.System.Variant.VARIANT varChild, winmdroot.System.Variant.VARIANT* pvarState)
{
return ((delegate *unmanaged [Stdcall]<IAccessible*,winmdroot.System.Variant.VARIANT ,winmdroot.System.Variant.VARIANT* ,winmdroot.Foundation.HRESULT>)lpVtbl[14])((IAccessible*)Unsafe.AsPointer(ref this), varChild, pvarState);
}
[UnmanagedCallersOnly(CallConvs = new []{
typeof(CallConvStdcall)}
)]
private static winmdroot.Foundation.HRESULT get_accHelp(IAccessible* pThis, winmdroot.System.Variant.VARIANT varChild, winmdroot.Foundation.BSTR* pszHelp)
{
try
{
winmdroot.Foundation.HRESULT __hr = ComHelpers.UnwrapCCW(pThis, out Interface __object);
if (__hr.Failed)
{
return __hr;
}
return __object.get_accHelp(varChild, pszHelp);
}
catch (Exception ex)
{
return (winmdroot.Foundation.HRESULT)ex.HResult;
}
}
/// <summary>The IAccessible::get_accHelp method retrieves the Help property string of an object. Not all objects support this property.</summary>
/// <param name="varChild">
/// <para>Type: <b>VARIANT</b> Specifies whether the retrieved help information belongs to the object or one of the object's child elements. This parameter is either CHILDID_SELF (to obtain information about the object) or a child ID (to obtain information about one of the object's child elements). For more information about initializing the <a href="https://docs.microsoft.com/windows/desktop/WinAuto/variant-structure">VARIANT</a>, see <a href="https://docs.microsoft.com/windows/desktop/WinAuto/how-child-ids-are-used-in-parameters">How Child IDs Are Used in Parameters</a>.</para>
/// <para><see href="https://learn.microsoft.com/windows/win32/api/oleacc/nf-oleacc-iaccessible-get_acchelp#parameters">Read more on docs.microsoft.com</see>.</para>
/// </param>
/// <param name="pszHelp">
/// <para>Type: <b>BSTR*</b> Address of a <b>BSTR</b> that receives the localized string containing the help information for the specified object, or <b>NULL</b> if no help information is available.</para>
/// <para><see href="https://learn.microsoft.com/windows/win32/api/oleacc/nf-oleacc-iaccessible-get_acchelp#parameters">Read more on docs.microsoft.com</see>.</para>
/// </param>
/// <returns>
/// <para>Type: <b><a href="https://docs.microsoft.com/windows/desktop/WinProg/windows-data-types">HRESULT</a></b> If successful, returns S_OK. If not successful, returns one of the values in the table that follows, or another standard <a href="https://docs.microsoft.com/windows/desktop/WinAuto/return-values">COM error code</a>. Servers return these values, but clients must always check output parameters to ensure that they contain valid values. For more information, see <a href="https://docs.microsoft.com/windows/desktop/WinAuto/checking-iaccessible-return-values">Checking IAccessible Return Values</a>. </para>
/// <para>This doc was truncated.</para>
/// </returns>
/// <remarks>
/// <para>None of the predefined and common controls support this property. <b>Note to server developers: </b>Localize the string returned from this property. This property returns a string, whereas <a href="https://docs.microsoft.com/windows/desktop/api/oleacc/nf-oleacc-iaccessible-get_acchelptopic">IAccessible::get_accHelpTopic</a> provides access to a Help topic in <a href="https://docs.microsoft.com/windows/win32/api/winuser/nf-winuser-winhelpa">WinHelp</a>. Objects are not required to support both <b>IAccessible::get_accHelp</b> and <b>IAccessible::get_accHelpTopic</b>, but they must support at least one. If they easily return a string, they must support <b>IAccessible::get_accHelp</b> ; otherwise they must support <b>IAccessible::get_accHelpTopic</b>. If both are supported, <b>IAccessible::get_accHelpTopic</b> provides more detailed information. <h3><a id="Server_Example"></a><a id="server_example"></a><a id="SERVER_EXAMPLE"></a>Server Example</h3> The following example code shows one possible implementation of this method for a custom list box. Different text is displayed depending on the status of the contact in the list. For simplicity, the example does not localize the returned string.</para>
/// <para></para>
/// <para>This doc was truncated.</para>
/// <para><see href="https://learn.microsoft.com/windows/win32/api/oleacc/nf-oleacc-iaccessible-get_acchelp#">Read more on docs.microsoft.com</see>.</para>
/// </remarks>
public unsafe winmdroot.Foundation.HRESULT get_accHelp(winmdroot.System.Variant.VARIANT varChild, winmdroot.Foundation.BSTR* pszHelp)
{
return ((delegate *unmanaged [Stdcall]<IAccessible*,winmdroot.System.Variant.VARIANT ,winmdroot.Foundation.BSTR* ,winmdroot.Foundation.HRESULT>)lpVtbl[15])((IAccessible*)Unsafe.AsPointer(ref this), varChild, pszHelp);
}
/// <inheritdoc cref="get_accHelpTopic(winmdroot.Foundation.BSTR*, winmdroot.System.Variant.VARIANT, int*)"/>
internal unsafe winmdroot.Foundation.HRESULT get_accHelpTopic(winmdroot.Foundation.BSTR* pszHelpFile, winmdroot.System.Variant.VARIANT varChild, out int pidTopic)
{
fixed (int* pidTopicLocal = &pidTopic)
{
winmdroot.Foundation.HRESULT __result = this.get_accHelpTopic(pszHelpFile, varChild, pidTopicLocal);
return __result;
}
}
[UnmanagedCallersOnly(CallConvs = new []{
typeof(CallConvStdcall)}
)]
private static winmdroot.Foundation.HRESULT get_accHelpTopic(IAccessible* pThis, winmdroot.Foundation.BSTR* pszHelpFile, winmdroot.System.Variant.VARIANT varChild, int* pidTopic)
{
try
{
winmdroot.Foundation.HRESULT __hr = ComHelpers.UnwrapCCW(pThis, out Interface __object);
if (__hr.Failed)
{
return __hr;
}
return __object.get_accHelpTopic(pszHelpFile, varChild, pidTopic);
}
catch (Exception ex)
{
return (winmdroot.Foundation.HRESULT)ex.HResult;
}
}
/// <summary>The IAccessible::get_accHelpTopic method retrieves the full path of the WinHelp file that is associated with the specified object; it also retrieves the identifier of the appropriate topic within that file.</summary>
/// <param name="pszHelpFile">
/// <para>Type: <b>BSTR*</b> Address of a <b>BSTR</b> that receives the full path of the WinHelp file that is associated with the specified object.</para>
/// <para><see href="https://learn.microsoft.com/windows/win32/api/oleacc/nf-oleacc-iaccessible-get_acchelptopic#parameters">Read more on docs.microsoft.com</see>.</para>
/// </param>
/// <param name="varChild">
/// <para>Type: <b>VARIANT</b> Specifies whether the retrieved Help topic belongs to the object or one of the object's child elements. This parameter is either CHILDID_SELF (to obtain a Help topic for the object) or a child ID (to obtain a Help topic for one of the object's child elements). For more information about initializing the <a href="https://docs.microsoft.com/windows/desktop/WinAuto/variant-structure">VARIANT</a>, see <a href="https://docs.microsoft.com/windows/desktop/WinAuto/how-child-ids-are-used-in-parameters">How Child IDs Are Used in Parameters</a>.</para>
/// <para><see href="https://learn.microsoft.com/windows/win32/api/oleacc/nf-oleacc-iaccessible-get_acchelptopic#parameters">Read more on docs.microsoft.com</see>.</para>
/// </param>
/// <param name="pidTopic">
/// <para>Type: <b>long*</b> [out, retval] Address of a variable that identifies the Help file topic associated with the specified object. This value is used as the context identifier of the desired topic that passes to the <a href="https://docs.microsoft.com/windows/win32/api/winuser/nf-winuser-winhelpa">WinHelp</a> function. When calling <a href="https://docs.microsoft.com/windows/win32/api/winuser/nf-winuser-winhelpa">WinHelp</a> to display the topic, set the <i>uCommand</i> parameter to HELP_CONTEXT, cast the value pointed to by <i>pidTopic</i> to a <b>DWORD</b>, and pass it as the <i>dwData</i> parameter.</para>
/// <para><see href="https://learn.microsoft.com/windows/win32/api/oleacc/nf-oleacc-iaccessible-get_acchelptopic#parameters">Read more on docs.microsoft.com</see>.</para>
/// </param>
/// <returns>
/// <para>Type: <b><a href="https://docs.microsoft.com/windows/desktop/WinProg/windows-data-types">HRESULT</a></b> If successful, returns S_OK. If not successful, returns one of the values in the table that follows, or another standard <a href="https://docs.microsoft.com/windows/desktop/WinAuto/return-values">COM error code</a>. Servers return these values, but clients must always check output parameters to ensure that they contain valid values. For more information, see <a href="https://docs.microsoft.com/windows/desktop/WinAuto/checking-iaccessible-return-values">Checking IAccessible Return Values</a>. </para>
/// <para>This doc was truncated.</para>
/// </returns>
/// <remarks>
/// <para>Getting information from a Help file might be time and memory intensive. <b>Note to server developers: </b>This property provides access to a Help topic in WinHelp, whereas <a href="https://docs.microsoft.com/windows/desktop/api/oleacc/nf-oleacc-iaccessible-get_acchelp">IAccessible::get_accHelp</a> returns a string. Objects are not required to support both <b>IAccessible::get_accHelp</b> and <b>IAccessible::get_accHelpTopic</b>, but they must support at least one. If they can easily return a string, they must support <b>IAccessible::get_accHelp</b>; otherwise they must support <b>IAccessible::get_accHelpTopic</b>. If both are supported, <b>IAccessible::get_accHelpTopic</b> provides more detailed information.</para>
/// <para><see href="https://learn.microsoft.com/windows/win32/api/oleacc/nf-oleacc-iaccessible-get_acchelptopic#">Read more on docs.microsoft.com</see>.</para>
/// </remarks>
public unsafe winmdroot.Foundation.HRESULT get_accHelpTopic(winmdroot.Foundation.BSTR* pszHelpFile, winmdroot.System.Variant.VARIANT varChild, int* pidTopic)
{
return ((delegate *unmanaged [Stdcall]<IAccessible*,winmdroot.Foundation.BSTR* ,winmdroot.System.Variant.VARIANT ,int* ,winmdroot.Foundation.HRESULT>)lpVtbl[16])((IAccessible*)Unsafe.AsPointer(ref this), pszHelpFile, varChild, pidTopic);
}
[UnmanagedCallersOnly(CallConvs = new []{
typeof(CallConvStdcall)}
)]
private static winmdroot.Foundation.HRESULT get_accKeyboardShortcut(IAccessible* pThis, winmdroot.System.Variant.VARIANT varChild, winmdroot.Foundation.BSTR* pszKeyboardShortcut)
{
try
{
winmdroot.Foundation.HRESULT __hr = ComHelpers.UnwrapCCW(pThis, out Interface __object);
if (__hr.Failed)
{
return __hr;
}
return __object.get_accKeyboardShortcut(varChild, pszKeyboardShortcut);
}
catch (Exception ex)
{
return (winmdroot.Foundation.HRESULT)ex.HResult;
}
}
/// <summary>The IAccessible::get_accKeyboardShortcut method retrieves the specified object's shortcut key or access key, also known as the mnemonic. All objects that have a shortcut key or an access key support this property.</summary>
/// <param name="varChild">
/// <para>Type: <b>VARIANT</b> Specifies whether the retrieved keyboard shortcut belongs to the object or one of the object's child elements. This parameter is either CHILDID_SELF (to obtain information about the object) or a child ID (to obtain information about the object's child element). For more information about initializing the <a href="https://docs.microsoft.com/windows/desktop/WinAuto/variant-structure">VARIANT</a>, see <a href="https://docs.microsoft.com/windows/desktop/WinAuto/how-child-ids-are-used-in-parameters">How Child IDs Are Used in Parameters</a>.</para>
/// <para><see href="https://learn.microsoft.com/windows/win32/api/oleacc/nf-oleacc-iaccessible-get_acckeyboardshortcut#parameters">Read more on docs.microsoft.com</see>.</para>
/// </param>
/// <param name="pszKeyboardShortcut">
/// <para>Type: <b>BSTR*</b> Address of a <b>BSTR</b> that receives a localized string that identifies the keyboard shortcut, or <b>NULL</b> if no keyboard shortcut is associated with the specified object.</para>
/// <para><see href="https://learn.microsoft.com/windows/win32/api/oleacc/nf-oleacc-iaccessible-get_acckeyboardshortcut#parameters">Read more on docs.microsoft.com</see>.</para>
/// </param>
/// <returns>
/// <para>Type: <b><a href="https://docs.microsoft.com/windows/desktop/WinProg/windows-data-types">HRESULT</a></b> If successful, returns S_OK. If not successful, returns one of the values in the table that follows, or another standard <a href="https://docs.microsoft.com/windows/desktop/WinAuto/return-values">COM error code</a>. Servers return these values, but clients must always check output parameters to ensure that they contain valid values. For more information, see <a href="https://docs.microsoft.com/windows/desktop/WinAuto/checking-iaccessible-return-values">Checking IAccessible Return Values</a>. </para>
/// <para>This doc was truncated.</para>
/// </returns>
/// <remarks>
/// <para>An access key is an underlined character in the text of a menu, menu item, or label of a button or some other control. For example, a user can display a menu by pressing the ALT key while also pressing the indicated underlined key, such as ALT+F to open the <u>F</u>ile menu. To use the access key of a menu item, the menu that contains the item must be active. Controls such as toolbar buttons and menu items often have an associated shortcut key, also known as a keyboard accelerator. Some menu items may have both an access key and a shortcut key, and some may have only one. For example, a menu item called <u>N</u>ew has an access key N and a shortcut key CTRL+N. The menu does not have to be active for the shortcut key to work. <b>Note to client developers: </b><p class="note">If this property returns a single character, you cannot assume it is an access key or a keyboard shortcut. With standard menu items, the access key is returned by <b>IAccessible::get_accKeyboardShortcut</b>, and the shortcut key is returned as part of the menu item name returned from <a href="https://docs.microsoft.com/windows/desktop/api/oleacc/nf-oleacc-iaccessible-get_accname">IAccessible::get_accName</a>. In general, access keys tend to be defined as ALT + <letter>, and keyboard shortcuts tend to be CTRL + <letter>.</para>
/// <para><b>Note to server developers: </b>If the UI element can receive keyboard focus, then you should expose the access key for the element. If the UI element cannot receive keyboard focus (such as toolbar icons), then you should display the shortcut key. Because shortcut keys are usually determined by the application rather than by the control itself, servers can usually return the value obtained from the standard accessible object for the window.</para>
/// <para><h3><a id="Client_Example"></a><a id="client_example"></a><a id="CLIENT_EXAMPLE"></a>Client Example</h3> The following example function retrieves the keyboard shortcut for the specified accessible object, or one of its children, and prints it to the console.</para>
/// <para></para>
/// <para>This doc was truncated.</para>
/// <para><see href="https://learn.microsoft.com/windows/win32/api/oleacc/nf-oleacc-iaccessible-get_acckeyboardshortcut#">Read more on docs.microsoft.com</see>.</para>
/// </remarks>
public unsafe winmdroot.Foundation.HRESULT get_accKeyboardShortcut(winmdroot.System.Variant.VARIANT varChild, winmdroot.Foundation.BSTR* pszKeyboardShortcut)
{
return ((delegate *unmanaged [Stdcall]<IAccessible*,winmdroot.System.Variant.VARIANT ,winmdroot.Foundation.BSTR* ,winmdroot.Foundation.HRESULT>)lpVtbl[17])((IAccessible*)Unsafe.AsPointer(ref this), varChild, pszKeyboardShortcut);
}
/// <inheritdoc cref="get_accFocus(winmdroot.System.Variant.VARIANT*)"/>
internal unsafe winmdroot.Foundation.HRESULT get_accFocus(out winmdroot.System.Variant.VARIANT pvarChild)
{
fixed (winmdroot.System.Variant.VARIANT* pvarChildLocal = &pvarChild)
{
winmdroot.Foundation.HRESULT __result = this.get_accFocus(pvarChildLocal);
return __result;
}
}
[UnmanagedCallersOnly(CallConvs = new []{
typeof(CallConvStdcall)}
)]
private static winmdroot.Foundation.HRESULT get_accFocus(IAccessible* pThis, winmdroot.System.Variant.VARIANT* pvarChild)
{
try
{
winmdroot.Foundation.HRESULT __hr = ComHelpers.UnwrapCCW(pThis, out Interface __object);
if (__hr.Failed)
{
return __hr;
}
return __object.get_accFocus(pvarChild);
}
catch (Exception ex)
{
return (winmdroot.Foundation.HRESULT)ex.HResult;
}
}
/// <summary>The IAccessible::get_accFocus method retrieves the object that has the keyboard focus. All objects that may receive the keyboard focus must support this property.</summary>
/// <param name="pvarChild">
/// <para>Type: <b>VARIANT*</b> Address of a <a href="https://docs.microsoft.com/windows/desktop/WinAuto/variant-structure">VARIANT structure</a> that receives information about the object that has the focus. The following table describes the information returned in <i>pvarID</i>. </para>
/// <para>This doc was truncated.</para>
/// <para><see href="https://learn.microsoft.com/windows/win32/api/oleacc/nf-oleacc-iaccessible-get_accfocus#parameters">Read more on docs.microsoft.com</see>.</para>
/// </param>
/// <returns>
/// <para>Type: <b><a href="https://docs.microsoft.com/windows/desktop/WinProg/windows-data-types">HRESULT</a></b> If successful, returns S_OK. If not successful, returns one of the values in the table that follows, or another standard <a href="https://docs.microsoft.com/windows/desktop/WinAuto/return-values">COM error code</a>. Servers return these values, but clients must always check output parameters to ensure that they contain valid values. For more information, see <a href="https://docs.microsoft.com/windows/desktop/WinAuto/checking-iaccessible-return-values">Checking IAccessible Return Values</a>. </para>
/// <para>This doc was truncated.</para>
/// </returns>
/// <remarks>
/// <para>The concept of keyboard focus is related to that of an active window. An active window is the foreground window on which the user works. The object with the keyboard focus is either the active window or a child object of the active window. Only one object or item within a container has the focus at any one time. The object with the keyboard focus is not always the selected object. For more information about the difference between selection and focus, see <a href="https://docs.microsoft.com/windows/desktop/WinAuto/selection-and-focus-properties-and-methods">Selection and Focus Properties and Methods</a>. This method returns either an <a href="https://docs.microsoft.com/windows/desktop/WinAuto/idispatch-interface">IDispatch</a> interface pointer or a child ID for the <i>pvarID</i>. For more information about how to use the <b>IDispatch</b> interface pointer or child ID, see <a href="https://docs.microsoft.com/windows/desktop/WinAuto/how-child-ids-are-used-in-parameters">How Child IDs Are Used in Parameters</a>. As with other <a href="https://docs.microsoft.com/windows/desktop/api/oleacc/nn-oleacc-iaccessible">IAccessible</a> methods and functions, clients might receive errors for <b>IAccessible</b> interface pointers because of a user action. For more information, see <a href="https://docs.microsoft.com/windows/desktop/WinAuto/receiving-errors-for-iaccessible-interface-pointers">Receiving Errors for IAccessible Interface Pointers</a>. <h3><a id="Server_Example"></a><a id="server_example"></a><a id="SERVER_EXAMPLE"></a>Server Example</h3> The following example code shows a possible implementation of this method for a custom single-selection list box. If the control does not have the focus, VT_EMPTY is returned in the variant by the standard accessible object for the HWND. If the control does have the focus, and an item is selected, the child ID of that item is returned; if there is no selection, CHILDID_SELF is returned.</para>
/// <para></para>
/// <para>This doc was truncated.</para>
/// <para><see href="https://learn.microsoft.com/windows/win32/api/oleacc/nf-oleacc-iaccessible-get_accfocus#">Read more on docs.microsoft.com</see>.</para>
/// </remarks>
public unsafe winmdroot.Foundation.HRESULT get_accFocus(winmdroot.System.Variant.VARIANT* pvarChild)
{
return ((delegate *unmanaged [Stdcall]<IAccessible*,winmdroot.System.Variant.VARIANT* ,winmdroot.Foundation.HRESULT>)lpVtbl[18])((IAccessible*)Unsafe.AsPointer(ref this), pvarChild);
}
/// <inheritdoc cref="get_accSelection(winmdroot.System.Variant.VARIANT*)"/>
internal unsafe winmdroot.Foundation.HRESULT get_accSelection(out winmdroot.System.Variant.VARIANT pvarChildren)
{
fixed (winmdroot.System.Variant.VARIANT* pvarChildrenLocal = &pvarChildren)
{
winmdroot.Foundation.HRESULT __result = this.get_accSelection(pvarChildrenLocal);
return __result;
}
}
[UnmanagedCallersOnly(CallConvs = new []{
typeof(CallConvStdcall)}
)]
private static winmdroot.Foundation.HRESULT get_accSelection(IAccessible* pThis, winmdroot.System.Variant.VARIANT* pvarChildren)
{
try
{
winmdroot.Foundation.HRESULT __hr = ComHelpers.UnwrapCCW(pThis, out Interface __object);
if (__hr.Failed)
{
return __hr;
}
return __object.get_accSelection(pvarChildren);
}
catch (Exception ex)
{
return (winmdroot.Foundation.HRESULT)ex.HResult;
}
}
/// <summary>The IAccessible::get_accSelection method retrieves the selected children of this object. All objects that support selection must support this property.</summary>
/// <param name="pvarChildren">
/// <para>Type: <b>VARIANT*</b> Address of a <a href="https://docs.microsoft.com/windows/desktop/WinAuto/variant-structure">VARIANT structure</a> that receives information about which children are selected. The following table describes the information returned in <i>pvarChildren</i>. </para>
/// <para>This doc was truncated.</para>
/// <para><see href="https://learn.microsoft.com/windows/win32/api/oleacc/nf-oleacc-iaccessible-get_accselection#parameters">Read more on docs.microsoft.com</see>.</para>
/// </param>
/// <returns>
/// <para>Type: <b><a href="https://docs.microsoft.com/windows/desktop/WinProg/windows-data-types">HRESULT</a></b> If successful, returns S_OK. If not successful, returns one of the values in the table that follows, or another standard <a href="https://docs.microsoft.com/windows/desktop/WinAuto/return-values">COM error code</a>. Servers return these values, but clients must always check output parameters to ensure that they contain valid values. For more information, see <a href="https://docs.microsoft.com/windows/desktop/WinAuto/checking-iaccessible-return-values">Checking IAccessible Return Values</a>. </para>
/// <para>This doc was truncated.</para>
/// </returns>
/// <remarks>
/// <para>This method must support the <a href="https://docs.microsoft.com/windows/win32/api/oaidl/nn-oaidl-ienumvariant">IEnumVARIANT</a> interface. This method returns either an <a href="https://docs.microsoft.com/windows/desktop/WinAuto/idispatch-interface">IDispatch</a> interface pointer or a child ID for the <i>pvarChildren</i> parameter. For more information about how to use the <b>IDispatch</b> interface pointer or child ID, see <a href="https://docs.microsoft.com/windows/desktop/WinAuto/how-child-ids-are-used-in-parameters">How Child IDs Are Used in Parameters</a>. As with other <a href="https://docs.microsoft.com/windows/desktop/api/oleacc/nn-oleacc-iaccessible">IAccessible</a> methods and functions, clients might receive errors for <b>IAccessible</b> interface pointers because of a user action. For more information, see <a href="https://docs.microsoft.com/windows/desktop/WinAuto/receiving-errors-for-iaccessible-interface-pointers">Receiving Errors for IAccessible Interface Pointers</a>. <b>Note: </b>This method retrieves a selected item, not selected text.</para>
/// <para><h3><a id="Server_Example"></a><a id="server_example"></a><a id="SERVER_EXAMPLE"></a>Server Example</h3> The following example code shows a possible implementation of this method for a custom single-selection list box. Its <b>GetSelectedIndex</b> method returns -1 if no item is selected.</para>
/// <para></para>
/// <para>This doc was truncated.</para>
/// <para><see href="https://learn.microsoft.com/windows/win32/api/oleacc/nf-oleacc-iaccessible-get_accselection#">Read more on docs.microsoft.com</see>.</para>
/// </remarks>
public unsafe winmdroot.Foundation.HRESULT get_accSelection(winmdroot.System.Variant.VARIANT* pvarChildren)
{
return ((delegate *unmanaged [Stdcall]<IAccessible*,winmdroot.System.Variant.VARIANT* ,winmdroot.Foundation.HRESULT>)lpVtbl[19])((IAccessible*)Unsafe.AsPointer(ref this), pvarChildren);
}
[UnmanagedCallersOnly(CallConvs = new []{
typeof(CallConvStdcall)}
)]
private static winmdroot.Foundation.HRESULT get_accDefaultAction(IAccessible* pThis, winmdroot.System.Variant.VARIANT varChild, winmdroot.Foundation.BSTR* pszDefaultAction)
{
try
{
winmdroot.Foundation.HRESULT __hr = ComHelpers.UnwrapCCW(pThis, out Interface __object);
if (__hr.Failed)
{
return __hr;
}
return __object.get_accDefaultAction(varChild, pszDefaultAction);
}
catch (Exception ex)
{
return (winmdroot.Foundation.HRESULT)ex.HResult;
}
}
/// <summary>The IAccessible::get_accDefaultAction method retrieves a string that indicates the object's default action. Not all objects have a default action.</summary>
/// <param name="varChild">
/// <para>Type: <b>VARIANT</b> Specifies whether the retrieved default action is performed by the object or of one of the object's child elements. This parameter is either CHILDID_SELF (to obtain information about the object) or a child ID (to obtain information about the object's child element). For more information about initializing the <a href="https://docs.microsoft.com/windows/desktop/WinAuto/variant-structure">VARIANT structure</a>, see <a href="https://docs.microsoft.com/windows/desktop/WinAuto/how-child-ids-are-used-in-parameters">How Child IDs Are Used in Parameters</a>.</para>
/// <para><see href="https://learn.microsoft.com/windows/win32/api/oleacc/nf-oleacc-iaccessible-get_accdefaultaction#parameters">Read more on docs.microsoft.com</see>.</para>
/// </param>
/// <param name="pszDefaultAction">
/// <para>Type: <b>BSTR*</b> Address of a <b>BSTR</b> that receives a localized string that describes the default action for the specified object; if this object has no default action, the value is <b>NULL</b>.</para>
/// <para><see href="https://learn.microsoft.com/windows/win32/api/oleacc/nf-oleacc-iaccessible-get_accdefaultaction#parameters">Read more on docs.microsoft.com</see>.</para>
/// </param>
/// <returns>
/// <para>Type: <b><a href="https://docs.microsoft.com/windows/desktop/WinProg/windows-data-types">HRESULT</a></b> If successful, returns S_OK. If not successful, returns one of the values in the table that follows, or another standard <a href="https://docs.microsoft.com/windows/desktop/WinAuto/return-values">COM error code</a>. Servers return these values, but clients must always check output parameters to ensure that they contain valid values. For more information, see <a href="https://docs.microsoft.com/windows/desktop/WinAuto/checking-iaccessible-return-values">Checking IAccessible Return Values</a>. </para>
/// <para>This doc was truncated.</para>
/// </returns>
/// <remarks>
/// <para>The retrieved string describes the action that is performed on an object, not what the object does as a result. For example, a toolbar button that prints a document has a default action of "Press" rather than "Prints the current document." Do not confuse an object's default action with its value. For more information, see <a href="https://docs.microsoft.com/windows/desktop/WinAuto/defaultaction-property">DefaultAction Property</a>. Only controls that perform actions support this method. <b>Note to server developers: </b>Localize the string returned from this property.</para>
/// <para><h3><a id="Server_Example"></a><a id="server_example"></a><a id="SERVER_EXAMPLE"></a>Server Example</h3> The following example code shows a possible implementation of this method for a custom list box. For simplicity, the strings are not localized.</para>
/// <para></para>
/// <para>This doc was truncated.</para>
/// <para><see href="https://learn.microsoft.com/windows/win32/api/oleacc/nf-oleacc-iaccessible-get_accdefaultaction#">Read more on docs.microsoft.com</see>.</para>
/// </remarks>
public unsafe winmdroot.Foundation.HRESULT get_accDefaultAction(winmdroot.System.Variant.VARIANT varChild, winmdroot.Foundation.BSTR* pszDefaultAction)
{
return ((delegate *unmanaged [Stdcall]<IAccessible*,winmdroot.System.Variant.VARIANT ,winmdroot.Foundation.BSTR* ,winmdroot.Foundation.HRESULT>)lpVtbl[20])((IAccessible*)Unsafe.AsPointer(ref this), varChild, pszDefaultAction);
}
[UnmanagedCallersOnly(CallConvs = new []{
typeof(CallConvStdcall)}
)]
private static winmdroot.Foundation.HRESULT accSelect(IAccessible* pThis, int flagsSelect, winmdroot.System.Variant.VARIANT varChild)
{
try
{
winmdroot.Foundation.HRESULT __hr = ComHelpers.UnwrapCCW(pThis, out Interface __object);
if (__hr.Failed)
{
return __hr;
}
return __object.accSelect(flagsSelect, varChild);
}
catch (Exception ex)
{
return (winmdroot.Foundation.HRESULT)ex.HResult;
}
}
/// <summary>The IAccessible::accSelect method modifies the selection or moves the keyboard focus of the specified object. All objects that support selection or receive the keyboard focus must support this method.</summary>
/// <param name="flagsSelect">
/// <para>Type: <b>long</b> Specifies which selection or focus operations are to be performed. This parameter must have a combination of the <a href="https://docs.microsoft.com/windows/desktop/WinAuto/selflag">SELFLAG Constants</a>.</para>
/// <para><see href="https://learn.microsoft.com/windows/win32/api/oleacc/nf-oleacc-iaccessible-accselect#parameters">Read more on docs.microsoft.com</see>.</para>
/// </param>
/// <param name="varChild">
/// <para>Type: <b>VARIANT</b> Specifies the selected object. If the value is CHILDID_SELF, the object itself is selected; if a child ID, one of the object's child elements is selected. For more information about initializing the <a href="https://docs.microsoft.com/windows/desktop/WinAuto/variant-structure">VARIANT structure</a>, see <a href="https://docs.microsoft.com/windows/desktop/WinAuto/how-child-ids-are-used-in-parameters">How Child IDs Are Used in Parameters</a>.</para>
/// <para><see href="https://learn.microsoft.com/windows/win32/api/oleacc/nf-oleacc-iaccessible-accselect#parameters">Read more on docs.microsoft.com</see>.</para>
/// </param>
/// <returns>
/// <para>Type: <b><a href="https://docs.microsoft.com/windows/desktop/WinProg/windows-data-types">HRESULT</a></b> If successful, returns S_OK. If not successful, returns one of the values in the table that follows, or another standard <a href="https://docs.microsoft.com/windows/desktop/WinAuto/return-values">COM error code</a>. </para>
/// <para>This doc was truncated.</para>
/// </returns>
/// <remarks>
/// <para>Client applications use this method to perform complex selection operations. For more information, see <a href="https://docs.microsoft.com/windows/desktop/WinAuto/selecting-child-objects">Selecting Child Objects</a>. This method provides the simplest way to programmatically switch the input focus between applications. This applies to applications running on Windows 2000. <b>Note: </b>This method is for the selection of items, not text.</para>
/// <para><h3><a id="Client_Example"></a><a id="client_example"></a><a id="CLIENT_EXAMPLE"></a>Client Example</h3> The following example function selects the item at a specified point on the screen. It is assumed that a single selection is wanted.</para>
/// <para></para>
/// <para>This doc was truncated.</para>
/// <para><see href="https://learn.microsoft.com/windows/win32/api/oleacc/nf-oleacc-iaccessible-accselect#">Read more on docs.microsoft.com</see>.</para>
/// </remarks>
public winmdroot.Foundation.HRESULT accSelect(int flagsSelect, winmdroot.System.Variant.VARIANT varChild)
{
return ((delegate *unmanaged [Stdcall]<IAccessible*,int ,winmdroot.System.Variant.VARIANT ,winmdroot.Foundation.HRESULT>)lpVtbl[21])((IAccessible*)Unsafe.AsPointer(ref this), flagsSelect, varChild);
}
/// <inheritdoc cref="accLocation(int*, int*, int*, int*, winmdroot.System.Variant.VARIANT)"/>
internal unsafe winmdroot.Foundation.HRESULT accLocation(out int pxLeft, out int pyTop, out int pcxWidth, out int pcyHeight, winmdroot.System.Variant.VARIANT varChild)
{
fixed (int* pcyHeightLocal = &pcyHeight)
{
fixed (int* pcxWidthLocal = &pcxWidth)
{
fixed (int* pyTopLocal = &pyTop)
{
fixed (int* pxLeftLocal = &pxLeft)
{
winmdroot.Foundation.HRESULT __result = this.accLocation(pxLeftLocal, pyTopLocal, pcxWidthLocal, pcyHeightLocal, varChild);
return __result;
}
}
}
}
}
[UnmanagedCallersOnly(CallConvs = new []{
typeof(CallConvStdcall)}
)]
private static winmdroot.Foundation.HRESULT accLocation(IAccessible* pThis, int* pxLeft, int* pyTop, int* pcxWidth, int* pcyHeight, winmdroot.System.Variant.VARIANT varChild)
{
try
{
winmdroot.Foundation.HRESULT __hr = ComHelpers.UnwrapCCW(pThis, out Interface __object);
if (__hr.Failed)
{
return __hr;
}
return __object.accLocation(pxLeft, pyTop, pcxWidth, pcyHeight, varChild);
}
catch (Exception ex)
{
return (winmdroot.Foundation.HRESULT)ex.HResult;
}
}
/// <summary>The IAccessible::accLocation method retrieves the specified object's current screen location. All visual objects must support this method. Sound objects do not support this method.</summary>
/// <param name="pxLeft">
/// <para>Type: <b>long*</b> Address, in physical screen coordinates, of the variable that receives the x-coordinate of the upper-left boundary of the object's location.</para>
/// <para><see href="https://learn.microsoft.com/windows/win32/api/oleacc/nf-oleacc-iaccessible-acclocation#parameters">Read more on docs.microsoft.com</see>.</para>
/// </param>
/// <param name="pyTop">
/// <para>Type: <b>long*</b> Address, in physical screen coordinates, of the variable that receives the y-coordinate of the upper-left boundary of the object's location.</para>
/// <para><see href="https://learn.microsoft.com/windows/win32/api/oleacc/nf-oleacc-iaccessible-acclocation#parameters">Read more on docs.microsoft.com</see>.</para>
/// </param>
/// <param name="pcxWidth">
/// <para>Type: <b>long*</b> Address, in pixels, of the variable that receives the object's width.</para>
/// <para><see href="https://learn.microsoft.com/windows/win32/api/oleacc/nf-oleacc-iaccessible-acclocation#parameters">Read more on docs.microsoft.com</see>.</para>
/// </param>
/// <param name="pcyHeight">
/// <para>Type: <b>long*</b> Address, in pixels, of the variable that receives the object's height.</para>
/// <para><see href="https://learn.microsoft.com/windows/win32/api/oleacc/nf-oleacc-iaccessible-acclocation#parameters">Read more on docs.microsoft.com</see>.</para>
/// </param>
/// <param name="varChild">
/// <para>Type: <b>VARIANT</b> Specifies whether the location that the server returns should be that of the object or that of one of the object's child elements. This parameter is either CHILDID_SELF (to obtain information about the object) or a child ID (to obtain information about the object's child element). For more information about initializing the <a href="https://docs.microsoft.com/windows/desktop/WinAuto/variant-structure">VARIANT structure</a>, see <a href="https://docs.microsoft.com/windows/desktop/WinAuto/how-child-ids-are-used-in-parameters">How Child IDs Are Used in Parameters</a>.</para>
/// <para><see href="https://learn.microsoft.com/windows/win32/api/oleacc/nf-oleacc-iaccessible-acclocation#parameters">Read more on docs.microsoft.com</see>.</para>
/// </param>
/// <returns>
/// <para>Type: <b><a href="https://docs.microsoft.com/windows/desktop/WinProg/windows-data-types">HRESULT</a></b> If successful, returns S_OK. Clients must always check that output parameters contain valid values. If not successful, returns one of the values in the table that follows, or another standard <a href="https://docs.microsoft.com/windows/desktop/WinAuto/return-values">COM error code</a>. For more information, see <a href="https://docs.microsoft.com/windows/desktop/WinAuto/checking-iaccessible-return-values">Checking IAccessible Return Values</a>. </para>
/// <para>This doc was truncated.</para>
/// </returns>
/// <remarks>
/// <para>This method retrieves the object's bounding rectangle. If the object has a non-rectangular shape, then this method returns the smallest rectangle that completely encompasses the entire object region. For non-rectangular objects, the coordinates of the object's bounding rectangle could fail if tested with <a href="https://docs.microsoft.com/windows/desktop/api/oleacc/nf-oleacc-iaccessible-acchittest">IAccessible::accHitTest</a>. Examples of such non-rectangular objects are list view items in large-icon mode where a single item has a rectangle for the icon and another rectangle for the text of the icon. Because <b>accLocation</b> returns a bounding rectangle, not all points in that rectangle will be within the actual bounds of the object. Some points within the bounding rectangle may not be on the object. For more information, see <a href="https://docs.microsoft.com/windows/desktop/WinAuto/navigation-through-hit-testing-and-screen-location">Navigation Through Hit Testing and Screen Location</a>. <b>Note: </b>This method returns width and height. If you want the right and bottom coordinates, calculate them using right = left + width, and bottom = top + height.</para>
/// <para><h3><a id="Server_Example"></a><a id="server_example"></a><a id="SERVER_EXAMPLE"></a>Server Example</h3> The following example shows a possible implementation of the method for a custom list box whose list items are child elements. For the list box itself, the call is passed to the standard accessible object, which returns the screen coordinates of the window.</para>
/// <para></para>
/// <para>This doc was truncated.</para>
/// <para><see href="https://learn.microsoft.com/windows/win32/api/oleacc/nf-oleacc-iaccessible-acclocation#">Read more on docs.microsoft.com</see>.</para>
/// </remarks>
public unsafe winmdroot.Foundation.HRESULT accLocation(int* pxLeft, int* pyTop, int* pcxWidth, int* pcyHeight, winmdroot.System.Variant.VARIANT varChild)
{
return ((delegate *unmanaged [Stdcall]<IAccessible*,int* ,int* ,int* ,int* ,winmdroot.System.Variant.VARIANT ,winmdroot.Foundation.HRESULT>)lpVtbl[22])((IAccessible*)Unsafe.AsPointer(ref this), pxLeft, pyTop, pcxWidth, pcyHeight, varChild);
}
/// <inheritdoc cref="accNavigate(int, winmdroot.System.Variant.VARIANT, winmdroot.System.Variant.VARIANT*)"/>
internal unsafe winmdroot.Foundation.HRESULT accNavigate(int navDir, winmdroot.System.Variant.VARIANT varStart, out winmdroot.System.Variant.VARIANT pvarEndUpAt)
{
fixed (winmdroot.System.Variant.VARIANT* pvarEndUpAtLocal = &pvarEndUpAt)
{
winmdroot.Foundation.HRESULT __result = this.accNavigate(navDir, varStart, pvarEndUpAtLocal);
return __result;
}
}
[UnmanagedCallersOnly(CallConvs = new []{
typeof(CallConvStdcall)}
)]
private static winmdroot.Foundation.HRESULT accNavigate(IAccessible* pThis, int navDir, winmdroot.System.Variant.VARIANT varStart, winmdroot.System.Variant.VARIANT* pvarEndUpAt)
{
try
{
winmdroot.Foundation.HRESULT __hr = ComHelpers.UnwrapCCW(pThis, out Interface __object);
if (__hr.Failed)
{
return __hr;
}
return __object.accNavigate(navDir, varStart, pvarEndUpAt);
}
catch (Exception ex)
{
return (winmdroot.Foundation.HRESULT)ex.HResult;
}
}
/// <summary>The IAccessible::accNavigate method traverses to another UI element within a container and retrieves the object. This method is optional.</summary>
/// <param name="navDir">
/// <para>Type: <b>long</b> Specifies the direction to navigate. This direction is in <i>spatial</i> order, such as left or right, or <i>logical</i> order, such as next or previous. This value is one of the <a href="https://docs.microsoft.com/windows/desktop/WinAuto/navigation-constants">navigation constants</a>.</para>
/// <para><see href="https://learn.microsoft.com/windows/win32/api/oleacc/nf-oleacc-iaccessible-accnavigate#parameters">Read more on docs.microsoft.com</see>.</para>
/// </param>
/// <param name="varStart">
/// <para>Type: <b>VARIANT</b> Specifies whether the starting object of the navigation is the object itself or one of the object's children. This parameter is either CHILDID_SELF (to start from the object) or a child ID (to start from one of the object's child elements). For more information about initializing the <a href="https://docs.microsoft.com/windows/desktop/WinAuto/variant-structure">VARIANT</a>, see <a href="https://docs.microsoft.com/windows/desktop/WinAuto/how-child-ids-are-used-in-parameters">How Child IDs Are Used in Parameters</a>.</para>
/// <para><see href="https://learn.microsoft.com/windows/win32/api/oleacc/nf-oleacc-iaccessible-accnavigate#parameters">Read more on docs.microsoft.com</see>.</para>
/// </param>
/// <param name="pvarEndUpAt">
/// <para>Type: <b>VARIANT*</b> [out, retval] Address of a <a href="https://docs.microsoft.com/windows/desktop/WinAuto/variant-structure">VARIANT</a> structure that receives information about the destination object. The following table describes the information that is returned in <i>pvarEnd</i>. </para>
/// <para>This doc was truncated.</para>
/// <para><see href="https://learn.microsoft.com/windows/win32/api/oleacc/nf-oleacc-iaccessible-accnavigate#parameters">Read more on docs.microsoft.com</see>.</para>
/// </param>
/// <returns>
/// <para>Type: <b><a href="https://docs.microsoft.com/windows/desktop/WinProg/windows-data-types">HRESULT</a></b> If successful, returns S_OK. If not successful, returns one of the values in the table that follows, or another standard <a href="https://docs.microsoft.com/windows/desktop/WinAuto/return-values">COM error code</a>. Servers return these values, but clients must always check output parameters to ensure that they contain valid values. For more information, see <a href="https://docs.microsoft.com/windows/desktop/WinAuto/checking-iaccessible-return-values">Checking IAccessible Return Values</a> and Return Values. </para>
/// <para>This doc was truncated.</para>
/// </returns>
/// <remarks>
/// <para>Navigation, both spatial and logical, is always restricted to the UI elements within a container. With spatial navigation, clients navigate only to a sibling of the starting object (<i>varStart</i>). Depending on the navigational flag used with logical navigation, clients navigate to either a child or to a sibling of the starting object. The <b>accNavigate</b> method retrieves UI elements that have a defined screen location, and invisible objects that do not have a defined screen location. This method does not change the selection or focus. To change the focus or to select an object, use <a href="https://docs.microsoft.com/windows/desktop/api/oleacc/nf-oleacc-iaccessible-accselect">IAccessible::accSelect</a>. To prevent looping when traversing screen elements, <b>accNavigate</b> returns S_FALSE with VT_EMPTY when you specify <a href="https://docs.microsoft.com/windows/desktop/WinAuto/navigation-constants">NAVDIR_NEXT</a> on the last element, or <a href="https://docs.microsoft.com/windows/desktop/WinAuto/navigation-constants">NAVDIR_PREVIOUS</a> on the first element. As with other <a href="https://docs.microsoft.com/windows/desktop/api/oleacc/nn-oleacc-iaccessible">IAccessible</a> methods and functions, clients might receive errors for <b>IAccessible</b> interface pointers because of a user action. For more information, see <a href="https://docs.microsoft.com/windows/desktop/WinAuto/receiving-errors-for-iaccessible-interface-pointers">Receiving Errors for IAccessible Interface Pointers</a>. Some system-defined UI elements such as menus, menu items, and pop-up menus allow navigation to invisible objects. However, other system-defined UI elements do not support this. Servers can choose whether to support navigating to invisible objects and can either skip over or expose them. Client applications must return post-process return values when using <b>accNavigate</b> to navigate between objects. The goal of the post-processing steps is to give clients an <a href="https://docs.microsoft.com/windows/desktop/api/oleacc/nn-oleacc-iaccessible">IAccessible</a> interface pointer and a child ID so that they can use the <b>IAccessible</b> methods and properties for a UI element. The following tables describe possible scenarios for <b>IAccessible::accNavigate</b>, based on the following criteria: </para>
/// <para>This doc was truncated.</para>
/// <para><see href="https://learn.microsoft.com/windows/win32/api/oleacc/nf-oleacc-iaccessible-accnavigate#">Read more on docs.microsoft.com</see>.</para>
/// </remarks>
public unsafe winmdroot.Foundation.HRESULT accNavigate(int navDir, winmdroot.System.Variant.VARIANT varStart, winmdroot.System.Variant.VARIANT* pvarEndUpAt)
{
return ((delegate *unmanaged [Stdcall]<IAccessible*,int ,winmdroot.System.Variant.VARIANT ,winmdroot.System.Variant.VARIANT* ,winmdroot.Foundation.HRESULT>)lpVtbl[23])((IAccessible*)Unsafe.AsPointer(ref this), navDir, varStart, pvarEndUpAt);
}
/// <inheritdoc cref="accHitTest(int, int, winmdroot.System.Variant.VARIANT*)"/>
internal unsafe winmdroot.Foundation.HRESULT accHitTest(int xLeft, int yTop, out winmdroot.System.Variant.VARIANT pvarChild)
{
fixed (winmdroot.System.Variant.VARIANT* pvarChildLocal = &pvarChild)
{
winmdroot.Foundation.HRESULT __result = this.accHitTest(xLeft, yTop, pvarChildLocal);
return __result;
}
}
[UnmanagedCallersOnly(CallConvs = new []{
typeof(CallConvStdcall)}
)]
private static winmdroot.Foundation.HRESULT accHitTest(IAccessible* pThis, int xLeft, int yTop, winmdroot.System.Variant.VARIANT* pvarChild)
{
try
{
winmdroot.Foundation.HRESULT __hr = ComHelpers.UnwrapCCW(pThis, out Interface __object);
if (__hr.Failed)
{
return __hr;
}
return __object.accHitTest(xLeft, yTop, pvarChild);
}
catch (Exception ex)
{
return (winmdroot.Foundation.HRESULT)ex.HResult;
}
}
/// <summary>The IAccessible::accHitTest method retrieves the child element or child object that is displayed at a specific point on the screen.</summary>
/// <param name="xLeft">
/// <para>Type: <b>long</b> Specifies the screen coordinates of the point that is hit tested. The x-coordinates increase from left to right. Note that when screen coordinates are used, the origin is the upper-left corner of the screen.</para>
/// <para><see href="https://learn.microsoft.com/windows/win32/api/oleacc/nf-oleacc-iaccessible-acchittest#parameters">Read more on docs.microsoft.com</see>.</para>
/// </param>
/// <param name="yTop">
/// <para>Type: <b>long</b> Specifies the screen coordinates of the point that is hit tested. The y-coordinates increase from top to bottom. Note that when screen coordinates are used, the origin is the upper-left corner of the screen.</para>
/// <para><see href="https://learn.microsoft.com/windows/win32/api/oleacc/nf-oleacc-iaccessible-acchittest#parameters">Read more on docs.microsoft.com</see>.</para>
/// </param>
/// <param name="pvarChild">
/// <para>Type: <b>VARIANT*</b> [out, retval] Address of a <a href="https://docs.microsoft.com/windows/desktop/WinAuto/variant-structure">VARIANT</a> that identifies the object displayed at the point specified by <i>xLeft</i> and <i>yTop</i>. The information returned in <i>pvarID</i> depends on the location of the specified point in relation to the object whose <b>accHitTest</b> method is being called. </para>
/// <para>This doc was truncated.</para>
/// <para><see href="https://learn.microsoft.com/windows/win32/api/oleacc/nf-oleacc-iaccessible-acchittest#parameters">Read more on docs.microsoft.com</see>.</para>
/// </param>
/// <returns>
/// <para>Type: <b><a href="https://docs.microsoft.com/windows/desktop/WinProg/windows-data-types">HRESULT</a></b> If successful, returns S_OK. If not successful, returns one of the values in the table that follows, or another standard <a href="https://docs.microsoft.com/windows/desktop/WinAuto/return-values">COM error code</a>. Servers return these values, but clients must always check output parameters to ensure that they contain valid values. For more information, see <a href="https://docs.microsoft.com/windows/desktop/WinAuto/checking-iaccessible-return-values">Checking IAccessible Return Values</a>. </para>
/// <para>This doc was truncated.</para>
/// </returns>
/// <remarks>
/// <para>If the tested point is on one of the object's children, and this child supports the <a href="https://docs.microsoft.com/windows/desktop/api/oleacc/nn-oleacc-iaccessible">IAccessible</a> interface itself, this method should return an <b>IAccessible</b> interface pointer. However, clients should be prepared to handle an <b>IAccessible</b> interface pointer or a child ID. For more information, see <a href="https://docs.microsoft.com/windows/desktop/WinAuto/how-child-ids-are-used-in-parameters">How Child IDs Are Used in Parameters</a>. Because <a href="https://docs.microsoft.com/windows/desktop/api/oleacc/nf-oleacc-iaccessible-acclocation">accLocation</a> returns a bounding rectangle, not all points in that rectangle will be within the actual bounds of the object. Some points within the bounding rectangle may not be on the object. For non-rectangular objects, such as list view items in large-icon mode where a single item has a rectangle for the icon and another rectangle for the text of the icon, the coordinates of the object's bounding rectangle retrieved by <b>IAccessible::accLocation</b> could fail if tested with <b>accHitTest</b> . As with other <a href="https://docs.microsoft.com/windows/desktop/api/oleacc/nn-oleacc-iaccessible">IAccessible</a> methods and functions, clients might receive errors for <b>IAccessible</b> interface pointers because of a user action. For more information, see <a href="https://docs.microsoft.com/windows/desktop/WinAuto/receiving-errors-for-iaccessible-interface-pointers">Receiving Errors for IAccessible Interface Pointers</a>. When this method is used in certain situations, additional usage notes apply. For more information, see <a href="https://docs.microsoft.com/windows/desktop/WinAuto/navigation-through-hit-testing-and-screen-location">Navigation Through Hit Testing and Screen Location</a>. <h3><a id="Server_Example"></a><a id="server_example"></a><a id="SERVER_EXAMPLE"></a>Server Example</h3> The following example code shows a possible implementation for a custom list box.</para>
/// <para></para>
/// <para>This doc was truncated.</para>
/// <para><see href="https://learn.microsoft.com/windows/win32/api/oleacc/nf-oleacc-iaccessible-acchittest#">Read more on docs.microsoft.com</see>.</para>
/// </remarks>
public unsafe winmdroot.Foundation.HRESULT accHitTest(int xLeft, int yTop, winmdroot.System.Variant.VARIANT* pvarChild)
{
return ((delegate *unmanaged [Stdcall]<IAccessible*,int ,int ,winmdroot.System.Variant.VARIANT* ,winmdroot.Foundation.HRESULT>)lpVtbl[24])((IAccessible*)Unsafe.AsPointer(ref this), xLeft, yTop, pvarChild);
}
[UnmanagedCallersOnly(CallConvs = new []{
typeof(CallConvStdcall)}
)]
private static winmdroot.Foundation.HRESULT accDoDefaultAction(IAccessible* pThis, winmdroot.System.Variant.VARIANT varChild)
{
try
{
winmdroot.Foundation.HRESULT __hr = ComHelpers.UnwrapCCW(pThis, out Interface __object);
if (__hr.Failed)
{
return __hr;
}
return __object.accDoDefaultAction(varChild);
}
catch (Exception ex)
{
return (winmdroot.Foundation.HRESULT)ex.HResult;
}
}
/// <summary>The IAccessible::accDoDefaultAction method performs the specified object's default action. Not all objects have a default action.</summary>
/// <param name="varChild">
/// <para>Type: <b>VARIANT</b> Specifies whether the default action belongs to the object or one of the object's child elements. For more information about initializing the <a href="https://docs.microsoft.com/windows/desktop/WinAuto/variant-structure">VARIANT</a>, see <a href="https://docs.microsoft.com/windows/desktop/WinAuto/how-child-ids-are-used-in-parameters">How Child IDs Are Used in Parameters</a>.</para>
/// <para><see href="https://learn.microsoft.com/windows/win32/api/oleacc/nf-oleacc-iaccessible-accdodefaultaction#parameters">Read more on docs.microsoft.com</see>.</para>
/// </param>
/// <returns>
/// <para>Type: <b><a href="https://docs.microsoft.com/windows/desktop/WinProg/windows-data-types">HRESULT</a></b> If successful, returns S_OK. If not successful, returns one of the values in the table that follows, or another standard <a href="https://docs.microsoft.com/windows/desktop/WinAuto/return-values">COM error code</a>. </para>
/// <para>This doc was truncated.</para>
/// </returns>
/// <remarks>
/// <para>Clients retrieve a string that describes the object's default action by calling <b>IAccessible::get_accDefaultAction</b>. <b>Note to client developers: </b>When used on a menu item in a standard system menu, <b>accDoDefaultAction</b> returns S_OK but fails to perform the action if the character used in the access key (the underlined character in the text of a menu item name, also called a mnemonic) is ?, !, @, or any other character that requires the SHIFT key or another modifier key. This also happens on international keyboards with an access key character that requires the ALT GR key to be pressed. This is not an issue for menus in other applications, such as Microsoft Office or Windows Internet Explorer. For more information about access keys, see <a href="https://docs.microsoft.com/windows/desktop/api/oleacc/nf-oleacc-iaccessible-get_acckeyboardshortcut">IAccessible::get_accKeyboardShortcut</a>. Also, while <b>accDoDefaultAction</b> is supposed to return immediately, some implementations block the return. For example, if clicking a link displays a dialog, some implementations will block the return until the dialog is dismissed. Such delays can prevent client applications from processing a dialog box. Servers should avoid implementations that block returns.</para>
/// <para><h3><a id="Server_Example"></a><a id="server_example"></a><a id="SERVER_EXAMPLE"></a>Server Example</h3> The following example shows a possible implementation for a custom list control whose default action is a double-click a child item. To prevent blocking, the method posts a custom message that, when received by the control window, triggers an action, such as displaying item properties.</para>
/// <para></para>
/// <para>This doc was truncated.</para>
/// <para><see href="https://learn.microsoft.com/windows/win32/api/oleacc/nf-oleacc-iaccessible-accdodefaultaction#">Read more on docs.microsoft.com</see>.</para>
/// </remarks>
public winmdroot.Foundation.HRESULT accDoDefaultAction(winmdroot.System.Variant.VARIANT varChild)
{
return ((delegate *unmanaged [Stdcall]<IAccessible*,winmdroot.System.Variant.VARIANT ,winmdroot.Foundation.HRESULT>)lpVtbl[25])((IAccessible*)Unsafe.AsPointer(ref this), varChild);
}
[UnmanagedCallersOnly(CallConvs = new []{
typeof(CallConvStdcall)}
)]
private static winmdroot.Foundation.HRESULT put_accName(IAccessible* pThis, winmdroot.System.Variant.VARIANT varChild, winmdroot.Foundation.BSTR szName)
{
try
{
winmdroot.Foundation.HRESULT __hr = ComHelpers.UnwrapCCW(pThis, out Interface __object);
if (__hr.Failed)
{
return __hr;
}
return __object.put_accName(varChild, szName);
}
catch (Exception ex)
{
return (winmdroot.Foundation.HRESULT)ex.HResult;
}
}
/// <summary>The IAccessible::put_accName method is no longer supported. Client applications should use a control-specific workaround, such as the SetWindowText function. Servers should return E_NOTIMPL.</summary>
/// <param name="varChild">Not supported.</param>
/// <param name="szName">Not supported.</param>
/// <returns>Not supported.</returns>
/// <remarks>
/// <para><see href="https://learn.microsoft.com/windows/win32/api/oleacc/nf-oleacc-iaccessible-put_accname">Learn more about this API from docs.microsoft.com</see>.</para>
/// </remarks>
public winmdroot.Foundation.HRESULT put_accName(winmdroot.System.Variant.VARIANT varChild, winmdroot.Foundation.BSTR szName)
{
return ((delegate *unmanaged [Stdcall]<IAccessible*,winmdroot.System.Variant.VARIANT ,winmdroot.Foundation.BSTR ,winmdroot.Foundation.HRESULT>)lpVtbl[26])((IAccessible*)Unsafe.AsPointer(ref this), varChild, szName);
}
[UnmanagedCallersOnly(CallConvs = new []{
typeof(CallConvStdcall)}
)]
private static winmdroot.Foundation.HRESULT put_accValue(IAccessible* pThis, winmdroot.System.Variant.VARIANT varChild, winmdroot.Foundation.BSTR szValue)
{
try
{
winmdroot.Foundation.HRESULT __hr = ComHelpers.UnwrapCCW(pThis, out Interface __object);
if (__hr.Failed)
{
return __hr;
}
return __object.put_accValue(varChild, szValue);
}
catch (Exception ex)
{
return (winmdroot.Foundation.HRESULT)ex.HResult;
}
}
/// <summary>The IAccessible::put_accValue method sets the value of the specified object. Not all objects have a value.</summary>
/// <param name="varChild">
/// <para>Type: <b>VARIANT</b> Specifies whether the value information being set belongs to the object or one of the object's child elements. This parameter is either CHILDID_SELF (to set information on the object) or a child ID (to set information about the object's child element). For more information about initializing the <a href="https://docs.microsoft.com/windows/desktop/WinAuto/variant-structure">VARIANT structure</a>, see <a href="https://docs.microsoft.com/windows/desktop/WinAuto/how-child-ids-are-used-in-parameters">How Child IDs Are Used in Parameters</a>.</para>
/// <para><see href="https://learn.microsoft.com/windows/win32/api/oleacc/nf-oleacc-iaccessible-put_accvalue#parameters">Read more on docs.microsoft.com</see>.</para>
/// </param>
/// <param name="szValue">
/// <para>Type: <b>BSTR</b> A localized string that contains the object's value.</para>
/// <para><see href="https://learn.microsoft.com/windows/win32/api/oleacc/nf-oleacc-iaccessible-put_accvalue#parameters">Read more on docs.microsoft.com</see>.</para>
/// </param>
/// <returns>
/// <para>Type: <b><a href="https://docs.microsoft.com/windows/desktop/WinProg/windows-data-types">HRESULT</a></b> If successful, returns S_OK. If not successful, returns one of the values in the table that follows, or another standard <a href="https://docs.microsoft.com/windows/desktop/WinAuto/return-values">COM error code</a>. Servers return these values, but clients must always check output parameters to ensure that they contain valid values. For more information, see <a href="https://docs.microsoft.com/windows/desktop/WinAuto/checking-iaccessible-return-values">Checking IAccessible Return Values</a>. </para>
/// <para>This doc was truncated.</para>
/// </returns>
/// <remarks>The <b>IAccessible::put_accValue</b> method is supported for some UI elements (usually edit controls). For UI elements that do not support this method, control-specific methods are used instead. For more information, see <a href="https://docs.microsoft.com/windows/desktop/WinAuto/appendix-a--supported-user-interface-elements-reference">Supported User Interface Element Reference</a>.</remarks>
public winmdroot.Foundation.HRESULT put_accValue(winmdroot.System.Variant.VARIANT varChild, winmdroot.Foundation.BSTR szValue)
{
return ((delegate *unmanaged [Stdcall]<IAccessible*,winmdroot.System.Variant.VARIANT ,winmdroot.Foundation.BSTR ,winmdroot.Foundation.HRESULT>)lpVtbl[27])((IAccessible*)Unsafe.AsPointer(ref this), varChild, szValue);
}
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]<IAccessible*,global::System.Guid* ,void** ,winmdroot.Foundation.HRESULT> QueryInterface_1;
internal delegate *unmanaged [Stdcall]<IAccessible*,uint> AddRef_2;
internal delegate *unmanaged [Stdcall]<IAccessible*,uint> Release_3;
internal delegate *unmanaged [Stdcall]<IAccessible*,uint* ,winmdroot.Foundation.HRESULT> GetTypeInfoCount_4;
internal delegate *unmanaged [Stdcall]<IAccessible*,uint ,uint ,winmdroot.System.Com.ITypeInfo** ,winmdroot.Foundation.HRESULT> GetTypeInfo_5;
internal delegate *unmanaged [Stdcall]<IAccessible*,global::System.Guid* ,winmdroot.Foundation.PWSTR* ,uint ,uint ,int* ,winmdroot.Foundation.HRESULT> GetIDsOfNames_6;
internal delegate *unmanaged [Stdcall]<IAccessible*,int ,global::System.Guid* ,uint ,winmdroot.System.Com.DISPATCH_FLAGS ,winmdroot.System.Com.DISPPARAMS* ,winmdroot.System.Variant.VARIANT* ,winmdroot.System.Com.EXCEPINFO* ,uint* ,winmdroot.Foundation.HRESULT> Invoke_7;
internal delegate *unmanaged [Stdcall]<IAccessible*,winmdroot.System.Com.IDispatch** ,winmdroot.Foundation.HRESULT> get_accParent_8;
internal delegate *unmanaged [Stdcall]<IAccessible*,int* ,winmdroot.Foundation.HRESULT> get_accChildCount_9;
internal delegate *unmanaged [Stdcall]<IAccessible*,winmdroot.System.Variant.VARIANT ,winmdroot.System.Com.IDispatch** ,winmdroot.Foundation.HRESULT> get_accChild_10;
internal delegate *unmanaged [Stdcall]<IAccessible*,winmdroot.System.Variant.VARIANT ,winmdroot.Foundation.BSTR* ,winmdroot.Foundation.HRESULT> get_accName_11;
internal delegate *unmanaged [Stdcall]<IAccessible*,winmdroot.System.Variant.VARIANT ,winmdroot.Foundation.BSTR* ,winmdroot.Foundation.HRESULT> get_accValue_12;
internal delegate *unmanaged [Stdcall]<IAccessible*,winmdroot.System.Variant.VARIANT ,winmdroot.Foundation.BSTR* ,winmdroot.Foundation.HRESULT> get_accDescription_13;
internal delegate *unmanaged [Stdcall]<IAccessible*,winmdroot.System.Variant.VARIANT ,winmdroot.System.Variant.VARIANT* ,winmdroot.Foundation.HRESULT> get_accRole_14;
internal delegate *unmanaged [Stdcall]<IAccessible*,winmdroot.System.Variant.VARIANT ,winmdroot.System.Variant.VARIANT* ,winmdroot.Foundation.HRESULT> get_accState_15;
internal delegate *unmanaged [Stdcall]<IAccessible*,winmdroot.System.Variant.VARIANT ,winmdroot.Foundation.BSTR* ,winmdroot.Foundation.HRESULT> get_accHelp_16;
internal delegate *unmanaged [Stdcall]<IAccessible*,winmdroot.Foundation.BSTR* ,winmdroot.System.Variant.VARIANT ,int* ,winmdroot.Foundation.HRESULT> get_accHelpTopic_17;
internal delegate *unmanaged [Stdcall]<IAccessible*,winmdroot.System.Variant.VARIANT ,winmdroot.Foundation.BSTR* ,winmdroot.Foundation.HRESULT> get_accKeyboardShortcut_18;
internal delegate *unmanaged [Stdcall]<IAccessible*,winmdroot.System.Variant.VARIANT* ,winmdroot.Foundation.HRESULT> get_accFocus_19;
internal delegate *unmanaged [Stdcall]<IAccessible*,winmdroot.System.Variant.VARIANT* ,winmdroot.Foundation.HRESULT> get_accSelection_20;
internal delegate *unmanaged [Stdcall]<IAccessible*,winmdroot.System.Variant.VARIANT ,winmdroot.Foundation.BSTR* ,winmdroot.Foundation.HRESULT> get_accDefaultAction_21;
internal delegate *unmanaged [Stdcall]<IAccessible*,int ,winmdroot.System.Variant.VARIANT ,winmdroot.Foundation.HRESULT> accSelect_22;
internal delegate *unmanaged [Stdcall]<IAccessible*,int* ,int* ,int* ,int* ,winmdroot.System.Variant.VARIANT ,winmdroot.Foundation.HRESULT> accLocation_23;
internal delegate *unmanaged [Stdcall]<IAccessible*,int ,winmdroot.System.Variant.VARIANT ,winmdroot.System.Variant.VARIANT* ,winmdroot.Foundation.HRESULT> accNavigate_24;
internal delegate *unmanaged [Stdcall]<IAccessible*,int ,int ,winmdroot.System.Variant.VARIANT* ,winmdroot.Foundation.HRESULT> accHitTest_25;
internal delegate *unmanaged [Stdcall]<IAccessible*,winmdroot.System.Variant.VARIANT ,winmdroot.Foundation.HRESULT> accDoDefaultAction_26;
internal delegate *unmanaged [Stdcall]<IAccessible*,winmdroot.System.Variant.VARIANT ,winmdroot.Foundation.BSTR ,winmdroot.Foundation.HRESULT> put_accName_27;
internal delegate *unmanaged [Stdcall]<IAccessible*,winmdroot.System.Variant.VARIANT ,winmdroot.Foundation.BSTR ,winmdroot.Foundation.HRESULT> put_accValue_28;
}
public static void PopulateVTable(Vtbl* vtable)
{
vtable->get_accParent_8 = &get_accParent;
vtable->get_accChildCount_9 = &get_accChildCount;
vtable->get_accChild_10 = &get_accChild;
vtable->get_accName_11 = &get_accName;
vtable->get_accValue_12 = &get_accValue;
vtable->get_accDescription_13 = &get_accDescription;
vtable->get_accRole_14 = &get_accRole;
vtable->get_accState_15 = &get_accState;
vtable->get_accHelp_16 = &get_accHelp;
vtable->get_accHelpTopic_17 = &get_accHelpTopic;
vtable->get_accKeyboardShortcut_18 = &get_accKeyboardShortcut;
vtable->get_accFocus_19 = &get_accFocus;
vtable->get_accSelection_20 = &get_accSelection;
vtable->get_accDefaultAction_21 = &get_accDefaultAction;
vtable->accSelect_22 = &accSelect;
vtable->accLocation_23 = &accLocation;
vtable->accNavigate_24 = &accNavigate;
vtable->accHitTest_25 = &accHitTest;
vtable->accDoDefaultAction_26 = &accDoDefaultAction;
vtable->put_accName_27 = &put_accName;
vtable->put_accValue_28 = &put_accValue;
}
private void** lpVtbl;
/// <summary>The IID guid for this interface.</summary>
/// <value>{618736e0-3c3d-11cf-810c-00aa00389b71}</value>
internal static readonly Guid IID_Guid = new Guid(0x618736E0, 0x3C3D, 0x11CF, 0x81, 0x0C, 0x00, 0xAA, 0x00, 0x38, 0x9B, 0x71);
static ref readonly Guid IComIID.Guid {
[MethodImpl(MethodImplOptions.AggressiveInlining)]
get
{
ReadOnlySpan<byte> data = new byte[] {
0xE0,0x36,0x87,0x61,0x3D,0x3C,0xCF,0x11,0x81,0x0C,0x00,0xAA,0x00,0x38,0x9B,0x71 };
return ref Unsafe.As<byte,Guid>(ref MemoryMarshal.GetReference(data));
}
}
[Guid("618736E0-3C3D-11CF-810C-00AA00389B71"),InterfaceType(ComInterfaceType.InterfaceIsDual),ComImport()]
[SupportedOSPlatform("windows5.0")]
internal interface Interface
{
[PreserveSig()]
unsafe winmdroot.Foundation.HRESULT get_accParent(winmdroot.System.Com.IDispatch** ppdispParent);
[PreserveSig()]
unsafe winmdroot.Foundation.HRESULT get_accChildCount(int* pcountChildren);
[PreserveSig()]
unsafe winmdroot.Foundation.HRESULT get_accChild(winmdroot.System.Variant.VARIANT varChild, winmdroot.System.Com.IDispatch** ppdispChild);
[PreserveSig()]
unsafe winmdroot.Foundation.HRESULT get_accName(winmdroot.System.Variant.VARIANT varChild, winmdroot.Foundation.BSTR* pszName);
[PreserveSig()]
unsafe winmdroot.Foundation.HRESULT get_accValue(winmdroot.System.Variant.VARIANT varChild, winmdroot.Foundation.BSTR* pszValue);
[PreserveSig()]
unsafe winmdroot.Foundation.HRESULT get_accDescription(winmdroot.System.Variant.VARIANT varChild, winmdroot.Foundation.BSTR* pszDescription);
[PreserveSig()]
unsafe winmdroot.Foundation.HRESULT get_accRole(winmdroot.System.Variant.VARIANT varChild, winmdroot.System.Variant.VARIANT* pvarRole);
[PreserveSig()]
unsafe winmdroot.Foundation.HRESULT get_accState(winmdroot.System.Variant.VARIANT varChild, winmdroot.System.Variant.VARIANT* pvarState);
[PreserveSig()]
unsafe winmdroot.Foundation.HRESULT get_accHelp(winmdroot.System.Variant.VARIANT varChild, winmdroot.Foundation.BSTR* pszHelp);
[PreserveSig()]
unsafe winmdroot.Foundation.HRESULT get_accHelpTopic(winmdroot.Foundation.BSTR* pszHelpFile, winmdroot.System.Variant.VARIANT varChild, int* pidTopic);
[PreserveSig()]
unsafe winmdroot.Foundation.HRESULT get_accKeyboardShortcut(winmdroot.System.Variant.VARIANT varChild, winmdroot.Foundation.BSTR* pszKeyboardShortcut);
[PreserveSig()]
unsafe winmdroot.Foundation.HRESULT get_accFocus(winmdroot.System.Variant.VARIANT* pvarChild);
[PreserveSig()]
unsafe winmdroot.Foundation.HRESULT get_accSelection(winmdroot.System.Variant.VARIANT* pvarChildren);
[PreserveSig()]
unsafe winmdroot.Foundation.HRESULT get_accDefaultAction(winmdroot.System.Variant.VARIANT varChild, winmdroot.Foundation.BSTR* pszDefaultAction);
[PreserveSig()]
winmdroot.Foundation.HRESULT accSelect(int flagsSelect, winmdroot.System.Variant.VARIANT varChild);
[PreserveSig()]
unsafe winmdroot.Foundation.HRESULT accLocation(int* pxLeft, int* pyTop, int* pcxWidth, int* pcyHeight, winmdroot.System.Variant.VARIANT varChild);
[PreserveSig()]
unsafe winmdroot.Foundation.HRESULT accNavigate(int navDir, winmdroot.System.Variant.VARIANT varStart, winmdroot.System.Variant.VARIANT* pvarEndUpAt);
[PreserveSig()]
unsafe winmdroot.Foundation.HRESULT accHitTest(int xLeft, int yTop, winmdroot.System.Variant.VARIANT* pvarChild);
[PreserveSig()]
winmdroot.Foundation.HRESULT accDoDefaultAction(winmdroot.System.Variant.VARIANT varChild);
[PreserveSig()]
winmdroot.Foundation.HRESULT put_accName(winmdroot.System.Variant.VARIANT varChild, winmdroot.Foundation.BSTR szName);
[PreserveSig()]
winmdroot.Foundation.HRESULT put_accValue(winmdroot.System.Variant.VARIANT varChild, winmdroot.Foundation.BSTR szValue);
}
}
}
}
|