2117 lines
59 KiB
Plaintext
2117 lines
59 KiB
Plaintext
//+-------------------------------------------------------------------------
|
|
//
|
|
// Microsoft Windows
|
|
// Copyright (C) Microsoft Corporation, 1992-2001.
|
|
//
|
|
// File: msctf.idl
|
|
//
|
|
// Contents: Text Framework declarations.
|
|
//
|
|
//
|
|
//--------------------------------------------------------------------------
|
|
|
|
cpp_quote("//=--------------------------------------------------------------------------=")
|
|
cpp_quote("// msctf.h")
|
|
cpp_quote("")
|
|
cpp_quote("")
|
|
cpp_quote("// Text Framework declarations.")
|
|
cpp_quote("")
|
|
cpp_quote("//=--------------------------------------------------------------------------=")
|
|
cpp_quote("// (C) Copyright 1995-2001 Microsoft Corporation. All Rights Reserved.")
|
|
cpp_quote("//")
|
|
cpp_quote("// THIS CODE AND INFORMATION IS PROVIDED \"AS IS\" WITHOUT WARRANTY OF")
|
|
cpp_quote("// ANY KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING BUT NOT LIMITED TO")
|
|
cpp_quote("// THE IMPLIED WARRANTIES OF MERCHANTABILITY AND/OR FITNESS FOR A")
|
|
cpp_quote("// PARTICULAR PURPOSE.")
|
|
cpp_quote("//=--------------------------------------------------------------------------=")
|
|
cpp_quote("")
|
|
|
|
cpp_quote("#ifndef MSCTF_DEFINED")
|
|
cpp_quote("#define MSCTF_DEFINED")
|
|
cpp_quote("")
|
|
cpp_quote("#include <windows.h>")
|
|
cpp_quote("")
|
|
cpp_quote("#ifdef __cplusplus")
|
|
cpp_quote("extern \"C\" {")
|
|
cpp_quote("#endif /* __cplusplus */")
|
|
cpp_quote("")
|
|
|
|
//
|
|
// error codes
|
|
//
|
|
cpp_quote("#define TF_E_LOCKED MAKE_HRESULT(SEVERITY_ERROR, FACILITY_ITF, 0x0500)")
|
|
cpp_quote("#define TF_E_STACKFULL MAKE_HRESULT(SEVERITY_ERROR, FACILITY_ITF, 0x0501)")
|
|
cpp_quote("#define TF_E_NOTOWNEDRANGE MAKE_HRESULT(SEVERITY_ERROR, FACILITY_ITF, 0x0502)")
|
|
cpp_quote("#define TF_E_NOPROVIDER MAKE_HRESULT(SEVERITY_ERROR, FACILITY_ITF, 0x0503)")
|
|
cpp_quote("#define TF_E_DISCONNECTED MAKE_HRESULT(SEVERITY_ERROR, FACILITY_ITF, 0x0504)")
|
|
cpp_quote("#define TF_E_INVALIDVIEW MAKE_HRESULT(SEVERITY_ERROR, FACILITY_ITF, 0x0505)")
|
|
cpp_quote("#define TF_E_ALREADY_EXISTS MAKE_HRESULT(SEVERITY_ERROR, FACILITY_ITF, 0x0506)")
|
|
cpp_quote("#define TF_E_RANGE_NOT_COVERED MAKE_HRESULT(SEVERITY_ERROR, FACILITY_ITF, 0x0507)")
|
|
cpp_quote("#define TF_E_COMPOSITION_REJECTED MAKE_HRESULT(SEVERITY_ERROR, FACILITY_ITF, 0x0508)")
|
|
cpp_quote("#define TF_E_EMPTYCONTEXT MAKE_HRESULT(SEVERITY_ERROR, FACILITY_ITF, 0x0509)")
|
|
|
|
// the following must match their TS_E_ counter parts!
|
|
cpp_quote("#define TF_E_INVALIDPOS MAKE_HRESULT(SEVERITY_ERROR, FACILITY_ITF, 0x0200)")
|
|
cpp_quote("#define TF_E_NOLOCK MAKE_HRESULT(SEVERITY_ERROR, FACILITY_ITF, 0x0201)")
|
|
cpp_quote("#define TF_E_NOOBJECT MAKE_HRESULT(SEVERITY_ERROR, FACILITY_ITF, 0x0202)")
|
|
cpp_quote("#define TF_E_NOSERVICE MAKE_HRESULT(SEVERITY_ERROR, FACILITY_ITF, 0x0203)")
|
|
cpp_quote("#define TF_E_NOINTERFACE MAKE_HRESULT(SEVERITY_ERROR, FACILITY_ITF, 0x0204)")
|
|
cpp_quote("#define TF_E_NOSELECTION MAKE_HRESULT(SEVERITY_ERROR, FACILITY_ITF, 0x0205)")
|
|
cpp_quote("#define TF_E_NOLAYOUT MAKE_HRESULT(SEVERITY_ERROR, FACILITY_ITF, 0x0206)")
|
|
cpp_quote("#define TF_E_INVALIDPOINT MAKE_HRESULT(SEVERITY_ERROR, FACILITY_ITF, 0x0207)")
|
|
cpp_quote("#define TF_E_SYNCHRONOUS MAKE_HRESULT(SEVERITY_ERROR, FACILITY_ITF, 0x0208)")
|
|
cpp_quote("#define TF_E_READONLY MAKE_HRESULT(SEVERITY_ERROR, FACILITY_ITF, 0x0209)")
|
|
cpp_quote("#define TF_E_FORMAT MAKE_HRESULT(SEVERITY_ERROR, FACILITY_ITF, 0x020a)")
|
|
|
|
// TF_S_ASYNC is only used as an [out] param for RequestEditSession
|
|
cpp_quote("#define TF_S_ASYNC MAKE_HRESULT(SEVERITY_SUCCESS, FACILITY_ITF, 0x0300)")
|
|
|
|
cpp_quote("")
|
|
|
|
cpp_quote("HRESULT WINAPI TF_CreateThreadMgr(ITfThreadMgr **pptim);")
|
|
cpp_quote("HRESULT WINAPI TF_GetThreadMgr(ITfThreadMgr **pptim);")
|
|
cpp_quote("HRESULT WINAPI TF_CreateInputProcessorProfiles(ITfInputProcessorProfiles **ppipr);")
|
|
cpp_quote("HRESULT WINAPI TF_CreateDisplayAttributeMgr(ITfDisplayAttributeMgr **ppdam);")
|
|
cpp_quote("HRESULT WINAPI TF_CreateLangBarMgr(ITfLangBarMgr **pppbm);")
|
|
cpp_quote("HRESULT WINAPI TF_CreateLangBarItemMgr(ITfLangBarItemMgr **pplbim);")
|
|
cpp_quote("")
|
|
|
|
cpp_quote("EXTERN_C const GUID GUID_PROP_TEXTOWNER;")
|
|
cpp_quote("EXTERN_C const GUID GUID_PROP_ATTRIBUTE;")
|
|
cpp_quote("EXTERN_C const GUID GUID_PROP_LANGID;")
|
|
cpp_quote("EXTERN_C const GUID GUID_PROP_READING;")
|
|
cpp_quote("EXTERN_C const GUID GUID_PROP_COMPOSING;")
|
|
cpp_quote("")
|
|
|
|
cpp_quote("EXTERN_C const CLSID CLSID_TF_ThreadMgr;")
|
|
cpp_quote("EXTERN_C const CLSID CLSID_TF_InputProcessorProfiles;")
|
|
cpp_quote("EXTERN_C const CLSID CLSID_TF_LangBarMgr;")
|
|
cpp_quote("EXTERN_C const CLSID CLSID_TF_DisplayAttributeMgr;")
|
|
cpp_quote("EXTERN_C const CLSID CLSID_TF_CategoryMgr;")
|
|
cpp_quote("EXTERN_C const CLSID CLSID_TF_LangBarItemMgr;")
|
|
|
|
cpp_quote("EXTERN_C const GUID GUID_SYSTEM_FUNCTIONPROVIDER;")
|
|
cpp_quote("EXTERN_C const GUID GUID_APP_FUNCTIONPROVIDER;")
|
|
cpp_quote("")
|
|
|
|
cpp_quote("")
|
|
|
|
//
|
|
// GUIDs for system predefined compartment
|
|
//
|
|
cpp_quote("EXTERN_C const GUID GUID_COMPARTMENT_KEYBOARD_DISABLED;")
|
|
cpp_quote("EXTERN_C const GUID GUID_COMPARTMENT_KEYBOARD_OPENCLOSE;")
|
|
cpp_quote("EXTERN_C const GUID GUID_COMPARTMENT_HANDWRITING_OPENCLOSE;")
|
|
cpp_quote("EXTERN_C const GUID GUID_COMPARTMENT_SPEECH_DISABLED;")
|
|
cpp_quote("EXTERN_C const GUID GUID_COMPARTMENT_SPEECH_OPENCLOSE;")
|
|
cpp_quote("EXTERN_C const GUID GUID_COMPARTMENT_SPEECH_GLOBALSTATE;")
|
|
cpp_quote("EXTERN_C const GUID GUID_COMPARTMENT_PERSISTMENUENABLED;")
|
|
cpp_quote("EXTERN_C const GUID GUID_COMPARTMENT_EMPTYCONTEXT;")
|
|
cpp_quote("EXTERN_C const GUID GUID_COMPARTMENT_TIPUISTATUS;")
|
|
cpp_quote("")
|
|
|
|
//
|
|
// Conversion Mode Bias Compartment
|
|
//
|
|
cpp_quote("EXTERN_C const GUID GUID_PROP_MODEBIAS;")
|
|
cpp_quote("")
|
|
|
|
//
|
|
// GUIDs for system predefined conversion mode bias
|
|
//
|
|
cpp_quote("EXTERN_C const GUID GUID_MODEBIAS_NONE;")
|
|
cpp_quote("EXTERN_C const GUID GUID_MODEBIAS_URLHISTORY;")
|
|
cpp_quote("EXTERN_C const GUID GUID_MODEBIAS_FILENAME;")
|
|
cpp_quote("EXTERN_C const GUID GUID_MODEBIAS_READING;")
|
|
cpp_quote("EXTERN_C const GUID GUID_MODEBIAS_DATETIME;")
|
|
cpp_quote("EXTERN_C const GUID GUID_MODEBIAS_NAME;")
|
|
cpp_quote("EXTERN_C const GUID GUID_MODEBIAS_CONVERSATION;")
|
|
cpp_quote("EXTERN_C const GUID GUID_MODEBIAS_NUMERIC;")
|
|
//
|
|
// These are FE language specific mode bias.
|
|
//
|
|
cpp_quote("EXTERN_C const GUID GUID_MODEBIAS_HIRAGANA;")
|
|
cpp_quote("EXTERN_C const GUID GUID_MODEBIAS_KATAKANA;")
|
|
cpp_quote("EXTERN_C const GUID GUID_MODEBIAS_HANGUL;")
|
|
cpp_quote("EXTERN_C const GUID GUID_MODEBIAS_CHINESE;")
|
|
|
|
cpp_quote("EXTERN_C const GUID GUID_MODEBIAS_HALFWIDTHKATAKANA;")
|
|
cpp_quote("EXTERN_C const GUID GUID_MODEBIAS_FULLWIDTHALPHANUMERIC;")
|
|
cpp_quote("EXTERN_C const GUID GUID_MODEBIAS_HALFWIDTHALPHANUMERIC;")
|
|
cpp_quote("EXTERN_C const GUID GUID_MODEBIAS_FULLWIDTHHANGUL;")
|
|
|
|
//
|
|
// GUID_TFCAT_CATEGORY_OF_TIP categrorize the types of tips.
|
|
// by default, this category contains the following guids.
|
|
// GUID_TFCAT_TIP_KEYBOARD
|
|
// GUID_TFCAT_TIP_SPEECH
|
|
// GUID_TFCAT_TIP_HANDWRITING
|
|
//
|
|
cpp_quote("EXTERN_C const GUID GUID_TFCAT_CATEGORY_OF_TIP;")
|
|
|
|
//
|
|
// GUIDs for the Tips category. Each category contains Tips classes.
|
|
//
|
|
cpp_quote("EXTERN_C const GUID GUID_TFCAT_TIP_KEYBOARD;")
|
|
cpp_quote("EXTERN_C const GUID GUID_TFCAT_TIP_SPEECH;")
|
|
cpp_quote("EXTERN_C const GUID GUID_TFCAT_TIP_HANDWRITING;")
|
|
|
|
//
|
|
// GUIDs for the property category. Each category contains Property GUID.
|
|
//
|
|
cpp_quote("EXTERN_C const GUID GUID_TFCAT_PROP_AUDIODATA;")
|
|
cpp_quote("EXTERN_C const GUID GUID_TFCAT_PROP_INKDATA;")
|
|
cpp_quote("")
|
|
|
|
//
|
|
// GUIDs for the property style.
|
|
//
|
|
cpp_quote("EXTERN_C const GUID GUID_TFCAT_PROPSTYLE_CUSTOM;")
|
|
cpp_quote("EXTERN_C const GUID GUID_TFCAT_PROPSTYLE_STATIC;")
|
|
cpp_quote("EXTERN_C const GUID GUID_TFCAT_PROPSTYLE_STATICCOMPACT;")
|
|
cpp_quote("")
|
|
|
|
//
|
|
// GUIDs for the display attribute provider category.
|
|
//
|
|
cpp_quote("EXTERN_C const GUID GUID_TFCAT_DISPLAYATTRIBUTEPROVIDER;")
|
|
cpp_quote("EXTERN_C const GUID GUID_TFCAT_DISPLAYATTRIBUTEPROPERTY;")
|
|
cpp_quote("")
|
|
|
|
cpp_quote("#define TF_INVALID_GUIDATOM ((TfGuidAtom)0)")
|
|
cpp_quote("#define TF_CLIENTID_NULL ((TfClientId)0)")
|
|
|
|
cpp_quote("")
|
|
|
|
cpp_quote("#define TF_MOD_ALT 0x0001")
|
|
cpp_quote("#define TF_MOD_CONTROL 0x0002")
|
|
cpp_quote("#define TF_MOD_SHIFT 0x0004")
|
|
cpp_quote("#define TF_MOD_RALT 0x0008")
|
|
cpp_quote("#define TF_MOD_RCONTROL 0x0010")
|
|
cpp_quote("#define TF_MOD_RSHIFT 0x0020")
|
|
cpp_quote("#define TF_MOD_LALT 0x0040")
|
|
cpp_quote("#define TF_MOD_LCONTROL 0x0080")
|
|
cpp_quote("#define TF_MOD_LSHIFT 0x0100")
|
|
cpp_quote("#define TF_MOD_ON_KEYUP 0x0200")
|
|
cpp_quote("#define TF_MOD_IGNORE_ALL_MODIFIER 0x0400")
|
|
cpp_quote("")
|
|
|
|
//
|
|
// flags for GUID_COMPARTMENT_TIPUISTATUS
|
|
//
|
|
cpp_quote("#define TF_US_HIDETIPUI 0x00000001")
|
|
cpp_quote("")
|
|
//
|
|
// flags for GUID GUID_COMPARTMENT_SPEECH_DISABLED
|
|
//
|
|
cpp_quote("#define TF_DISABLE_SPEECH 0x00000001")
|
|
cpp_quote("#define TF_DISABLE_DICTATION 0x00000002")
|
|
cpp_quote("#define TF_DISABLE_COMMANDING 0x00000004")
|
|
cpp_quote("")
|
|
|
|
cpp_quote("#define TF_PROCESS_ATOM TEXT(\"_CTF_PROCESS_ATOM_\")")
|
|
cpp_quote("#define TF_ENABLE_PROCESS_ATOM TEXT(\"_CTF_ENABLE_PROCESS_ATOM_\")")
|
|
|
|
|
|
cpp_quote("#ifdef __cplusplus")
|
|
cpp_quote("}")
|
|
cpp_quote("#endif /* __cplusplus */")
|
|
|
|
|
|
import "oaidl.idl";
|
|
import "comcat.idl";
|
|
import "textstor.idl";
|
|
import "ctfutb.idl";
|
|
|
|
cpp_quote("")
|
|
cpp_quote("#if 0")
|
|
typedef [uuid(4f5d560f-5ab5-4dde-8c4d-404592857ab0)] UINT_PTR HKL;
|
|
cpp_quote("#endif")
|
|
cpp_quote("")
|
|
|
|
interface ITfThreadMgrEventSink;
|
|
interface ITfTextInputProcessor;
|
|
interface ITfRange;
|
|
interface ITfRangeACP;
|
|
interface ITfDocumentMgr;
|
|
interface ITfContext;
|
|
interface ITfKeyFocusNotifySink;
|
|
interface ITfEditSession;
|
|
interface ITfProperty;
|
|
interface ITfPersistentPropertyLoaderACP;
|
|
interface IEnumTfProperties;
|
|
interface ITfKeyEventSink;
|
|
interface IEnumTfTextDeltas;
|
|
interface ITfFunctionProvider;
|
|
interface IEnumTfFunctionProviders;
|
|
interface IEnumTfDocumentMgrs;
|
|
interface IEnumTfContexts;
|
|
interface ITfSource;
|
|
interface ITfCompartmentMgr;
|
|
interface ITfRangeBackup;
|
|
interface IEnumTfRanges;
|
|
interface ITfMouseSink;
|
|
interface ITfReadOnlyProperty;
|
|
interface IEnumTfLanguageProfiles;
|
|
|
|
typedef [uuid(7213778c-7bb0-4270-b050-6189ee594e97)] DWORD TfEditCookie;
|
|
|
|
const TfEditCookie TF_INVALID_EDIT_COOKIE = 0;
|
|
|
|
typedef [uuid(88a9c478-f3ec-4763-8345-cd9250443f8d)] DWORD TfGuidAtom;
|
|
|
|
typedef [uuid(de403c21-89fd-4f85-8b87-64584d063fbc)] DWORD TfClientId;
|
|
|
|
typedef [uuid(e26d9e1d-691e-4f29-90d7-338dcf1f8cef)] struct TF_PERSISTENT_PROPERTY_HEADER_ACP
|
|
{
|
|
GUID guidType; // property type
|
|
LONG ichStart; // range information of this property data
|
|
LONG cch; // range information of this property data
|
|
ULONG cb; // the data size of pStream in BYTE count
|
|
DWORD dwPrivate; // private data
|
|
CLSID clsidTIP; // the original owner of the property data
|
|
} TF_PERSISTENT_PROPERTY_HEADER_ACP;
|
|
|
|
typedef [uuid(e1b5808d-1e46-4c19-84dc-68c5f5978cc8)] struct TF_LANGUAGEPROFILE
|
|
{
|
|
CLSID clsid; // CLSID of tip
|
|
LANGID langid; // language id
|
|
GUID catid; // category of tip
|
|
BOOL fActive; // activated profile
|
|
GUID guidProfile; // profile description
|
|
} TF_LANGUAGEPROFILE;
|
|
|
|
|
|
typedef [uuid(5a886226-ae9a-489b-b991-2b1e25ee59a9)] enum { TF_ANCHOR_START = 0, TF_ANCHOR_END = 1 } TfAnchor;
|
|
|
|
//
|
|
// ITfThreadMgr
|
|
//
|
|
[
|
|
object,
|
|
local,
|
|
uuid(aa80e801-2021-11d2-93e0-0060b067b86e),
|
|
pointer_default(unique)
|
|
]
|
|
interface ITfThreadMgr : IUnknown
|
|
{
|
|
HRESULT Activate([out] TfClientId *ptid);
|
|
|
|
HRESULT Deactivate();
|
|
|
|
HRESULT CreateDocumentMgr([out] ITfDocumentMgr **ppdim);
|
|
|
|
HRESULT EnumDocumentMgrs([out] IEnumTfDocumentMgrs **ppEnum);
|
|
|
|
HRESULT GetFocus([out] ITfDocumentMgr **ppdimFocus);
|
|
|
|
HRESULT SetFocus([in] ITfDocumentMgr *pdimFocus);
|
|
|
|
HRESULT AssociateFocus([in] HWND hwnd,
|
|
[in, unique] ITfDocumentMgr *pdimNew,
|
|
[out] ITfDocumentMgr **ppdimPrev);
|
|
|
|
HRESULT IsThreadFocus([out] BOOL *pfThreadFocus);
|
|
|
|
HRESULT GetFunctionProvider([in] REFCLSID clsid,
|
|
[out] ITfFunctionProvider **ppFuncProv);
|
|
|
|
HRESULT EnumFunctionProviders([out] IEnumTfFunctionProviders **ppEnum);
|
|
|
|
HRESULT GetGlobalCompartment([out] ITfCompartmentMgr **ppCompMgr);
|
|
};
|
|
|
|
//
|
|
// ITfThreadMgrEventSink
|
|
//
|
|
[
|
|
object,
|
|
uuid(aa80e80e-2021-11d2-93e0-0060b067b86e),
|
|
pointer_default(unique)
|
|
]
|
|
interface ITfThreadMgrEventSink : IUnknown
|
|
{
|
|
HRESULT OnInitDocumentMgr([in] ITfDocumentMgr *pdim);
|
|
|
|
HRESULT OnUninitDocumentMgr([in] ITfDocumentMgr *pdim);
|
|
|
|
HRESULT OnSetFocus([in] ITfDocumentMgr *pdimFocus, [in] ITfDocumentMgr *pdimPrevFocus);
|
|
|
|
HRESULT OnPushContext([in] ITfContext *pic);
|
|
|
|
HRESULT OnPopContext([in] ITfContext *pic);
|
|
};
|
|
|
|
//
|
|
// ITfConfigureSystemKeystrokeFeed
|
|
//
|
|
[
|
|
object,
|
|
local,
|
|
uuid(0d2c969a-bc9c-437c-84ee-951c49b1a764),
|
|
pointer_default(unique)
|
|
]
|
|
interface ITfConfigureSystemKeystrokeFeed : IUnknown
|
|
{
|
|
HRESULT DisableSystemKeystrokeFeed();
|
|
|
|
HRESULT EnableSystemKeystrokeFeed();
|
|
};
|
|
|
|
//
|
|
// IEnumTfDocumentMgrs
|
|
//
|
|
[
|
|
object,
|
|
uuid(aa80e808-2021-11d2-93e0-0060b067b86e),
|
|
pointer_default(unique)
|
|
]
|
|
interface IEnumTfDocumentMgrs : IUnknown
|
|
{
|
|
HRESULT Clone([out] IEnumTfDocumentMgrs **ppEnum);
|
|
|
|
HRESULT Next([in] ULONG ulCount,
|
|
[out, size_is(ulCount), length_is(*pcFetched)] ITfDocumentMgr **rgDocumentMgr,
|
|
[out] ULONG *pcFetched);
|
|
|
|
HRESULT Reset();
|
|
|
|
HRESULT Skip([in] ULONG ulCount);
|
|
};
|
|
|
|
//
|
|
// ITfDocumentMgr
|
|
//
|
|
[
|
|
object,
|
|
uuid(aa80e7f4-2021-11d2-93e0-0060b067b86e),
|
|
pointer_default(unique)
|
|
]
|
|
interface ITfDocumentMgr : IUnknown
|
|
{
|
|
HRESULT CreateContext([in] TfClientId tidOwner,
|
|
[in] DWORD dwFlags,
|
|
[in, unique] IUnknown *punk,
|
|
[out] ITfContext **ppic,
|
|
[out] TfEditCookie *pecTextStore);
|
|
|
|
HRESULT Push([in] ITfContext *pic);
|
|
|
|
const DWORD TF_POPF_ALL = 0x0001;
|
|
|
|
HRESULT Pop([in] DWORD dwFlags);
|
|
|
|
HRESULT GetTop([out] ITfContext **ppic);
|
|
|
|
HRESULT GetBase([out] ITfContext **ppic);
|
|
|
|
HRESULT EnumContexts([out] IEnumTfContexts **ppEnum);
|
|
};
|
|
|
|
//
|
|
// IEnumTfContexts
|
|
//
|
|
[
|
|
object,
|
|
uuid(8f1a7ea6-1654-4502-a86e-b2902344d507),
|
|
pointer_default(unique)
|
|
]
|
|
interface IEnumTfContexts : IUnknown
|
|
{
|
|
HRESULT Clone([out] IEnumTfContexts **ppEnum);
|
|
|
|
HRESULT Next([in] ULONG ulCount,
|
|
[out, size_is(ulCount), length_is(*pcFetched)] ITfContext **rgContext,
|
|
[out] ULONG *pcFetched);
|
|
|
|
HRESULT Reset();
|
|
|
|
HRESULT Skip([in] ULONG ulCount);
|
|
};
|
|
|
|
|
|
//
|
|
// ITfCompositionView
|
|
//
|
|
[
|
|
object,
|
|
uuid(D7540241-F9A1-4364-BEFC-DBCD2C4395B7),
|
|
pointer_default(unique)
|
|
]
|
|
interface ITfCompositionView : IUnknown
|
|
{
|
|
HRESULT GetOwnerClsid([out] CLSID *pclsid);
|
|
|
|
HRESULT GetRange([out] ITfRange **ppRange);
|
|
};
|
|
|
|
//
|
|
// IEnumITfCompositionView
|
|
//
|
|
[
|
|
object,
|
|
uuid(5EFD22BA-7838-46CB-88E2-CADB14124F8F),
|
|
pointer_default(unique)
|
|
]
|
|
interface IEnumITfCompositionView : IUnknown
|
|
{
|
|
HRESULT Clone([out] IEnumITfCompositionView **ppEnum);
|
|
|
|
HRESULT Next([in] ULONG ulCount,
|
|
[out, size_is(ulCount), length_is(*pcFetched)] ITfCompositionView **rgCompositionView,
|
|
[out] ULONG *pcFetched);
|
|
|
|
HRESULT Reset();
|
|
|
|
HRESULT Skip([in] ULONG ulCount);
|
|
};
|
|
|
|
//
|
|
// ITfComposition
|
|
//
|
|
[
|
|
object,
|
|
uuid(20168D64-5A8F-4A5A-B7BD-CFA29F4D0FD9),
|
|
pointer_default(unique)
|
|
]
|
|
interface ITfComposition : IUnknown
|
|
{
|
|
HRESULT GetRange([out] ITfRange **ppRange);
|
|
|
|
HRESULT ShiftStart([in] TfEditCookie ecWrite,
|
|
[in] ITfRange *pNewStart);
|
|
|
|
HRESULT ShiftEnd([in] TfEditCookie ecWrite,
|
|
[in] ITfRange *pNewEnd);
|
|
|
|
HRESULT EndComposition([in] TfEditCookie ecWrite);
|
|
};
|
|
|
|
//
|
|
// ITfCompositionSink
|
|
//
|
|
[
|
|
object,
|
|
uuid(A781718C-579A-4B15-A280-32B8577ACC5E),
|
|
pointer_default(unique)
|
|
]
|
|
interface ITfCompositionSink : IUnknown
|
|
{
|
|
HRESULT OnCompositionTerminated([in] TfEditCookie ecWrite, [in] ITfComposition *pComposition);
|
|
};
|
|
|
|
//
|
|
// ITfContextComposition
|
|
//
|
|
[
|
|
object,
|
|
uuid(D40C8AAE-AC92-4FC7-9A11-0EE0E23AA39B),
|
|
pointer_default(unique)
|
|
]
|
|
interface ITfContextComposition : IUnknown
|
|
{
|
|
HRESULT StartComposition([in] TfEditCookie ecWrite,
|
|
[in] ITfRange *pCompositionRange,
|
|
[in] ITfCompositionSink *pSink,
|
|
[out] ITfComposition **ppComposition);
|
|
|
|
HRESULT EnumCompositions([out] IEnumITfCompositionView **ppEnum);
|
|
|
|
HRESULT FindComposition([in] TfEditCookie ecRead,
|
|
[in] ITfRange *pTestRange,
|
|
[out] IEnumITfCompositionView **ppEnum);
|
|
|
|
HRESULT TakeOwnership([in] TfEditCookie ecWrite,
|
|
[in] ITfCompositionView *pComposition,
|
|
[in] ITfCompositionSink *pSink,
|
|
[out] ITfComposition **ppComposition);
|
|
};
|
|
|
|
//
|
|
// ITfContextOwnerCompositionServices
|
|
//
|
|
[
|
|
object,
|
|
uuid(86462810-593B-4916-9764-19C08E9CE110),
|
|
pointer_default(unique)
|
|
]
|
|
interface ITfContextOwnerCompositionServices : ITfContextComposition
|
|
{
|
|
HRESULT TerminateComposition([in] ITfCompositionView *pComposition);
|
|
};
|
|
|
|
//
|
|
// ITfContextOwnerCompositionSink
|
|
//
|
|
[
|
|
object,
|
|
uuid(5F20AA40-B57A-4F34-96AB-3576F377CC79),
|
|
pointer_default(unique)
|
|
]
|
|
interface ITfContextOwnerCompositionSink : IUnknown
|
|
{
|
|
HRESULT OnStartComposition([in] ITfCompositionView *pComposition,
|
|
[out] BOOL *pfOk);
|
|
|
|
HRESULT OnUpdateComposition([in] ITfCompositionView *pComposition,
|
|
[in] ITfRange *pRangeNew);
|
|
|
|
HRESULT OnEndComposition([in] ITfCompositionView *pComposition);
|
|
};
|
|
|
|
//
|
|
// ITfContextView
|
|
//
|
|
[
|
|
object,
|
|
uuid(2433bf8e-0f9b-435c-ba2c-180611978c30),
|
|
pointer_default(unique)
|
|
]
|
|
interface ITfContextView : IUnknown
|
|
{
|
|
HRESULT GetRangeFromPoint([in] TfEditCookie ec,
|
|
[in] const POINT *ppt,
|
|
[in] DWORD dwFlags,
|
|
[out] ITfRange **ppRange);
|
|
|
|
HRESULT GetTextExt([in] TfEditCookie ec,
|
|
[in] ITfRange *pRange,
|
|
[out] RECT *prc,
|
|
[out] BOOL *pfClipped);
|
|
|
|
HRESULT GetScreenExt([out] RECT *prc);
|
|
|
|
HRESULT GetWnd([out] HWND *phwnd);
|
|
};
|
|
|
|
//
|
|
// IEnumTfContextView
|
|
//
|
|
[
|
|
object,
|
|
uuid(F0C0F8DD-CF38-44E1-BB0F-68CF0D551C78),
|
|
pointer_default(unique)
|
|
]
|
|
interface IEnumTfContextViews : IUnknown
|
|
{
|
|
HRESULT Clone([out] IEnumTfContextViews **ppEnum);
|
|
|
|
HRESULT Next([in] ULONG ulCount,
|
|
[out, size_is(ulCount), length_is(*pcFetched)] ITfContextView **rgViews,
|
|
[out] ULONG *pcFetched);
|
|
|
|
HRESULT Reset();
|
|
|
|
HRESULT Skip([in] ULONG ulCount);
|
|
};
|
|
|
|
//
|
|
// ITfContext
|
|
//
|
|
[
|
|
object,
|
|
uuid(aa80e7fd-2021-11d2-93e0-0060b067b86e),
|
|
pointer_default(unique)
|
|
]
|
|
interface ITfContext : IUnknown
|
|
{
|
|
const DWORD TF_ES_ASYNCDONTCARE = 0x0;
|
|
const DWORD TF_ES_SYNC = 0x1;
|
|
const DWORD TF_ES_READ = 0x2;
|
|
const DWORD TF_ES_READWRITE = 0x6;
|
|
const DWORD TF_ES_ASYNC = 0x8;
|
|
|
|
HRESULT RequestEditSession([in] TfClientId tid,
|
|
[in] ITfEditSession *pes,
|
|
[in] DWORD dwFlags,
|
|
[out] HRESULT *phrSession);
|
|
|
|
HRESULT InWriteSession([in] TfClientId tid,
|
|
[out] BOOL *pfWriteSession);
|
|
|
|
typedef [uuid(1690be9b-d3e9-49f6-8d8b-51b905af4c43)] enum { TF_AE_NONE = 0, TF_AE_START = 1, TF_AE_END = 2 } TfActiveSelEnd;
|
|
|
|
typedef [uuid(36ae42a4-6989-4bdc-b48a-6137b7bf2e42)] struct TF_SELECTIONSTYLE
|
|
{
|
|
TfActiveSelEnd ase;
|
|
BOOL fInterimChar;
|
|
} TF_SELECTIONSTYLE;
|
|
|
|
typedef [uuid(75eb22f2-b0bf-46a8-8006-975a3b6efcf1)] struct TF_SELECTION
|
|
{
|
|
ITfRange *range;
|
|
TF_SELECTIONSTYLE style;
|
|
} TF_SELECTION;
|
|
|
|
const ULONG TF_DEFAULT_SELECTION = TS_DEFAULT_SELECTION;
|
|
|
|
HRESULT GetSelection([in] TfEditCookie ec,
|
|
[in] ULONG ulIndex,
|
|
[in] ULONG ulCount,
|
|
[out, size_is(ulCount), length_is(*pcFetched)] TF_SELECTION *pSelection,
|
|
[out] ULONG *pcFetched);
|
|
|
|
HRESULT SetSelection([in] TfEditCookie ec,
|
|
[in] ULONG ulCount,
|
|
[in, size_is(ulCount)] const TF_SELECTION *pSelection);
|
|
|
|
HRESULT GetStart([in] TfEditCookie ec,
|
|
[out] ITfRange **ppStart);
|
|
|
|
HRESULT GetEnd([in] TfEditCookie ec,
|
|
[out] ITfRange **ppEnd);
|
|
|
|
// bit values for TF_STATUS's dwDynamicFlags field
|
|
const DWORD TF_SD_READONLY = TS_SD_READONLY; // if set, document is read only; writes will fail
|
|
const DWORD TF_SD_LOADING = TS_SD_LOADING; // if set, document is loading, expect additional inserts
|
|
// bit values for TF_STATUS's dwStaticFlags field
|
|
const DWORD TF_SS_DISJOINTSEL = TS_SS_DISJOINTSEL; // if set, the document supports multiple selections
|
|
const DWORD TF_SS_REGIONS = TS_SS_REGIONS; // if clear, the document will never contain multiple regions
|
|
const DWORD TF_SS_TRANSITORY = TS_SS_TRANSITORY; // if set, the document is expected to have a short lifespan
|
|
|
|
typedef [uuid(bc7d979a-846a-444d-afef-0a9bfa82b961)] TS_STATUS TF_STATUS;
|
|
|
|
HRESULT GetActiveView([out] ITfContextView **ppView);
|
|
|
|
HRESULT EnumViews([out] IEnumTfContextViews **ppEnum);
|
|
|
|
HRESULT GetStatus([out] TF_STATUS *pdcs);
|
|
|
|
HRESULT GetProperty([in] REFGUID guidProp,
|
|
[out] ITfProperty **ppProp);
|
|
|
|
HRESULT GetAppProperty([in] REFGUID guidProp,
|
|
[out] ITfReadOnlyProperty **ppProp);
|
|
|
|
HRESULT TrackProperties([in, size_is(cProp)] const GUID **prgProp,
|
|
[in] ULONG cProp,
|
|
[in, size_is(cAppProp)] const GUID **prgAppProp,
|
|
[in] ULONG cAppProp,
|
|
[out] ITfReadOnlyProperty **ppProperty);
|
|
|
|
HRESULT EnumProperties([out] IEnumTfProperties **ppEnum);
|
|
|
|
HRESULT GetDocumentMgr([out] ITfDocumentMgr **ppDm);
|
|
|
|
HRESULT CreateRangeBackup([in] TfEditCookie ec,
|
|
[in] ITfRange *pRange,
|
|
[out] ITfRangeBackup **ppBackup);
|
|
};
|
|
|
|
[
|
|
object,
|
|
uuid(0fab9bdb-d250-4169-84e5-6be118fdd7a8),
|
|
pointer_default(unique)
|
|
]
|
|
interface ITfQueryEmbedded : IUnknown
|
|
{
|
|
HRESULT QueryInsertEmbedded([in] const GUID *pguidService,
|
|
[in] const FORMATETC *pFormatEtc,
|
|
[out] BOOL *pfInsertable);
|
|
};
|
|
|
|
//
|
|
// ITfInsertAtSelection
|
|
//
|
|
[
|
|
object,
|
|
uuid(55ce16ba-3014-41c1-9ceb-fade1446ac6c),
|
|
pointer_default(unique)
|
|
]
|
|
interface ITfInsertAtSelection : IUnknown
|
|
{
|
|
const DWORD TF_IAS_NOQUERY = 0x1; // ppRange will be NULL at exit.
|
|
const DWORD TF_IAS_QUERYONLY = 0x2; // Don't do the actual insert, caller only interested in ppRange. Exclusive with TF_IAS_NOQUERY.
|
|
const DWORD TF_IAS_NO_DEFAULT_COMPOSITION = 0x80000000; // caller takes responsibility for starting a composition over the range
|
|
|
|
HRESULT InsertTextAtSelection([in] TfEditCookie ec,
|
|
[in] DWORD dwFlags,
|
|
[in, size_is(cch)] const WCHAR *pchText,
|
|
[in] LONG cch,
|
|
[out] ITfRange **ppRange);
|
|
|
|
HRESULT InsertEmbeddedAtSelection([in] TfEditCookie ec,
|
|
[in] DWORD dwFlags,
|
|
[in] IDataObject *pDataObject,
|
|
[out] ITfRange **ppRange);
|
|
};
|
|
|
|
//
|
|
// ITfCleanupContextSink
|
|
//
|
|
[
|
|
object,
|
|
uuid(01689689-7acb-4e9b-ab7c-7ea46b12b522),
|
|
pointer_default(unique)
|
|
]
|
|
interface ITfCleanupContextSink : IUnknown
|
|
{
|
|
HRESULT OnCleanupContext([in] TfEditCookie ecWrite, [in] ITfContext *pic);
|
|
};
|
|
|
|
//
|
|
// ITfCleanupContextDurationSink
|
|
//
|
|
[
|
|
object,
|
|
uuid(45c35144-154e-4797-bed8-d33ae7bf8794),
|
|
pointer_default(unique)
|
|
]
|
|
interface ITfCleanupContextDurationSink : IUnknown
|
|
{
|
|
HRESULT OnStartCleanupContext();
|
|
|
|
HRESULT OnEndCleanupContext();
|
|
};
|
|
|
|
//
|
|
// ITfReadOnlyProperty
|
|
//
|
|
[
|
|
object,
|
|
uuid(17d49a3d-f8b8-4b2f-b254-52319dd64c53),
|
|
pointer_default(unique)
|
|
]
|
|
interface ITfReadOnlyProperty : IUnknown
|
|
{
|
|
HRESULT GetType([out] GUID *pguid);
|
|
|
|
HRESULT EnumRanges([in] TfEditCookie ec,
|
|
[out] IEnumTfRanges **ppEnum,
|
|
[in] ITfRange *pTargetRange);
|
|
|
|
HRESULT GetValue([in] TfEditCookie ec,
|
|
[in] ITfRange *pRange,
|
|
[out] VARIANT *pvarValue);
|
|
|
|
HRESULT GetContext([out] ITfContext **ppContext);
|
|
};
|
|
|
|
typedef [uuid(d678c645-eb6a-45c9-b4ee-0f3e3a991348)] struct TF_PROPERTYVAL
|
|
{
|
|
GUID guidId;
|
|
VARIANT varValue;
|
|
} TF_PROPERTYVAL;
|
|
|
|
//
|
|
// IEnumTfPropertyValue
|
|
//
|
|
[
|
|
object,
|
|
uuid(8ed8981b-7c10-4d7d-9fb3-ab72e9c75f72),
|
|
pointer_default(unique)
|
|
]
|
|
interface IEnumTfPropertyValue : IUnknown
|
|
{
|
|
HRESULT Clone([out] IEnumTfPropertyValue **ppEnum);
|
|
|
|
HRESULT Next([in] ULONG ulCount,
|
|
[out, size_is(ulCount), length_is(*pcFetched)] TF_PROPERTYVAL *rgValues,
|
|
[out] ULONG *pcFetched);
|
|
|
|
HRESULT Reset();
|
|
|
|
HRESULT Skip([in] ULONG ulCount);
|
|
};
|
|
|
|
//
|
|
// ITfMouseTracker
|
|
//
|
|
[
|
|
object,
|
|
uuid(09d146cd-a544-4132-925b-7afa8ef322d0),
|
|
pointer_default(unique)
|
|
]
|
|
interface ITfMouseTracker : IUnknown
|
|
{
|
|
HRESULT AdviseMouseSink([in] ITfRange *range,
|
|
[in] ITfMouseSink *pSink,
|
|
[out] DWORD *pdwCookie);
|
|
|
|
HRESULT UnadviseMouseSink([in] DWORD dwCookie);
|
|
};
|
|
|
|
//
|
|
// ITfMouseTracker
|
|
//
|
|
[
|
|
object,
|
|
uuid(3bdd78e2-c16e-47fd-b883-ce6facc1a208),
|
|
pointer_default(unique)
|
|
]
|
|
interface ITfMouseTrackerACP : IUnknown
|
|
{
|
|
HRESULT AdviseMouseSink([in] ITfRangeACP *range,
|
|
[in] ITfMouseSink *pSink,
|
|
[out] DWORD *pdwCookie);
|
|
|
|
HRESULT UnadviseMouseSink([in] DWORD dwCookie);
|
|
};
|
|
|
|
//
|
|
// ITfMouseSink
|
|
//
|
|
[
|
|
object,
|
|
local,
|
|
uuid(a1adaaa2-3a24-449d-ac96-5183e7f5c217),
|
|
pointer_default(unique)
|
|
]
|
|
interface ITfMouseSink : IUnknown
|
|
{
|
|
HRESULT OnMouseEvent([in] ULONG uEdge,
|
|
[in] ULONG uQuadrant,
|
|
[in] DWORD dwBtnStatus,
|
|
[out] BOOL *pfEaten);
|
|
};
|
|
|
|
//
|
|
// ITfEditRecord
|
|
//
|
|
[
|
|
object,
|
|
uuid(42d4d099-7c1a-4a89-b836-6c6f22160df0),
|
|
pointer_default(unique)
|
|
]
|
|
interface ITfEditRecord : IUnknown
|
|
{
|
|
const DWORD TF_GTP_INCL_TEXT = 0x1;
|
|
|
|
HRESULT GetSelectionStatus([out] BOOL *pfChanged);
|
|
|
|
HRESULT GetTextAndPropertyUpdates([in] DWORD dwFlags,
|
|
[in, size_is(cProperties)] const GUID **prgProperties,
|
|
[in] ULONG cProperties,
|
|
[out] IEnumTfRanges **ppEnum);
|
|
};
|
|
|
|
//
|
|
// ITfTextEditSink
|
|
//
|
|
[
|
|
object,
|
|
uuid(8127d409-ccd3-4683-967a-b43d5b482bf7),
|
|
pointer_default(unique)
|
|
]
|
|
interface ITfTextEditSink : IUnknown
|
|
{
|
|
HRESULT OnEndEdit([in] ITfContext *pic, [in] TfEditCookie ecReadOnly, [in] ITfEditRecord *pEditRecord);
|
|
};
|
|
|
|
//
|
|
// ITfTextLayoutSink
|
|
//
|
|
[
|
|
object,
|
|
uuid(2af2d06a-dd5b-4927-a0b4-54f19c91fade),
|
|
pointer_default(unique)
|
|
]
|
|
interface ITfTextLayoutSink : IUnknown
|
|
{
|
|
typedef [uuid(603553cf-9edd-4cc1-9ecc-069e4a427734)] enum { TF_LC_CREATE = 0, TF_LC_CHANGE = 1, TF_LC_DESTROY = 2, } TfLayoutCode;
|
|
|
|
HRESULT OnLayoutChange([in] ITfContext *pic, [in] TfLayoutCode lcode, [in] ITfContextView *pView);
|
|
};
|
|
|
|
//
|
|
// ITfStatusSink
|
|
//
|
|
[
|
|
object,
|
|
uuid(6b7d8d73-b267-4f69-b32e-1ca321ce4f45),
|
|
pointer_default(unique)
|
|
]
|
|
interface ITfStatusSink : IUnknown
|
|
{
|
|
HRESULT OnStatusChange([in] ITfContext *pic, [in] DWORD dwFlags);
|
|
};
|
|
|
|
//
|
|
// ITfEditTransactionSink
|
|
//
|
|
[
|
|
object,
|
|
uuid(708fbf70-b520-416b-b06c-2c41ab44f8ba),
|
|
pointer_default(unique)
|
|
]
|
|
interface ITfEditTransactionSink : IUnknown
|
|
{
|
|
HRESULT OnStartEditTransaction([in] ITfContext *pic);
|
|
|
|
HRESULT OnEndEditTransaction([in] ITfContext *pic);
|
|
};
|
|
|
|
//
|
|
// ITfContextOwner
|
|
//
|
|
[
|
|
object,
|
|
uuid(aa80e80c-2021-11d2-93e0-0060b067b86e),
|
|
pointer_default(unique)
|
|
]
|
|
interface ITfContextOwner : IUnknown
|
|
{
|
|
HRESULT GetACPFromPoint([in] const POINT *ptScreen,
|
|
[in] DWORD dwFlags,
|
|
[out] LONG *pacp);
|
|
|
|
HRESULT GetTextExt([in] LONG acpStart,
|
|
[in] LONG acpEnd,
|
|
[out] RECT *prc,
|
|
[out] BOOL *pfClipped);
|
|
|
|
HRESULT GetScreenExt([out] RECT *prc);
|
|
|
|
HRESULT GetStatus([out] TF_STATUS *pdcs);
|
|
|
|
HRESULT GetWnd([out] HWND *phwnd);
|
|
|
|
HRESULT GetAttribute([in] REFGUID rguidAttribute, [out] VARIANT *pvarValue);
|
|
};
|
|
|
|
|
|
//
|
|
// ITfContextOwnerServices
|
|
//
|
|
[
|
|
object,
|
|
uuid(b23eb630-3e1c-11d3-a745-0050040ab407),
|
|
pointer_default(unique)
|
|
]
|
|
interface ITfContextOwnerServices : IUnknown
|
|
{
|
|
HRESULT OnLayoutChange();
|
|
|
|
HRESULT OnStatusChange([in] DWORD dwFlags);
|
|
|
|
HRESULT OnAttributeChange([in] REFGUID rguidAttribute);
|
|
|
|
HRESULT Serialize([in] ITfProperty *pProp,
|
|
[in] ITfRange *pRange,
|
|
[out] TF_PERSISTENT_PROPERTY_HEADER_ACP *pHdr,
|
|
[in] IStream *pStream);
|
|
|
|
HRESULT Unserialize([in] ITfProperty *pProp,
|
|
[in] const TF_PERSISTENT_PROPERTY_HEADER_ACP *pHdr,
|
|
[in] IStream *pStream,
|
|
[in] ITfPersistentPropertyLoaderACP *pLoader);
|
|
|
|
HRESULT ForceLoadProperty([in] ITfProperty *pProp);
|
|
|
|
HRESULT CreateRange([in] LONG acpStart,
|
|
[in] LONG acpEnd,
|
|
[out] ITfRangeACP **ppRange);
|
|
}
|
|
|
|
//
|
|
// ITfContextKeyEventSink
|
|
//
|
|
[
|
|
object,
|
|
local,
|
|
uuid(0552ba5d-c835-4934-bf50-846aaa67432f),
|
|
pointer_default(unique)
|
|
]
|
|
interface ITfContextKeyEventSink : IUnknown
|
|
{
|
|
HRESULT OnKeyDown([in] WPARAM wParam,
|
|
[in] LPARAM lParam,
|
|
[out] BOOL *pfEaten);
|
|
|
|
HRESULT OnKeyUp([in] WPARAM wParam,
|
|
[in] LPARAM lParam,
|
|
[out] BOOL *pfEaten);
|
|
|
|
HRESULT OnTestKeyDown([in] WPARAM wParam,
|
|
[in] LPARAM lParam,
|
|
[out] BOOL *pfEaten);
|
|
|
|
HRESULT OnTestKeyUp([in] WPARAM wParam,
|
|
[in] LPARAM lParam,
|
|
[out] BOOL *pfEaten);
|
|
};
|
|
|
|
//
|
|
// ITfEditSession
|
|
//
|
|
[
|
|
object,
|
|
uuid(aa80e803-2021-11d2-93e0-0060b067b86e),
|
|
pointer_default(unique)
|
|
]
|
|
interface ITfEditSession : IUnknown
|
|
{
|
|
HRESULT DoEditSession([in] TfEditCookie ec);
|
|
}
|
|
|
|
|
|
//
|
|
// ITfRange
|
|
//
|
|
[
|
|
object,
|
|
uuid(aa80e7ff-2021-11d2-93e0-0060b067b86e),
|
|
pointer_default(unique)
|
|
]
|
|
interface ITfRange : IUnknown
|
|
{
|
|
const WCHAR TF_CHAR_EMBEDDED = TS_CHAR_EMBEDDED; // unicode 2.1 object replacement character
|
|
|
|
typedef [uuid(cf610f06-2882-46f6-abe5-298568b664c4)] enum { TF_GRAVITY_BACKWARD = 0, TF_GRAVITY_FORWARD = 1 } TfGravity;
|
|
|
|
typedef [uuid(1e512533-bbdc-4530-9a8e-a1dc0af67468)] enum { TF_SD_BACKWARD = 0, TF_SD_FORWARD = 1 } TfShiftDir;
|
|
|
|
const DWORD TF_HF_OBJECT = 1; // halt shift for TF_CHAR_EMBEDDED
|
|
|
|
const DWORD TF_TF_MOVESTART = 1; // update start anchor
|
|
const DWORD TF_TF_IGNOREEND = 2; // ignore the end anchor
|
|
|
|
const DWORD TF_ST_CORRECTION = 1; // the replacement is a transform of existing content (correction), not new content
|
|
|
|
const DWORD TF_IE_CORRECTION = 1;
|
|
|
|
typedef [uuid(49930d51-7d93-448c-a48c-fea5dac192b1)] struct TF_HALTCOND
|
|
{
|
|
ITfRange *pHaltRange; // halt shift if anchor encountered
|
|
TfAnchor aHaltPos; // ignored if pHaltRange == NULL
|
|
DWORD dwFlags; // TF_HF_*
|
|
} TF_HALTCOND;
|
|
|
|
HRESULT GetText([in] TfEditCookie ec,
|
|
[in] DWORD dwFlags,
|
|
[out, size_is(cchMax), length_is(*pcch)] WCHAR *pchText,
|
|
[in] ULONG cchMax,
|
|
[out] ULONG *pcch);
|
|
|
|
HRESULT SetText([in] TfEditCookie ec,
|
|
[in] DWORD dwFlags,
|
|
[in, size_is(cch), unique] const WCHAR *pchText,
|
|
[in] LONG cch);
|
|
|
|
HRESULT GetFormattedText([in] TfEditCookie ec,
|
|
[out] IDataObject **ppDataObject);
|
|
|
|
HRESULT GetEmbedded([in] TfEditCookie ec,
|
|
[in] REFGUID rguidService,
|
|
[in] REFIID riid,
|
|
[out, iid_is(riid)] IUnknown **ppunk);
|
|
|
|
HRESULT InsertEmbedded([in] TfEditCookie ec,
|
|
[in] DWORD dwFlags,
|
|
[in] IDataObject *pDataObject);
|
|
|
|
HRESULT ShiftStart([in] TfEditCookie ec,
|
|
[in] LONG cchReq,
|
|
[out] LONG *pcch,
|
|
[in, unique] const TF_HALTCOND *pHalt);
|
|
|
|
HRESULT ShiftEnd([in] TfEditCookie ec,
|
|
[in] LONG cchReq,
|
|
[out] LONG *pcch,
|
|
[in, unique] const TF_HALTCOND *pHalt);
|
|
|
|
HRESULT ShiftStartToRange([in] TfEditCookie ec,
|
|
[in] ITfRange *pRange,
|
|
[in] TfAnchor aPos);
|
|
|
|
HRESULT ShiftEndToRange([in] TfEditCookie ec,
|
|
[in] ITfRange *pRange,
|
|
[in] TfAnchor aPos);
|
|
|
|
HRESULT ShiftStartRegion([in] TfEditCookie ec,
|
|
[in] TfShiftDir dir,
|
|
[out] BOOL *pfNoRegion);
|
|
|
|
HRESULT ShiftEndRegion([in] TfEditCookie ec,
|
|
[in] TfShiftDir dir,
|
|
[out] BOOL *pfNoRegion);
|
|
|
|
HRESULT IsEmpty([in] TfEditCookie ec,
|
|
[out] BOOL *pfEmpty);
|
|
|
|
HRESULT Collapse([in] TfEditCookie ec,
|
|
[in] TfAnchor aPos);
|
|
|
|
HRESULT IsEqualStart([in] TfEditCookie ec,
|
|
[in] ITfRange *pWith,
|
|
[in] TfAnchor aPos,
|
|
[out] BOOL *pfEqual);
|
|
|
|
HRESULT IsEqualEnd([in] TfEditCookie ec,
|
|
[in] ITfRange *pWith,
|
|
[in] TfAnchor aPos,
|
|
[out] BOOL *pfEqual);
|
|
|
|
HRESULT CompareStart([in] TfEditCookie ec,
|
|
[in] ITfRange *pWith,
|
|
[in] TfAnchor aPos,
|
|
[out] LONG *plResult);
|
|
|
|
HRESULT CompareEnd([in] TfEditCookie ec,
|
|
[in] ITfRange *pWith,
|
|
[in] TfAnchor aPos,
|
|
[out] LONG *plResult);
|
|
|
|
HRESULT AdjustForInsert([in] TfEditCookie ec,
|
|
[in] ULONG cchInsert,
|
|
[out] BOOL *pfInsertOk);
|
|
|
|
HRESULT GetGravity([out] TfGravity *pgStart,
|
|
[out] TfGravity *pgEnd);
|
|
|
|
HRESULT SetGravity([in] TfEditCookie ec,
|
|
[in] TfGravity gStart,
|
|
[in] TfGravity gEnd);
|
|
|
|
HRESULT Clone([out] ITfRange **ppClone);
|
|
|
|
HRESULT GetContext([out] ITfContext **ppContext);
|
|
};
|
|
|
|
//
|
|
// ITfRangeACP
|
|
//
|
|
[
|
|
object,
|
|
uuid(057a6296-029b-4154-b79a-0d461d4ea94c),
|
|
pointer_default(unique)
|
|
]
|
|
interface ITfRangeACP : ITfRange
|
|
{
|
|
HRESULT GetExtent([out] LONG *pacpAnchor,
|
|
[out] LONG *pcch);
|
|
|
|
HRESULT SetExtent([in] LONG acpAnchor,
|
|
[in] LONG cch);
|
|
}
|
|
|
|
//
|
|
// ITextStoreACPServices
|
|
//
|
|
[
|
|
object,
|
|
uuid(aa80e901-2021-11d2-93e0-0060b067b86e),
|
|
pointer_default(unique)
|
|
]
|
|
interface ITextStoreACPServices : IUnknown
|
|
{
|
|
HRESULT Serialize([in] ITfProperty *pProp,
|
|
[in] ITfRange *pRange,
|
|
[out] TF_PERSISTENT_PROPERTY_HEADER_ACP *pHdr,
|
|
[in] IStream *pStream);
|
|
|
|
HRESULT Unserialize([in] ITfProperty *pProp,
|
|
[in] const TF_PERSISTENT_PROPERTY_HEADER_ACP *pHdr,
|
|
[in] IStream *pStream,
|
|
[in] ITfPersistentPropertyLoaderACP *pLoader);
|
|
|
|
HRESULT ForceLoadProperty([in] ITfProperty *pProp);
|
|
|
|
HRESULT CreateRange([in] LONG acpStart,
|
|
[in] LONG acpEnd,
|
|
[out] ITfRangeACP **ppRange);
|
|
};
|
|
|
|
//
|
|
// ITfRangeBackup
|
|
//
|
|
[
|
|
object,
|
|
uuid(463a506d-6992-49d2-9b88-93d55e70bb16),
|
|
pointer_default(unique)
|
|
]
|
|
interface ITfRangeBackup : IUnknown
|
|
{
|
|
HRESULT Restore([in] TfEditCookie ec,
|
|
[in] ITfRange *pRange);
|
|
};
|
|
|
|
|
|
//
|
|
// ITfPropertyStore
|
|
//
|
|
[
|
|
object,
|
|
uuid(6834b120-88cb-11d2-bf45-00105a2799b5),
|
|
pointer_default(unique)
|
|
]
|
|
interface ITfPropertyStore : IUnknown
|
|
{
|
|
// OnTextUpdated flags
|
|
const DWORD TF_TU_CORRECTION = 0x1;
|
|
|
|
HRESULT GetType([out] GUID *pguid);
|
|
|
|
HRESULT GetDataType([out] DWORD *pdwReserved);
|
|
|
|
HRESULT GetData([out] VARIANT *pvarValue);
|
|
|
|
HRESULT OnTextUpdated([in] DWORD dwFlags,
|
|
[in] ITfRange *pRangeNew,
|
|
[out] BOOL *pfAccept);
|
|
|
|
HRESULT Shrink([in] ITfRange *pRangeNew,
|
|
[out] BOOL *pfFree);
|
|
|
|
HRESULT Divide([in] ITfRange *pRangeThis,
|
|
[in] ITfRange *pRangeNew,
|
|
[out] ITfPropertyStore **ppPropStore);
|
|
|
|
HRESULT Clone([out] ITfPropertyStore **pPropStore);
|
|
|
|
HRESULT GetPropertyRangeCreator([out] CLSID *pclsid);
|
|
|
|
HRESULT Serialize([in] IStream *pStream,
|
|
[out] ULONG *pcb);
|
|
}
|
|
|
|
//
|
|
// IEnumTfRanges
|
|
//
|
|
[
|
|
object,
|
|
uuid(f99d3f40-8e32-11d2-bf46-00105a2799b5),
|
|
pointer_default(unique)
|
|
]
|
|
interface IEnumTfRanges : IUnknown
|
|
{
|
|
HRESULT Clone([out] IEnumTfRanges **ppEnum);
|
|
|
|
HRESULT Next([in] ULONG ulCount,
|
|
[out, size_is(ulCount), length_is(*pcFetched)] ITfRange **ppRange,
|
|
[out] ULONG *pcFetched);
|
|
|
|
HRESULT Reset();
|
|
|
|
HRESULT Skip(ULONG ulCount);
|
|
};
|
|
|
|
//
|
|
// ITfCreatePropertyStore
|
|
//
|
|
[
|
|
object,
|
|
uuid(2463fbf0-b0af-11d2-afc5-00105a2799b5),
|
|
pointer_default(unique)
|
|
]
|
|
interface ITfCreatePropertyStore : IUnknown
|
|
{
|
|
HRESULT IsStoreSerializable([in] REFGUID guidProp,
|
|
[in] ITfRange *pRange,
|
|
[in] ITfPropertyStore *pPropStore,
|
|
[out] BOOL *pfSerializable);
|
|
|
|
HRESULT CreatePropertyStore([in] REFGUID guidProp,
|
|
[in] ITfRange *pRange,
|
|
[in] ULONG cb,
|
|
[in] IStream *pStream,
|
|
[out] ITfPropertyStore **ppStore);
|
|
}
|
|
|
|
//
|
|
// ITfPersistentPropertyLoaderACP
|
|
//
|
|
[
|
|
object,
|
|
uuid(4ef89150-0807-11d3-8df0-00105a2799b5),
|
|
pointer_default(unique)
|
|
]
|
|
interface ITfPersistentPropertyLoaderACP : IUnknown
|
|
{
|
|
HRESULT LoadProperty([in] const TF_PERSISTENT_PROPERTY_HEADER_ACP *pHdr,
|
|
[out] IStream **ppStream);
|
|
}
|
|
|
|
//
|
|
// ITfProperty
|
|
//
|
|
[
|
|
object,
|
|
uuid(e2449660-9542-11d2-bf46-00105a2799b5),
|
|
pointer_default(unique)
|
|
]
|
|
interface ITfProperty : ITfReadOnlyProperty
|
|
{
|
|
HRESULT FindRange([in] TfEditCookie ec,
|
|
[in] ITfRange *pRange,
|
|
[out] ITfRange **ppRange,
|
|
[in] TfAnchor aPos);
|
|
|
|
|
|
HRESULT SetValueStore([in] TfEditCookie ec,
|
|
[in] ITfRange *pRange,
|
|
[in] ITfPropertyStore *pPropStore);
|
|
|
|
HRESULT SetValue([in] TfEditCookie ec,
|
|
[in] ITfRange *pRange,
|
|
[in] const VARIANT *pvarValue);
|
|
|
|
HRESULT Clear([in] TfEditCookie ec,
|
|
[in] ITfRange *pRange);
|
|
}
|
|
|
|
//
|
|
// IEnumTfProperties
|
|
//
|
|
[
|
|
object,
|
|
uuid(19188cb0-aca9-11d2-afc5-00105a2799b5),
|
|
pointer_default(unique)
|
|
]
|
|
interface IEnumTfProperties : IUnknown
|
|
{
|
|
HRESULT Clone([out] IEnumTfProperties **ppEnum);
|
|
|
|
HRESULT Next([in] ULONG ulCount,
|
|
[out, size_is(ulCount), length_is(*pcFetched)] ITfProperty **ppProp,
|
|
[out] ULONG *pcFetched);
|
|
|
|
HRESULT Reset();
|
|
|
|
HRESULT Skip([in] ULONG ulCount);
|
|
}
|
|
|
|
//
|
|
// ITfCompartment
|
|
//
|
|
[
|
|
object,
|
|
uuid(bb08f7a9-607a-4384-8623-056892b64371),
|
|
pointer_default(unique)
|
|
]
|
|
interface ITfCompartment : IUnknown
|
|
{
|
|
HRESULT SetValue([in] TfClientId tid,
|
|
[in] const VARIANT *pvarValue);
|
|
|
|
HRESULT GetValue([out] VARIANT *pvarValue);
|
|
}
|
|
|
|
//
|
|
// ITfCompartmentEventSink
|
|
//
|
|
[
|
|
object,
|
|
uuid(743abd5f-f26d-48df-8cc5-238492419b64),
|
|
pointer_default(unique)
|
|
]
|
|
interface ITfCompartmentEventSink : IUnknown
|
|
{
|
|
HRESULT OnChange([in] REFGUID rguid);
|
|
}
|
|
|
|
//
|
|
// ITfCompartmentMgr
|
|
//
|
|
[
|
|
object,
|
|
uuid(7dcf57ac-18ad-438b-824d-979bffb74b7c),
|
|
pointer_default(unique)
|
|
]
|
|
interface ITfCompartmentMgr : IUnknown
|
|
{
|
|
HRESULT GetCompartment([in] REFGUID rguid,
|
|
[out] ITfCompartment **ppcomp);
|
|
|
|
HRESULT ClearCompartment([in] TfClientId tid,
|
|
[in] REFGUID rguid);
|
|
|
|
HRESULT EnumCompartments([out] IEnumGUID **ppEnum);
|
|
}
|
|
|
|
|
|
//
|
|
// ITfFunction
|
|
//
|
|
[
|
|
object,
|
|
uuid(db593490-098f-11d3-8df0-00105a2799b5),
|
|
pointer_default(unique)
|
|
]
|
|
interface ITfFunction : IUnknown
|
|
{
|
|
HRESULT GetDisplayName([out] BSTR *pbstrName);
|
|
}
|
|
|
|
//
|
|
// ITfFunctionProvider
|
|
//
|
|
[
|
|
object,
|
|
uuid(101d6610-0990-11d3-8df0-00105a2799b5),
|
|
pointer_default(unique)
|
|
]
|
|
interface ITfFunctionProvider : IUnknown
|
|
{
|
|
HRESULT GetType([out] GUID *pguid);
|
|
|
|
HRESULT GetDescription([out] BSTR *pbstrDesc);
|
|
|
|
HRESULT GetFunction([in] REFGUID rguid,
|
|
[in] REFIID riid,
|
|
[out, iid_is(riid)] IUnknown **ppunk);
|
|
}
|
|
|
|
|
|
//
|
|
// IEnumTfFunctionProviders
|
|
//
|
|
[
|
|
object,
|
|
uuid(e4b24db0-0990-11d3-8df0-00105a2799b5),
|
|
pointer_default(unique)
|
|
]
|
|
interface IEnumTfFunctionProviders : IUnknown
|
|
{
|
|
HRESULT Clone([out] IEnumTfFunctionProviders **ppEnum);
|
|
|
|
HRESULT Next([in] ULONG ulCount,
|
|
[out, size_is(ulCount), length_is(*pcFetch)] ITfFunctionProvider **ppCmdobj,
|
|
[out] ULONG *pcFetch);
|
|
|
|
HRESULT Reset();
|
|
|
|
HRESULT Skip([in] ULONG ulCount);
|
|
};
|
|
|
|
|
|
//
|
|
// ITfInputProcessorProfiles
|
|
//
|
|
[
|
|
object,
|
|
local,
|
|
uuid(1F02B6C5-7842-4EE6-8A0B-9A24183A95CA),
|
|
pointer_default(unique)
|
|
]
|
|
interface ITfInputProcessorProfiles : IUnknown
|
|
{
|
|
HRESULT Register([in] REFCLSID rclsid);
|
|
|
|
HRESULT Unregister([in] REFCLSID rclsid);
|
|
|
|
HRESULT AddLanguageProfile([in] REFCLSID rclsid,
|
|
[in] LANGID langid,
|
|
[in] REFGUID guidProfile,
|
|
[in, size_is(cchDesc)] const WCHAR *pchDesc,
|
|
[in] ULONG cchDesc,
|
|
[in, size_is(cchFile)] const WCHAR *pchIconFile,
|
|
[in] ULONG cchFile,
|
|
[in] ULONG uIconIndex);
|
|
|
|
HRESULT RemoveLanguageProfile([in] REFCLSID rclsid,
|
|
[in] LANGID langid,
|
|
[in] REFGUID guidProfile);
|
|
|
|
HRESULT EnumInputProcessorInfo([out] IEnumGUID **ppEnum);
|
|
|
|
HRESULT GetDefaultLanguageProfile([in] LANGID langid,
|
|
[in] REFGUID catid,
|
|
[out] CLSID *pclsid,
|
|
[out] GUID *pguidProfile);
|
|
|
|
HRESULT SetDefaultLanguageProfile([in] LANGID langid,
|
|
[in] REFCLSID rclsid,
|
|
[in] REFGUID guidProfiles);
|
|
|
|
HRESULT ActivateLanguageProfile([in] REFCLSID rclsid,
|
|
[in] LANGID langid,
|
|
[in] REFGUID guidProfiles);
|
|
|
|
HRESULT GetActiveLanguageProfile([in] REFCLSID rclsid,
|
|
[out] LANGID *plangid,
|
|
[out] GUID *pguidProfile);
|
|
|
|
HRESULT GetLanguageProfileDescription([in] REFCLSID rclsid,
|
|
[in] LANGID langid,
|
|
[in] REFGUID guidProfile,
|
|
[out] BSTR *pbstrProfile);
|
|
|
|
HRESULT GetCurrentLanguage([out] LANGID *plangid);
|
|
|
|
HRESULT ChangeCurrentLanguage([in] LANGID langid);
|
|
|
|
HRESULT GetLanguageList([out] LANGID **ppLangId,
|
|
[out] ULONG *pulCount);
|
|
|
|
HRESULT EnumLanguageProfiles([in] LANGID langid,
|
|
[out] IEnumTfLanguageProfiles **ppEnum);
|
|
|
|
HRESULT EnableLanguageProfile([in] REFCLSID rclsid,
|
|
[in] LANGID langid,
|
|
[in] REFGUID guidProfile,
|
|
[in] BOOL fEnable);
|
|
|
|
HRESULT IsEnabledLanguageProfile([in] REFCLSID rclsid,
|
|
[in] LANGID langid,
|
|
[in] REFGUID guidProfile,
|
|
[out] BOOL *pfEnable);
|
|
|
|
HRESULT EnableLanguageProfileByDefault([in] REFCLSID rclsid,
|
|
[in] LANGID langid,
|
|
[in] REFGUID guidProfile,
|
|
[in] BOOL fEnable);
|
|
|
|
HRESULT SubstituteKeyboardLayout([in] REFCLSID rclsid,
|
|
[in] LANGID langid,
|
|
[in] REFGUID guidProfile,
|
|
[in] HKL hKL);
|
|
}
|
|
|
|
//
|
|
// ITfInputProcessorProfilesEx
|
|
//
|
|
// Implemented by Cicero
|
|
//
|
|
[
|
|
object,
|
|
uuid(892f230f-fe00-4a41-a98e-fcd6de0d35ef),
|
|
pointer_default(unique)
|
|
]
|
|
interface ITfInputProcessorProfilesEx : ITfInputProcessorProfiles
|
|
{
|
|
HRESULT SetLanguageProfileDisplayName([in] REFCLSID rclsid,
|
|
[in] LANGID langid,
|
|
[in] REFGUID guidProfile,
|
|
[in, size_is(cchFile)] const WCHAR *pchFile,
|
|
[in] ULONG cchFile,
|
|
[in] ULONG uResId);
|
|
};
|
|
|
|
//
|
|
// ITfInputProcessorProfileSubstituteLayout
|
|
//
|
|
// Implemented by Cicero
|
|
//
|
|
[
|
|
object,
|
|
uuid(4fd67194-1002-4513-bff2-c0ddf6258552),
|
|
pointer_default(unique)
|
|
]
|
|
interface ITfInputProcessorProfileSubstituteLayout : IUnknown
|
|
{
|
|
HRESULT GetSubstituteKeyboardLayout([in] REFCLSID rclsid,
|
|
[in] LANGID langid,
|
|
[in] REFGUID guidProfile,
|
|
[out] HKL *phKL);
|
|
};
|
|
|
|
//
|
|
// ITfActiveLanguageProfileNotifySink
|
|
//
|
|
[
|
|
object,
|
|
uuid(b246cb75-a93e-4652-bf8c-b3fe0cfd7e57),
|
|
pointer_default(unique)
|
|
]
|
|
interface ITfActiveLanguageProfileNotifySink : IUnknown
|
|
{
|
|
HRESULT OnActivated([in] REFCLSID clsid,
|
|
[in] REFGUID guidProfile,
|
|
[in] BOOL fActivated);
|
|
}
|
|
|
|
//
|
|
// IEnumTfLanguageProfiles
|
|
//
|
|
[
|
|
object,
|
|
uuid(3d61bf11-ac5f-42c8-a4cb-931bcc28c744),
|
|
pointer_default(unique)
|
|
]
|
|
interface IEnumTfLanguageProfiles : IUnknown
|
|
{
|
|
HRESULT Clone([out] IEnumTfLanguageProfiles **ppEnum);
|
|
|
|
HRESULT Next([in] ULONG ulCount,
|
|
[out, size_is(ulCount), length_is(*pcFetch)] TF_LANGUAGEPROFILE *pProfile,
|
|
[out] ULONG *pcFetch);
|
|
|
|
HRESULT Reset();
|
|
|
|
HRESULT Skip([in] ULONG ulCount);
|
|
};
|
|
|
|
|
|
//
|
|
// ITfLanguageProfileNotifySink
|
|
//
|
|
[
|
|
object,
|
|
uuid(43c9fe15-f494-4c17-9de2-b8a4ac350aa8),
|
|
pointer_default(unique)
|
|
]
|
|
interface ITfLanguageProfileNotifySink : IUnknown
|
|
{
|
|
HRESULT OnLanguageChange([in] LANGID langid,
|
|
[out] BOOL *pfAccept);
|
|
|
|
HRESULT OnLanguageChanged();
|
|
}
|
|
|
|
typedef [uuid(77c12f95-b783-450d-879f-1cd2362c6521)] struct TF_PRESERVEDKEY
|
|
{
|
|
UINT uVKey;
|
|
UINT uModifiers;
|
|
} TF_PRESERVEDKEY;
|
|
|
|
//
|
|
// ITfKeystrokeMgr
|
|
//
|
|
[
|
|
object,
|
|
local,
|
|
uuid(aa80e7f0-2021-11d2-93e0-0060b067b86e),
|
|
pointer_default(unique)
|
|
]
|
|
interface ITfKeystrokeMgr : IUnknown
|
|
{
|
|
HRESULT AdviseKeyEventSink([in] TfClientId tid,
|
|
[in] ITfKeyEventSink *pSink,
|
|
[in] BOOL fForeground);
|
|
|
|
HRESULT UnadviseKeyEventSink([in] TfClientId tid);
|
|
|
|
HRESULT GetForeground([out] CLSID *pclsid);
|
|
|
|
HRESULT TestKeyDown([in] WPARAM wParam,
|
|
[in] LPARAM lParam,
|
|
[out] BOOL *pfEaten);
|
|
|
|
HRESULT TestKeyUp([in] WPARAM wParam,
|
|
[in] LPARAM lParam,
|
|
[out] BOOL *pfEaten);
|
|
|
|
HRESULT KeyDown([in] WPARAM wParam,
|
|
[in] LPARAM lParam,
|
|
[out] BOOL *pfEaten);
|
|
|
|
HRESULT KeyUp([in] WPARAM wParam,
|
|
[in] LPARAM lParam,
|
|
[out] BOOL *pfEaten);
|
|
|
|
HRESULT GetPreservedKey([in] ITfContext *pic,
|
|
[in] const TF_PRESERVEDKEY *pprekey,
|
|
[out] GUID *pguid);
|
|
|
|
HRESULT IsPreservedKey([in] REFGUID rguid,
|
|
[in] const TF_PRESERVEDKEY *pprekey,
|
|
[out] BOOL *pfRegistered);
|
|
|
|
HRESULT PreserveKey([in] TfClientId tid,
|
|
[in] REFGUID rguid,
|
|
[in] const TF_PRESERVEDKEY *prekey,
|
|
[in, size_is(cchDesc)] const WCHAR *pchDesc,
|
|
[in] ULONG cchDesc);
|
|
|
|
HRESULT UnpreserveKey([in] REFGUID rguid,
|
|
[in] const TF_PRESERVEDKEY *pprekey);
|
|
|
|
HRESULT SetPreservedKeyDescription([in] REFGUID rguid,
|
|
[in, size_is(cchDesc)] const WCHAR *pchDesc,
|
|
[in] ULONG cchDesc);
|
|
|
|
HRESULT GetPreservedKeyDescription([in] REFGUID rguid,
|
|
[out] BSTR *pbstrDesc);
|
|
|
|
HRESULT SimulatePreservedKey([in] ITfContext *pic,
|
|
[in] REFGUID rguid,
|
|
[out] BOOL *pfEaten);
|
|
};
|
|
|
|
//
|
|
// ITfKeyEventSink
|
|
//
|
|
[
|
|
object,
|
|
local,
|
|
uuid(aa80e7f5-2021-11d2-93e0-0060b067b86e),
|
|
pointer_default(unique)
|
|
]
|
|
interface ITfKeyEventSink : IUnknown
|
|
{
|
|
HRESULT OnSetFocus([in] BOOL fForeground);
|
|
|
|
HRESULT OnTestKeyDown([in] ITfContext *pic,
|
|
[in] WPARAM wParam,
|
|
[in] LPARAM lParam,
|
|
[out] BOOL *pfEaten);
|
|
|
|
HRESULT OnTestKeyUp([in] ITfContext *pic,
|
|
[in] WPARAM wParam,
|
|
[in] LPARAM lParam,
|
|
[out] BOOL *pfEaten);
|
|
|
|
HRESULT OnKeyDown([in] ITfContext *pic,
|
|
[in] WPARAM wParam,
|
|
[in] LPARAM lParam,
|
|
[out] BOOL *pfEaten);
|
|
|
|
HRESULT OnKeyUp([in] ITfContext *pic,
|
|
[in] WPARAM wParam,
|
|
[in] LPARAM lParam,
|
|
[out] BOOL *pfEaten);
|
|
|
|
HRESULT OnPreservedKey([in] ITfContext *pic,
|
|
[in] REFGUID rguid,
|
|
[out] BOOL *pfEaten);
|
|
};
|
|
|
|
//
|
|
// ITfKeyTraceEventSink
|
|
//
|
|
[
|
|
object,
|
|
local,
|
|
uuid(1cd4c13b-1c36-4191-a70a-7f3e611f367d),
|
|
pointer_default(unique)
|
|
]
|
|
interface ITfKeyTraceEventSink : IUnknown
|
|
{
|
|
HRESULT OnKeyTraceDown([in] WPARAM wParam,
|
|
[in] LPARAM lParam);
|
|
|
|
HRESULT OnKeyTraceUp([in] WPARAM wParam,
|
|
[in] LPARAM lParam);
|
|
};
|
|
|
|
//
|
|
// ITfPreservedKeyNotifySink
|
|
//
|
|
[
|
|
object,
|
|
uuid(6f77c993-d2b1-446e-853e-5912efc8a286),
|
|
pointer_default(unique)
|
|
]
|
|
interface ITfPreservedKeyNotifySink : IUnknown
|
|
{
|
|
HRESULT OnUpdated([in] const TF_PRESERVEDKEY *pprekey);
|
|
}
|
|
|
|
//
|
|
// ITfMessagePump
|
|
//
|
|
[
|
|
object,
|
|
local,
|
|
uuid(8f1b8ad8-0b6b-4874-90c5-bd76011e8f7c),
|
|
pointer_default(unique)
|
|
]
|
|
interface ITfMessagePump : IUnknown
|
|
{
|
|
HRESULT PeekMessageA([out] LPMSG pMsg,
|
|
[in] HWND hwnd,
|
|
[in] UINT wMsgFilterMin,
|
|
[in] UINT wMsgFilterMax,
|
|
[in] UINT wRemoveMsg,
|
|
[out] BOOL *pfResult);
|
|
|
|
HRESULT GetMessageA([out] LPMSG pMsg,
|
|
[in] HWND hwnd,
|
|
[in] UINT wMsgFilterMin,
|
|
[in] UINT wMsgFilterMax,
|
|
[out] BOOL *pfResult);
|
|
|
|
HRESULT PeekMessageW([out] LPMSG pMsg,
|
|
[in] HWND hwnd,
|
|
[in] UINT wMsgFilterMin,
|
|
[in] UINT wMsgFilterMax,
|
|
[in] UINT wRemoveMsg,
|
|
[out] BOOL *pfResult);
|
|
|
|
HRESULT GetMessageW([out] LPMSG pMsg,
|
|
[in] HWND hwnd,
|
|
[in] UINT wMsgFilterMin,
|
|
[in] UINT wMsgFilterMax,
|
|
[out] BOOL *pfResult);
|
|
};
|
|
|
|
//
|
|
// ITfUIFocusSink
|
|
//
|
|
[
|
|
object,
|
|
local,
|
|
uuid(c0f1db0c-3a20-405c-a303-96b6010a885f),
|
|
pointer_default(unique)
|
|
]
|
|
interface ITfThreadFocusSink : IUnknown
|
|
{
|
|
HRESULT OnSetThreadFocus();
|
|
|
|
HRESULT OnKillThreadFocus();
|
|
};
|
|
|
|
//
|
|
// ITfTextInputProcessor
|
|
//
|
|
[
|
|
object,
|
|
local,
|
|
uuid(aa80e7f7-2021-11d2-93e0-0060b067b86e),
|
|
pointer_default(unique)
|
|
]
|
|
interface ITfTextInputProcessor : IUnknown
|
|
{
|
|
HRESULT Activate([in] ITfThreadMgr *ptim,
|
|
[in] TfClientId tid);
|
|
|
|
HRESULT Deactivate();
|
|
};
|
|
|
|
//
|
|
// ITfClientId
|
|
//
|
|
[
|
|
object,
|
|
local,
|
|
uuid(d60a7b49-1b9f-4be2-b702-47e9dc05dec3),
|
|
pointer_default(unique)
|
|
]
|
|
interface ITfClientId : IUnknown
|
|
{
|
|
HRESULT GetClientId([in] REFCLSID rclsid,
|
|
[out] TfClientId *ptid);
|
|
};
|
|
|
|
typedef [uuid(c4cc07f1-80cc-4a7b-bc54-98512782cbe3)] enum {
|
|
TF_LS_NONE = 0,
|
|
TF_LS_SOLID = 1,
|
|
TF_LS_DOT = 2,
|
|
TF_LS_DASH = 3,
|
|
TF_LS_SQUIGGLE = 4
|
|
} TF_DA_LINESTYLE;
|
|
|
|
typedef [uuid(d9b92e21-084a-401b-9c64-1e6dad91a1ab)] enum {
|
|
TF_CT_NONE = 0,
|
|
TF_CT_SYSCOLOR = 1,
|
|
TF_CT_COLORREF = 2
|
|
} TF_DA_COLORTYPE;
|
|
|
|
typedef [uuid(90d0cb5e-6520-4a0f-b47c-c39bd955f0d6)] struct TF_DA_COLOR
|
|
{
|
|
TF_DA_COLORTYPE type;
|
|
[switch_type(TF_DA_COLORTYPE), switch_is(type)] union {
|
|
[case(TF_CT_SYSCOLOR)] int nIndex;
|
|
[case(TF_CT_COLORREF)] COLORREF cr;
|
|
};
|
|
} TF_DA_COLOR;
|
|
|
|
typedef [uuid(33d2fe4b-6c24-4f67-8d75-3bc1819e4126)] enum {
|
|
TF_ATTR_INPUT = 0,
|
|
TF_ATTR_TARGET_CONVERTED = 1,
|
|
TF_ATTR_CONVERTED = 2,
|
|
TF_ATTR_TARGET_NOTCONVERTED = 3,
|
|
TF_ATTR_INPUT_ERROR = 4,
|
|
TF_ATTR_FIXEDCONVERTED = 5,
|
|
TF_ATTR_OTHER = -1
|
|
} TF_DA_ATTR_INFO;
|
|
|
|
typedef [uuid(1bf1c305-419b-4182-a4d2-9bfadc3f021f)] struct TF_DISPLAYATTRIBUTE
|
|
{
|
|
TF_DA_COLOR crText;
|
|
TF_DA_COLOR crBk;
|
|
TF_DA_LINESTYLE lsStyle;
|
|
BOOL fBoldLine;
|
|
TF_DA_COLOR crLine;
|
|
TF_DA_ATTR_INFO bAttr;
|
|
|
|
} TF_DISPLAYATTRIBUTE;
|
|
|
|
|
|
//
|
|
// ITfDisplayAttributeInfo
|
|
//
|
|
[
|
|
object,
|
|
uuid(70528852-2f26-4aea-8c96-215150578932),
|
|
pointer_default(unique)
|
|
]
|
|
interface ITfDisplayAttributeInfo : IUnknown
|
|
{
|
|
HRESULT GetGUID([out] GUID *pguid);
|
|
|
|
HRESULT GetDescription([out] BSTR *pbstrDesc);
|
|
|
|
HRESULT GetAttributeInfo([out] TF_DISPLAYATTRIBUTE *pda);
|
|
|
|
HRESULT SetAttributeInfo([in] const TF_DISPLAYATTRIBUTE *pda);
|
|
|
|
HRESULT Reset();
|
|
}
|
|
|
|
//
|
|
// IEnumTfDisplayAttributeInfo interface
|
|
//
|
|
[
|
|
object,
|
|
uuid(7cef04d7-cb75-4e80-a7ab-5f5bc7d332de),
|
|
pointer_default(unique)
|
|
]
|
|
interface IEnumTfDisplayAttributeInfo : IUnknown
|
|
{
|
|
HRESULT Clone([out] IEnumTfDisplayAttributeInfo **ppEnum);
|
|
|
|
HRESULT Next([in] ULONG ulCount,
|
|
[out, size_is(ulCount), length_is(*pcFetched)] ITfDisplayAttributeInfo **rgInfo,
|
|
[out] ULONG *pcFetched);
|
|
|
|
HRESULT Reset();
|
|
|
|
HRESULT Skip([in] ULONG ulCount);
|
|
}
|
|
|
|
//
|
|
// ITfDisplayAttributeProvider interface
|
|
//
|
|
[
|
|
object,
|
|
uuid(fee47777-163c-4769-996a-6e9c50ad8f54),
|
|
pointer_default(unique)
|
|
]
|
|
interface ITfDisplayAttributeProvider : IUnknown
|
|
{
|
|
HRESULT EnumDisplayAttributeInfo([out] IEnumTfDisplayAttributeInfo **ppEnum);
|
|
|
|
HRESULT GetDisplayAttributeInfo([in] REFGUID guid,
|
|
[out] ITfDisplayAttributeInfo **ppInfo);
|
|
}
|
|
|
|
|
|
//
|
|
// ITfDisplayAttributeMgr interface
|
|
//
|
|
[
|
|
object,
|
|
local,
|
|
uuid(8ded7393-5db1-475c-9e71-a39111b0ff67),
|
|
pointer_default(unique)
|
|
]
|
|
interface ITfDisplayAttributeMgr : IUnknown
|
|
{
|
|
HRESULT OnUpdateInfo();
|
|
|
|
HRESULT EnumDisplayAttributeInfo([out] IEnumTfDisplayAttributeInfo **ppEnum);
|
|
|
|
HRESULT GetDisplayAttributeInfo([in] REFGUID guid,
|
|
[out] ITfDisplayAttributeInfo **ppInfo,
|
|
[out] CLSID *pclsidOwner);
|
|
|
|
}
|
|
|
|
//
|
|
// ITfDisplayAttributeNotifySink interface
|
|
//
|
|
[
|
|
object,
|
|
uuid(ad56f402-e162-4f25-908f-7d577cf9bda9),
|
|
pointer_default(unique)
|
|
]
|
|
interface ITfDisplayAttributeNotifySink : IUnknown
|
|
{
|
|
HRESULT OnUpdateInfo();
|
|
}
|
|
|
|
|
|
//
|
|
// ITfCategoryMgr interface
|
|
//
|
|
[
|
|
object,
|
|
local,
|
|
uuid(c3acefb5-f69d-4905-938f-fcadcf4be830),
|
|
pointer_default(unique)
|
|
]
|
|
interface ITfCategoryMgr : IUnknown
|
|
{
|
|
HRESULT RegisterCategory([in] REFCLSID rclsid,
|
|
[in] REFGUID rcatid,
|
|
[in] REFGUID rguid);
|
|
|
|
HRESULT UnregisterCategory([in] REFCLSID rclsid,
|
|
[in] REFGUID rcatid,
|
|
[in] REFGUID rguid);
|
|
|
|
HRESULT EnumCategoriesInItem([in] REFGUID rguid,
|
|
[out] IEnumGUID **ppEnum);
|
|
|
|
HRESULT EnumItemsInCategory([in] REFGUID rcatid,
|
|
[out] IEnumGUID **ppEnum);
|
|
|
|
HRESULT FindClosestCategory([in] REFGUID rguid,
|
|
[out] GUID *pcatid,
|
|
[in, size_is(ulCount)] const GUID **ppcatidList,
|
|
[in] ULONG ulCount);
|
|
|
|
HRESULT RegisterGUIDDescription([in] REFCLSID rclsid,
|
|
[in] REFGUID rguid,
|
|
[in, size_is(cch)] const WCHAR *pchDesc,
|
|
[in] ULONG cch);
|
|
|
|
HRESULT UnregisterGUIDDescription([in] REFCLSID rclsid,
|
|
[in] REFGUID rguid);
|
|
|
|
HRESULT GetGUIDDescription([in] REFGUID rguid,
|
|
[out] BSTR *pbstrDesc);
|
|
|
|
HRESULT RegisterGUIDDWORD([in] REFCLSID rclsid,
|
|
[in] REFGUID rguid,
|
|
[in] DWORD dw);
|
|
|
|
HRESULT UnregisterGUIDDWORD([in] REFCLSID rclsid,
|
|
[in] REFGUID rguid);
|
|
|
|
HRESULT GetGUIDDWORD([in] REFGUID rguid,
|
|
[out] DWORD *pdw);
|
|
|
|
HRESULT RegisterGUID([in] REFGUID rguid,
|
|
[out] TfGuidAtom *pguidatom);
|
|
|
|
HRESULT GetGUID([in] TfGuidAtom guidatom,
|
|
[out] GUID *pguid);
|
|
|
|
HRESULT IsEqualTfGuidAtom([in] TfGuidAtom guidatom,
|
|
[in] REFGUID rguid,
|
|
[out] BOOL *pfEqual);
|
|
}
|
|
|
|
// value guarenteed never to be returned by ITfSource/Single::AdviseSink
|
|
const DWORD TF_INVALID_COOKIE = 0xffffffff;
|
|
|
|
//
|
|
// ITfSource
|
|
//
|
|
[
|
|
object,
|
|
uuid(4ea48a35-60ae-446f-8fd6-e6a8d82459f7),
|
|
pointer_default(unique)
|
|
]
|
|
interface ITfSource : IUnknown
|
|
{
|
|
HRESULT AdviseSink([in] REFIID riid,
|
|
[in, iid_is(riid)] IUnknown *punk,
|
|
[out] DWORD *pdwCookie);
|
|
|
|
HRESULT UnadviseSink([in] DWORD dwCookie);
|
|
};
|
|
|
|
//
|
|
// ITfSourceSingle
|
|
//
|
|
[
|
|
object,
|
|
uuid(73131f9c-56a9-49dd-b0ee-d046633f7528),
|
|
pointer_default(unique)
|
|
]
|
|
interface ITfSourceSingle : IUnknown
|
|
{
|
|
HRESULT AdviseSingleSink([in] TfClientId tid,
|
|
[in] REFIID riid,
|
|
[in, iid_is(riid)] IUnknown *punk);
|
|
|
|
HRESULT UnadviseSingleSink([in] TfClientId tid,
|
|
[in] REFIID riid);
|
|
};
|
|
|
|
cpp_quote("#endif // MSCTF_DEFINED")
|