mirror of https://github.com/dahall/Vanara.git
2690 lines
117 KiB
C#
2690 lines
117 KiB
C#
using System;
|
|
using System.Runtime.InteropServices;
|
|
using Vanara.Collections;
|
|
using LPARAM = System.IntPtr;
|
|
|
|
using WPARAM = System.IntPtr;
|
|
|
|
namespace Vanara.PInvoke
|
|
{
|
|
public static partial class MSCTF
|
|
{
|
|
/// <summary>Specifies the actual confidence for this element.</summary>
|
|
[PInvokeData("sapi.h")]
|
|
public enum SP_CONFIDENCE
|
|
{
|
|
/// <summary>The speech engine has low confidence in the element.</summary>
|
|
SP_LOW_CONFIDENCE = -1,
|
|
|
|
/// <summary>The speech engine has normal confidence in the element.</summary>
|
|
SP_NORMAL_CONFIDENCE = 0,
|
|
|
|
/// <summary>The speech engine has high confidence in the element.</summary>
|
|
SP_HIGH_CONFIDENCE = 1
|
|
}
|
|
|
|
/// <summary>The property UI status.</summary>
|
|
[PInvokeData("ctffunc.h", MSDNShortId = "NN:ctffunc.ITfFnPropertyUIStatus")]
|
|
public enum TF_PROPUI_STATUS
|
|
{
|
|
/// <summary>The property can be serialized. If this value is not present, the property cannot be serialized.</summary>
|
|
TF_PROPUI_STATUS_SAVETOFILE = 1
|
|
}
|
|
|
|
/// <summary>
|
|
/// Elements of the <c>TfCandidateResult</c> enumeration are used with the ITfCandidateList::SetResult method to specify the result
|
|
/// of a reconversion operation performed on a given candidate string.
|
|
/// </summary>
|
|
// https://docs.microsoft.com/en-us/windows/win32/api/ctffunc/ne-ctffunc-tfcandidateresult
|
|
[PInvokeData("ctffunc.h", MSDNShortId = "NE:ctffunc.__MIDL_ITfCandidateList_0001")]
|
|
[Guid("BAA898F2-0207-4643-92CA-F3F7B0CF6F80")]
|
|
public enum TfCandidateResult : uint
|
|
{
|
|
/// <summary>
|
|
/// The candidate string has been selected and accepted. The previous text should be replaced with the specified candidate.
|
|
/// </summary>
|
|
CAND_FINALIZED,
|
|
|
|
/// <summary>The candidate string has been selected, but the selection is not yet final.</summary>
|
|
CAND_SELECTED,
|
|
|
|
/// <summary>The reconversion operation has been canceled.</summary>
|
|
CAND_CANCELED,
|
|
}
|
|
|
|
/// <summary>
|
|
/// Elements of the <c>TfIntegratableCandidateListSelectionStyle</c> enumeration specify the integratable candidate list selection styles.
|
|
/// </summary>
|
|
// https://docs.microsoft.com/en-us/windows/win32/api/ctffunc/ne-ctffunc-tfintegratablecandidatelistselectionstyle
|
|
[PInvokeData("ctffunc.h", MSDNShortId = "NE:ctffunc.__MIDL___MIDL_itf_ctffunc_0000_0022_0001")]
|
|
[Guid("AF8F5D86-0615-4af3-90FA-5DCBB407A5D4")]
|
|
public enum TfIntegratableCandidateListSelectionStyle : uint
|
|
{
|
|
/// <summary>The selection can be changed with the arrow keys.</summary>
|
|
STYLE_ACTIVE_SELECTION,
|
|
|
|
/// <summary>The default selection key will choose the selection.</summary>
|
|
STYLE_IMPLIED_SELECTION,
|
|
}
|
|
|
|
/// <summary>
|
|
/// Elements of the <c>TfSapiObject</c> enumeration are used with the ITfFnGetSAPIObject::Get method to specify a specific type of
|
|
/// Speech API (SAPI) object.
|
|
/// </summary>
|
|
// https://docs.microsoft.com/en-us/windows/win32/api/ctffunc/ne-ctffunc-tfsapiobject
|
|
[PInvokeData("ctffunc.h", MSDNShortId = "NE:ctffunc.__MIDL___MIDL_itf_ctffunc_0000_0011_0001")]
|
|
[Guid("36ADB6D9-DA1F-45D8-A499-86167E0F936B")]
|
|
public enum TfSapiObject : uint
|
|
{
|
|
/// <summary>Specifies an ISpResourceManager object.</summary>
|
|
GETIF_RESMGR,
|
|
|
|
/// <summary>Specifies an ISpRecoContext object.</summary>
|
|
GETIF_RECOCONTEXT,
|
|
|
|
/// <summary>Specifies an ISpRecognizer object.</summary>
|
|
GETIF_RECOGNIZER,
|
|
|
|
/// <summary>Specifies an ISpVoice object.</summary>
|
|
GETIF_VOICE,
|
|
|
|
/// <summary>Specifies an ISpRecoGrammar object.</summary>
|
|
GETIF_DICTGRAM,
|
|
|
|
/// <summary>Specifies an ISpRecognizer object. SAPI will not be initialized if it is not already.</summary>
|
|
GETIF_RECOGNIZERNOINIT,
|
|
}
|
|
|
|
/// <summary>
|
|
/// Each identifier is specific to a certain language, and these are all specific to the touch keyboard. There is no way to request
|
|
/// support for other layouts, or to add new touch optimized layouts dynamically.
|
|
/// </summary>
|
|
[PInvokeData("ctffunc.h")]
|
|
public enum TKBLayoutId : ushort
|
|
{
|
|
#pragma warning disable CS1591 // Missing XML comment for publicly visible type or member
|
|
TKBLT_UNDEFINED = 0,
|
|
TKBL_CLASSIC_TRADITIONAL_CHINESE_PHONETIC = 0x0404,
|
|
TKBL_CLASSIC_TRADITIONAL_CHINESE_CHANGJIE = 0xF042,
|
|
TKBL_CLASSIC_TRADITIONAL_CHINESE_DAYI = 0xF043,
|
|
TKBL_OPT_JAPANESE_ABC = 0x0411,
|
|
TKBL_OPT_KOREAN_HANGUL_2_BULSIK = 0x0412,
|
|
TKBL_OPT_SIMPLIFIED_CHINESE_PINYIN = 0x0804,
|
|
#pragma warning disable CA1069 // Enums values should not be duplicated
|
|
TKBL_OPT_TRADITIONAL_CHINESE_PHONETIC = 0x0404,
|
|
#pragma warning restore CA1069 // Enums values should not be duplicated
|
|
#pragma warning restore CS1591 // Missing XML comment for publicly visible type or member
|
|
}
|
|
|
|
/// <summary>
|
|
/// Elements of the <c>TKBLayoutType</c> enumeration are passed by an IME in a call to
|
|
/// ITfFnGetPreferredTouchKeyboardLayout::GetLayout to specify the type of layout.
|
|
/// </summary>
|
|
// https://docs.microsoft.com/en-us/windows/win32/api/ctffunc/ne-ctffunc-tkblayouttype
|
|
[PInvokeData("ctffunc.h", MSDNShortId = "NE:ctffunc.__MIDL_ITfFnGetPreferredTouchKeyboardLayout_0001")]
|
|
[Guid("5F309A41-590A-4ACC-A97F-D8EFFF13FDFC")]
|
|
public enum TKBLayoutType : uint
|
|
{
|
|
/// <summary>Undefined. If specified, it will cause the layout to fallback to a classic layout.</summary>
|
|
TKBLT_UNDEFINED,
|
|
|
|
/// <summary>The touch keyboard is to use a classic layout.</summary>
|
|
TKBLT_CLASSIC,
|
|
|
|
/// <summary>The touch keyboard is to use a touch-optimized layout.</summary>
|
|
TKBLT_OPTIMIZED,
|
|
}
|
|
|
|
/// <summary>Undocumented.</summary>
|
|
/// <seealso cref="Vanara.Collections.ICOMEnum{T}"/>
|
|
[PInvokeData("ctffunc.h")]
|
|
[ComImport, Guid("8C5DAC4F-083C-4B85-A4C9-71746048ADCA"), InterfaceType(ComInterfaceType.InterfaceIsIUnknown)]
|
|
public interface IEnumSpeechCommands : ICOMEnum<string>
|
|
{
|
|
/// <summary>Creates a copy of the enumerator object.</summary>
|
|
/// <returns>Pointer to an IEnumSpeechCommands interface pointer that receives the new enumerator.</returns>
|
|
IEnumSpeechCommands Clone();
|
|
|
|
/// <summary>Obtains, from the current position, the specified number of elements in the enumeration sequence.</summary>
|
|
/// <param name="ulCount">Specifies the number of elements to obtain.</param>
|
|
/// <param name="pSpCmds">
|
|
/// Pointer to an array of string pointers that receives the requested objects. This array must be at least ulCount elements in size.
|
|
/// </param>
|
|
/// <param name="pcFetched">
|
|
/// Pointer to a ULONG value that receives the number of elements obtained. This value can be less than the number of items
|
|
/// requested. This parameter can be <c>NULL</c>.
|
|
/// </param>
|
|
/// <returns>
|
|
/// <para>This method can return one of these values.</para>
|
|
/// <list type="table">
|
|
/// <listheader>
|
|
/// <term>Value</term>
|
|
/// <term>Description</term>
|
|
/// </listheader>
|
|
/// <item>
|
|
/// <term>S_OK</term>
|
|
/// <term>The method was successful.</term>
|
|
/// </item>
|
|
/// <item>
|
|
/// <term>S_FALSE</term>
|
|
/// <term>The method reached the end of the enumeration before the specified number of elements could be obtained.</term>
|
|
/// </item>
|
|
/// <item>
|
|
/// <term>E_INVALIDARG</term>
|
|
/// <term>pSpCmds is invalid.</term>
|
|
/// </item>
|
|
/// </list>
|
|
/// </returns>
|
|
[PreserveSig]
|
|
HRESULT Next([In] uint ulCount, [Out, MarshalAs(UnmanagedType.LPArray, ArraySubType = UnmanagedType.LPWStr)] string[] pSpCmds, [NullAllowed] out uint pcFetched);
|
|
|
|
/// <summary>Resets the enumerator object by moving the current position to the beginning of the enumeration sequence.</summary>
|
|
void Reset();
|
|
|
|
/// <summary>Moves the current position forward in the enumeration sequence by the specified number of elements.</summary>
|
|
/// <param name="ulCount">Contains the number of elements to skip.</param>
|
|
/// <returns>
|
|
/// <para>This method can return one of these values.</para>
|
|
/// <list type="table">
|
|
/// <listheader>
|
|
/// <term>Value</term>
|
|
/// <term>Description</term>
|
|
/// </listheader>
|
|
/// <item>
|
|
/// <term>S_OK</term>
|
|
/// <term>The method was successful.</term>
|
|
/// </item>
|
|
/// <item>
|
|
/// <term>S_FALSE</term>
|
|
/// <term>The method reached the end of the enumeration before the specified number of elements could be skipped.</term>
|
|
/// </item>
|
|
/// </list>
|
|
/// </returns>
|
|
[PreserveSig]
|
|
HRESULT Skip([In] uint ulCount);
|
|
}
|
|
|
|
/// <summary>
|
|
/// The <c>IEnumTfCandidates</c> interface is implemented by a text service and used by the TSF manager to provide an enumeration of
|
|
/// candidate string objects.
|
|
/// </summary>
|
|
// https://docs.microsoft.com/en-us/windows/win32/api/ctffunc/nn-ctffunc-ienumtfcandidates
|
|
[PInvokeData("ctffunc.h", MSDNShortId = "NN:ctffunc.IEnumTfCandidates")]
|
|
[ComImport, InterfaceType(ComInterfaceType.InterfaceIsIUnknown), Guid("DEFB1926-6C80-4CE8-87D4-D6B72B812BDE")]
|
|
public interface IEnumTfCandidates : ICOMEnum<ITfCandidateString>
|
|
{
|
|
/// <summary>Creates a copy of the enumerator object.</summary>
|
|
/// <param name="ppEnum">Pointer to an IEnumTfCandidates interface pointer that receives the new enumerator.</param>
|
|
/// <returns>
|
|
/// <para>This method can return one of these values.</para>
|
|
/// <list type="table">
|
|
/// <listheader>
|
|
/// <term>Value</term>
|
|
/// <term>Description</term>
|
|
/// </listheader>
|
|
/// <item>
|
|
/// <term>S_OK</term>
|
|
/// <term>The method was successful.</term>
|
|
/// </item>
|
|
/// <item>
|
|
/// <term>E_OUTOFMEMORY</term>
|
|
/// <term>A memory allocation failure occurred.</term>
|
|
/// </item>
|
|
/// </list>
|
|
/// </returns>
|
|
// https://docs.microsoft.com/en-us/windows/win32/api/ctffunc/nf-ctffunc-ienumtfcandidates-clone HRESULT Clone(
|
|
// IEnumTfCandidates **ppEnum );
|
|
[PreserveSig]
|
|
HRESULT Clone([Out, MarshalAs(UnmanagedType.Interface)] out IEnumTfCandidates ppEnum);
|
|
|
|
/// <summary>Obtains, from the current position, the specified number of elements in the enumeration sequence.</summary>
|
|
/// <param name="ulCount">Specifies the number of elements to obtain.</param>
|
|
/// <param name="ppCand">
|
|
/// Pointer to an array of ITfCandidateString interface pointers that receives the requested objects. This array must be at
|
|
/// least ulCount elements in size.
|
|
/// </param>
|
|
/// <param name="pcFetched">
|
|
/// Pointer to a ULONG value that receives the number of elements obtained. This value can be less than the number of items
|
|
/// requested. This parameter can be <c>NULL</c>.
|
|
/// </param>
|
|
/// <returns>
|
|
/// <para>This method can return one of these values.</para>
|
|
/// <list type="table">
|
|
/// <listheader>
|
|
/// <term>Value</term>
|
|
/// <term>Description</term>
|
|
/// </listheader>
|
|
/// <item>
|
|
/// <term>S_OK</term>
|
|
/// <term>The method was successful.</term>
|
|
/// </item>
|
|
/// <item>
|
|
/// <term>S_FALSE</term>
|
|
/// <term>The method reached the end of the enumeration before the specified number of elements were obtained.</term>
|
|
/// </item>
|
|
/// <item>
|
|
/// <term>E_INVALIDARG</term>
|
|
/// <term>ppCand is invalid.</term>
|
|
/// </item>
|
|
/// </list>
|
|
/// </returns>
|
|
// https://docs.microsoft.com/en-us/windows/win32/api/ctffunc/nf-ctffunc-ienumtfcandidates-next HRESULT Next( ULONG ulCount,
|
|
// ITfCandidateString **ppCand, ULONG *pcFetched );
|
|
[PreserveSig]
|
|
HRESULT Next([In] uint ulCount, [Out, MarshalAs(UnmanagedType.LPArray, ArraySubType = UnmanagedType.Interface)] ITfCandidateString[] ppCand, [NullAllowed] out uint pcFetched);
|
|
|
|
/// <summary>Resets the enumerator object by moving the current position to the beginning of the enumeration sequence.</summary>
|
|
/// <returns>
|
|
/// <para>This method can return one of these values.</para>
|
|
/// <list type="table">
|
|
/// <listheader>
|
|
/// <term>Value</term>
|
|
/// <term>Description</term>
|
|
/// </listheader>
|
|
/// <item>
|
|
/// <term>S_OK</term>
|
|
/// <term>The method was successful.</term>
|
|
/// </item>
|
|
/// </list>
|
|
/// </returns>
|
|
// https://docs.microsoft.com/en-us/windows/win32/api/ctffunc/nf-ctffunc-ienumtfcandidates-reset HRESULT Reset();
|
|
[PreserveSig]
|
|
HRESULT Reset();
|
|
|
|
/// <summary>Moves the current position forward in the enumeration sequence by the specified number of elements.</summary>
|
|
/// <param name="ulCount">Contains the number of elements to skip.</param>
|
|
/// <returns>
|
|
/// <para>This method can return one of these values.</para>
|
|
/// <list type="table">
|
|
/// <listheader>
|
|
/// <term>Value</term>
|
|
/// <term>Description</term>
|
|
/// </listheader>
|
|
/// <item>
|
|
/// <term>S_OK</term>
|
|
/// <term>The method was successful.</term>
|
|
/// </item>
|
|
/// <item>
|
|
/// <term>S_FALSE</term>
|
|
/// <term>The method reached the end of the enumeration before the specified number of elements could be skipped.</term>
|
|
/// </item>
|
|
/// </list>
|
|
/// </returns>
|
|
// https://docs.microsoft.com/en-us/windows/win32/api/ctffunc/nf-ctffunc-ienumtfcandidates-skip HRESULT Skip( ULONG ulCount );
|
|
[PreserveSig]
|
|
HRESULT Skip([In] uint ulCount);
|
|
}
|
|
|
|
/// <summary>
|
|
/// The <c>IEnumTfLatticeElements</c> interface is implemented by the TSF manager to provide an enumeration of lattice elements.
|
|
/// </summary>
|
|
// https://docs.microsoft.com/en-us/windows/win32/api/ctffunc/nn-ctffunc-ienumtflatticeelements
|
|
[PInvokeData("ctffunc.h", MSDNShortId = "NN:ctffunc.IEnumTfLatticeElements")]
|
|
[ComImport, Guid("56988052-47DA-4A05-911A-E3D941F17145"), InterfaceType(ComInterfaceType.InterfaceIsIUnknown)]
|
|
public interface IEnumTfLatticeElements : ICOMEnum<ITfCompositionView>
|
|
{
|
|
/// <summary>Creates a copy of the enumerator object.</summary>
|
|
/// <returns>Pointer to an IEnumTfLatticeElements interface pointer that receives the new enumerator.</returns>
|
|
// https://docs.microsoft.com/en-us/windows/win32/api/ctffunc/nf-ctffunc-ienumtflatticeelements-clone HRESULT Clone(
|
|
// IEnumTfLatticeElements **ppEnum );
|
|
IEnumTfLatticeElements Clone();
|
|
|
|
/// <summary>Obtains the specified number of elements in the enumeration sequence from the current position.</summary>
|
|
/// <param name="ulCount">Specifies the number of elements to obtain.</param>
|
|
/// <param name="rgsElements">
|
|
/// <para>
|
|
/// Pointer to an array of TF_LMLATTELEMENT structures that receives the requested data. This array must be at least ulCount
|
|
/// elements in size.
|
|
/// </para>
|
|
/// <para>
|
|
/// The caller must free the <c>bstrText</c> member of every structure obtained using SysFreeString when it is no longer required.
|
|
/// </para>
|
|
/// </param>
|
|
/// <param name="pcFetched">
|
|
/// Pointer to a ULONG value that receives the number of elements actually obtained. This value can be less than the number of
|
|
/// items requested. This parameter can be <c>NULL</c>.
|
|
/// </param>
|
|
/// <returns>
|
|
/// <para>This method can return one of these values.</para>
|
|
/// <list type="table">
|
|
/// <listheader>
|
|
/// <term>Value</term>
|
|
/// <term>Description</term>
|
|
/// </listheader>
|
|
/// <item>
|
|
/// <term>S_OK</term>
|
|
/// <term>The method was successful.</term>
|
|
/// </item>
|
|
/// <item>
|
|
/// <term>S_FALSE</term>
|
|
/// <term>The method reached the end of the enumeration before the specified number of elements could be obtained.</term>
|
|
/// </item>
|
|
/// <item>
|
|
/// <term>E_INVALIDARG</term>
|
|
/// <term>rgsElements is invalid.</term>
|
|
/// </item>
|
|
/// </list>
|
|
/// </returns>
|
|
// https://docs.microsoft.com/en-us/windows/win32/api/ctffunc/nf-ctffunc-ienumtflatticeelements-next HRESULT Next( ULONG
|
|
// ulCount, TF_LMLATTELEMENT *rgsElements, ULONG *pcFetched );
|
|
[PreserveSig]
|
|
HRESULT Next([In] uint ulCount, [Out] TF_LMLATTELEMENT[] rgsElements, [NullAllowed] out uint pcFetched);
|
|
|
|
/// <summary>Resets the enumerator object by moving the current position to the beginning of the enumeration sequence.</summary>
|
|
// https://docs.microsoft.com/en-us/windows/win32/api/ctffunc/nf-ctffunc-ienumtflatticeelements-reset HRESULT Reset();
|
|
void Reset();
|
|
|
|
/// <summary>Moves the current position forward in the enumeration sequence by the specified number of elements.</summary>
|
|
/// <param name="ulCount">Contains the number of elements to skip.</param>
|
|
/// <returns>
|
|
/// <para>This method can return one of these values.</para>
|
|
/// <list type="table">
|
|
/// <listheader>
|
|
/// <term>Value</term>
|
|
/// <term>Description</term>
|
|
/// </listheader>
|
|
/// <item>
|
|
/// <term>S_OK</term>
|
|
/// <term>The method was successful.</term>
|
|
/// </item>
|
|
/// <item>
|
|
/// <term>S_FALSE</term>
|
|
/// <term>The method reached the end of the enumeration before the specified number of elements could be skipped.</term>
|
|
/// </item>
|
|
/// </list>
|
|
/// </returns>
|
|
// https://docs.microsoft.com/en-us/windows/win32/api/ctffunc/nf-ctffunc-ienumtflatticeelements-skip HRESULT Skip( ULONG ulCount );
|
|
[PreserveSig]
|
|
HRESULT Skip([In] uint ulCount);
|
|
}
|
|
|
|
/// <summary>Undocumented.</summary>
|
|
[PInvokeData("ctffunc.h")]
|
|
[ComImport, Guid("38E09D4C-586D-435A-B592-C8A86691DEC6"), InterfaceType(ComInterfaceType.InterfaceIsIUnknown)]
|
|
public interface ISpeechCommandProvider
|
|
{
|
|
/// <summary>Undocumented.</summary>
|
|
/// <param name="langid">The langid.</param>
|
|
/// <param name="ppEnum">The pp enum.</param>
|
|
/// <returns></returns>
|
|
[PreserveSig]
|
|
HRESULT EnumSpeechCommands([In] LANGID langid, [Out, MarshalAs(UnmanagedType.Interface)] out IEnumSpeechCommands ppEnum);
|
|
|
|
/// <summary>Undocumented.</summary>
|
|
/// <param name="pszCommand">The PSZ command.</param>
|
|
/// <param name="cch">The CCH.</param>
|
|
/// <param name="langid">The langid.</param>
|
|
/// <returns></returns>
|
|
[PreserveSig]
|
|
HRESULT ProcessCommand([In, MarshalAs(UnmanagedType.LPWStr)] string pszCommand, [In] uint cch, [In] LANGID langid);
|
|
}
|
|
|
|
/// <summary>
|
|
/// <para>
|
|
/// The <c>ITfCandidateString</c> interface is implemented by a text service and is used by the TSF manager or a client to obtain
|
|
/// information about a candidate string object.
|
|
/// </para>
|
|
/// <para>
|
|
/// The TSF manager implements this interface to provide access to this interface to other clients. This enables the TSF manager to
|
|
/// function as a mediator between the client and the text service.
|
|
/// </para>
|
|
/// <para>To obtain an instance of this interface, the TSF manager or client can call ITfCandidateList::GetCandidate.</para>
|
|
/// </summary>
|
|
// https://docs.microsoft.com/en-us/windows/win32/api/ctffunc/nn-ctffunc-itfcandidatestring
|
|
[PInvokeData("ctffunc.h", MSDNShortId = "NN:ctffunc.ITfCandidateString")]
|
|
[ComImport, InterfaceType(ComInterfaceType.InterfaceIsIUnknown), Guid("581F317E-FD9D-443F-B972-ED00467C5D40")]
|
|
public interface ITfCandidateString
|
|
{
|
|
/// <summary>Obtains the text of the candidate string object.</summary>
|
|
/// <param name="pbstr">
|
|
/// Pointer to a <c>BSTR</c> value that receives the text of the candidate string object. The caller must release this memory
|
|
/// using SysFreeString when it is no longer required.
|
|
/// </param>
|
|
/// <returns>
|
|
/// <para>This method can return one of these values.</para>
|
|
/// <list type="table">
|
|
/// <listheader>
|
|
/// <term>Value</term>
|
|
/// <term>Description</term>
|
|
/// </listheader>
|
|
/// <item>
|
|
/// <term>S_OK</term>
|
|
/// <term>The method was successful.</term>
|
|
/// </item>
|
|
/// <item>
|
|
/// <term>E_INVALIDARG</term>
|
|
/// <term>pbstr is invalid.</term>
|
|
/// </item>
|
|
/// <item>
|
|
/// <term>E_OUTOFMEMORY</term>
|
|
/// <term>A memory allocation failure occurred.</term>
|
|
/// </item>
|
|
/// </list>
|
|
/// </returns>
|
|
// https://docs.microsoft.com/en-us/windows/win32/api/ctffunc/nf-ctffunc-itfcandidatestring-getstring HRESULT GetString( BSTR
|
|
// *pbstr );
|
|
[PreserveSig]
|
|
HRESULT GetString([Out, MarshalAs(UnmanagedType.BStr)] out string pbstr);
|
|
|
|
/// <summary>
|
|
/// <para>
|
|
/// <code>pnIndex</code>
|
|
/// </para>
|
|
/// <para>
|
|
/// Pointer to a <c>ULONG</c> value that receives the zero-based index of the candidate string object within the candidate list.
|
|
/// </para>
|
|
/// </summary>
|
|
/// <param name="pnIndex">
|
|
/// Pointer to a <c>ULONG</c> value that receives the zero-based index of the candidate string object within the candidate list.
|
|
/// </param>
|
|
/// <returns>
|
|
/// <para>This method can return one of these values.</para>
|
|
/// <list type="table">
|
|
/// <listheader>
|
|
/// <term>Value</term>
|
|
/// <term>Description</term>
|
|
/// </listheader>
|
|
/// <item>
|
|
/// <term>S_OK</term>
|
|
/// <term>The method was successful.</term>
|
|
/// </item>
|
|
/// <item>
|
|
/// <term>E_INVALIDARG</term>
|
|
/// <term>pnIndex is invalid.</term>
|
|
/// </item>
|
|
/// </list>
|
|
/// </returns>
|
|
// https://docs.microsoft.com/en-us/windows/win32/api/ctffunc/nf-ctffunc-itfcandidatestring-getindex HRESULT GetIndex( ULONG
|
|
// *pnIndex );
|
|
[PreserveSig]
|
|
HRESULT GetIndex(out uint pnIndex);
|
|
}
|
|
|
|
/// <summary>
|
|
/// <para>
|
|
/// The <c>ITfFnAdviseText</c> interface is implemented by a text service and used by the TSF manager to supply notifications when
|
|
/// the text or lattice element in a context changes.
|
|
/// </para>
|
|
/// <para>
|
|
/// The manager obtains this interface from the text service by calling the text service ITfFunctionProvider::GetFunction interface
|
|
/// with IID_ITfFnAdviseText.
|
|
/// </para>
|
|
/// </summary>
|
|
// https://docs.microsoft.com/en-us/windows/win32/api/ctffunc/nn-ctffunc-itffnadvisetext
|
|
[PInvokeData("ctffunc.h", MSDNShortId = "NN:ctffunc.ITfFnAdviseText")]
|
|
[ComImport, Guid("3527268B-7D53-4DD9-92B7-7296AE461249"), InterfaceType(ComInterfaceType.InterfaceIsIUnknown)]
|
|
public interface ITfFnAdviseText : ITfFunction
|
|
{
|
|
/// <summary>Obtains the function display name.</summary>
|
|
/// <param name="pbstrName">
|
|
/// Pointer to a BSTR value that receives the display name. This value must be allocated using SysAllocString. The caller must
|
|
/// free this memory using SysFreeString when it is no longer required.
|
|
/// </param>
|
|
/// <returns>
|
|
/// <para>This method can return one of these values.</para>
|
|
/// <list type="table">
|
|
/// <listheader>
|
|
/// <term>Value</term>
|
|
/// <term>Description</term>
|
|
/// </listheader>
|
|
/// <item>
|
|
/// <term>S_OK</term>
|
|
/// <term>The method was successful.</term>
|
|
/// </item>
|
|
/// <item>
|
|
/// <term>E_OUTOFMEMORY</term>
|
|
/// <term>A memory allocation failure occurred.</term>
|
|
/// </item>
|
|
/// <item>
|
|
/// <term>E_INVALIDARG</term>
|
|
/// <term>pbstrName is invalid.</term>
|
|
/// </item>
|
|
/// </list>
|
|
/// </returns>
|
|
// https://docs.microsoft.com/en-us/windows/win32/api/msctf/nf-msctf-itffunction-getdisplayname HRESULT GetDisplayName( BSTR
|
|
// *pbstrName );
|
|
[PreserveSig]
|
|
new HRESULT GetDisplayName([Out, MarshalAs(UnmanagedType.BStr)] out string pbstrName);
|
|
|
|
/// <summary>Called when the text within a context changes.</summary>
|
|
/// <param name="pRange">Pointer to an ITfRange object that represents the range of text that has changed.</param>
|
|
/// <param name="pchText">Pointer to a <c>WCHAR</c> buffer that contains the new text for the range.</param>
|
|
/// <param name="cch">Specifies the number of characters contained in pchText.</param>
|
|
/// <returns>
|
|
/// <para>This method can return one of these values.</para>
|
|
/// <list type="table">
|
|
/// <listheader>
|
|
/// <term>Value</term>
|
|
/// <term>Description</term>
|
|
/// </listheader>
|
|
/// <item>
|
|
/// <term>S_OK</term>
|
|
/// <term>The method was successful.</term>
|
|
/// </item>
|
|
/// <item>
|
|
/// <term>E_INVALIDARG</term>
|
|
/// <term>One or more parameters are invalid.</term>
|
|
/// </item>
|
|
/// </list>
|
|
/// </returns>
|
|
// https://docs.microsoft.com/en-us/windows/win32/api/ctffunc/nf-ctffunc-itffnadvisetext-ontextupdate HRESULT OnTextUpdate(
|
|
// ITfRange *pRange, const WCHAR *pchText, LONG cch );
|
|
[PreserveSig]
|
|
HRESULT OnTextUpdate([In] ITfRange pRange, [In, MarshalAs(UnmanagedType.LPWStr)] string pchText, int cch);
|
|
|
|
/// <summary>Called when a lattice element within a context changes.</summary>
|
|
/// <param name="pRange">Pointer to an ITfRange object that represents the range of text that changed.</param>
|
|
/// <param name="pLattice">Pointer to an ITfLMLattice object that represents the new lattice element.</param>
|
|
/// <returns>
|
|
/// <para>This method can return one of these values.</para>
|
|
/// <list type="table">
|
|
/// <listheader>
|
|
/// <term>Value</term>
|
|
/// <term>Description</term>
|
|
/// </listheader>
|
|
/// <item>
|
|
/// <term>S_OK</term>
|
|
/// <term>The method was successful.</term>
|
|
/// </item>
|
|
/// <item>
|
|
/// <term>E_INVALIDARG</term>
|
|
/// <term>One or more parameters are invalid.</term>
|
|
/// </item>
|
|
/// </list>
|
|
/// </returns>
|
|
// https://docs.microsoft.com/en-us/windows/win32/api/ctffunc/nf-ctffunc-itffnadvisetext-onlatticeupdate HRESULT
|
|
// OnLatticeUpdate( ITfRange *pRange, ITfLMLattice *pLattice );
|
|
[PreserveSig]
|
|
HRESULT OnLatticeUpdate([In] ITfRange pRange, [In] ITfLMLattice pLattice);
|
|
}
|
|
|
|
/// <summary>
|
|
/// <para>
|
|
/// The <c>ITfFnBalloon</c> interface is implemented by a text service and is used by an application or other text service to update
|
|
/// the balloon item that the text service adds to the language bar.
|
|
/// </para>
|
|
/// <para>
|
|
/// An application or text service obtains an instance of this interface by calling ITfThreadMgr::GetFunctionProvider with the class
|
|
/// identifier of the text service and then calling ITfFunctionProvider::GetFunction with GUID_NULL and IID_ITfFnBalloon.
|
|
/// </para>
|
|
/// </summary>
|
|
// https://docs.microsoft.com/en-us/windows/win32/api/ctffunc/nn-ctffunc-itffnballoon
|
|
[PInvokeData("ctffunc.h", MSDNShortId = "NN:ctffunc.ITfFnBalloon")]
|
|
[ComImport, InterfaceType(ComInterfaceType.InterfaceIsIUnknown), Guid("3BAB89E4-5FBE-45F4-A5BC-DCA36AD225A8")]
|
|
public interface ITfFnBalloon
|
|
{
|
|
/// <summary>Changes the style and text of a language bar balloon item.</summary>
|
|
/// <param name="style">Contains one of the TfLBBalloonStyle values that specifies the new balloon style.</param>
|
|
/// <param name="pch">Pointer to a <c>WCHAR</c> buffer that contains the new text for the balloon.</param>
|
|
/// <param name="cch">Contains the number of characters of the new text in pch.</param>
|
|
/// <returns>
|
|
/// <para>This method can return one of these values.</para>
|
|
/// <list type="table">
|
|
/// <listheader>
|
|
/// <term>Value</term>
|
|
/// <term>Description</term>
|
|
/// </listheader>
|
|
/// <item>
|
|
/// <term>S_OK</term>
|
|
/// <term>The method was successful.</term>
|
|
/// </item>
|
|
/// <item>
|
|
/// <term>E_INVALIDARG</term>
|
|
/// <term>One or more parameters are invalid.</term>
|
|
/// </item>
|
|
/// </list>
|
|
/// </returns>
|
|
/// <remarks>
|
|
/// The language bar balloon implementation should update its style and text by modifying the values returned from
|
|
/// ITfLangBarItemBalloon::GetBalloonInfo and then call ITfLangBarItemSink::OnUpdate with TF_LBI_BALLOON to cause the language
|
|
/// bar to obtain the updated information.
|
|
/// </remarks>
|
|
// https://docs.microsoft.com/en-us/windows/win32/api/ctffunc/nf-ctffunc-itffnballoon-updateballoon HRESULT UpdateBalloon(
|
|
// TfLBBalloonStyle style, const WCHAR *pch, ULONG cch );
|
|
[PreserveSig]
|
|
HRESULT UpdateBalloon([In] TfLBBalloonStyle style, [In, MarshalAs(UnmanagedType.LPWStr)] string pch, uint cch);
|
|
}
|
|
|
|
/// <summary>
|
|
/// <para>
|
|
/// The <c>ITfFnConfigure</c> interface is implemented by a text service to enable the Text Services control panel application to
|
|
/// allow the text service to display a configuration dialog box.
|
|
/// </para>
|
|
/// <para>
|
|
/// The Text Services control panel application obtains an instance of this interface by calling CoCreateInstance with the class
|
|
/// identifier passed to ITfInputProcessorProfiles::Register and IID_ITfFnConfigure.
|
|
/// </para>
|
|
/// </summary>
|
|
// https://docs.microsoft.com/en-us/windows/win32/api/ctffunc/nn-ctffunc-itffnconfigure
|
|
[PInvokeData("ctffunc.h", MSDNShortId = "NN:ctffunc.ITfFnConfigure")]
|
|
[ComImport, Guid("88F567C6-1757-49F8-A1B2-89234C1EEFF9"), InterfaceType(ComInterfaceType.InterfaceIsIUnknown)]
|
|
public interface ITfFnConfigure : ITfFunction
|
|
{
|
|
/// <summary>Obtains the function display name.</summary>
|
|
/// <param name="pbstrName">
|
|
/// Pointer to a BSTR value that receives the display name. This value must be allocated using SysAllocString. The caller must
|
|
/// free this memory using SysFreeString when it is no longer required.
|
|
/// </param>
|
|
/// <returns>
|
|
/// <para>This method can return one of these values.</para>
|
|
/// <list type="table">
|
|
/// <listheader>
|
|
/// <term>Value</term>
|
|
/// <term>Description</term>
|
|
/// </listheader>
|
|
/// <item>
|
|
/// <term>S_OK</term>
|
|
/// <term>The method was successful.</term>
|
|
/// </item>
|
|
/// <item>
|
|
/// <term>E_OUTOFMEMORY</term>
|
|
/// <term>A memory allocation failure occurred.</term>
|
|
/// </item>
|
|
/// <item>
|
|
/// <term>E_INVALIDARG</term>
|
|
/// <term>pbstrName is invalid.</term>
|
|
/// </item>
|
|
/// </list>
|
|
/// </returns>
|
|
// https://docs.microsoft.com/en-us/windows/win32/api/msctf/nf-msctf-itffunction-getdisplayname HRESULT GetDisplayName( BSTR
|
|
// *pbstrName );
|
|
[PreserveSig]
|
|
new HRESULT GetDisplayName([Out, MarshalAs(UnmanagedType.BStr)] out string pbstrName);
|
|
|
|
/// <summary>
|
|
/// Called when the user opens the Text Services control panel application, selects the text service from the list and presses
|
|
/// the Properties pushbutton.
|
|
/// </summary>
|
|
/// <param name="hwndParent">
|
|
/// Handle of the parent window. The text service typically uses this as the parent or owner window when creating a dialog box.
|
|
/// </param>
|
|
/// <param name="langid">
|
|
/// Contains a <c>LANGID</c> value that specifies the identifier of the language selected in the Text Services control panel application.
|
|
/// </param>
|
|
/// <param name="rguidProfile">
|
|
/// Contains a GUID value that specifies the language profile identifier that the text service is under. This is the value
|
|
/// specified in ITfInputProcessorProfiles::AddLanguageProfile when the profile was added.
|
|
/// </param>
|
|
/// <returns>If this method succeeds, it returns <c>S_OK</c>. Otherwise, it returns an <c>HRESULT</c> error code.</returns>
|
|
/// <remarks>This method should not return until the user closes the dialog box or property sheet.</remarks>
|
|
// https://docs.microsoft.com/en-us/windows/win32/api/ctffunc/nf-ctffunc-itffnconfigure-show HRESULT Show( HWND hwndParent,
|
|
// LANGID langid, REFGUID rguidProfile );
|
|
[PreserveSig]
|
|
HRESULT Show([In] HWND hwndParent, [In] LANGID langid, in Guid rguidProfile);
|
|
}
|
|
|
|
/// <summary>
|
|
/// The <c>ITfFnConfigureRegisterEudc</c> interface is implemented by a text service to provide the UI to register the key sequence
|
|
/// for the given EUDC.
|
|
/// </summary>
|
|
// https://docs.microsoft.com/en-us/windows/win32/api/ctffunc/nn-ctffunc-itffnconfigureregistereudc
|
|
[PInvokeData("ctffunc.h", MSDNShortId = "NN:ctffunc.ITfFnConfigureRegisterEudc")]
|
|
[ComImport, Guid("B5E26FF5-D7AD-4304-913F-21A2ED95A1B0"), InterfaceType(ComInterfaceType.InterfaceIsIUnknown)]
|
|
public interface ITfFnConfigureRegisterEudc : ITfFunction
|
|
{
|
|
/// <summary>Obtains the function display name.</summary>
|
|
/// <param name="pbstrName">
|
|
/// Pointer to a BSTR value that receives the display name. This value must be allocated using SysAllocString. The caller must
|
|
/// free this memory using SysFreeString when it is no longer required.
|
|
/// </param>
|
|
/// <returns>
|
|
/// <para>This method can return one of these values.</para>
|
|
/// <list type="table">
|
|
/// <listheader>
|
|
/// <term>Value</term>
|
|
/// <term>Description</term>
|
|
/// </listheader>
|
|
/// <item>
|
|
/// <term>S_OK</term>
|
|
/// <term>The method was successful.</term>
|
|
/// </item>
|
|
/// <item>
|
|
/// <term>E_OUTOFMEMORY</term>
|
|
/// <term>A memory allocation failure occurred.</term>
|
|
/// </item>
|
|
/// <item>
|
|
/// <term>E_INVALIDARG</term>
|
|
/// <term>pbstrName is invalid.</term>
|
|
/// </item>
|
|
/// </list>
|
|
/// </returns>
|
|
// https://docs.microsoft.com/en-us/windows/win32/api/msctf/nf-msctf-itffunction-getdisplayname HRESULT GetDisplayName( BSTR
|
|
// *pbstrName );
|
|
[PreserveSig]
|
|
new HRESULT GetDisplayName([Out, MarshalAs(UnmanagedType.BStr)] out string pbstrName);
|
|
|
|
/// <summary>The ITfFnConfigureRegisterEudc::Show method shows the EUDC key sequence register UI.</summary>
|
|
/// <param name="hwndParent">
|
|
/// [in] Handle of the parent window. The text service typically uses this as the parent or owner window when creating a dialog box.
|
|
/// </param>
|
|
/// <param name="langid">[in] Contains a LANGID value that specifies the identifier of the language.</param>
|
|
/// <param name="rguidProfile">
|
|
/// [in] Contains a GUID value that specifies the language profile identifier that the text service is under.
|
|
/// </param>
|
|
/// <param name="bstrRegistered">
|
|
/// [in, unique] Contains a BSTR that contains the EUDC to be registered with the text service. This is optional and can be
|
|
/// <c>NULL</c>. If <c>NULL</c>, the text service should display a default register EUDC dialog box.
|
|
/// </param>
|
|
/// <returns>
|
|
/// <para>This method can return one of these values.</para>
|
|
/// <list type="table">
|
|
/// <listheader>
|
|
/// <term>Value</term>
|
|
/// <term>Description</term>
|
|
/// </listheader>
|
|
/// <item>
|
|
/// <term>S_OK</term>
|
|
/// <term>The method was successful.</term>
|
|
/// </item>
|
|
/// <item>
|
|
/// <term>E_FAIL</term>
|
|
/// <term>An unspecified error occurred.</term>
|
|
/// </item>
|
|
/// </list>
|
|
/// </returns>
|
|
// https://docs.microsoft.com/en-us/windows/win32/api/ctffunc/nf-ctffunc-itffnconfigureregistereudc-show HRESULT Show( HWND
|
|
// hwndParent, LANGID langid, REFGUID rguidProfile, BSTR bstrRegistered );
|
|
[PreserveSig]
|
|
HRESULT Show([In] HWND hwndParent, [In] LANGID langid, in Guid rguidProfile, [In, Optional, MarshalAs(UnmanagedType.BStr)] string bstrRegistered);
|
|
}
|
|
|
|
/// <summary>
|
|
/// <para>
|
|
/// The <c>ITfFnConfigureRegisterWord</c> interface is implemented by a text service to enable the Active Input Method Editor (IME)
|
|
/// to cause the text service to display a word registration dialog box.
|
|
/// </para>
|
|
/// <para>To obtain an instance of this interface the IME can call ITfFunctionProvider::GetFunction with IID_ITfFnConfigureRegisterWord.</para>
|
|
/// </summary>
|
|
// https://docs.microsoft.com/en-us/windows/win32/api/ctffunc/nn-ctffunc-itffnconfigureregisterword
|
|
[PInvokeData("ctffunc.h", MSDNShortId = "NN:ctffunc.ITfFnConfigureRegisterWord")]
|
|
[ComImport, Guid("BB95808A-6D8F-4BCA-8400-5390B586AEDF"), InterfaceType(ComInterfaceType.InterfaceIsIUnknown)]
|
|
public interface ITfFnConfigureRegisterWord : ITfFunction
|
|
{
|
|
/// <summary>Obtains the function display name.</summary>
|
|
/// <param name="pbstrName">
|
|
/// Pointer to a BSTR value that receives the display name. This value must be allocated using SysAllocString. The caller must
|
|
/// free this memory using SysFreeString when it is no longer required.
|
|
/// </param>
|
|
/// <returns>
|
|
/// <para>This method can return one of these values.</para>
|
|
/// <list type="table">
|
|
/// <listheader>
|
|
/// <term>Value</term>
|
|
/// <term>Description</term>
|
|
/// </listheader>
|
|
/// <item>
|
|
/// <term>S_OK</term>
|
|
/// <term>The method was successful.</term>
|
|
/// </item>
|
|
/// <item>
|
|
/// <term>E_OUTOFMEMORY</term>
|
|
/// <term>A memory allocation failure occurred.</term>
|
|
/// </item>
|
|
/// <item>
|
|
/// <term>E_INVALIDARG</term>
|
|
/// <term>pbstrName is invalid.</term>
|
|
/// </item>
|
|
/// </list>
|
|
/// </returns>
|
|
// https://docs.microsoft.com/en-us/windows/win32/api/msctf/nf-msctf-itffunction-getdisplayname HRESULT GetDisplayName( BSTR
|
|
// *pbstrName );
|
|
[PreserveSig]
|
|
new HRESULT GetDisplayName([Out, MarshalAs(UnmanagedType.BStr)] out string pbstrName);
|
|
|
|
/// <summary>Called to cause the text service to display a dialog box to register a word with the text service.</summary>
|
|
/// <param name="hwndParent">
|
|
/// Handle of the parent window. The text service typically uses this as the parent or owner window when creating the dialog box.
|
|
/// </param>
|
|
/// <param name="langid">
|
|
/// Contains a <c>LANGID</c> that specifies the identifier of the language currently used by the Input Method Editor (IME).
|
|
/// </param>
|
|
/// <param name="rguidProfile">
|
|
/// Contains a GUID that specifies the language profile identifier that the text service is under. This is the value specified
|
|
/// in ITfInputProcessorProfiles::AddLanguageProfile when the profile was added.
|
|
/// </param>
|
|
/// <param name="bstrRegistered">
|
|
/// Contains a <c>BSTR</c> that contains the word to be registered with the text service. This is optional and can be NULL. If
|
|
/// NULL, the text service should display a default register word dialog box.
|
|
/// </param>
|
|
/// <returns>
|
|
/// <para>This method can return one of these values.</para>
|
|
/// <list type="table">
|
|
/// <listheader>
|
|
/// <term>Value</term>
|
|
/// <term>Description</term>
|
|
/// </listheader>
|
|
/// <item>
|
|
/// <term>S_OK</term>
|
|
/// <term>The method was successful.</term>
|
|
/// </item>
|
|
/// <item>
|
|
/// <term>E_NOTIMPL</term>
|
|
/// <term>The text service does not implement this method.</term>
|
|
/// </item>
|
|
/// </list>
|
|
/// </returns>
|
|
// https://docs.microsoft.com/en-us/windows/win32/api/ctffunc/nf-ctffunc-itffnconfigureregisterword-show HRESULT Show( HWND
|
|
// hwndParent, LANGID langid, REFGUID rguidProfile, BSTR bstrRegistered );
|
|
[PreserveSig]
|
|
HRESULT Show([In] HWND hwndParent, [In] LANGID langid, in Guid rguidProfile, [In, Optional, MarshalAs(UnmanagedType.BStr)] string bstrRegistered);
|
|
}
|
|
|
|
/// <summary>Undocumented.</summary>
|
|
/// <seealso cref="Vanara.PInvoke.MSCTF.ITfFunction"/>
|
|
[PInvokeData("ctffunc.h")]
|
|
[ComImport, Guid("FCA6C349-A12F-43A3-8DD6-5A5A4282577B"), InterfaceType(ComInterfaceType.InterfaceIsIUnknown)]
|
|
public interface ITfFnCustomSpeechCommand : ITfFunction
|
|
{
|
|
/// <summary>Obtains the function display name.</summary>
|
|
/// <param name="pbstrName">
|
|
/// Pointer to a BSTR value that receives the display name. This value must be allocated using SysAllocString. The caller must
|
|
/// free this memory using SysFreeString when it is no longer required.
|
|
/// </param>
|
|
/// <returns>
|
|
/// <para>This method can return one of these values.</para>
|
|
/// <list type="table">
|
|
/// <listheader>
|
|
/// <term>Value</term>
|
|
/// <term>Description</term>
|
|
/// </listheader>
|
|
/// <item>
|
|
/// <term>S_OK</term>
|
|
/// <term>The method was successful.</term>
|
|
/// </item>
|
|
/// <item>
|
|
/// <term>E_OUTOFMEMORY</term>
|
|
/// <term>A memory allocation failure occurred.</term>
|
|
/// </item>
|
|
/// <item>
|
|
/// <term>E_INVALIDARG</term>
|
|
/// <term>pbstrName is invalid.</term>
|
|
/// </item>
|
|
/// </list>
|
|
/// </returns>
|
|
// https://docs.microsoft.com/en-us/windows/win32/api/msctf/nf-msctf-itffunction-getdisplayname HRESULT GetDisplayName( BSTR
|
|
// *pbstrName );
|
|
[PreserveSig]
|
|
new HRESULT GetDisplayName([Out, MarshalAs(UnmanagedType.BStr)] out string pbstrName);
|
|
|
|
/// <summary>Undocumented.</summary>
|
|
/// <param name="pspcmdProvider">Undocumented.</param>
|
|
/// <returns>Undocumented.</returns>
|
|
[PreserveSig]
|
|
HRESULT SetSpeechCommandProvider([In, MarshalAs(UnmanagedType.IUnknown)] object pspcmdProvider);
|
|
}
|
|
|
|
/// <summary>
|
|
/// <para>
|
|
/// The <c>ITfFnGetPreferredTouchKeyboardLayout</c> interface is implemented by a text service to specify the use of a particular
|
|
/// keyboard layout supported by the inbox Windows 8 touch keyboard.
|
|
/// </para>
|
|
/// <para>
|
|
/// When an IME is active the touch keyboard will use ITfFunctionProvider::GetFunction with
|
|
/// <c>IID_ITfFnGetPreferredTouchKeyboardLayout</c> to query the IME for this function.
|
|
/// </para>
|
|
/// <para>If the function is not supported by the IME, then the touch keyboard will show the default layout for the language.</para>
|
|
/// </summary>
|
|
/// <remarks>
|
|
/// <para>For more information on the layouts which can be specified, see GetLayout.</para>
|
|
/// <para>
|
|
/// This interface applies only to IMEs written using the Text Services Framework and not to legacy IMM32 IMEs, and it only applies
|
|
/// to the following input languages:
|
|
/// </para>
|
|
/// <list type="bullet">
|
|
/// <item>
|
|
/// <term>Japanese</term>
|
|
/// </item>
|
|
/// <item>
|
|
/// <term>Korean</term>
|
|
/// </item>
|
|
/// <item>
|
|
/// <term>Simplified Chinese</term>
|
|
/// </item>
|
|
/// <item>
|
|
/// <term>Traditional Chinese</term>
|
|
/// </item>
|
|
/// </list>
|
|
/// </remarks>
|
|
// https://docs.microsoft.com/en-us/windows/win32/api/ctffunc/nn-ctffunc-itffngetpreferredtouchkeyboardlayout
|
|
[PInvokeData("ctffunc.h", MSDNShortId = "NN:ctffunc.ITfFnGetPreferredTouchKeyboardLayout")]
|
|
[ComImport, InterfaceType(ComInterfaceType.InterfaceIsIUnknown), Guid("5F309A41-590A-4ACC-A97F-D8EFFF13FDFC")]
|
|
public interface ITfFnGetPreferredTouchKeyboardLayout
|
|
{
|
|
/// <summary>
|
|
/// Obtains the touch keyboard layout identifier of the layout that the IME directs the touch keyboard to show while the IME is active.
|
|
/// </summary>
|
|
/// <param name="pTKBLayoutType">Pointer to a TKBLayoutType enumeration that receives the layout type.</param>
|
|
/// <param name="pwPreferredLayoutId">Pointer to a <c>WORD</c> value that receives the layout identifier.</param>
|
|
/// <returns>The touch keyboard always expects S_OK.</returns>
|
|
/// <remarks>
|
|
/// <para>TKBLayoutType is an enumeration with the following values.</para>
|
|
/// <list type="table">
|
|
/// <listheader>
|
|
/// <term>TKBLT_UNDEFINED</term>
|
|
/// <term>Undefined.</term>
|
|
/// </listheader>
|
|
/// <item>
|
|
/// <term>TKBLT_CLASSIC</term>
|
|
/// <term>The touch keyboard is to use a classic layout. Classic layouts represent the legacy layouts of physical keyboards.</term>
|
|
/// </item>
|
|
/// <item>
|
|
/// <term>TKBLT_OPTIMIZED</term>
|
|
/// <term>
|
|
/// The touch keyboard is to use a touch-optimized layout. Touch-optimized layouts have been specifically designed with touch in mind.
|
|
/// </term>
|
|
/// </item>
|
|
/// </list>
|
|
/// <para>
|
|
/// The layout identifiers returned by this API must be one from the following list. Each identifier is specific to a certain
|
|
/// language, and these are all specific to the touch keyboard. There is no way to request support for other layouts, or to add
|
|
/// new touch optimized layouts dynamically.
|
|
/// </para>
|
|
/// <list type="table">
|
|
/// <listheader>
|
|
/// <term>Layout Definition</term>
|
|
/// <term>Value</term>
|
|
/// <term>Supported Input Language</term>
|
|
/// </listheader>
|
|
/// <item>
|
|
/// <term>TKBL_UNDEFINED</term>
|
|
/// <term>0</term>
|
|
/// <term>n/a</term>
|
|
/// </item>
|
|
/// <item>
|
|
/// <term>TKBL_CLASSIC_TRADITIONAL_CHINESE_PHONETIC</term>
|
|
/// <term>0x0404</term>
|
|
/// <term>CHT</term>
|
|
/// </item>
|
|
/// <item>
|
|
/// <term>TKBL_CLASSIC_TRADITIONAL_CHINESE_CHANGJIE</term>
|
|
/// <term>0xF042</term>
|
|
/// <term>CHT</term>
|
|
/// </item>
|
|
/// <item>
|
|
/// <term>TKBL_CLASSIC_TRADITIONAL_CHINESE_DAYI</term>
|
|
/// <term>0xF043</term>
|
|
/// <term>CHT</term>
|
|
/// </item>
|
|
/// <item>
|
|
/// <term>TKBL_OPT_JAPANESE_ABC</term>
|
|
/// <term>0x0411</term>
|
|
/// <term>JPN</term>
|
|
/// </item>
|
|
/// <item>
|
|
/// <term>TKBL_OPT_KOREAN_HANGUL_2_BULSIK</term>
|
|
/// <term>0x0412</term>
|
|
/// <term>KOR</term>
|
|
/// </item>
|
|
/// <item>
|
|
/// <term>TKBL_OPT_SIMPLIFIED_CHINESE_PINYIN</term>
|
|
/// <term>0x0804</term>
|
|
/// <term>CHS</term>
|
|
/// </item>
|
|
/// <item>
|
|
/// <term>TKBL_OPT_TRADITIONAL_CHINESE_PHONETIC</term>
|
|
/// <term>0x0404</term>
|
|
/// <term>CHT</term>
|
|
/// </item>
|
|
/// </list>
|
|
/// </remarks>
|
|
// https://docs.microsoft.com/en-us/windows/win32/api/ctffunc/nf-ctffunc-itffngetpreferredtouchkeyboardlayout-getlayout HRESULT
|
|
// GetLayout( TKBLayoutType *pTKBLayoutType, WORD *pwPreferredLayoutId );
|
|
[PreserveSig]
|
|
HRESULT GetLayout(out TKBLayoutType pTKBLayoutType, out TKBLayoutId pwPreferredLayoutId);
|
|
}
|
|
|
|
/// <summary>
|
|
/// <para>
|
|
/// The <c>ITfFnGetSAPIObject</c> interface is implemented by the Speech API (SAPI) text service. This interface is used by the TSF
|
|
/// manager or a client (application or other text service) to obtain various SAPI objects.
|
|
/// </para>
|
|
/// <para>
|
|
/// A client obtains an instance of this interface by obtaining the ITfFunctionProvider for the SAPI text service and calling
|
|
/// ITfFunctionProvider::GetFunction with IID_ITfFnGetSAPIObject.
|
|
/// </para>
|
|
/// </summary>
|
|
// https://docs.microsoft.com/en-us/windows/win32/api/ctffunc/nn-ctffunc-itffngetsapiobject
|
|
[PInvokeData("ctffunc.h", MSDNShortId = "NN:ctffunc.ITfFnGetSAPIObject")]
|
|
[ComImport, InterfaceType(ComInterfaceType.InterfaceIsIUnknown), Guid("5C0AB7EA-167D-4F59-BFB5-4693755E90CA")]
|
|
public interface ITfFnGetSAPIObject : ITfFunction
|
|
{
|
|
/// <summary>Obtains the function display name.</summary>
|
|
/// <param name="pbstrName">
|
|
/// Pointer to a BSTR value that receives the display name. This value must be allocated using SysAllocString. The caller must
|
|
/// free this memory using SysFreeString when it is no longer required.
|
|
/// </param>
|
|
/// <returns>
|
|
/// <para>This method can return one of these values.</para>
|
|
/// <list type="table">
|
|
/// <listheader>
|
|
/// <term>Value</term>
|
|
/// <term>Description</term>
|
|
/// </listheader>
|
|
/// <item>
|
|
/// <term>S_OK</term>
|
|
/// <term>The method was successful.</term>
|
|
/// </item>
|
|
/// <item>
|
|
/// <term>E_OUTOFMEMORY</term>
|
|
/// <term>A memory allocation failure occurred.</term>
|
|
/// </item>
|
|
/// <item>
|
|
/// <term>E_INVALIDARG</term>
|
|
/// <term>pbstrName is invalid.</term>
|
|
/// </item>
|
|
/// </list>
|
|
/// </returns>
|
|
// https://docs.microsoft.com/en-us/windows/win32/api/msctf/nf-msctf-itffunction-getdisplayname HRESULT GetDisplayName( BSTR
|
|
// *pbstrName );
|
|
[PreserveSig]
|
|
new HRESULT GetDisplayName([Out, MarshalAs(UnmanagedType.BStr)] out string pbstrName);
|
|
|
|
/// <summary>Obtains a specified SAPI object.</summary>
|
|
/// <param name="sObj">Contains a TfSapiObject value that specifies the SAPI object to obtain.</param>
|
|
/// <param name="ppunk">
|
|
/// Pointer to an <c>IUnknown</c> interface pointer that receives the requested SAPI object. The caller must release this
|
|
/// interface when it is no longer required.
|
|
/// </param>
|
|
/// <returns>
|
|
/// <para>This method can return one of these values.</para>
|
|
/// <list type="table">
|
|
/// <listheader>
|
|
/// <term>Value</term>
|
|
/// <term>Description</term>
|
|
/// </listheader>
|
|
/// <item>
|
|
/// <term>S_OK</term>
|
|
/// <term>The method was successful.</term>
|
|
/// </item>
|
|
/// <item>
|
|
/// <term>S_FALSE</term>
|
|
/// <term>The requested object cannot be obtained.</term>
|
|
/// </item>
|
|
/// <item>
|
|
/// <term>E_NOTIMPL</term>
|
|
/// <term>The requested object is not implemented.</term>
|
|
/// </item>
|
|
/// </list>
|
|
/// </returns>
|
|
// https://docs.microsoft.com/en-us/windows/win32/api/ctffunc/nf-ctffunc-itffngetsapiobject-get HRESULT Get( TfSapiObject sObj,
|
|
// IUnknown **ppunk );
|
|
[PreserveSig]
|
|
HRESULT Get([In] TfSapiObject sObj, [Out, MarshalAs(UnmanagedType.IUnknown)] out object ppunk);
|
|
}
|
|
|
|
/// <summary>
|
|
/// The <c>ITfFnLangProfileUtil</c> interface is implemented by the speech text service and used to provide utility methods for the
|
|
/// speech text service. A text service can create an instance of this interface by calling CoCreateInstance with CLSID_SapiLayr and IID_ITfFnLangProfileUtil.
|
|
/// </summary>
|
|
// https://docs.microsoft.com/en-us/windows/win32/api/ctffunc/nn-ctffunc-itffnlangprofileutil
|
|
[PInvokeData("ctffunc.h", MSDNShortId = "NN:ctffunc.ITfFnLangProfileUtil")]
|
|
[ComImport, InterfaceType(ComInterfaceType.InterfaceIsIUnknown), Guid("A87A8574-A6C1-4E15-99F0-3D3965F548EB")]
|
|
public interface ITfFnLangProfileUtil : ITfFunction
|
|
{
|
|
/// <summary>Obtains the function display name.</summary>
|
|
/// <param name="pbstrName">
|
|
/// Pointer to a BSTR value that receives the display name. This value must be allocated using SysAllocString. The caller must
|
|
/// free this memory using SysFreeString when it is no longer required.
|
|
/// </param>
|
|
/// <returns>
|
|
/// <para>This method can return one of these values.</para>
|
|
/// <list type="table">
|
|
/// <listheader>
|
|
/// <term>Value</term>
|
|
/// <term>Description</term>
|
|
/// </listheader>
|
|
/// <item>
|
|
/// <term>S_OK</term>
|
|
/// <term>The method was successful.</term>
|
|
/// </item>
|
|
/// <item>
|
|
/// <term>E_OUTOFMEMORY</term>
|
|
/// <term>A memory allocation failure occurred.</term>
|
|
/// </item>
|
|
/// <item>
|
|
/// <term>E_INVALIDARG</term>
|
|
/// <term>pbstrName is invalid.</term>
|
|
/// </item>
|
|
/// </list>
|
|
/// </returns>
|
|
// https://docs.microsoft.com/en-us/windows/win32/api/msctf/nf-msctf-itffunction-getdisplayname HRESULT GetDisplayName( BSTR
|
|
// *pbstrName );
|
|
[PreserveSig]
|
|
new HRESULT GetDisplayName([Out, MarshalAs(UnmanagedType.BStr)] out string pbstrName);
|
|
|
|
/// <summary>Causes the speech text service to register its active profiles.</summary>
|
|
/// <returns>
|
|
/// <para>This method can return one of these values.</para>
|
|
/// <list type="table">
|
|
/// <listheader>
|
|
/// <term>Value</term>
|
|
/// <term>Description</term>
|
|
/// </listheader>
|
|
/// <item>
|
|
/// <term>S_OK</term>
|
|
/// <term>The method was successful.</term>
|
|
/// </item>
|
|
/// <item>
|
|
/// <term>S_FALSE</term>
|
|
/// <term>The speech text service removed its active profiles based on user actions.</term>
|
|
/// </item>
|
|
/// <item>
|
|
/// <term>E_FAIL</term>
|
|
/// <term>An unspecified error occurred.</term>
|
|
/// </item>
|
|
/// </list>
|
|
/// </returns>
|
|
// https://docs.microsoft.com/en-us/windows/win32/api/ctffunc/nf-ctffunc-itffnlangprofileutil-registeractiveprofiles HRESULT RegisterActiveProfiles();
|
|
[PreserveSig]
|
|
HRESULT RegisterActiveProfiles();
|
|
|
|
/// <summary>Determines if the speech text service has a profile available for a specific language.</summary>
|
|
/// <param name="langid">Contains a <c>LANGID</c> that specifies the language that the query applies to.</param>
|
|
/// <param name="pfAvailable">
|
|
/// Pointer to a <c>BOOL</c> that receives nonzero if a profile is available for the language identified by langid or zero otherwise.
|
|
/// </param>
|
|
/// <returns>
|
|
/// <para>This method can return one of these values.</para>
|
|
/// <list type="table">
|
|
/// <listheader>
|
|
/// <term>Value</term>
|
|
/// <term>Description</term>
|
|
/// </listheader>
|
|
/// <item>
|
|
/// <term>S_OK</term>
|
|
/// <term>The method was successful.</term>
|
|
/// </item>
|
|
/// <item>
|
|
/// <term>E_INVALIDARG</term>
|
|
/// <term>pfAvailable is invalid.</term>
|
|
/// </item>
|
|
/// </list>
|
|
/// </returns>
|
|
// https://docs.microsoft.com/en-us/windows/win32/api/ctffunc/nf-ctffunc-itffnlangprofileutil-isprofileavailableforlang HRESULT
|
|
// IsProfileAvailableForLang( LANGID langid, BOOL *pfAvailable );
|
|
[PreserveSig]
|
|
HRESULT IsProfileAvailableForLang([In] LANGID langid, [Out, MarshalAs(UnmanagedType.Bool)] out bool pfAvailable);
|
|
}
|
|
|
|
/// <summary>The <c>ITfFnLMInternal</c> interface is not used.</summary>
|
|
// https://docs.microsoft.com/en-us/windows/win32/api/ctffunc/nn-ctffunc-itffnlminternal
|
|
[PInvokeData("ctffunc.h", MSDNShortId = "NN:ctffunc.ITfFnLMInternal")]
|
|
[ComImport, Guid("04B825B1-AC9A-4F7B-B5AD-C7168F1EE445"), InterfaceType(ComInterfaceType.InterfaceIsIUnknown)]
|
|
public interface ITfFnLMInternal : ITfFnLMProcessor
|
|
{
|
|
/// <summary>Obtains the function display name.</summary>
|
|
/// <param name="pbstrName">
|
|
/// Pointer to a BSTR value that receives the display name. This value must be allocated using SysAllocString. The caller must
|
|
/// free this memory using SysFreeString when it is no longer required.
|
|
/// </param>
|
|
/// <returns>
|
|
/// <para>This method can return one of these values.</para>
|
|
/// <list type="table">
|
|
/// <listheader>
|
|
/// <term>Value</term>
|
|
/// <term>Description</term>
|
|
/// </listheader>
|
|
/// <item>
|
|
/// <term>S_OK</term>
|
|
/// <term>The method was successful.</term>
|
|
/// </item>
|
|
/// <item>
|
|
/// <term>E_OUTOFMEMORY</term>
|
|
/// <term>A memory allocation failure occurred.</term>
|
|
/// </item>
|
|
/// <item>
|
|
/// <term>E_INVALIDARG</term>
|
|
/// <term>pbstrName is invalid.</term>
|
|
/// </item>
|
|
/// </list>
|
|
/// </returns>
|
|
// https://docs.microsoft.com/en-us/windows/win32/api/msctf/nf-msctf-itffunction-getdisplayname HRESULT GetDisplayName( BSTR
|
|
// *pbstrName );
|
|
[PreserveSig]
|
|
new HRESULT GetDisplayName([Out, MarshalAs(UnmanagedType.BStr)] out string pbstrName);
|
|
|
|
/// <summary>Obtains the range of text that a reconversion applies to.</summary>
|
|
/// <param name="pRange">Pointer to an ITfRange object that covers all or part of the text to be reconverted.</param>
|
|
/// <param name="ppNewRange">
|
|
/// <para>
|
|
/// Pointer to an ITfRange pointer that receives a range object that covers all of the text that can be reconverted. If none of
|
|
/// the text covered by pRange can be reconverted, this parameters receives <c>NULL</c>. In this case, the method will return
|
|
/// S_OK; the caller must verify that this parameter is not <c>NULL</c> before using the pointer.
|
|
/// </para>
|
|
/// <para>This parameter is optional and can be <c>NULL</c>. In this case, the range is not required.</para>
|
|
/// </param>
|
|
/// <param name="pfAccepted">
|
|
/// Pointer to a <c>BOOL</c> value that receives zero if none of the text covered by pRange can be reconverted or nonzero otherwise.
|
|
/// </param>
|
|
/// <returns>
|
|
/// <para>This method can return one of these values.</para>
|
|
/// <list type="table">
|
|
/// <listheader>
|
|
/// <term>Value</term>
|
|
/// <term>Description</term>
|
|
/// </listheader>
|
|
/// <item>
|
|
/// <term>S_OK</term>
|
|
/// <term>The method was successful.</term>
|
|
/// </item>
|
|
/// <item>
|
|
/// <term>E_INVALIDARG</term>
|
|
/// <term>One or more parameters are invalid.</term>
|
|
/// </item>
|
|
/// <item>
|
|
/// <term>E_OUTOFMEMORY</term>
|
|
/// <term>A memory allocation failure occurred.</term>
|
|
/// </item>
|
|
/// </list>
|
|
/// </returns>
|
|
/// <remarks>
|
|
/// This method is identical to ITfFnReconversion::QueryRange. When <c>ITfFnReconversion::QueryRange</c> is called in the text
|
|
/// service, the text service should forward the call to this method if a language model processor is installed. If no language
|
|
/// model processor is installed, the text service should perform its default processing.
|
|
/// </remarks>
|
|
// https://docs.microsoft.com/en-us/windows/win32/api/ctffunc/nf-ctffunc-itffnlmprocessor-queryrange HRESULT QueryRange(
|
|
// ITfRange *pRange, ITfRange **ppNewRange, BOOL *pfAccepted );
|
|
[PreserveSig]
|
|
new HRESULT QueryRange([In] ITfRange pRange, out ITfRange ppNewRange, [Out, MarshalAs(UnmanagedType.Bool)] out bool pfAccepted);
|
|
|
|
/// <summary>Determines if the language model text service supports a particular language.</summary>
|
|
/// <param name="langid">Contains a <c>LANGID</c> that specifies the identifier of the language that the query applies to.</param>
|
|
/// <param name="pfAccepted">
|
|
/// Pointer to a <c>BOOL</c> value that receives nonzero if the language model text service supports the language identified by
|
|
/// langid or zero otherwise.
|
|
/// </param>
|
|
/// <returns>
|
|
/// <para>This method can return one of these values.</para>
|
|
/// <list type="table">
|
|
/// <listheader>
|
|
/// <term>Value</term>
|
|
/// <term>Description</term>
|
|
/// </listheader>
|
|
/// <item>
|
|
/// <term>S_OK</term>
|
|
/// <term>The method was successful.</term>
|
|
/// </item>
|
|
/// <item>
|
|
/// <term>E_INVALIDARG</term>
|
|
/// <term>pfAccepted is invalid.</term>
|
|
/// </item>
|
|
/// </list>
|
|
/// </returns>
|
|
/// <remarks>If a client can possibly generate more than one language identifier of text, it should query all with this method.</remarks>
|
|
// https://docs.microsoft.com/en-us/windows/win32/api/ctffunc/nf-ctffunc-itffnlmprocessor-querylangid HRESULT QueryLangID(
|
|
// LANGID langid, BOOL *pfAccepted );
|
|
[PreserveSig]
|
|
new HRESULT QueryLangID([In] LANGID langid, [Out, MarshalAs(UnmanagedType.Bool)] out bool pfAccepted);
|
|
|
|
/// <summary>Obtains an ITfCandidateList object for a range from the language model text service.</summary>
|
|
/// <param name="pRange">
|
|
/// Pointer to an ITfRange object that covers the text to be reconverted. To obtain this range object, call ITfFnReconversion::QueryRange.
|
|
/// </param>
|
|
/// <param name="ppCandList">Pointer to an <c>ITfCandidateList</c> pointer that receives the candidate list object.</param>
|
|
/// <returns>
|
|
/// <para>This method can return one of these values.</para>
|
|
/// <list type="table">
|
|
/// <listheader>
|
|
/// <term>Value</term>
|
|
/// <term>Description</term>
|
|
/// </listheader>
|
|
/// <item>
|
|
/// <term>S_OK</term>
|
|
/// <term>The method was successful.</term>
|
|
/// </item>
|
|
/// <item>
|
|
/// <term>E_FAIL</term>
|
|
/// <term>An unspecified error occurred.</term>
|
|
/// </item>
|
|
/// <item>
|
|
/// <term>E_INVALIDARG</term>
|
|
/// <term>One or more parameters are invalid.</term>
|
|
/// </item>
|
|
/// <item>
|
|
/// <term>E_OUTOFMEMORY</term>
|
|
/// <term>A memory allocation failure occurred.</term>
|
|
/// </item>
|
|
/// </list>
|
|
/// </returns>
|
|
/// <remarks>
|
|
/// This method is identical to ITfFnReconversion::GetReconversion. When <c>ITfFnReconversion::GetReconversion</c> is called in
|
|
/// the text service, the text service should forward the call to this method if a language model processor is installed. If no
|
|
/// language model processor is installed, the text service should perform its default processing.
|
|
/// </remarks>
|
|
// https://docs.microsoft.com/en-us/windows/win32/api/ctffunc/nf-ctffunc-itffnlmprocessor-getreconversion HRESULT
|
|
// GetReconversion( ITfRange *pRange, ITfCandidateList **ppCandList );
|
|
[PreserveSig]
|
|
new HRESULT GetReconversion([In] ITfRange pRange, out ITfCandidateList ppCandList);
|
|
|
|
/// <summary>Invokes the reconversion process in the language model text service for a range.</summary>
|
|
/// <param name="pRange">Pointer to an ITfRange object that covers the text to reconvert.</param>
|
|
/// <returns>
|
|
/// <para>This method can return one of these values.</para>
|
|
/// <list type="table">
|
|
/// <listheader>
|
|
/// <term>Value</term>
|
|
/// <term>Description</term>
|
|
/// </listheader>
|
|
/// <item>
|
|
/// <term>S_OK</term>
|
|
/// <term>The method was successful.</term>
|
|
/// </item>
|
|
/// <item>
|
|
/// <term>E_FAIL</term>
|
|
/// <term>An unspecified error occurred.</term>
|
|
/// </item>
|
|
/// <item>
|
|
/// <term>E_INVALIDARG</term>
|
|
/// <term>pRange is invalid.</term>
|
|
/// </item>
|
|
/// </list>
|
|
/// </returns>
|
|
/// <remarks>
|
|
/// This method is identical to ITfFnReconversion::Reconvet. When <c>ITfFnReconversion::Reconvet</c> is called in the text
|
|
/// service, the text service should forward the call to this method if a language model processor is installed. If no language
|
|
/// model processor is installed, the text service should perform its default processing.
|
|
/// </remarks>
|
|
// https://docs.microsoft.com/en-us/windows/win32/api/ctffunc/nf-ctffunc-itffnlmprocessor-reconvert HRESULT Reconvert( ITfRange
|
|
// *pRange );
|
|
[PreserveSig]
|
|
new HRESULT Reconvert([In] ITfRange pRange);
|
|
|
|
/// <summary>Called to determine if the language model text service handles a key event.</summary>
|
|
/// <param name="fUp">
|
|
/// Contains a <c>BOOL</c> that specifies if this is a key-down or a key-up event. Contains zero if this is a key-down event or
|
|
/// nonzero otherwise.
|
|
/// </param>
|
|
/// <param name="vKey">
|
|
/// Contains the virtual-key code of the key. For more information about this parameter, see the wParam parameter in WM_KEYDOWN.
|
|
/// </param>
|
|
/// <param name="lparamKeydata">
|
|
/// Specifies the repeat count, scan code, extended-key flag, context code, previous key-state flag, and transition-state flag
|
|
/// of the key. For more information about this parameter, see the lParam parameter in WM_KEYDOWN.
|
|
/// </param>
|
|
/// <param name="pfInterested">
|
|
/// Pointer to a <c>BOOL</c> that receives nonzero if the language model text service will handle the key event or zero otherwise.
|
|
/// </param>
|
|
/// <returns>
|
|
/// <para>This method can return one of these values.</para>
|
|
/// <list type="table">
|
|
/// <listheader>
|
|
/// <term>Value</term>
|
|
/// <term>Description</term>
|
|
/// </listheader>
|
|
/// <item>
|
|
/// <term>S_OK</term>
|
|
/// <term>The method was successful.</term>
|
|
/// </item>
|
|
/// </list>
|
|
/// </returns>
|
|
// https://docs.microsoft.com/en-us/windows/win32/api/ctffunc/nf-ctffunc-itffnlmprocessor-querykey HRESULT QueryKey( BOOL fUp,
|
|
// WPARAM vKey, LPARAM lparamKeydata, BOOL *pfInterested );
|
|
[PreserveSig]
|
|
new HRESULT QueryKey(int fUp, [In] WPARAM vKey, [In] LPARAM lparamKeydata, [Out, MarshalAs(UnmanagedType.Bool)] out bool pfInterested);
|
|
|
|
/// <summary>Called to enable the language model text service to process a key event.</summary>
|
|
/// <param name="fUp">
|
|
/// Contains a <c>BOOL</c> that specifies if this is a key-down or a key-up event. Contains zero if this is a key-down event or
|
|
/// nonzero otherwise.
|
|
/// </param>
|
|
/// <param name="vKey">
|
|
/// Contains the virtual-key code of the key. For more information about this parameter, see the wParam parameter in WM_KEYDOWN.
|
|
/// </param>
|
|
/// <param name="lparamKeydata">
|
|
/// Specifies the repeat count, scan code, extended-key flag, context code, previous key-state flag, and transition-state flag
|
|
/// of the key. For more information about this parameter, see the lParam parameter in WM_KEYDOWN.
|
|
/// </param>
|
|
/// <returns>
|
|
/// <para>This method can return one of these values.</para>
|
|
/// <list type="table">
|
|
/// <listheader>
|
|
/// <term>Value</term>
|
|
/// <term>Description</term>
|
|
/// </listheader>
|
|
/// <item>
|
|
/// <term>S_OK</term>
|
|
/// <term>The method was successful.</term>
|
|
/// </item>
|
|
/// </list>
|
|
/// </returns>
|
|
// https://docs.microsoft.com/en-us/windows/win32/api/ctffunc/nf-ctffunc-itffnlmprocessor-invokekey HRESULT InvokeKey( BOOL fUp,
|
|
// WPARAM vKey, LPARAM lparamKeyData );
|
|
[PreserveSig]
|
|
new HRESULT InvokeKey(int fUp, [In] WPARAM vKey, [In] LPARAM lparamKeydata);
|
|
|
|
/// <summary>Invokes a function of the language model text service.</summary>
|
|
/// <param name="pic">Pointer to an ITfContext interface that represents context to perform the function on.</param>
|
|
/// <param name="refguidFunc">
|
|
/// Contains a GUID that specifies the function to invoke. Possible values for this parameter are defined by the language model
|
|
/// text service provider.
|
|
/// </param>
|
|
/// <returns>
|
|
/// <para>This method can return one of these values.</para>
|
|
/// <list type="table">
|
|
/// <listheader>
|
|
/// <term>Value</term>
|
|
/// <term>Description</term>
|
|
/// </listheader>
|
|
/// <item>
|
|
/// <term>S_OK</term>
|
|
/// <term>The method was successful.</term>
|
|
/// </item>
|
|
/// </list>
|
|
/// </returns>
|
|
// https://docs.microsoft.com/en-us/windows/win32/api/ctffunc/nf-ctffunc-itffnlmprocessor-invokefunc HRESULT InvokeFunc(
|
|
// ITfContext *pic, REFGUID refguidFunc );
|
|
[PreserveSig]
|
|
new HRESULT InvokeFunc([In] ITfContext pic, in Guid refguidFunc);
|
|
|
|
/// <summary>Not used.</summary>
|
|
/// <param name="pRange">Not used.</param>
|
|
/// <returns>
|
|
/// <para>This method can return one of these values.</para>
|
|
/// <list type="table">
|
|
/// <listheader>
|
|
/// <term>Value</term>
|
|
/// <term>Description</term>
|
|
/// </listheader>
|
|
/// <item>
|
|
/// <term>S_OK</term>
|
|
/// <term>The method was successful.</term>
|
|
/// </item>
|
|
/// <item>
|
|
/// <term>E_FAIL</term>
|
|
/// <term>An unspecified error occurred.</term>
|
|
/// </item>
|
|
/// </list>
|
|
/// </returns>
|
|
// https://docs.microsoft.com/en-us/windows/win32/api/ctffunc/nf-ctffunc-itffnlminternal-processlattice HRESULT ProcessLattice(
|
|
// ITfRange *pRange );
|
|
[PreserveSig]
|
|
HRESULT ProcessLattice([In] ITfRange pRange);
|
|
}
|
|
|
|
/// <summary>
|
|
/// <para>
|
|
/// The <c>ITfFnLMProcessor</c> interface is implemented by the language model text service and is used by an application or text
|
|
/// service to enable alternate language model processing.
|
|
/// </para>
|
|
/// <para>
|
|
/// The application or text service obtains this interface from a thread manager object by calling ITfThreadMgr::GetFunctionProvider
|
|
/// with GUID_MASTERLM_FUNCTIONPROVIDER and then calling ITfFunctionProvider::GetFunction interface with IID_ITfFnLMProcessor. If
|
|
/// <c>ITfThreadMgr::GetFunctionProvider</c> fails, then no language model processor is installed.
|
|
/// </para>
|
|
/// </summary>
|
|
// https://docs.microsoft.com/en-us/windows/win32/api/ctffunc/nn-ctffunc-itffnlmprocessor
|
|
[PInvokeData("ctffunc.h", MSDNShortId = "NN:ctffunc.ITfFnLMProcessor")]
|
|
[ComImport, InterfaceType(ComInterfaceType.InterfaceIsIUnknown), Guid("7AFBF8E7-AC4B-4082-B058-890899D3A010")]
|
|
public interface ITfFnLMProcessor : ITfFunction
|
|
{
|
|
/// <summary>Obtains the function display name.</summary>
|
|
/// <param name="pbstrName">
|
|
/// Pointer to a BSTR value that receives the display name. This value must be allocated using SysAllocString. The caller must
|
|
/// free this memory using SysFreeString when it is no longer required.
|
|
/// </param>
|
|
/// <returns>
|
|
/// <para>This method can return one of these values.</para>
|
|
/// <list type="table">
|
|
/// <listheader>
|
|
/// <term>Value</term>
|
|
/// <term>Description</term>
|
|
/// </listheader>
|
|
/// <item>
|
|
/// <term>S_OK</term>
|
|
/// <term>The method was successful.</term>
|
|
/// </item>
|
|
/// <item>
|
|
/// <term>E_OUTOFMEMORY</term>
|
|
/// <term>A memory allocation failure occurred.</term>
|
|
/// </item>
|
|
/// <item>
|
|
/// <term>E_INVALIDARG</term>
|
|
/// <term>pbstrName is invalid.</term>
|
|
/// </item>
|
|
/// </list>
|
|
/// </returns>
|
|
// https://docs.microsoft.com/en-us/windows/win32/api/msctf/nf-msctf-itffunction-getdisplayname HRESULT GetDisplayName( BSTR
|
|
// *pbstrName );
|
|
[PreserveSig]
|
|
new HRESULT GetDisplayName([Out, MarshalAs(UnmanagedType.BStr)] out string pbstrName);
|
|
|
|
/// <summary>Obtains the range of text that a reconversion applies to.</summary>
|
|
/// <param name="pRange">Pointer to an ITfRange object that covers all or part of the text to be reconverted.</param>
|
|
/// <param name="ppNewRange">
|
|
/// <para>
|
|
/// Pointer to an ITfRange pointer that receives a range object that covers all of the text that can be reconverted. If none of
|
|
/// the text covered by pRange can be reconverted, this parameters receives <c>NULL</c>. In this case, the method will return
|
|
/// S_OK; the caller must verify that this parameter is not <c>NULL</c> before using the pointer.
|
|
/// </para>
|
|
/// <para>This parameter is optional and can be <c>NULL</c>. In this case, the range is not required.</para>
|
|
/// </param>
|
|
/// <param name="pfAccepted">
|
|
/// Pointer to a <c>BOOL</c> value that receives zero if none of the text covered by pRange can be reconverted or nonzero otherwise.
|
|
/// </param>
|
|
/// <returns>
|
|
/// <para>This method can return one of these values.</para>
|
|
/// <list type="table">
|
|
/// <listheader>
|
|
/// <term>Value</term>
|
|
/// <term>Description</term>
|
|
/// </listheader>
|
|
/// <item>
|
|
/// <term>S_OK</term>
|
|
/// <term>The method was successful.</term>
|
|
/// </item>
|
|
/// <item>
|
|
/// <term>E_INVALIDARG</term>
|
|
/// <term>One or more parameters are invalid.</term>
|
|
/// </item>
|
|
/// <item>
|
|
/// <term>E_OUTOFMEMORY</term>
|
|
/// <term>A memory allocation failure occurred.</term>
|
|
/// </item>
|
|
/// </list>
|
|
/// </returns>
|
|
/// <remarks>
|
|
/// This method is identical to ITfFnReconversion::QueryRange. When <c>ITfFnReconversion::QueryRange</c> is called in the text
|
|
/// service, the text service should forward the call to this method if a language model processor is installed. If no language
|
|
/// model processor is installed, the text service should perform its default processing.
|
|
/// </remarks>
|
|
// https://docs.microsoft.com/en-us/windows/win32/api/ctffunc/nf-ctffunc-itffnlmprocessor-queryrange HRESULT QueryRange(
|
|
// ITfRange *pRange, ITfRange **ppNewRange, BOOL *pfAccepted );
|
|
[PreserveSig]
|
|
HRESULT QueryRange([In] ITfRange pRange, out ITfRange ppNewRange, [Out, MarshalAs(UnmanagedType.Bool)] out bool pfAccepted);
|
|
|
|
/// <summary>Determines if the language model text service supports a particular language.</summary>
|
|
/// <param name="langid">Contains a <c>LANGID</c> that specifies the identifier of the language that the query applies to.</param>
|
|
/// <param name="pfAccepted">
|
|
/// Pointer to a <c>BOOL</c> value that receives nonzero if the language model text service supports the language identified by
|
|
/// langid or zero otherwise.
|
|
/// </param>
|
|
/// <returns>
|
|
/// <para>This method can return one of these values.</para>
|
|
/// <list type="table">
|
|
/// <listheader>
|
|
/// <term>Value</term>
|
|
/// <term>Description</term>
|
|
/// </listheader>
|
|
/// <item>
|
|
/// <term>S_OK</term>
|
|
/// <term>The method was successful.</term>
|
|
/// </item>
|
|
/// <item>
|
|
/// <term>E_INVALIDARG</term>
|
|
/// <term>pfAccepted is invalid.</term>
|
|
/// </item>
|
|
/// </list>
|
|
/// </returns>
|
|
/// <remarks>If a client can possibly generate more than one language identifier of text, it should query all with this method.</remarks>
|
|
// https://docs.microsoft.com/en-us/windows/win32/api/ctffunc/nf-ctffunc-itffnlmprocessor-querylangid HRESULT QueryLangID(
|
|
// LANGID langid, BOOL *pfAccepted );
|
|
[PreserveSig]
|
|
HRESULT QueryLangID([In] LANGID langid, [Out, MarshalAs(UnmanagedType.Bool)] out bool pfAccepted);
|
|
|
|
/// <summary>Obtains an ITfCandidateList object for a range from the language model text service.</summary>
|
|
/// <param name="pRange">
|
|
/// Pointer to an ITfRange object that covers the text to be reconverted. To obtain this range object, call ITfFnReconversion::QueryRange.
|
|
/// </param>
|
|
/// <param name="ppCandList">Pointer to an <c>ITfCandidateList</c> pointer that receives the candidate list object.</param>
|
|
/// <returns>
|
|
/// <para>This method can return one of these values.</para>
|
|
/// <list type="table">
|
|
/// <listheader>
|
|
/// <term>Value</term>
|
|
/// <term>Description</term>
|
|
/// </listheader>
|
|
/// <item>
|
|
/// <term>S_OK</term>
|
|
/// <term>The method was successful.</term>
|
|
/// </item>
|
|
/// <item>
|
|
/// <term>E_FAIL</term>
|
|
/// <term>An unspecified error occurred.</term>
|
|
/// </item>
|
|
/// <item>
|
|
/// <term>E_INVALIDARG</term>
|
|
/// <term>One or more parameters are invalid.</term>
|
|
/// </item>
|
|
/// <item>
|
|
/// <term>E_OUTOFMEMORY</term>
|
|
/// <term>A memory allocation failure occurred.</term>
|
|
/// </item>
|
|
/// </list>
|
|
/// </returns>
|
|
/// <remarks>
|
|
/// This method is identical to ITfFnReconversion::GetReconversion. When <c>ITfFnReconversion::GetReconversion</c> is called in
|
|
/// the text service, the text service should forward the call to this method if a language model processor is installed. If no
|
|
/// language model processor is installed, the text service should perform its default processing.
|
|
/// </remarks>
|
|
// https://docs.microsoft.com/en-us/windows/win32/api/ctffunc/nf-ctffunc-itffnlmprocessor-getreconversion HRESULT
|
|
// GetReconversion( ITfRange *pRange, ITfCandidateList **ppCandList );
|
|
[PreserveSig]
|
|
HRESULT GetReconversion([In] ITfRange pRange, out ITfCandidateList ppCandList);
|
|
|
|
/// <summary>Invokes the reconversion process in the language model text service for a range.</summary>
|
|
/// <param name="pRange">Pointer to an ITfRange object that covers the text to reconvert.</param>
|
|
/// <returns>
|
|
/// <para>This method can return one of these values.</para>
|
|
/// <list type="table">
|
|
/// <listheader>
|
|
/// <term>Value</term>
|
|
/// <term>Description</term>
|
|
/// </listheader>
|
|
/// <item>
|
|
/// <term>S_OK</term>
|
|
/// <term>The method was successful.</term>
|
|
/// </item>
|
|
/// <item>
|
|
/// <term>E_FAIL</term>
|
|
/// <term>An unspecified error occurred.</term>
|
|
/// </item>
|
|
/// <item>
|
|
/// <term>E_INVALIDARG</term>
|
|
/// <term>pRange is invalid.</term>
|
|
/// </item>
|
|
/// </list>
|
|
/// </returns>
|
|
/// <remarks>
|
|
/// This method is identical to ITfFnReconversion::Reconvet. When <c>ITfFnReconversion::Reconvet</c> is called in the text
|
|
/// service, the text service should forward the call to this method if a language model processor is installed. If no language
|
|
/// model processor is installed, the text service should perform its default processing.
|
|
/// </remarks>
|
|
// https://docs.microsoft.com/en-us/windows/win32/api/ctffunc/nf-ctffunc-itffnlmprocessor-reconvert HRESULT Reconvert( ITfRange
|
|
// *pRange );
|
|
[PreserveSig]
|
|
HRESULT Reconvert([In] ITfRange pRange);
|
|
|
|
/// <summary>Called to determine if the language model text service handles a key event.</summary>
|
|
/// <param name="fUp">
|
|
/// Contains a <c>BOOL</c> that specifies if this is a key-down or a key-up event. Contains zero if this is a key-down event or
|
|
/// nonzero otherwise.
|
|
/// </param>
|
|
/// <param name="vKey">
|
|
/// Contains the virtual-key code of the key. For more information about this parameter, see the wParam parameter in WM_KEYDOWN.
|
|
/// </param>
|
|
/// <param name="lparamKeydata">
|
|
/// Specifies the repeat count, scan code, extended-key flag, context code, previous key-state flag, and transition-state flag
|
|
/// of the key. For more information about this parameter, see the lParam parameter in WM_KEYDOWN.
|
|
/// </param>
|
|
/// <param name="pfInterested">
|
|
/// Pointer to a <c>BOOL</c> that receives nonzero if the language model text service will handle the key event or zero otherwise.
|
|
/// </param>
|
|
/// <returns>
|
|
/// <para>This method can return one of these values.</para>
|
|
/// <list type="table">
|
|
/// <listheader>
|
|
/// <term>Value</term>
|
|
/// <term>Description</term>
|
|
/// </listheader>
|
|
/// <item>
|
|
/// <term>S_OK</term>
|
|
/// <term>The method was successful.</term>
|
|
/// </item>
|
|
/// </list>
|
|
/// </returns>
|
|
// https://docs.microsoft.com/en-us/windows/win32/api/ctffunc/nf-ctffunc-itffnlmprocessor-querykey HRESULT QueryKey( BOOL fUp,
|
|
// WPARAM vKey, LPARAM lparamKeydata, BOOL *pfInterested );
|
|
[PreserveSig]
|
|
HRESULT QueryKey(int fUp, [In] WPARAM vKey, [In] LPARAM lparamKeydata, [Out, MarshalAs(UnmanagedType.Bool)] out bool pfInterested);
|
|
|
|
/// <summary>Called to enable the language model text service to process a key event.</summary>
|
|
/// <param name="fUp">
|
|
/// Contains a <c>BOOL</c> that specifies if this is a key-down or a key-up event. Contains zero if this is a key-down event or
|
|
/// nonzero otherwise.
|
|
/// </param>
|
|
/// <param name="vKey">
|
|
/// Contains the virtual-key code of the key. For more information about this parameter, see the wParam parameter in WM_KEYDOWN.
|
|
/// </param>
|
|
/// <param name="lparamKeydata">
|
|
/// Specifies the repeat count, scan code, extended-key flag, context code, previous key-state flag, and transition-state flag
|
|
/// of the key. For more information about this parameter, see the lParam parameter in WM_KEYDOWN.
|
|
/// </param>
|
|
/// <returns>
|
|
/// <para>This method can return one of these values.</para>
|
|
/// <list type="table">
|
|
/// <listheader>
|
|
/// <term>Value</term>
|
|
/// <term>Description</term>
|
|
/// </listheader>
|
|
/// <item>
|
|
/// <term>S_OK</term>
|
|
/// <term>The method was successful.</term>
|
|
/// </item>
|
|
/// </list>
|
|
/// </returns>
|
|
// https://docs.microsoft.com/en-us/windows/win32/api/ctffunc/nf-ctffunc-itffnlmprocessor-invokekey HRESULT InvokeKey( BOOL fUp,
|
|
// WPARAM vKey, LPARAM lparamKeyData );
|
|
[PreserveSig]
|
|
HRESULT InvokeKey(int fUp, [In] WPARAM vKey, [In] LPARAM lparamKeydata);
|
|
|
|
/// <summary>Invokes a function of the language model text service.</summary>
|
|
/// <param name="pic">Pointer to an ITfContext interface that represents context to perform the function on.</param>
|
|
/// <param name="refguidFunc">
|
|
/// Contains a GUID that specifies the function to invoke. Possible values for this parameter are defined by the language model
|
|
/// text service provider.
|
|
/// </param>
|
|
/// <returns>
|
|
/// <para>This method can return one of these values.</para>
|
|
/// <list type="table">
|
|
/// <listheader>
|
|
/// <term>Value</term>
|
|
/// <term>Description</term>
|
|
/// </listheader>
|
|
/// <item>
|
|
/// <term>S_OK</term>
|
|
/// <term>The method was successful.</term>
|
|
/// </item>
|
|
/// </list>
|
|
/// </returns>
|
|
// https://docs.microsoft.com/en-us/windows/win32/api/ctffunc/nf-ctffunc-itffnlmprocessor-invokefunc HRESULT InvokeFunc(
|
|
// ITfContext *pic, REFGUID refguidFunc );
|
|
[PreserveSig]
|
|
HRESULT InvokeFunc([In] ITfContext pic, in Guid refguidFunc);
|
|
}
|
|
|
|
/// <summary>
|
|
/// <para>
|
|
/// The <c>ITfFnPlayBack</c> interface is implemented by the Speech API (SAPI) text service. This interface is used by the TSF
|
|
/// manager or a client (application or other text service) to control the audio data for speech input text.
|
|
/// </para>
|
|
/// <para>
|
|
/// Each spoken word or phrase has audio data stored with the text. This interface is used to obtain the range that covers the
|
|
/// spoken text and to play back the audio data.
|
|
/// </para>
|
|
/// <para>
|
|
/// A client obtains an instance of this interface by obtaining the ITfFunctionProvider for the SAPI text service and calling
|
|
/// ITfFunctionProvider::GetFunction with IID_ITfFnPlayBack.
|
|
/// </para>
|
|
/// </summary>
|
|
// https://docs.microsoft.com/en-us/windows/win32/api/ctffunc/nn-ctffunc-itffnplayback
|
|
[PInvokeData("ctffunc.h", MSDNShortId = "NN:ctffunc.ITfFnPlayBack")]
|
|
[ComImport, Guid("A3A416A4-0F64-11D3-B5B7-00C04FC324A1"), InterfaceType(ComInterfaceType.InterfaceIsIUnknown)]
|
|
public interface ITfFnPlayBack : ITfFunction
|
|
{
|
|
/// <summary>Obtains the function display name.</summary>
|
|
/// <param name="pbstrName">
|
|
/// Pointer to a BSTR value that receives the display name. This value must be allocated using SysAllocString. The caller must
|
|
/// free this memory using SysFreeString when it is no longer required.
|
|
/// </param>
|
|
/// <returns>
|
|
/// <para>This method can return one of these values.</para>
|
|
/// <list type="table">
|
|
/// <listheader>
|
|
/// <term>Value</term>
|
|
/// <term>Description</term>
|
|
/// </listheader>
|
|
/// <item>
|
|
/// <term>S_OK</term>
|
|
/// <term>The method was successful.</term>
|
|
/// </item>
|
|
/// <item>
|
|
/// <term>E_OUTOFMEMORY</term>
|
|
/// <term>A memory allocation failure occurred.</term>
|
|
/// </item>
|
|
/// <item>
|
|
/// <term>E_INVALIDARG</term>
|
|
/// <term>pbstrName is invalid.</term>
|
|
/// </item>
|
|
/// </list>
|
|
/// </returns>
|
|
// https://docs.microsoft.com/en-us/windows/win32/api/msctf/nf-msctf-itffunction-getdisplayname HRESULT GetDisplayName( BSTR
|
|
// *pbstrName );
|
|
[PreserveSig]
|
|
new HRESULT GetDisplayName([Out, MarshalAs(UnmanagedType.BStr)] out string pbstrName);
|
|
|
|
/// <summary>Obtains the range of text for a word or phrase that contains audio data.</summary>
|
|
/// <param name="pRange">Pointer to an ITfRange object that covers all or part of the text that contains audio data.</param>
|
|
/// <param name="ppNewRange">
|
|
/// Pointer to an ITfRange pointer that receives a range object that covers all of the text that contains audio data. If there
|
|
/// is no audio data for the text covered by pRange, this parameters receives <c>NULL</c>. In this case, the method returns
|
|
/// S_OK, so the caller must verify that this parameter is not <c>NULL</c> before using the pointer.
|
|
/// </param>
|
|
/// <param name="pfPlayable">
|
|
/// Pointer to a <c>BOOL</c> that receives zero if none of the text covered by pRange has any audio data or nonzero otherwise.
|
|
/// </param>
|
|
/// <returns>
|
|
/// <para>This method can return one of these values.</para>
|
|
/// <list type="table">
|
|
/// <listheader>
|
|
/// <term>Value</term>
|
|
/// <term>Description</term>
|
|
/// </listheader>
|
|
/// <item>
|
|
/// <term>S_OK</term>
|
|
/// <term>The method was successful.</term>
|
|
/// </item>
|
|
/// <item>
|
|
/// <term>E_INVALIDARG</term>
|
|
/// <term>One or more parameters are invalid.</term>
|
|
/// </item>
|
|
/// <item>
|
|
/// <term>E_OUTOFMEMORY</term>
|
|
/// <term>A memory allocation failure occurred.</term>
|
|
/// </item>
|
|
/// </list>
|
|
/// </returns>
|
|
/// <remarks>
|
|
/// The current implementation of this method is simple. It clones pRange, places the clone in ppNewRange, sets pfPlayable to
|
|
/// <c>TRUE</c> and returns S_OK.
|
|
/// </remarks>
|
|
// https://docs.microsoft.com/en-us/windows/win32/api/ctffunc/nf-ctffunc-itffnplayback-queryrange HRESULT QueryRange( ITfRange
|
|
// *pRange, ITfRange **ppNewRange, BOOL *pfPlayable );
|
|
[PreserveSig]
|
|
HRESULT QueryRange([In] ITfRange pRange, out ITfRange ppNewRange, [Out, MarshalAs(UnmanagedType.Bool)] out bool pfPlayable);
|
|
|
|
/// <summary>Causes the audio data for a range of text to be played.</summary>
|
|
/// <param name="pRange">
|
|
/// <para>
|
|
/// Pointer to an ITfRange object that covers the text to play the audio data for. This range object is obtained by calling ITfFnPlayBack::QueryRange.
|
|
/// </para>
|
|
/// <para>
|
|
/// If the range has zero length, the range played is expanded to cover the entire spoken phrase. If the range has a nonzero
|
|
/// length, the range played is expanded to include the entire word, or words, that the range partially covers.
|
|
/// </para>
|
|
/// </param>
|
|
/// <returns>
|
|
/// <para>This method can return one of these values.</para>
|
|
/// <list type="table">
|
|
/// <listheader>
|
|
/// <term>Value</term>
|
|
/// <term>Description</term>
|
|
/// </listheader>
|
|
/// <item>
|
|
/// <term>S_OK</term>
|
|
/// <term>The method was successful.</term>
|
|
/// </item>
|
|
/// <item>
|
|
/// <term>E_FAIL</term>
|
|
/// <term>An unspecified error occurred.</term>
|
|
/// </item>
|
|
/// <item>
|
|
/// <term>E_OUTOFMEMORY</term>
|
|
/// <term>A memory allocation failure occurred.</term>
|
|
/// </item>
|
|
/// </list>
|
|
/// </returns>
|
|
// https://docs.microsoft.com/en-us/windows/win32/api/ctffunc/nf-ctffunc-itffnplayback-play HRESULT Play( ITfRange *pRange );
|
|
[PreserveSig]
|
|
HRESULT Play([In] ITfRange pRange);
|
|
}
|
|
|
|
/// <summary>
|
|
/// <para>
|
|
/// The <c>ITfFnPropertyUIStatus</c> interface is implemented by a text service and used by an application or text service to obtain
|
|
/// and set the status of the text service property UI.
|
|
/// </para>
|
|
/// <para>
|
|
/// An application or text service obtains an instance of this interface by obtaining the ITfFunctionProvider for the text service
|
|
/// and calling ITfFunctionProvider::GetFunction with IID_ITfFnPropertyUIStatus.
|
|
/// </para>
|
|
/// </summary>
|
|
// https://docs.microsoft.com/en-us/windows/win32/api/ctffunc/nn-ctffunc-itffnpropertyuistatus
|
|
[PInvokeData("ctffunc.h", MSDNShortId = "NN:ctffunc.ITfFnPropertyUIStatus")]
|
|
[ComImport, InterfaceType(ComInterfaceType.InterfaceIsIUnknown), Guid("2338AC6E-2B9D-44C0-A75E-EE64F256B3BD")]
|
|
public interface ITfFnPropertyUIStatus : ITfFunction
|
|
{
|
|
/// <summary>Obtains the function display name.</summary>
|
|
/// <param name="pbstrName">
|
|
/// Pointer to a BSTR value that receives the display name. This value must be allocated using SysAllocString. The caller must
|
|
/// free this memory using SysFreeString when it is no longer required.
|
|
/// </param>
|
|
/// <returns>
|
|
/// <para>This method can return one of these values.</para>
|
|
/// <list type="table">
|
|
/// <listheader>
|
|
/// <term>Value</term>
|
|
/// <term>Description</term>
|
|
/// </listheader>
|
|
/// <item>
|
|
/// <term>S_OK</term>
|
|
/// <term>The method was successful.</term>
|
|
/// </item>
|
|
/// <item>
|
|
/// <term>E_OUTOFMEMORY</term>
|
|
/// <term>A memory allocation failure occurred.</term>
|
|
/// </item>
|
|
/// <item>
|
|
/// <term>E_INVALIDARG</term>
|
|
/// <term>pbstrName is invalid.</term>
|
|
/// </item>
|
|
/// </list>
|
|
/// </returns>
|
|
// https://docs.microsoft.com/en-us/windows/win32/api/msctf/nf-msctf-itffunction-getdisplayname HRESULT GetDisplayName( BSTR
|
|
// *pbstrName );
|
|
[PreserveSig]
|
|
new HRESULT GetDisplayName([Out, MarshalAs(UnmanagedType.BStr)] out string pbstrName);
|
|
|
|
/// <summary>Obtains the status of a text service property UI.</summary>
|
|
/// <param name="refguidProp">
|
|
/// Specifies the property identifier. This can be a custom identifier or one of the predefined property identifiers.
|
|
/// </param>
|
|
/// <param name="pdw">
|
|
/// <para>Pointer to a <c>DWORD</c> that recevies the property UI status. This can be zero or the following value.</para>
|
|
/// <list type="table">
|
|
/// <listheader>
|
|
/// <term>Value</term>
|
|
/// <term>Meaning</term>
|
|
/// </listheader>
|
|
/// <item>
|
|
/// <term>TF_PROPUI_STATUS_SAVETOFILE</term>
|
|
/// <term>The property can be serialized. If this value is not present, the property cannot be serialized.</term>
|
|
/// </item>
|
|
/// </list>
|
|
/// </param>
|
|
/// <returns>
|
|
/// <para>This method can return one of these values.</para>
|
|
/// <list type="table">
|
|
/// <listheader>
|
|
/// <term>Value</term>
|
|
/// <term>Description</term>
|
|
/// </listheader>
|
|
/// <item>
|
|
/// <term>S_OK</term>
|
|
/// <term>The method was successful.</term>
|
|
/// </item>
|
|
/// <item>
|
|
/// <term>E_INVALIDARG</term>
|
|
/// <term>pdw is invalid.</term>
|
|
/// </item>
|
|
/// <item>
|
|
/// <term>E_NOTIMPL</term>
|
|
/// <term>The text service does not support this method.</term>
|
|
/// </item>
|
|
/// </list>
|
|
/// </returns>
|
|
// https://docs.microsoft.com/en-us/windows/win32/api/ctffunc/nf-ctffunc-itffnpropertyuistatus-getstatus HRESULT GetStatus(
|
|
// REFGUID refguidProp, DWORD *pdw );
|
|
[PreserveSig]
|
|
HRESULT GetStatus(in Guid refguidProp, out TF_PROPUI_STATUS pdw);
|
|
|
|
/// <summary>Modifies the status of a text service property UI.</summary>
|
|
/// <param name="refguidProp">
|
|
/// Specifies the property identifier. This can be a custom identifier or one of the predefined property identifiers.
|
|
/// </param>
|
|
/// <param name="dw">
|
|
/// Contains the new property UI status. See the pdw parameter of ITfFnPropertyUIStatus::GetStatus for possible values.
|
|
/// </param>
|
|
/// <returns>
|
|
/// <para>This method can return one of these values.</para>
|
|
/// <list type="table">
|
|
/// <listheader>
|
|
/// <term>Value</term>
|
|
/// <term>Description</term>
|
|
/// </listheader>
|
|
/// <item>
|
|
/// <term>S_OK</term>
|
|
/// <term>The method was successful.</term>
|
|
/// </item>
|
|
/// <item>
|
|
/// <term>E_NOTIMPL</term>
|
|
/// <term>The text service does not support this method.</term>
|
|
/// </item>
|
|
/// </list>
|
|
/// </returns>
|
|
// https://docs.microsoft.com/en-us/windows/win32/api/ctffunc/nf-ctffunc-itffnpropertyuistatus-setstatus HRESULT SetStatus(
|
|
// REFGUID refguidProp, DWORD dw );
|
|
[PreserveSig]
|
|
HRESULT SetStatus(in Guid refguidProp, TF_PROPUI_STATUS dw);
|
|
}
|
|
|
|
/// <summary>
|
|
/// <para>
|
|
/// The <c>ITfFnReconversion</c> interface is implemented by a text service and is used by the TSF manager or a client to support
|
|
/// reconversion of text provided by the text service.
|
|
/// </para>
|
|
/// <para>
|
|
/// The TSF manager implements this interface to provide access to this interface to other clients. This allows the TSF manager to
|
|
/// function as a mediator between the client and the text service.
|
|
/// </para>
|
|
/// <para>The TSF manager obtains this interface by calling the text service ITfFunctionProvider::GetFunction method with IID_ITfFnReconversion.</para>
|
|
/// <para>An application obtains this interface by calling the TSF manager <c>ITfFunctionProvider::GetFunction</c> method with IID_ITfFnReconversion.</para>
|
|
/// </summary>
|
|
/// <remarks>
|
|
/// When a text service must interpret text before it is inserted into a context, there might be more than one possible
|
|
/// interpretation of the text. Speech input is an example of this. If the spoken word is "there", other possible interpretations
|
|
/// might be "their" or "they're". The text service will insert the most appropriate text, but there is still some chance of error
|
|
/// involved. Text reconversion is the process of allowing the user to select alternate text for the inserted text.
|
|
/// </remarks>
|
|
// https://docs.microsoft.com/en-us/windows/win32/api/ctffunc/nn-ctffunc-itffnreconversion
|
|
[PInvokeData("ctffunc.h", MSDNShortId = "NN:ctffunc.ITfFnReconversion")]
|
|
[ComImport, InterfaceType(ComInterfaceType.InterfaceIsIUnknown), Guid("4CEA93C0-0A58-11D3-8DF0-00105A2799B5")]
|
|
public interface ITfFnReconversion : ITfFunction
|
|
{
|
|
/// <summary>Obtains the function display name.</summary>
|
|
/// <param name="pbstrName">
|
|
/// Pointer to a BSTR value that receives the display name. This value must be allocated using SysAllocString. The caller must
|
|
/// free this memory using SysFreeString when it is no longer required.
|
|
/// </param>
|
|
/// <returns>
|
|
/// <para>This method can return one of these values.</para>
|
|
/// <list type="table">
|
|
/// <listheader>
|
|
/// <term>Value</term>
|
|
/// <term>Description</term>
|
|
/// </listheader>
|
|
/// <item>
|
|
/// <term>S_OK</term>
|
|
/// <term>The method was successful.</term>
|
|
/// </item>
|
|
/// <item>
|
|
/// <term>E_OUTOFMEMORY</term>
|
|
/// <term>A memory allocation failure occurred.</term>
|
|
/// </item>
|
|
/// <item>
|
|
/// <term>E_INVALIDARG</term>
|
|
/// <term>pbstrName is invalid.</term>
|
|
/// </item>
|
|
/// </list>
|
|
/// </returns>
|
|
// https://docs.microsoft.com/en-us/windows/win32/api/msctf/nf-msctf-itffunction-getdisplayname HRESULT GetDisplayName( BSTR
|
|
// *pbstrName );
|
|
[PreserveSig]
|
|
new HRESULT GetDisplayName([Out, MarshalAs(UnmanagedType.BStr)] out string pbstrName);
|
|
|
|
/// <summary>The <c>ITfFnReconversion::QueryRange</c> method obtains the range of text that the reconversion applies to.</summary>
|
|
/// <param name="pRange">Pointer to an ITfRange object that covers all or part of the text to be reconverted.</param>
|
|
/// <param name="ppNewRange">
|
|
/// <para>
|
|
/// [in, out] Pointer to an ITfRange pointer that receives a range object that covers all of text that can be reconverted. If
|
|
/// none of the text covered by pRange can be reconverted, this parameters receives NULL. In this case, the method will return
|
|
/// S_OK, so the caller must verify that this parameter is not NULL before using the pointer.
|
|
/// </para>
|
|
/// <para>
|
|
/// When this method is implemented by a text service, this parameter is optional and can be NULL. In this case, the range is
|
|
/// not required.
|
|
/// </para>
|
|
/// <para>When the TSF manager implementation of this method is called, this parameter is not optional and cannot be NULL.</para>
|
|
/// </param>
|
|
/// <param name="pfConvertable">
|
|
/// Pointer to a <c>BOOL</c> value that receives zero if none of the text covered by pRange can be reconverted or nonzero otherwise.
|
|
/// </param>
|
|
/// <returns>
|
|
/// <para>This method can return one of these values.</para>
|
|
/// <list type="table">
|
|
/// <listheader>
|
|
/// <term>Value</term>
|
|
/// <term>Description</term>
|
|
/// </listheader>
|
|
/// <item>
|
|
/// <term>S_OK</term>
|
|
/// <term>The method was successful.</term>
|
|
/// </item>
|
|
/// <item>
|
|
/// <term>E_INVALIDARG</term>
|
|
/// <term>One or more parameters are invalid.</term>
|
|
/// </item>
|
|
/// <item>
|
|
/// <term>E_OUTOFMEMORY</term>
|
|
/// <term>A memory allocation failure occurred.</term>
|
|
/// </item>
|
|
/// </list>
|
|
/// </returns>
|
|
// https://docs.microsoft.com/en-us/windows/win32/api/ctffunc/nf-ctffunc-itffnreconversion-queryrange HRESULT QueryRange(
|
|
// ITfRange *pRange, ITfRange **ppNewRange, BOOL *pfConvertable );
|
|
[PreserveSig]
|
|
HRESULT QueryRange([In] ITfRange pRange, out ITfRange ppNewRange, [Out, MarshalAs(UnmanagedType.Bool)] out bool pfConvertable);
|
|
|
|
/// <summary>Obtains an ITfCandidateList object for a range of text.</summary>
|
|
/// <param name="pRange">
|
|
/// Pointer to an ITfRange object that covers the text to be reconverted. This range object is obtained by calling ITfFnReconversion::QueryRange.
|
|
/// </param>
|
|
/// <param name="ppCandList">Pointer to an <c>ITfCandidateList</c> pointer that receives the candidate list object.</param>
|
|
/// <returns>
|
|
/// <para>This method can return one of these values.</para>
|
|
/// <list type="table">
|
|
/// <listheader>
|
|
/// <term>Value</term>
|
|
/// <term>Description</term>
|
|
/// </listheader>
|
|
/// <item>
|
|
/// <term>S_OK</term>
|
|
/// <term>The method was successful.</term>
|
|
/// </item>
|
|
/// <item>
|
|
/// <term>E_FAIL</term>
|
|
/// <term>An unspecified error occurred.</term>
|
|
/// </item>
|
|
/// <item>
|
|
/// <term>E_INVALIDARG</term>
|
|
/// <term>One or more parameters are invalid.</term>
|
|
/// </item>
|
|
/// <item>
|
|
/// <term>E_OUTOFMEMORY</term>
|
|
/// <term>A memory allocation failure occurred.</term>
|
|
/// </item>
|
|
/// </list>
|
|
/// </returns>
|
|
// https://docs.microsoft.com/en-us/windows/win32/api/ctffunc/nf-ctffunc-itffnreconversion-getreconversion HRESULT
|
|
// GetReconversion( ITfRange *pRange, ITfCandidateList **ppCandList );
|
|
[PreserveSig]
|
|
HRESULT GetReconversion([In] ITfRange pRange, out ITfCandidateList ppCandList);
|
|
|
|
/// <summary>Invokes the reconversion process for a range of text.</summary>
|
|
/// <param name="pRange">
|
|
/// Pointer to an ITfRange object that covers the text to be reconverted. To obtain this range object call ITfFnReconversion::QueryRange.
|
|
/// </param>
|
|
/// <returns>
|
|
/// <para>This method can return one of these values.</para>
|
|
/// <list type="table">
|
|
/// <listheader>
|
|
/// <term>Value</term>
|
|
/// <term>Description</term>
|
|
/// </listheader>
|
|
/// <item>
|
|
/// <term>S_OK</term>
|
|
/// <term>The method was successful.</term>
|
|
/// </item>
|
|
/// <item>
|
|
/// <term>E_FAIL</term>
|
|
/// <term>An unspecified error occurred.</term>
|
|
/// </item>
|
|
/// <item>
|
|
/// <term>E_INVALIDARG</term>
|
|
/// <term>One or more parameters are invalid.</term>
|
|
/// </item>
|
|
/// <item>
|
|
/// <term>E_OUTOFMEMORY</term>
|
|
/// <term>A memory allocation failure occurred.</term>
|
|
/// </item>
|
|
/// </list>
|
|
/// </returns>
|
|
/// <remarks>
|
|
/// If this method causes some type of user interface to be displayed, such as a dialog box, this method must not wait for the
|
|
/// UI to be dismissed before returning.
|
|
/// </remarks>
|
|
// https://docs.microsoft.com/en-us/windows/win32/api/ctffunc/nf-ctffunc-itffnreconversion-reconvert HRESULT Reconvert( ITfRange
|
|
// *pRange );
|
|
[PreserveSig]
|
|
HRESULT Reconvert([In] ITfRange pRange);
|
|
}
|
|
|
|
/// <summary>Enables an integrated search experience in an Input Method Editor (IME).</summary>
|
|
/// <remarks>
|
|
/// <para>
|
|
/// Implement the <c>ITfFnSearchCandidateProvider</c> interface in your Input Method Editor (IME) to enable an integrated search
|
|
/// experience. Implementing this interface enables searches with meaningful results to begin before IME input has been completed,
|
|
/// by providing a set of possible IME conversion candidates for a given input string. Apps can use this interface to obtain IME
|
|
/// conversions for a string, so the <c>ITfFnSearchCandidateProvider</c> interface, along with ITfFnGetLinguisticAlternates,
|
|
/// provides a TSF-based replacement for the ImmGetConversionList function. Typically IMEs implement either
|
|
/// <c>ITfFnGetLinguisticAlternates</c> or <c>ITfFnSearchCandidateProvider</c> (or neither).
|
|
/// </para>
|
|
/// <para>
|
|
/// Call GetFunctionProvider with the CLSID of a text service to get an ITfFunctionProvider instance. Use the following call to the
|
|
/// ITfFunctionProvider::GetFunction method to get the <c>ITfFnSearchCandidateProvider</c> interface pointer.
|
|
/// </para>
|
|
/// <para>
|
|
/// <code>ITfFunctionProvider::GetFunction(GUID_NULL, IID_ITfFnSearchCandidateProvider, &pSearchCandidate)</code>
|
|
/// </para>
|
|
/// </remarks>
|
|
// https://docs.microsoft.com/en-us/windows/win32/api/ctffunc/nn-ctffunc-itffnsearchcandidateprovider
|
|
[PInvokeData("ctffunc.h", MSDNShortId = "NN:ctffunc.ITfFnSearchCandidateProvider")]
|
|
[ComImport, InterfaceType(ComInterfaceType.InterfaceIsIUnknown), Guid("87a2ad8f-f27b-4920-8501-67602280175d")]
|
|
public interface ITfFnSearchCandidateProvider : ITfFunction
|
|
{
|
|
/// <summary>Obtains the function display name.</summary>
|
|
/// <param name="pbstrName">
|
|
/// Pointer to a BSTR value that receives the display name. This value must be allocated using SysAllocString. The caller must
|
|
/// free this memory using SysFreeString when it is no longer required.
|
|
/// </param>
|
|
/// <returns>
|
|
/// <para>This method can return one of these values.</para>
|
|
/// <list type="table">
|
|
/// <listheader>
|
|
/// <term>Value</term>
|
|
/// <term>Description</term>
|
|
/// </listheader>
|
|
/// <item>
|
|
/// <term>S_OK</term>
|
|
/// <term>The method was successful.</term>
|
|
/// </item>
|
|
/// <item>
|
|
/// <term>E_OUTOFMEMORY</term>
|
|
/// <term>A memory allocation failure occurred.</term>
|
|
/// </item>
|
|
/// <item>
|
|
/// <term>E_INVALIDARG</term>
|
|
/// <term>pbstrName is invalid.</term>
|
|
/// </item>
|
|
/// </list>
|
|
/// </returns>
|
|
// https://docs.microsoft.com/en-us/windows/win32/api/msctf/nf-msctf-itffunction-getdisplayname HRESULT GetDisplayName( BSTR
|
|
// *pbstrName );
|
|
[PreserveSig]
|
|
new HRESULT GetDisplayName([Out, MarshalAs(UnmanagedType.BStr)] out string pbstrName);
|
|
|
|
/// <summary>Gets a list of conversion candidates for a given string without generating any IME-related messages or events.</summary>
|
|
/// <param name="bstrQuery">A string that specifies the reading string that the text service attempts to convert.</param>
|
|
/// <param name="bstrApplicationId">
|
|
/// App-specified string that enables a text service to optionally provide different candidates to different apps or contexts
|
|
/// based on input history. You can pass an empty <c>BSTR</c>, L””, for a generic context.
|
|
/// </param>
|
|
/// <param name="pplist">An ITfCandidateList that receives the requested candidate data.</param>
|
|
/// <returns>
|
|
/// <para>This method can return one of these values.</para>
|
|
/// <list type="table">
|
|
/// <listheader>
|
|
/// <term>Return code</term>
|
|
/// <term>Description</term>
|
|
/// </listheader>
|
|
/// <item>
|
|
/// <term>S_OK</term>
|
|
/// <term>The method was successful.</term>
|
|
/// </item>
|
|
/// <item>
|
|
/// <term>S_FALSE</term>
|
|
/// <term>No candidates could be returned for the input string, pplist may be NULL.</term>
|
|
/// </item>
|
|
/// </list>
|
|
/// </returns>
|
|
// https://docs.microsoft.com/en-us/windows/win32/api/ctffunc/nf-ctffunc-itffnsearchcandidateprovider-getsearchcandidates
|
|
// HRESULT GetSearchCandidates( BSTR bstrQuery, BSTR bstrApplicationId, ITfCandidateList **pplist );
|
|
[PreserveSig]
|
|
HRESULT GetSearchCandidates([In, MarshalAs(UnmanagedType.BStr)] string bstrQuery, [In, MarshalAs(UnmanagedType.BStr)] string bstrApplicationId, out ITfCandidateList pplist);
|
|
|
|
/// <summary>Provides a text Service or IME with history data when a candidate is chosen by the user.</summary>
|
|
/// <param name="bstrQuery">The reading string for the text service or IME to convert.</param>
|
|
/// <param name="bstrApplicationID">
|
|
/// App-specified string that enables a text service or IME to optionally provide different candidates to different apps or
|
|
/// contexts based on input history. You can pass an empty <c>BSTR</c>, L””, for a generic context.
|
|
/// </param>
|
|
/// <param name="bstrResult">
|
|
/// A string that represents the candidate string chosen by the user. It should be one of the candidate string values returned
|
|
/// by the GetSearchCandidates method.
|
|
/// </param>
|
|
/// <returns>
|
|
/// <para>This method can return one of these values.</para>
|
|
/// <list type="table">
|
|
/// <listheader>
|
|
/// <term>Value</term>
|
|
/// <term>Description</term>
|
|
/// </listheader>
|
|
/// <item>
|
|
/// <term>S_OK</term>
|
|
/// <term>The method was successful.</term>
|
|
/// </item>
|
|
/// </list>
|
|
/// </returns>
|
|
/// <remarks>
|
|
/// <para>Implementing and calling the SetResult method is optional.</para>
|
|
/// <para>
|
|
/// A text service or IME can return <c>E_PENDING</c> if no corresponding call to GetSearchCandidates has been made yet for the
|
|
/// value of bstrQuery.
|
|
/// </para>
|
|
/// </remarks>
|
|
// https://docs.microsoft.com/en-us/windows/win32/api/ctffunc/nf-ctffunc-itffnsearchcandidateprovider-setresult HRESULT
|
|
// SetResult( BSTR bstrQuery, BSTR bstrApplicationID, BSTR bstrResult );
|
|
[PreserveSig]
|
|
HRESULT SetResult([In, MarshalAs(UnmanagedType.BStr)] string bstrQuery, [In, MarshalAs(UnmanagedType.BStr)] string bstrApplicationID, [In, MarshalAs(UnmanagedType.BStr)] string bstrResult);
|
|
};
|
|
|
|
/// <summary>
|
|
/// The <c>ITfFnShowHelp</c> interface is implemented by a text service to enable the language bar to place a help command for the
|
|
/// text service in the language bar help menu.
|
|
/// </summary>
|
|
/// <remarks>
|
|
/// <para>
|
|
/// The TSF manager obtains this interface from the text service by calling the text service ITfFunctionProvider::GetFunction
|
|
/// interface with IID_ITfFnShowHelp.
|
|
/// </para>
|
|
/// <para>The TSF manager obtains the help menu text by calling the text service's ITfFunction::GetDisplayName.</para>
|
|
/// </remarks>
|
|
// https://docs.microsoft.com/en-us/windows/win32/api/ctffunc/nn-ctffunc-itffnshowhelp
|
|
[PInvokeData("ctffunc.h", MSDNShortId = "NN:ctffunc.ITfFnShowHelp")]
|
|
[ComImport, Guid("5AB1D30C-094D-4C29-8EA5-0BF59BE87BF3"), InterfaceType(ComInterfaceType.InterfaceIsIUnknown)]
|
|
public interface ITfFnShowHelp : ITfFunction
|
|
{
|
|
/// <summary>Obtains the function display name.</summary>
|
|
/// <param name="pbstrName">
|
|
/// Pointer to a BSTR value that receives the display name. This value must be allocated using SysAllocString. The caller must
|
|
/// free this memory using SysFreeString when it is no longer required.
|
|
/// </param>
|
|
/// <returns>
|
|
/// <para>This method can return one of these values.</para>
|
|
/// <list type="table">
|
|
/// <listheader>
|
|
/// <term>Value</term>
|
|
/// <term>Description</term>
|
|
/// </listheader>
|
|
/// <item>
|
|
/// <term>S_OK</term>
|
|
/// <term>The method was successful.</term>
|
|
/// </item>
|
|
/// <item>
|
|
/// <term>E_OUTOFMEMORY</term>
|
|
/// <term>A memory allocation failure occurred.</term>
|
|
/// </item>
|
|
/// <item>
|
|
/// <term>E_INVALIDARG</term>
|
|
/// <term>pbstrName is invalid.</term>
|
|
/// </item>
|
|
/// </list>
|
|
/// </returns>
|
|
// https://docs.microsoft.com/en-us/windows/win32/api/msctf/nf-msctf-itffunction-getdisplayname HRESULT GetDisplayName( BSTR
|
|
// *pbstrName );
|
|
[PreserveSig]
|
|
new HRESULT GetDisplayName([Out, MarshalAs(UnmanagedType.BStr)] out string pbstrName);
|
|
|
|
/// <summary>Called when the user selects a text service help menu item.</summary>
|
|
/// <param name="hwndParent">Handle of the parent window. This value can be <c>NULL</c>.</param>
|
|
/// <returns>
|
|
/// <para>This method can return one of these values.</para>
|
|
/// <list type="table">
|
|
/// <listheader>
|
|
/// <term>Value</term>
|
|
/// <term>Description</term>
|
|
/// </listheader>
|
|
/// <item>
|
|
/// <term>S_OK</term>
|
|
/// <term>The method was successful.</term>
|
|
/// </item>
|
|
/// </list>
|
|
/// </returns>
|
|
/// <remarks>The text service should not wait for the help UI to be complete before returning from this method.</remarks>
|
|
// https://docs.microsoft.com/en-us/windows/win32/api/ctffunc/nf-ctffunc-itffnshowhelp-show HRESULT Show( HWND hwndParent );
|
|
[PreserveSig]
|
|
HRESULT Show([In] HWND hwndParent);
|
|
}
|
|
|
|
/// <summary>
|
|
/// The <c>ITfFunction</c> interface is the base interface for the individual function interfaces. This interface is implemented by
|
|
/// the provider of the function object and used by any component to obtain the display name of the function object. Instances of
|
|
/// this interface are not obtained directly. This interface is always part of a derived interface, such as ITfFnShowHelp.
|
|
/// </summary>
|
|
// https://docs.microsoft.com/en-us/windows/win32/api/msctf/nn-msctf-itffunction
|
|
[PInvokeData("msctf.h", MSDNShortId = "NN:msctf.ITfFunction")]
|
|
[ComImport, InterfaceType(ComInterfaceType.InterfaceIsIUnknown), Guid("DB593490-098F-11D3-8DF0-00105A2799B5")]
|
|
public interface ITfFunction
|
|
{
|
|
/// <summary>Obtains the function display name.</summary>
|
|
/// <param name="pbstrName">
|
|
/// Pointer to a BSTR value that receives the display name. This value must be allocated using SysAllocString. The caller must
|
|
/// free this memory using SysFreeString when it is no longer required.
|
|
/// </param>
|
|
/// <returns>
|
|
/// <para>This method can return one of these values.</para>
|
|
/// <list type="table">
|
|
/// <listheader>
|
|
/// <term>Value</term>
|
|
/// <term>Description</term>
|
|
/// </listheader>
|
|
/// <item>
|
|
/// <term>S_OK</term>
|
|
/// <term>The method was successful.</term>
|
|
/// </item>
|
|
/// <item>
|
|
/// <term>E_OUTOFMEMORY</term>
|
|
/// <term>A memory allocation failure occurred.</term>
|
|
/// </item>
|
|
/// <item>
|
|
/// <term>E_INVALIDARG</term>
|
|
/// <term>pbstrName is invalid.</term>
|
|
/// </item>
|
|
/// </list>
|
|
/// </returns>
|
|
// https://docs.microsoft.com/en-us/windows/win32/api/msctf/nf-msctf-itffunction-getdisplayname HRESULT GetDisplayName( BSTR
|
|
// *pbstrName );
|
|
[PreserveSig]
|
|
HRESULT GetDisplayName([Out, MarshalAs(UnmanagedType.BStr)] out string pbstrName);
|
|
}
|
|
|
|
/// <summary>Enables text services and Input Method Editors (IMEs) to adjust UI-less mode behavior.</summary>
|
|
/// <remarks>
|
|
/// <para>
|
|
/// The <c>ITfIntegratableCandidateListUIElement</c> interface is implemented by text services and Input Method Editors (IMEs) to
|
|
/// adjust UI-less mode behavior for a better UI and keyboarding experience in IME-integrated controls, like the Windows 8 Search
|
|
/// box. The interface is used by apps that need a more streamlined UI and keyboarding experience with IME languages.
|
|
/// </para>
|
|
/// <para>
|
|
/// You can get an <c>ITfIntegratableCandidateListUIElement</c> interface pointer by calling QueryInterface on the ITfUIElement
|
|
/// interface pointer that's provided by using the dwUIElementId parameters of the ITfUIElementSink callback functions to obtain the
|
|
/// interface from ITfUIElementMgr.
|
|
/// </para>
|
|
/// <para>
|
|
/// The <c>ITfIntegratableCandidateListUIElement</c> interface is an optional interface that's implemented by a text service or IME
|
|
/// that needs greater control over how its UI is presented in UI-less mode. Apps can use it to implement more streamlined,
|
|
/// special-purpose input controls, as in auto-complete or search suggestions.
|
|
/// </para>
|
|
/// <para>
|
|
/// Implement the <c>ITfIntegratableCandidateListUIElement</c> interface in the same class that implements the ITfUIElement,
|
|
/// ITfCandidateListUIElement, and ITfCandidateListUIElementBehavior interfaces. These interfaces work together to create a fully
|
|
/// integrated experience in which the app renders candidate list UI for the text service or IME and can also have some IME-specific
|
|
/// UI customization and keyboard interaction behavior.
|
|
/// </para>
|
|
/// </remarks>
|
|
// https://docs.microsoft.com/en-us/windows/win32/api/ctffunc/nn-ctffunc-itfintegratablecandidatelistuielement
|
|
[PInvokeData("ctffunc.h", MSDNShortId = "NN:ctffunc.ITfIntegratableCandidateListUIElement")]
|
|
[ComImport, InterfaceType(ComInterfaceType.InterfaceIsIUnknown), Guid("C7A6F54F-B180-416F-B2BF-7BF2E4683D7B")]
|
|
public interface ITfIntegratableCandidateListUIElement
|
|
{
|
|
/// <summary>Sets the integration style.</summary>
|
|
/// <param name="guidIntegrationStyle">The desired type of keyboard integration experience.</param>
|
|
/// <returns>
|
|
/// <para>This method can return one of these values.</para>
|
|
/// <list type="table">
|
|
/// <listheader>
|
|
/// <term>Value</term>
|
|
/// <term>Description</term>
|
|
/// </listheader>
|
|
/// <item>
|
|
/// <term>S_OK</term>
|
|
/// <term>The text service supports the integration style.</term>
|
|
/// </item>
|
|
/// <item>
|
|
/// <term>E_NOTIMPL</term>
|
|
/// <term>The text service does not support the integration style.</term>
|
|
/// </item>
|
|
/// </list>
|
|
/// </returns>
|
|
/// <remarks>
|
|
/// If an app needs a keyboard-integrated experience, it can set a <c>GUID</c> for the desired type of integration experience.
|
|
/// If the text service supports the integration style, it should return <c>S_OK</c>. If it's not supported, it should return
|
|
/// <c>E_NOTIMPL</c>. When called, the text service may adjust its respond to keyboard interaction for the lifetime of the
|
|
/// ITfCandidateListUIElement object, for example, until ITfUIElementSink::EndUIElement is called.
|
|
/// </remarks>
|
|
// https://docs.microsoft.com/en-us/windows/win32/api/ctffunc/nf-ctffunc-itfintegratablecandidatelistuielement-setintegrationstyle
|
|
// HRESULT SetIntegrationStyle( GUID guidIntegrationStyle );
|
|
[PreserveSig]
|
|
HRESULT SetIntegrationStyle(in Guid guidIntegrationStyle);
|
|
|
|
/// <summary>Retrieves the selection style.</summary>
|
|
/// <param name="ptfSelectionStyle">A value that specifies the selection style.</param>
|
|
/// <returns>
|
|
/// <para>This method can return one of these values.</para>
|
|
/// <list type="table">
|
|
/// <listheader>
|
|
/// <term>Value</term>
|
|
/// <term>Description</term>
|
|
/// </listheader>
|
|
/// <item>
|
|
/// <term>S_OK</term>
|
|
/// <term>The method was successful.</term>
|
|
/// </item>
|
|
/// </list>
|
|
/// </returns>
|
|
/// <remarks>
|
|
/// The active selection style usually indicates that the selection can be changed with the arrow keys. The implied selection
|
|
/// style indicates the default selection key chooses it. If the app supports changing selection styles, this method should be
|
|
/// called when the UpdateUIElement method is called.
|
|
/// </remarks>
|
|
// https://docs.microsoft.com/en-us/windows/win32/api/ctffunc/nf-ctffunc-itfintegratablecandidatelistuielement-getselectionstyle
|
|
// HRESULT GetSelectionStyle( TfIntegratableCandidateListSelectionStyle *ptfSelectionStyle );
|
|
[PreserveSig]
|
|
HRESULT GetSelectionStyle(out TfIntegratableCandidateListSelectionStyle ptfSelectionStyle);
|
|
|
|
/// <summary>Processes a key press.</summary>
|
|
/// <param name="wParam">
|
|
/// Specifies the virtual-key code of the key. For more information about this parameter, see the wParam parameter in WM_KEYDOWN.
|
|
/// </param>
|
|
/// <param name="lParam">
|
|
/// Specifies the repeat count, scan code, extended-key flag, context code, previous key-state flag, and transition-state flag
|
|
/// of the key. For more information about this parameter, see the lParam parameter in WM_KEYDOWN.
|
|
/// </param>
|
|
/// <param name="pfEaten"><c>TRUE</c> if the key event was handled; otherwise, <c>FALSE</c>.</param>
|
|
/// <returns>
|
|
/// <para>This method can return one of these values.</para>
|
|
/// <list type="table">
|
|
/// <listheader>
|
|
/// <term>Value</term>
|
|
/// <term>Description</term>
|
|
/// </listheader>
|
|
/// <item>
|
|
/// <term>S_OK</term>
|
|
/// <term>The method was successful.</term>
|
|
/// </item>
|
|
/// </list>
|
|
/// </returns>
|
|
/// <remarks>
|
|
/// <para>
|
|
/// The OnKeyDown method enables an app to ask query the text service if it wants to process a given key in an integration
|
|
/// style. The behavior of the <c>OnKeyDown</c> method can depend on the integration style. If the text service returns
|
|
/// *pfEaten= <c>TRUE</c>, then the app should do no processing of the key. If <c>FALSE</c> is returned, the app can perform its
|
|
/// own action in response to the key.
|
|
/// </para>
|
|
/// <para>
|
|
/// <c>GUID_INTEGRATIONSTYLE_SEARCHBOX</c> ({E6D1BD11-82F7-4903-AE21-1A6397CDE2EB}) enables an implementation of a keyboarding
|
|
/// experience in which the user can move perceived keyboard focus from the search box to the candidate list to search
|
|
/// suggestions. The text service can process keys like <c>VK_UP</c> and <c>VK_DOWN</c> before Search handles them to change its
|
|
/// internal state.
|
|
/// </para>
|
|
/// </remarks>
|
|
// https://docs.microsoft.com/en-us/windows/win32/api/ctffunc/nf-ctffunc-itfintegratablecandidatelistuielement-onkeydown HRESULT
|
|
// OnKeyDown( WPARAM wParam, LPARAM lParam, BOOL *pfEaten );
|
|
[PreserveSig]
|
|
HRESULT OnKeyDown([In] WPARAM wParam, [In] LPARAM lParam, [Out, MarshalAs(UnmanagedType.Bool)] out bool pfEaten);
|
|
|
|
/// <summary>Specifies whether candidate numbers should be shown.</summary>
|
|
/// <param name="pfShow"><c>TRUE</c> if candidate numbers should be shown; otherwise <c>FALSE</c>.</param>
|
|
/// <returns>
|
|
/// <para>This method can return one of these values.</para>
|
|
/// <list type="table">
|
|
/// <listheader>
|
|
/// <term>Value</term>
|
|
/// <term>Description</term>
|
|
/// </listheader>
|
|
/// <item>
|
|
/// <term>S_OK</term>
|
|
/// <term>The method was successful.</term>
|
|
/// </item>
|
|
/// </list>
|
|
/// </returns>
|
|
// https://docs.microsoft.com/en-us/windows/win32/api/ctffunc/nf-ctffunc-itfintegratablecandidatelistuielement-showcandidatenumbers
|
|
// HRESULT ShowCandidateNumbers( BOOL *pfShow );
|
|
[PreserveSig]
|
|
HRESULT ShowCandidateNumbers([Out, MarshalAs(UnmanagedType.Bool)] out bool pfShow);
|
|
|
|
/// <summary>Enables text services and Input Method Editors (IMEs) to adjust UI-less mode behavior.</summary>
|
|
/// <remarks>
|
|
/// <para>
|
|
/// The <c>ITfIntegratableCandidateListUIElement</c> interface is implemented by text services and Input Method Editors (IMEs)
|
|
/// to adjust UI-less mode behavior for a better UI and keyboarding experience in IME-integrated controls, like the Windows 8
|
|
/// Search box. The interface is used by apps that need a more streamlined UI and keyboarding experience with IME languages.
|
|
/// </para>
|
|
/// <para>
|
|
/// You can get an <c>ITfIntegratableCandidateListUIElement</c> interface pointer by calling QueryInterface on the ITfUIElement
|
|
/// interface pointer that's provided by using the dwUIElementId parameters of the ITfUIElementSink callback functions to obtain
|
|
/// the interface from ITfUIElementMgr.
|
|
/// </para>
|
|
/// <para>
|
|
/// The <c>ITfIntegratableCandidateListUIElement</c> interface is an optional interface that's implemented by a text service or
|
|
/// IME that needs greater control over how its UI is presented in UI-less mode. Apps can use it to implement more streamlined,
|
|
/// special-purpose input controls, as in auto-complete or search suggestions.
|
|
/// </para>
|
|
/// <para>
|
|
/// Implement the <c>ITfIntegratableCandidateListUIElement</c> interface in the same class that implements the ITfUIElement,
|
|
/// ITfCandidateListUIElement, and ITfCandidateListUIElementBehavior interfaces. These interfaces work together to create a
|
|
/// fully integrated experience in which the app renders candidate list UI for the text service or IME and can also have some
|
|
/// IME-specific UI customization and keyboard interaction behavior.
|
|
/// </para>
|
|
/// </remarks>
|
|
// https://docs.microsoft.com/en-us/windows/win32/api/ctffunc/nn-ctffunc-itfintegratablecandidatelistuielement
|
|
[PreserveSig]
|
|
HRESULT FinalizeExactCompositionString();
|
|
}
|
|
|
|
/// <summary>
|
|
/// The <c>ITfLMLattice</c> interface is implemented by the speech text service to provide information about lattice element
|
|
/// properties and is used by a client (application or other text service). A client obtains this interface from the
|
|
/// GUID_PROP_LMLATTICE property by calling ITfReadOnlyProperty::GetValue. For more information, see Predefined Properties.
|
|
/// </summary>
|
|
// https://docs.microsoft.com/en-us/windows/win32/api/ctffunc/nn-ctffunc-itflmlattice
|
|
[PInvokeData("ctffunc.h", MSDNShortId = "NN:ctffunc.ITfLMLattice")]
|
|
[ComImport, InterfaceType(ComInterfaceType.InterfaceIsIUnknown), Guid("D4236675-A5BF-4570-9D42-5D6D7B02D59B")]
|
|
public interface ITfLMLattice
|
|
{
|
|
/// <summary>Determines if a specific lattice element type is supported by the lattice property.</summary>
|
|
/// <param name="rguidType">Specifies the lattice type identifier. This can be one of the Lattice Type values.</param>
|
|
/// <returns>
|
|
/// Pointer to a <c>BOOL</c> that receives a value that indicates if the lattice type is supported. If the lattice type is
|
|
/// supported, this parameter receives a nonzero value and the method returns S_OK. If the lattice type is unsupported, this
|
|
/// parameter receives zero and the method returns E_INVALIDARG.
|
|
/// </returns>
|
|
// https://docs.microsoft.com/en-us/windows/win32/api/ctffunc/nf-ctffunc-itflmlattice-querytype HRESULT QueryType( REFGUID
|
|
// rguidType, BOOL *pfSupported );
|
|
[return: MarshalAs(UnmanagedType.Bool)]
|
|
bool QueryType(in Guid rguidType);
|
|
|
|
/// <summary>
|
|
/// Obtains an enumerator that contains all lattice elements contained in the lattice property that start at or after a specific
|
|
/// offset from the start of the frame.
|
|
/// </summary>
|
|
/// <param name="dwFrameStart">
|
|
/// Specifies the offset, in 100-nanosecond units, relative to the start of the phrase, of the first element to obtain.
|
|
/// </param>
|
|
/// <param name="rguidType">Specifies the lattice type identifier. This can be one of the Lattice Type values.</param>
|
|
/// <returns>Pointer to an IEnumTfLatticeElements interface pointer that receives the enumerator object.</returns>
|
|
// https://docs.microsoft.com/en-us/windows/win32/api/ctffunc/nf-ctffunc-itflmlattice-enumlatticeelements HRESULT
|
|
// EnumLatticeElements( DWORD dwFrameStart, REFGUID rguidType, IEnumTfLatticeElements **ppEnum );
|
|
IEnumTfLatticeElements EnumLatticeElements(uint dwFrameStart, in Guid rguidType);
|
|
}
|
|
|
|
/// <summary>
|
|
/// The <c>TF_LMLATTELEMENT</c> structure contains information about a lattice element. A lattice element is used in speech
|
|
/// recognition. This structure is used with the IEnumTfLatticeElements::Next method.
|
|
/// </summary>
|
|
// https://docs.microsoft.com/en-us/windows/win32/api/ctffunc/ns-ctffunc-tf_lmlattelement typedef struct TF_LMLATTELEMENT { DWORD
|
|
// dwFrameStart; DWORD dwFrameLen; DWORD dwFlags; union { INT iCost; }; BSTR bstrText; } TF_LMLATTELEMENT;
|
|
[PInvokeData("ctffunc.h", MSDNShortId = "NS:ctffunc.TF_LMLATTELEMENT")]
|
|
[StructLayout(LayoutKind.Sequential, Pack = 4), Guid("1B646EFE-3CE3-4CE2-B41F-35B93FE5552F")]
|
|
public struct TF_LMLATTELEMENT
|
|
{
|
|
/// <summary>Contains the starting offset, in 100-nanosecond units, of the element relative to the start of the phrase.</summary>
|
|
public uint dwFrameStart;
|
|
|
|
/// <summary>Contains the length, in 100-nanosecond units, of the element.</summary>
|
|
public uint dwFrameLen;
|
|
|
|
/// <summary>Not currently used.</summary>
|
|
public uint dwFlags;
|
|
|
|
/// <summary>
|
|
/// <para>Specifies the actual confidence for this element. This can be one of the following values.</para>
|
|
/// <list type="table">
|
|
/// <listheader>
|
|
/// <term>Value</term>
|
|
/// <term>Meaning</term>
|
|
/// </listheader>
|
|
/// <item>
|
|
/// <term>SP_LOW_CONFIDENCE</term>
|
|
/// <term>The speech engine has low confidence in the element.</term>
|
|
/// </item>
|
|
/// <item>
|
|
/// <term>SP_NORMAL_CONFIDENCE</term>
|
|
/// <term>The speech engine has normal confidence in the element.</term>
|
|
/// </item>
|
|
/// <item>
|
|
/// <term>SP_HIGH_CONFIDENCE</term>
|
|
/// <term>The speech engine has high confidence in the element.</term>
|
|
/// </item>
|
|
/// </list>
|
|
/// </summary>
|
|
public SP_CONFIDENCE iCost;
|
|
|
|
/// <summary>
|
|
/// Contains the display text for the element. If the spoken word is "two", the display text will be "2". The caller must free
|
|
/// this string using SysFreeString when it is no longer required.
|
|
/// </summary>
|
|
[MarshalAs(UnmanagedType.BStr)]
|
|
public string bstrText;
|
|
}
|
|
}
|
|
} |