Intravision/reactos
1
0
Fork 0
mirror of https://github.com/reactos/reactos.git synced 2024-05-18 03:12:06 +00:00
Code Issues Packages Projects Releases Wiki Activity

[REACTOS] Standardize <imm.h> and <immdev.h> (#6493)

Browse source 
Improve header compatibility and
code quality.
JIRA issue: CORE-19268
- Improve <imm.h> and <immdev.h>
  compatibility by correctly choosing
  the items.
- Use <immdev.h> instead of
  <ddk/immdev.h>.
- Move INPUTCONTEXTDX, IMEINFOEX,
  IMEDPI, and CLIENTIMC into
  <imm32_undoc.h>.
- Adapt to these changes.
This commit is contained in:
Katayama Hirofumi MZ 2024-02-13 20:33:14 +09:00 committed by GitHub
parent bdcfc6bc8e
commit 8ea93d2ab2
No known key found for this signature in database
GPG key ID: B5690EEEBB952194
21 changed files with 783 additions and 730 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

5
dll/ime/msctfime/msctfime.h
View file

@ -15,7 +15,8 @@
#include <windows.h>
#include <imm.h>
#include <ddk/immdev.h>
#include <immdev.h>
#include <imm32_undoc.h>
#include <cguid.h>
#include <tchar.h>
#include <msctf.h>
@ -34,6 +35,4 @@
#include "resource.h"
#define IS_IME_HKL(hKL) ((((ULONG_PTR)(hKL)) & 0xF0000000) == 0xE0000000)
extern HINSTANCE g_hInst;

1
dll/win32/comctl32/edit.c
View file

@ -47,6 +47,7 @@
#include "imm.h"
#ifdef __REACTOS__
#include <immdev.h>
#include <imm32_undoc.h>
#endif
#include "usp10.h"
#include "commctrl.h"

4
dll/win32/imm32/precomp.h
View file

@ -27,7 +27,8 @@
#include <winver.h>
#include <imm.h>
#include <ddk/immdev.h>
#include <immdev.h>
#include <imm32_undoc.h>
#define NTOS_MODE_USER
#include <ndk/umtypes.h>
@ -40,7 +41,6 @@
/* Undocumented user definitions */
#include <undocuser.h>
#include <imm32_undoc.h>
#include <strsafe.h>

1
dll/win32/msctf/utils.cpp
View file

@ -16,7 +16,6 @@
#include <windows.h>
#include <sddl.h>
#include <imm.h>
#include <ddk/immdev.h>
#include <cguid.h>
#include <tchar.h>
#include <msctf.h>

1
dll/win32/msutb/precomp.h
View file

@ -16,7 +16,6 @@
#include <windows.h>
#include <oleacc.h>
#include <imm.h>
#include <ddk/immdev.h>
#include <undocuser.h>
#include <cguid.h>
#include <msctf.h>

3
dll/win32/riched20/editor.c
View file

@ -234,7 +234,8 @@
#include "rtf.h"
#include "imm.h"
#ifdef __REACTOS__
#include "immdev.h"
#include <immdev.h>
#include <imm32_undoc.h>
#endif
#include "res.h"

4
modules/rostests/apitests/imm32/precomp.h
View file

@ -4,13 +4,13 @@
#define WIN32_NO_STATUS
#include <windows.h>
#include <imm.h>
#include <ddk/immdev.h>
#include <immdev.h>
#include <imm32_undoc.h>
#include <pseh/pseh2.h>
#include <ndk/umtypes.h>
#include <ndk/pstypes.h>
#include "../../../win32ss/include/ntuser.h"
#include <undocuser.h>
#include <imm32_undoc.h>
#include <ndk/rtlfuncs.h>
#include <wine/test.h>
#include <stdio.h>

2
modules/rostests/apitests/win32nt/win32nt.h
View file

@ -14,6 +14,8 @@
#include <wingdi.h>
#include <objbase.h>
#include <imm.h>
#include <immdev.h>
#include <imm32_undoc.h>
#include <winddi.h>
#include <prntfont.h>

364
sdk/include/ddk/immdev.h
View file

@ -2,7 +2,7 @@
* PROJECT: ReactOS headers
* LICENSE: LGPL-2.0-or-later (https://spdx.org/licenses/LGPL-2.0-or-later)
* PURPOSE: Providing DDK-compatible <immdev.h> and IME/IMM development helper
* COPYRIGHT: Copyright 2021-2022 Katayama Hirofumi MZ <katayama.hirofumi.mz@gmail.com>
* COPYRIGHT: Copyright 2021-2024 Katayama Hirofumi MZ <katayama.hirofumi.mz@gmail.com>
*/
#ifndef _IMMDEV_
@ -17,14 +17,70 @@
extern "C" {
#endif
BOOL WINAPI ImmDisableTextFrameService(_In_ DWORD dwThreadId);
BOOL WINAPI CtfImmIsCiceroStartedInThread(VOID);
typedef struct _tagIMEINFO {
DWORD dwPrivateDataSize;
DWORD fdwProperty;
DWORD fdwConversionCaps;
DWORD fdwSentenceCaps;
DWORD fdwUICaps;
DWORD fdwSCSCaps;
DWORD fdwSelectCaps;
} IMEINFO, *PIMEINFO, NEAR *NPIMEINFO, FAR *LPIMEINFO;
typedef struct tagSOFTKBDDATA
{
typedef struct tagCANDIDATEINFO {
DWORD dwSize;
DWORD dwCount;
DWORD dwOffset[32];
DWORD dwPrivateSize;
DWORD dwPrivateOffset;
} CANDIDATEINFO, *PCANDIDATEINFO, NEAR *NPCANDIDATEINFO, FAR *LPCANDIDATEINFO;
#if (WINVER >= 0x040A)
BOOL WINAPI ImmDisableTextFrameService(_In_ DWORD dwThreadId);
#endif
typedef struct tagSOFTKBDDATA {
UINT uCount;
WORD wCode[1][256];
} SOFTKBDDATA, *PSOFTKBDDATA, *LPSOFTKBDDATA;
WORD wCode[ANYSIZE_ARRAY][256];
} SOFTKBDDATA, *PSOFTKBDDATA, NEAR *NPSOFTKBDDATA, FAR *LPSOFTKBDDATA;
typedef struct tagCOMPOSITIONSTRING {
DWORD dwSize;
DWORD dwCompReadAttrLen;
DWORD dwCompReadAttrOffset;
DWORD dwCompReadClauseLen;
DWORD dwCompReadClauseOffset;
DWORD dwCompReadStrLen;
DWORD dwCompReadStrOffset;
DWORD dwCompAttrLen;
DWORD dwCompAttrOffset;
DWORD dwCompClauseLen;
DWORD dwCompClauseOffset;
DWORD dwCompStrLen;
DWORD dwCompStrOffset;
DWORD dwCursorPos;
DWORD dwDeltaStart;
DWORD dwResultReadClauseLen;
DWORD dwResultReadClauseOffset;
DWORD dwResultReadStrLen;
DWORD dwResultReadStrOffset;
DWORD dwResultClauseLen;
DWORD dwResultClauseOffset;
DWORD dwResultStrLen;
DWORD dwResultStrOffset;
DWORD dwPrivateSize;
DWORD dwPrivateOffset;
} COMPOSITIONSTRING, *PCOMPOSITIONSTRING, NEAR *NPCOMPOSITIONSTRING, FAR *LPCOMPOSITIONSTRING;
typedef struct tagGUIDELINE {
DWORD dwSize;
DWORD dwLevel;
DWORD dwIndex;
DWORD dwStrLen;
DWORD dwStrOffset;
DWORD dwPrivateSize;
DWORD dwPrivateOffset;
} GUIDELINE, *PGUIDELINE, NEAR *NPGUIDELINE, FAR *LPGUIDELINE;
/* wParam for WM_IME_CONTROL */
#define IMC_GETCONVERSIONMODE 0x0001
@ -90,70 +146,30 @@ typedef struct _tagINPUTCONTEXT {
HIMCC hMsgBuf;
DWORD fdwInit;
DWORD dwReserve[3];
} INPUTCONTEXT, *PINPUTCONTEXT, *LPINPUTCONTEXT;
} INPUTCONTEXT, *PINPUTCONTEXT, NEAR *NPINPUTCONTEXT, FAR *LPINPUTCONTEXT;
#ifdef _WIN64
C_ASSERT(offsetof(INPUTCONTEXT, hWnd) == 0x0);
C_ASSERT(offsetof(INPUTCONTEXT, fOpen) == 0x8);
C_ASSERT(offsetof(INPUTCONTEXT, ptStatusWndPos) == 0xc);
C_ASSERT(offsetof(INPUTCONTEXT, ptSoftKbdPos) == 0x14);
C_ASSERT(offsetof(INPUTCONTEXT, fdwConversion) == 0x1c);
C_ASSERT(offsetof(INPUTCONTEXT, fdwSentence) == 0x20);
C_ASSERT(offsetof(INPUTCONTEXT, lfFont) == 0x24);
C_ASSERT(offsetof(INPUTCONTEXT, cfCompForm) == 0x80);
C_ASSERT(offsetof(INPUTCONTEXT, cfCandForm) == 0x9c);
C_ASSERT(offsetof(INPUTCONTEXT, hCompStr) == 0x120);
C_ASSERT(offsetof(INPUTCONTEXT, hCandInfo) == 0x128);
C_ASSERT(offsetof(INPUTCONTEXT, hGuideLine) == 0x130);
C_ASSERT(offsetof(INPUTCONTEXT, hPrivate) == 0x138);
C_ASSERT(offsetof(INPUTCONTEXT, dwNumMsgBuf) == 0x140);
C_ASSERT(offsetof(INPUTCONTEXT, hMsgBuf) == 0x148);
C_ASSERT(offsetof(INPUTCONTEXT, fdwInit) == 0x150);
C_ASSERT(offsetof(INPUTCONTEXT, dwReserve) == 0x154);
C_ASSERT(sizeof(INPUTCONTEXT) == 0x160);
#else
#ifndef _WIN64
C_ASSERT(offsetof(INPUTCONTEXT, hWnd) == 0x0);
C_ASSERT(offsetof(INPUTCONTEXT, fOpen) == 0x4);
C_ASSERT(offsetof(INPUTCONTEXT, ptStatusWndPos) == 0x8);
C_ASSERT(offsetof(INPUTCONTEXT, ptSoftKbdPos) == 0x10);
C_ASSERT(offsetof(INPUTCONTEXT, fdwConversion) == 0x18);
C_ASSERT(offsetof(INPUTCONTEXT, fdwSentence) == 0x1c);
C_ASSERT(offsetof(INPUTCONTEXT, fdwSentence) == 0x1C);
C_ASSERT(offsetof(INPUTCONTEXT, lfFont) == 0x20);
C_ASSERT(offsetof(INPUTCONTEXT, cfCompForm) == 0x7c);
C_ASSERT(offsetof(INPUTCONTEXT, cfCompForm) == 0x7C);
C_ASSERT(offsetof(INPUTCONTEXT, cfCandForm) == 0x98);
C_ASSERT(offsetof(INPUTCONTEXT, hCompStr) == 0x118);
C_ASSERT(offsetof(INPUTCONTEXT, hCandInfo) == 0x11c);
C_ASSERT(offsetof(INPUTCONTEXT, hCandInfo) == 0x11C);
C_ASSERT(offsetof(INPUTCONTEXT, hGuideLine) == 0x120);
C_ASSERT(offsetof(INPUTCONTEXT, hPrivate) == 0x124);
C_ASSERT(offsetof(INPUTCONTEXT, dwNumMsgBuf) == 0x128);
C_ASSERT(offsetof(INPUTCONTEXT, hMsgBuf) == 0x12c);
C_ASSERT(offsetof(INPUTCONTEXT, hMsgBuf) == 0x12C);
C_ASSERT(offsetof(INPUTCONTEXT, fdwInit) == 0x130);
C_ASSERT(offsetof(INPUTCONTEXT, dwReserve) == 0x134);
C_ASSERT(sizeof(INPUTCONTEXT) == 0x140);
#endif
struct IME_STATE;
/* unconfirmed */
#ifdef __cplusplus
typedef struct INPUTCONTEXTDX : INPUTCONTEXT
{
#else
typedef struct INPUTCONTEXTDX
{
INPUTCONTEXT;
#endif
UINT nVKey; // +0x140
BOOL bNeedsTrans; // +0x144
DWORD dwUnknown1;
DWORD dwUIFlags; // +0x14c
DWORD dwUnknown2;
struct IME_STATE *pState; // +0x154
DWORD dwChange; // +0x158
HIMCC hCtfImeContext;
} INPUTCONTEXTDX, *PINPUTCONTEXTDX, *LPINPUTCONTEXTDX;
// bits of fdwInit of INPUTCONTEXT
/* bits of fdwInit of INPUTCONTEXT */
#define INIT_STATUSWNDPOS 0x00000001
#define INIT_CONVERSION 0x00000002
#define INIT_SENTENCE 0x00000004
@ -162,7 +178,7 @@ typedef struct INPUTCONTEXTDX
#define INIT_SOFTKBDPOS 0x00000020
#define INIT_GUIDMAP 0x00000040
// bits for INPUTCONTEXTDX.dwChange
/* bits for INPUTCONTEXTDX.dwChange */
#define INPUTCONTEXTDX_CHANGE_OPEN 0x1
#define INPUTCONTEXTDX_CHANGE_CONVERSION 0x2
#define INPUTCONTEXTDX_CHANGE_SENTENCE 0x4
@ -172,7 +188,7 @@ typedef struct INPUTCONTEXTDX
#define WM_IME_REPORT 0x280
#endif
// WM_IME_REPORT wParam
/* WM_IME_REPORT wParam */
#define IR_STRINGSTART 0x100
#define IR_STRINGEND 0x101
#define IR_OPENCONVERT 0x120
@ -186,193 +202,110 @@ typedef struct INPUTCONTEXTDX
#define IR_STRINGEX 0x180
#define IR_MODEINFO 0x190
// for IR_UNDETERMINE
typedef struct tagUNDETERMINESTRUCT
{
DWORD dwSize;
UINT uDefIMESize;
UINT uDefIMEPos;
UINT uUndetTextLen;
UINT uUndetTextPos;
UINT uUndetAttrPos;
UINT uCursorPos;
UINT uDeltaStart;
UINT uDetermineTextLen;
UINT uDetermineTextPos;
UINT uDetermineDelimPos;
UINT uYomiTextLen;
UINT uYomiTextPos;
UINT uYomiDelimPos;
} UNDETERMINESTRUCT, *PUNDETERMINESTRUCT, *LPUNDETERMINESTRUCT;
/* IMC */
LPINPUTCONTEXT WINAPI ImmLockIMC(HIMC);
LPINPUTCONTEXT WINAPI ImmLockIMC(_In_ HIMC hIMC);
BOOL WINAPI ImmUnlockIMC(_In_ HIMC hIMC);
DWORD WINAPI ImmGetIMCLockCount(_In_ HIMC hIMC);
typedef struct IME_SUBSTATE
{
struct IME_SUBSTATE *pNext;
HKL hKL;
DWORD dwValue;
} IME_SUBSTATE, *PIME_SUBSTATE;
/* IMCC */
#ifndef _WIN64
C_ASSERT(sizeof(IME_SUBSTATE) == 0xc);
HIMCC WINAPI ImmCreateIMCC(_In_ DWORD size);
HIMCC WINAPI ImmDestroyIMCC(_In_ HIMCC block);
LPVOID WINAPI ImmLockIMCC(_In_ HIMCC imcc);
BOOL WINAPI ImmUnlockIMCC(_In_ HIMCC imcc);
DWORD WINAPI ImmGetIMCCLockCount(_In_ HIMCC imcc);
HIMCC WINAPI ImmReSizeIMCC(_In_ HIMCC imcc, _In_ DWORD size);
DWORD WINAPI ImmGetIMCCSize(_In_ HIMCC imcc);
/* Messaging */
BOOL WINAPI ImmGenerateMessage(_In_ HIMC hIMC);
BOOL WINAPI
ImmTranslateMessage(
_In_ HWND hwnd,
_In_ UINT msg,
_In_ WPARAM wParam,
_In_ LPARAM lKeyData);
LRESULT WINAPI ImmRequestMessageA(_In_ HIMC hIMC, _In_ WPARAM wParam, _In_ LPARAM lParam);
LRESULT WINAPI ImmRequestMessageW(_In_ HIMC hIMC, _In_ WPARAM wParam, _In_ LPARAM lParam);
#ifdef UNICODE
#define ImmRequestMessage ImmRequestMessageW
#else
#define ImmRequestMessage ImmRequestMessageA
#endif
typedef struct IME_STATE
{
struct IME_STATE *pNext;
WORD wLang;
WORD fOpen;
DWORD dwConversion;
DWORD dwSentence;
DWORD dwInit;
PIME_SUBSTATE pSubState;
} IME_STATE, *PIME_STATE;
#ifndef _WIN64
C_ASSERT(sizeof(IME_STATE) == 0x18);
#endif
typedef struct _tagTRANSMSG
{
typedef struct _tagTRANSMSG {
UINT message;
WPARAM wParam;
LPARAM lParam;
} TRANSMSG, *PTRANSMSG, *LPTRANSMSG;
} TRANSMSG, *PTRANSMSG, NEAR *NPTRANSMSG, FAR *LPTRANSMSG;
typedef struct _tagTRANSMSGLIST
{
typedef struct _tagTRANSMSGLIST {
UINT uMsgCount;
TRANSMSG TransMsg[ANYSIZE_ARRAY];
} TRANSMSGLIST, *PTRANSMSGLIST, *LPTRANSMSGLIST;
} TRANSMSGLIST, *PTRANSMSGLIST, NEAR *NPTRANSMSGLIST, FAR *LPTRANSMSGLIST;
#define DEFINE_IME_ENTRY(type, name, params, extended) typedef type (WINAPI *FN_##name) params;
#include <imetable.h>
#undef DEFINE_IME_ENTRY
/* Soft keyboard */
typedef struct IMEDPI
{
struct IMEDPI *pNext;
HINSTANCE hInst;
HKL hKL;
IMEINFO ImeInfo;
UINT uCodePage;
WCHAR szUIClass[16];
DWORD cLockObj;
DWORD dwFlags;
#define DEFINE_IME_ENTRY(type, name, params, extended) FN_##name name;
#include <imetable.h>
#undef DEFINE_IME_ENTRY
} IMEDPI, *PIMEDPI;
HWND WINAPI
ImmCreateSoftKeyboard(
_In_ UINT uType,
_In_ HWND hwndParent,
_In_ INT x,
_In_ INT y);
#ifndef _WIN64
C_ASSERT(offsetof(IMEDPI, pNext) == 0x0);
C_ASSERT(offsetof(IMEDPI, hInst) == 0x4);
C_ASSERT(offsetof(IMEDPI, hKL) == 0x8);
C_ASSERT(offsetof(IMEDPI, ImeInfo) == 0xc);
C_ASSERT(offsetof(IMEDPI, uCodePage) == 0x28);
C_ASSERT(offsetof(IMEDPI, szUIClass) == 0x2c);
C_ASSERT(offsetof(IMEDPI, cLockObj) == 0x4c);
C_ASSERT(offsetof(IMEDPI, dwFlags) == 0x50);
C_ASSERT(offsetof(IMEDPI, ImeInquire) == 0x54);
C_ASSERT(offsetof(IMEDPI, ImeConversionList) == 0x58);
C_ASSERT(offsetof(IMEDPI, ImeRegisterWord) == 0x5c);
C_ASSERT(offsetof(IMEDPI, ImeUnregisterWord) == 0x60);
C_ASSERT(offsetof(IMEDPI, ImeGetRegisterWordStyle) == 0x64);
C_ASSERT(offsetof(IMEDPI, ImeEnumRegisterWord) == 0x68);
C_ASSERT(offsetof(IMEDPI, ImeConfigure) == 0x6c);
C_ASSERT(offsetof(IMEDPI, ImeDestroy) == 0x70);
C_ASSERT(offsetof(IMEDPI, ImeEscape) == 0x74);
C_ASSERT(offsetof(IMEDPI, ImeProcessKey) == 0x78);
C_ASSERT(offsetof(IMEDPI, ImeSelect) == 0x7c);
C_ASSERT(offsetof(IMEDPI, ImeSetActiveContext) == 0x80);
C_ASSERT(offsetof(IMEDPI, ImeToAsciiEx) == 0x84);
C_ASSERT(offsetof(IMEDPI, NotifyIME) == 0x88);
C_ASSERT(offsetof(IMEDPI, ImeSetCompositionString) == 0x8c);
C_ASSERT(offsetof(IMEDPI, ImeGetImeMenuItems) == 0x90);
C_ASSERT(offsetof(IMEDPI, CtfImeInquireExW) == 0x94);
C_ASSERT(offsetof(IMEDPI, CtfImeSelectEx) == 0x98);
C_ASSERT(offsetof(IMEDPI, CtfImeEscapeEx) == 0x9c);
C_ASSERT(offsetof(IMEDPI, CtfImeGetGuidAtom) == 0xa0);
C_ASSERT(offsetof(IMEDPI, CtfImeIsGuidMapEnable) == 0xa4);
C_ASSERT(sizeof(IMEDPI) == 0xa8);
#endif
BOOL WINAPI
ImmShowSoftKeyboard(
_In_ HWND hwndSoftKBD,
_In_ INT nCmdShow);
/* flags for IMEDPI.dwFlags */
#define IMEDPI_FLAG_UNLOADED 0x1
#define IMEDPI_FLAG_LOCKED 0x2
/* unconfirmed */
typedef struct tagCLIENTIMC
{
HANDLE hInputContext; /* LocalAlloc'ed LHND */
LONG cLockObj;
DWORD dwFlags;
DWORD dwCompatFlags;
RTL_CRITICAL_SECTION cs;
UINT uCodePage;
HKL hKL;
BOOL bCtfIme;
} CLIENTIMC, *PCLIENTIMC;
#ifndef _WIN64
C_ASSERT(offsetof(CLIENTIMC, hInputContext) == 0x0);
C_ASSERT(offsetof(CLIENTIMC, cLockObj) == 0x4);
C_ASSERT(offsetof(CLIENTIMC, dwFlags) == 0x8);
C_ASSERT(offsetof(CLIENTIMC, dwCompatFlags) == 0xc);
C_ASSERT(offsetof(CLIENTIMC, cs) == 0x10);
C_ASSERT(offsetof(CLIENTIMC, uCodePage) == 0x28);
C_ASSERT(offsetof(CLIENTIMC, hKL) == 0x2c);
C_ASSERT(sizeof(CLIENTIMC) == 0x34);
#endif
/* flags for CLIENTIMC */
#define CLIENTIMC_WIDE 0x1
#define CLIENTIMC_ACTIVE 0x2
#define CLIENTIMC_UNKNOWN4 0x20
#define CLIENTIMC_DESTROY 0x40
#define CLIENTIMC_DISABLEIME 0x80
#define CLIENTIMC_UNKNOWN2 0x100
BOOL WINAPI
ImmDestroySoftKeyboard(
_In_ HWND hwndSoftKBD);
/* IME file interface */
BOOL WINAPI
ImeInquire(
_Out_ LPIMEINFO lpIMEInfo,
_Out_ LPWSTR lpszWndClass,
_Out_ LPTSTR lpszWndClass,
_In_ DWORD dwSystemInfoFlags);
DWORD WINAPI
ImeConversionList(
_In_ HIMC hIMC,
_In_ LPCWSTR lpSrc,
_In_ LPCTSTR lpSrc,
_Out_ LPCANDIDATELIST lpDst,
_In_ DWORD dwBufLen,
_In_ UINT uFlag);
BOOL WINAPI
ImeRegisterWord(
_In_ LPCWSTR lpszReading,
_In_ LPCTSTR lpszReading,
_In_ DWORD dwStyle,
_In_ LPCWSTR lpszString);
_In_ LPCTSTR lpszString);
BOOL WINAPI
ImeUnregisterWord(
_In_ LPCWSTR lpszReading,
_In_ LPCTSTR lpszReading,
_In_ DWORD dwStyle,
_In_ LPCWSTR lpszString);
_In_ LPCTSTR lpszString);
UINT WINAPI
ImeGetRegisterWordStyle(
_In_ UINT nItem,
_Out_ LPSTYLEBUFW lpStyleBuf);
_Out_ LPSTYLEBUF lpStyleBuf);
UINT WINAPI
ImeEnumRegisterWord(
_In_ REGISTERWORDENUMPROCW lpfnEnumProc,
_In_opt_ LPCWSTR lpszReading,
_In_ REGISTERWORDENUMPROC lpfnEnumProc,
_In_opt_ LPCTSTR lpszReading,
_In_ DWORD dwStyle,
_In_opt_ LPCWSTR lpszString,
_In_opt_ LPCTSTR lpszString,
_In_opt_ LPVOID lpData);
BOOL WINAPI
@ -439,12 +372,41 @@ ImeGetImeMenuItems(
_In_ HIMC hIMC,
_In_ DWORD dwFlags,
_In_ DWORD dwType,
_Inout_opt_ LPIMEMENUITEMINFOW lpImeParentMenu,
_Inout_opt_ LPIMEMENUITEMINFOW lpImeMenu,
_Inout_opt_ LPIMEMENUITEMINFO lpImeParentMenu,
_Inout_opt_ LPIMEMENUITEMINFO lpImeMenu,
_In_ DWORD dwSize);
#ifdef __cplusplus
} // extern "C"
} /* extern "C" */
#endif
/* IME Property bits */
#define IME_PROP_END_UNLOAD 0x0001
#define IME_PROP_KBD_CHAR_FIRST 0x0002
#define IME_PROP_IGNORE_UPKEYS 0x0004
#define IME_PROP_NEED_ALTKEY 0x0008
#define IME_PROP_NO_KEYS_ON_CLOSE 0x0010
#define IME_PROP_ACCEPT_WIDE_VKEY 0x0020
/* for NI_CONTEXTUPDATED */
#define IMC_SETCONVERSIONMODE 0x0002
#define IMC_SETSENTENCEMODE 0x0004
#define IMC_SETOPENSTATUS 0x0006
/* dwAction for ImmNotifyIME */
#define NI_CONTEXTUPDATED 0x0003
#define NI_OPENCANDIDATE 0x0010
#define NI_CLOSECANDIDATE 0x0011
#define NI_SELECTCANDIDATESTR 0x0012
#define NI_CHANGECANDIDATELIST 0x0013
#define NI_FINALIZECONVERSIONRESULT 0x0014
#define NI_COMPOSITIONSTR 0x0015
#define NI_SETCANDIDATE_PAGESTART 0x0016
#define NI_SETCANDIDATE_PAGESIZE 0x0017
#define NI_IMEMENUSELECTED 0x0018
/* dwSystemInfoFlags bits */
#define IME_SYSINFO_WINLOGON 0x0001
#define IME_SYSINFO_WOW16 0x0002
#endif /* ndef _IMMDEV_ */

582
sdk/include/psdk/imm.h
View file

@ -1,21 +1,9 @@
/*
* Declarations for IMM32
*
* Copyright (C) the Wine project
*
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public
* License as published by the Free Software Foundation; either
* version 2.1 of the License, or (at your option) any later version.
*
* This library is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public
* License along with this library; if not, write to the Free Software
* Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
* PROJECT: ReactOS headers
* LICENSE: LGPL-2.1-or-later (https://spdx.org/licenses/LGPL-2.1-or-later)
* PURPOSE: Declarations for IMM32
* COPYRIGHT: Copyright (C) the Wine project
* Copyright (C) 2021-2024 Katayama Hirofumi MZ <katayama.hirofumi.mz@gmail.com>
*/
#ifndef __WINE_IMM_H
@ -25,75 +13,71 @@
extern "C" {
#endif
#ifdef __REACTOS__
#if (WINVER >= 0x040A)
DECLARE_HANDLE(HIMC);
DECLARE_HANDLE(HIMCC);
typedef HKL *LPHKL;
#else
typedef HANDLE HIMC;
typedef HANDLE HIMCC;
typedef DWORD HIMC;
typedef DWORD HIMCC;
#endif
typedef HKL FAR *LPHKL;
typedef UINT FAR *LPUINT;
typedef struct tagREGISTERWORDA {
LPSTR lpReading;
LPSTR lpWord;
} REGISTERWORDA, *PREGISTERWORDA, *NPREGISTERWORDA, *LPREGISTERWORDA;
} REGISTERWORDA, *PREGISTERWORDA, NEAR *NPREGISTERWORDA, FAR *LPREGISTERWORDA;
typedef struct tagREGISTERWORDW {
LPWSTR lpReading;
LPWSTR lpWord;
} REGISTERWORDW, *PREGISTERWORDW, *NPREGISTERWORDW, *LPREGISTERWORDW;
} REGISTERWORDW, *PREGISTERWORDW, NEAR *NPREGISTERWORDW, FAR *LPREGISTERWORDW;
typedef int
(CALLBACK *REGISTERWORDENUMPROCA)(
_In_ LPCSTR,
_In_ DWORD,
_In_ LPCSTR,
_In_ LPVOID);
typedef INT (CALLBACK *REGISTERWORDENUMPROCA)(
_In_ LPCSTR lpszReading,
_In_ DWORD dwStyle,
_In_ LPCSTR lpszRegister,
_Inout_opt_ LPVOID lpData);
typedef int
(CALLBACK *REGISTERWORDENUMPROCW)(
_In_ LPCWSTR,
_In_ DWORD,
_In_ LPCWSTR,
_In_ LPVOID);
typedef INT (CALLBACK *REGISTERWORDENUMPROCW)(
_In_ LPCWSTR lpszReading,
_In_ DWORD dwStyle,
_In_ LPCWSTR lpszRegister,
_Inout_opt_ LPVOID lpData);
typedef struct tagCANDIDATEFORM
{
typedef struct tagCANDIDATEFORM {
DWORD dwIndex;
DWORD dwStyle;
POINT ptCurrentPos;
RECT rcArea;
} CANDIDATEFORM, *LPCANDIDATEFORM;
} CANDIDATEFORM, *PCANDIDATEFORM, NEAR *NPCANDIDATEFORM, FAR *LPCANDIDATEFORM;
typedef struct tagCANDIDATELIST
{
typedef struct tagCANDIDATELIST {
DWORD dwSize;
DWORD dwStyle;
DWORD dwCount;
DWORD dwSelection;
DWORD dwPageStart;
DWORD dwPageSize;
DWORD dwOffset[1];
} CANDIDATELIST, *LPCANDIDATELIST;
DWORD dwOffset[ANYSIZE_ARRAY];
} CANDIDATELIST, *PCANDIDATELIST, NEAR *NPCANDIDATELIST, FAR *LPCANDIDATELIST;
typedef struct tagSTYLEBUFA
{
#define STYLE_DESCRIPTION_SIZE 32
typedef struct tagSTYLEBUFA {
DWORD dwStyle;
CHAR szDescription[32];
} STYLEBUFA, *LPSTYLEBUFA;
CHAR szDescription[STYLE_DESCRIPTION_SIZE];
} STYLEBUFA, *PSTYLEBUFA, NEAR *NPSTYLEBUFA, FAR *LPSTYLEBUFA;
typedef struct tagSTYLEBUFW
{
typedef struct tagSTYLEBUFW {
DWORD dwStyle;
WCHAR szDescription[32];
} STYLEBUFW, *LPSTYLEBUFW;
WCHAR szDescription[STYLE_DESCRIPTION_SIZE];
} STYLEBUFW, *PSTYLEBUFW, NEAR *NPSTYLEBUFW, FAR *LPSTYLEBUFW;
DECL_WINELIB_TYPE_AW(STYLEBUF)
DECL_WINELIB_TYPE_AW(LPSTYLEBUF)
#if (WINVER >= 0x040A)
typedef struct tagRECONVERTSTRING
{
typedef struct tagRECONVERTSTRING {
DWORD dwSize;
DWORD dwVersion;
DWORD dwStrLen;
@ -102,13 +86,11 @@ typedef struct tagRECONVERTSTRING
DWORD dwCompStrOffset;
DWORD dwTargetStrLen;
DWORD dwTargetStrOffset;
} RECONVERTSTRING, *LPRECONVERTSTRING;
} RECONVERTSTRING, *PRECONVERTSTRING, NEAR *NPRECONVERTSTRING, FAR *LPRECONVERTSTRING;
#define IMEMENUITEM_STRING_SIZE 80
typedef struct tagIMEMENUITEMINFOA
{
typedef struct tagIMEMENUITEMINFOA {
UINT cbSize;
UINT fType;
UINT fState;
@ -118,10 +100,9 @@ typedef struct tagIMEMENUITEMINFOA
DWORD dwItemData;
CHAR szString[IMEMENUITEM_STRING_SIZE];
HBITMAP hbmpItem;
} IMEMENUITEMINFOA, *LPIMEMENUITEMINFOA;
} IMEMENUITEMINFOA, *PIMEMENUITEMINFOA, NEAR *NPIMEMENUITEMINFOA, FAR *LPIMEMENUITEMINFOA;
typedef struct tagIMEMENUITEMINFOW
{
typedef struct tagIMEMENUITEMINFOW {
UINT cbSize;
UINT fType;
UINT fState;
@ -131,10 +112,19 @@ typedef struct tagIMEMENUITEMINFOW
DWORD dwItemData;
WCHAR szString[IMEMENUITEM_STRING_SIZE];
HBITMAP hbmpItem;
} IMEMENUITEMINFOW, *LPIMEMENUITEMINFOW;
} IMEMENUITEMINFOW, *PIMEMENUITEMINFOW, NEAR *NPIMEMENUITEMINFOW, FAR *LPIMEMENUITEMINFOW;
DECL_WINELIB_TYPE_AW(IMEMENUITEMINFO)
DECL_WINELIB_TYPE_AW(LPIMEMENUITEMINFO)
#ifdef UNICODE
typedef IMEMENUITEMINFOW IMEMENUITEMINFO;
typedef PIMEMENUITEMINFOW PIMEMENUITEMINFO;
typedef NPIMEMENUITEMINFOW NPIMEMENUITEMINFO;
typedef LPIMEMENUITEMINFOW LPIMEMENUITEMINFO;
#else
typedef IMEMENUITEMINFOA IMEMENUITEMINFO;
typedef PIMEMENUITEMINFOA PIMEMENUITEMINFO;
typedef NPIMEMENUITEMINFOA NPIMEMENUITEMINFO;
typedef LPIMEMENUITEMINFOA LPIMEMENUITEMINFO;
#endif
typedef struct tagIMECHARPOSITION {
DWORD dwSize;
@ -144,131 +134,15 @@ typedef struct tagIMECHARPOSITION {
RECT rcDocument;
} IMECHARPOSITION, *PIMECHARPOSITION, *NPIMECHARPOSITION, *LPIMECHARPOSITION;
typedef BOOL (CALLBACK* IMCENUMPROC)(HIMC, LPARAM);
typedef BOOL (CALLBACK *IMCENUMPROC)(_In_ HIMC hIMC, _In_ LPARAM lParam);
typedef struct _tagCOMPOSITIONFORM
{
#endif /* WINVER >= 0x040A */
typedef struct _tagCOMPOSITIONFORM {
DWORD dwStyle;
POINT ptCurrentPos;
RECT rcArea;
} COMPOSITIONFORM, *LPCOMPOSITIONFORM;
typedef struct _tagIMEINFO {
DWORD dwPrivateDataSize;
DWORD fdwProperty;
DWORD fdwConversionCaps;
DWORD fdwSentenceCaps;
DWORD fdwUICaps;
DWORD fdwSCSCaps;
DWORD fdwSelectCaps;
} IMEINFO, *LPIMEINFO;
typedef struct tagCOMPOSITIONSTRING {
DWORD dwSize;
DWORD dwCompReadAttrLen;
DWORD dwCompReadAttrOffset;
DWORD dwCompReadClauseLen;
DWORD dwCompReadClauseOffset;
DWORD dwCompReadStrLen;
DWORD dwCompReadStrOffset;
DWORD dwCompAttrLen;
DWORD dwCompAttrOffset;
DWORD dwCompClauseLen;
DWORD dwCompClauseOffset;
DWORD dwCompStrLen;
DWORD dwCompStrOffset;
DWORD dwCursorPos;
DWORD dwDeltaStart;
DWORD dwResultReadClauseLen;
DWORD dwResultReadClauseOffset;
DWORD dwResultReadStrLen;
DWORD dwResultReadStrOffset;
DWORD dwResultClauseLen;
DWORD dwResultClauseOffset;
DWORD dwResultStrLen;
DWORD dwResultStrOffset;
DWORD dwPrivateSize;
DWORD dwPrivateOffset;
} COMPOSITIONSTRING, *LPCOMPOSITIONSTRING;
typedef struct tagGUIDELINE {
DWORD dwSize;
DWORD dwLevel;
DWORD dwIndex;
DWORD dwStrLen;
DWORD dwStrOffset;
DWORD dwPrivateSize;
DWORD dwPrivateOffset;
} GUIDELINE, *LPGUIDELINE;
typedef struct tagCANDIDATEINFO {
DWORD dwSize;
DWORD dwCount;
DWORD dwOffset[32];
DWORD dwPrivateSize;
DWORD dwPrivateOffset;
} CANDIDATEINFO, *LPCANDIDATEINFO;
/* IME Property bits */
#define IME_PROP_END_UNLOAD 0x0001
#define IME_PROP_KBD_CHAR_FIRST 0x0002
#define IME_PROP_IGNORE_UPKEYS 0x0004
#define IME_PROP_NEED_ALTKEY 0x0008
#define IME_PROP_NO_KEYS_ON_CLOSE 0x0010
#define IME_PROP_ACCEPT_WIDE_VKEY 0x0020
/* for NI_CONTEXTUPDATED */
#define IMC_SETCONVERSIONMODE 0x0002
#define IMC_SETSENTENCEMODE 0x0004
#define IMC_SETOPENSTATUS 0x0006
/* dwAction for ImmNotifyIME */
#define NI_CONTEXTUPDATED 0x0003
#define NI_OPENCANDIDATE 0x0010
#define NI_CLOSECANDIDATE 0x0011
#define NI_SELECTCANDIDATESTR 0x0012
#define NI_CHANGECANDIDATELIST 0x0013
#define NI_FINALIZECONVERSIONRESULT 0x0014
#define NI_COMPOSITIONSTR 0x0015
#define NI_SETCANDIDATE_PAGESTART 0x0016
#define NI_SETCANDIDATE_PAGESIZE 0x0017
#define NI_IMEMENUSELECTED 0x0018
/* dwSystemInfoFlags bits */
#define IME_SYSINFO_WINLOGON 0x0001
#define IME_SYSINFO_WOW16 0x0002
BOOL WINAPI ImmUnlockIMC(HIMC);
DWORD WINAPI ImmGetIMCLockCount(HIMC);
HIMCC WINAPI ImmCreateIMCC(DWORD);
HIMCC WINAPI ImmDestroyIMCC(HIMCC);
LPVOID WINAPI ImmLockIMCC(HIMCC);
BOOL WINAPI ImmUnlockIMCC(HIMCC);
DWORD WINAPI ImmGetIMCCLockCount(HIMCC);
HIMCC WINAPI ImmReSizeIMCC(HIMCC, DWORD);
DWORD WINAPI ImmGetIMCCSize(HIMCC);
BOOL WINAPI ImmGenerateMessage(HIMC);
LRESULT WINAPI ImmRequestMessageA(HIMC, WPARAM, LPARAM);
LRESULT WINAPI ImmRequestMessageW(HIMC, WPARAM, LPARAM);
#define ImmRequestMessage WINELIB_NAME_AW(ImmRequestMessage);
BOOL WINAPI ImmTranslateMessage(HWND, UINT, WPARAM, LPARAM);
HWND WINAPI
ImmCreateSoftKeyboard(
_In_ UINT uType,
_In_ HWND hwndParent,
_In_ INT x,
_In_ INT y);
BOOL WINAPI
ImmShowSoftKeyboard(
_In_ HWND hwndSoftKBD,
_In_ INT nCmdShow);
BOOL WINAPI
ImmDestroySoftKeyboard(
_In_ HWND hwndSoftKBD);
} COMPOSITIONFORM, *PCOMPOSITIONFORM, NEAR *NPCOMPOSITIONFORM, FAR *LPCOMPOSITIONFORM;
/* wParam for WM_IME_CONTROL */
#define IMC_GETCANDIDATEPOS 0x0007
@ -282,10 +156,7 @@ ImmDestroySoftKeyboard(
#define IMC_CLOSESTATUSWINDOW 0x0021
#define IMC_OPENSTATUSWINDOW 0x0022
/*
* wParam for WM_IME_CONTROL to the soft keyboard
* dwAction for ImmNotifyIME
*/
/* dwAction for ImmNotifyIME */
#define NI_OPENCANDIDATE 0x0010
#define NI_CLOSECANDIDATE 0x0011
#define NI_SELECTCANDIDATESTR 0x0012
@ -303,14 +174,12 @@ ImmDestroySoftKeyboard(
#define ISC_SHOWUIALLCANDIDATEWINDOW 0x0000000F
#define ISC_SHOWUIALL 0xC000000F
/* dwIndex for ImmNotifyIME/NI_COMPOSITIONSTR */
#define CPS_COMPLETE 0x0001
#define CPS_CONVERT 0x0002
#define CPS_REVERT 0x0003
#define CPS_CANCEL 0x0004
/* the modifiers of hot key */
#define MOD_ALT 0x0001
#define MOD_CONTROL 0x0002
@ -322,7 +191,6 @@ ImmDestroySoftKeyboard(
#define MOD_ON_KEYUP 0x0800
#define MOD_IGNORE_ALL_MODIFIER 0x0400
/* Windows for Simplified Chinese Edition hot key ID from 0x10 - 0x2F */
#define IME_CHOTKEY_IME_NONIME_TOGGLE 0x10
#define IME_CHOTKEY_SHAPE_TOGGLE 0x11
@ -352,11 +220,7 @@ ImmDestroySoftKeyboard(
#define IME_ITHOTKEY_RECONVERTSTRING 0x203
#define IME_HOTKEY_PRIVATE_LAST 0x21F
/*
* dwSystemInfoFlags bits
* parameter of ImmGetCompositionString
*/
/* parameter of ImmGetCompositionString */
#define GCS_COMPREADSTR 0x0001
#define GCS_COMPREADATTR 0x0002
#define GCS_COMPREADCLAUSE 0x0004
@ -374,11 +238,7 @@ ImmDestroySoftKeyboard(
#define CS_INSERTCHAR 0x2000
#define CS_NOMOVECARET 0x4000
/*
* bits of fdwInit of INPUTCONTEXT
* IME version constants
*/
/* IME version constants */
#define IMEVER_0310 0x0003000A
#define IMEVER_0400 0x00040000
@ -404,8 +264,7 @@ ImmDestroySoftKeyboard(
#define SELECT_CAP_CONVERSION 0x00000001
#define SELECT_CAP_SENTENCE 0x00000002
/* ID for deIndex of ImmGetGuideLine */
/* ID for dwIndex of ImmGetGuideLine */
#define GGL_LEVEL 0x00000001
#define GGL_INDEX 0x00000002
#define GGL_STRING 0x00000003
@ -440,12 +299,11 @@ ImmDestroySoftKeyboard(
#define IGP_GETIMEVERSION (DWORD)(-4)
#define IGP_PROPERTY 0x00000004
#define IGP_CONVERSION 0x00000008
#define IGP_SENTENCE 0x0000000c
#define IGP_SENTENCE 0x0000000C
#define IGP_UI 0x00000010
#define IGP_SETCOMPSTR 0x00000014
#define IGP_SELECT 0x00000018
/* dwIndex for ImmSetCompositionString API */
#define SCS_SETSTR (GCS_COMPREADSTR | GCS_COMPSTR)
#define SCS_CHANGEATTR (GCS_COMPREADATTR | GCS_COMPATTR)
@ -461,7 +319,6 @@ ImmDestroySoftKeyboard(
#define ATTR_INPUT_ERROR 0x04
#define ATTR_FIXEDCONVERTED 0x05
/* bit field for IMC_SETCOMPOSITIONWINDOW, IMC_SETCANDIDATEWINDOW */
#define CFS_DEFAULT 0x0000
#define CFS_RECT 0x0001
@ -475,7 +332,6 @@ ImmDestroySoftKeyboard(
#define GCL_REVERSECONVERSION 0x0002
#define GCL_REVERSE_LENGTH 0x0003
/* bit field for conversion mode */
#define IME_CMODE_ALPHANUMERIC 0x0000
#define IME_CMODE_NATIVE 0x0001
@ -496,7 +352,7 @@ ImmDestroySoftKeyboard(
#define IME_CMODE_SYMBOL 0x0400
#define IME_CMODE_FIXED 0x0800
/* bit field for sentence mode */
#define IME_SMODE_NONE 0x0000
#define IME_SMODE_PLAURALCLAUSE 0x0001
#define IME_SMODE_SINGLECONVERT 0x0002
@ -512,7 +368,6 @@ ImmDestroySoftKeyboard(
#define IME_CAND_RADICAL 0x0004
#define IME_CAND_STROKE 0x0005
/* wParam of report message WM_IME_NOTIFY */
#define IMN_CLOSESTATUSWINDOW 0x0001
#define IMN_OPENSTATUSWINDOW 0x0002
@ -529,6 +384,7 @@ ImmDestroySoftKeyboard(
#define IMN_GUIDELINE 0x000D
#define IMN_PRIVATE 0x000E
#if (WINVER >= 0x040A)
/* wParam of report message WM_IME_REQUEST */
#define IMR_COMPOSITIONWINDOW 0x0001
@ -539,12 +395,12 @@ ImmDestroySoftKeyboard(
#define IMR_QUERYCHARPOSITION 0x0006
#define IMR_DOCUMENTFEED 0x0007
#endif
/* error code of ImmGetCompositionString */
#define IMM_ERROR_NODATA (-1)
#define IMM_ERROR_GENERAL (-2)
/* dialog mode of ImmConfigureIME */
#define IME_CONFIG_GENERAL 1
#define IME_CONFIG_REGISTERWORD 2
@ -564,15 +420,16 @@ ImmDestroySoftKeyboard(
#define IME_ESC_SYNC_HOTKEY 0x1007
#define IME_ESC_HANJA_MODE 0x1008
#define IME_ESC_AUTOMATA 0x1009
#define IME_ESC_PRIVATE_HOTKEY 0x100a
#define IME_ESC_GETHELPFILENAME 0x100b
#define IME_ESC_PRIVATE_HOTKEY 0x100A
#define IME_ESC_GETHELPFILENAME 0x100B
/* style of word registration */
#define IME_REGWORD_STYLE_EUDC 0x00000001
#define IME_REGWORD_STYLE_USER_FIRST 0x80000000
#define IME_REGWORD_STYLE_USER_LAST 0xFFFFFFFF
#if (WINVER >= 0x040A)
/* dwFlags for ImmAssociateContextEx */
#define IACE_CHILDREN 0x0001
#define IACE_DEFAULT 0x0010
@ -605,61 +462,64 @@ ImmDestroySoftKeyboard(
#define IMFS_UNHILITE MFS_UNHILITE
#define IMFS_DEFAULT MFS_DEFAULT
#endif /* WINVER >= 0x040A */
/*
* type of soft keyboard
* for Windows Tranditional Chinese Edition
*/
#define SOFTKEYBOARD_TYPE_T1 0x0001
/* for Windows Simplified Chinese Edition */
#define SOFTKEYBOARD_TYPE_C1 0x0002
/* types of soft keyboard */
#define SOFTKEYBOARD_TYPE_T1 0x0001 /* for Tranditional Chinese */
#define SOFTKEYBOARD_TYPE_C1 0x0002 /* for Simplified Chinese */
HIMC WINAPI ImmAssociateContext(_In_ HWND hWnd, _In_ HIMC hIMC);
#if (WINVER >= 0x040A)
BOOL WINAPI ImmAssociateContextEx(_In_ HWND hWnd, _In_ HIMC hIMC, _In_ DWORD dwFlags);
#endif
HIMC WINAPI ImmAssociateContext(_In_ HWND, _In_ HIMC);
BOOL WINAPI ImmAssociateContextEx(_In_ HWND, _In_ HIMC, _In_ DWORD);
BOOL WINAPI ImmConfigureIMEA(_In_ HKL, _In_ HWND, _In_ DWORD, _In_ LPVOID);
BOOL WINAPI ImmConfigureIMEW(_In_ HKL, _In_ HWND, _In_ DWORD, _In_ LPVOID);
#define ImmConfigureIME WINELIB_NAME_AW(ImmConfigureIME)
HIMC WINAPI ImmCreateContext(void);
BOOL WINAPI ImmSetActiveContext(HWND hwnd, HIMC hIMC, BOOL fFlag);
BOOL WINAPI ImmConfigureIMEA(_In_ HKL hKL, _In_ HWND hWnd, _In_ DWORD dwMode, _In_ LPVOID lpData);
BOOL WINAPI ImmConfigureIMEW(_In_ HKL hKL, _In_ HWND hWnd, _In_ DWORD dwMode, _In_ LPVOID lpData);
HIMC WINAPI ImmCreateContext(VOID);
BOOL WINAPI ImmDestroyContext(_In_ HIMC hIMC);
#if (WINVER >= 0x040A)
BOOL WINAPI ImmDisableIME(_In_ DWORD idThread);
BOOL WINAPI ImmEnumInputContext(_In_ DWORD, _In_ IMCENUMPROC, _In_ LPARAM);
BOOL WINAPI ImmLoadIME(HKL hKL);
BOOL WINAPI CtfImmIsTextFrameServiceDisabled(VOID);
BOOL WINAPI ImmEnumInputContext(_In_ DWORD dwThreadId, _In_ IMCENUMPROC lpfn, _In_ LPARAM lParam);
#endif
UINT
WINAPI
ImmEnumRegisterWordA(
_In_ HKL,
_In_ REGISTERWORDENUMPROCA,
_In_ HKL hKL,
_In_ REGISTERWORDENUMPROCA lpfnEnumProc,
_In_opt_ LPCSTR lpszReading,
_In_ DWORD,
_In_ DWORD dwStyle,
_In_opt_ LPCSTR lpszRegister,
_In_ LPVOID);
_Inout_opt_ LPVOID lpData);
UINT
WINAPI
ImmEnumRegisterWordW(
_In_ HKL,
_In_ REGISTERWORDENUMPROCW,
_In_ HKL hKL,
_In_ REGISTERWORDENUMPROCW lpfnEnumProc,
_In_opt_ LPCWSTR lpszReading,
_In_ DWORD,
_In_ DWORD dwStyle,
_In_opt_ LPCWSTR lpszRegister,
_In_ LPVOID);
_Inout_opt_ LPVOID lpData);
#define ImmEnumRegisterWord WINELIB_NAME_AW(ImmEnumRegisterWord)
LRESULT WINAPI
ImmEscapeA(
_In_ HKL hKL,
_In_ HIMC hIMC,
_In_ UINT uSubFunc,
_Inout_opt_ LPVOID lpData);
LRESULT WINAPI ImmEscapeA(_In_ HKL, _In_ HIMC, _In_ UINT, _In_ LPVOID);
LRESULT WINAPI ImmEscapeW(_In_ HKL, _In_ HIMC, _In_ UINT, _In_ LPVOID);
#define ImmEscape WINELIB_NAME_AW(ImmEscape)
LRESULT WINAPI
ImmEscapeW(
_In_ HKL hKL,
_In_ HIMC hIMC,
_In_ UINT uSubFunc,
_Inout_opt_ LPVOID lpData);
DWORD
WINAPI
ImmGetCandidateListA(
_In_ HIMC,
_In_ HIMC hIMC,
_In_ DWORD deIndex,
_Out_writes_bytes_opt_(dwBufLen) LPCANDIDATELIST lpCandList,
_In_ DWORD dwBufLen);
@ -667,62 +527,61 @@ ImmGetCandidateListA(
DWORD
WINAPI
ImmGetCandidateListW(
_In_ HIMC,
_In_ HIMC hIMC,
_In_ DWORD deIndex,
_Out_writes_bytes_opt_(dwBufLen) LPCANDIDATELIST lpCandList,
_In_ DWORD dwBufLen);
#define ImmGetCandidateList WINELIB_NAME_AW(ImmGetCandidateList)
DWORD WINAPI ImmGetCandidateListCountA(_In_ HIMC, _Out_ LPDWORD);
DWORD WINAPI ImmGetCandidateListCountW(_In_ HIMC, _Out_ LPDWORD);
#define ImmGetCandidateListCount WINELIB_NAME_AW(ImmGetCandidateListCount)
DWORD WINAPI ImmGetCandidateListCountA(_In_ HIMC hIMC, _Out_ LPDWORD lpdwListCount);
DWORD WINAPI ImmGetCandidateListCountW(_In_ HIMC hIMC, _Out_ LPDWORD lpdwListCount);
BOOL
WINAPI
ImmGetCandidateWindow(
_In_ HIMC,
_In_ DWORD,
_In_ HIMC hIMC,
_In_ DWORD dwIndex,
_Out_ LPCANDIDATEFORM lpCandidate);
#if defined(_WINGDI_) && !defined(NOGDI)
BOOL WINAPI ImmGetCompositionFontA(_In_ HIMC, _Out_ LPLOGFONTA);
BOOL WINAPI ImmGetCompositionFontW(_In_ HIMC, _Out_ LPLOGFONTW);
#define ImmGetCompositionFont WINELIB_NAME_AW(ImmGetCompositionFont)
BOOL WINAPI ImmGetCompositionFontA(_In_ HIMC hIMC, _Out_ LPLOGFONTA lplf);
BOOL WINAPI ImmGetCompositionFontW(_In_ HIMC hIMC, _Out_ LPLOGFONTW lplf);
BOOL WINAPI ImmSetCompositionFontA(_In_ HIMC, _In_ LPLOGFONTA);
BOOL WINAPI ImmSetCompositionFontW(_In_ HIMC, _In_ LPLOGFONTW);
#define ImmSetCompositionFont WINELIB_NAME_AW(ImmSetCompositionFont)
BOOL WINAPI ImmSetCompositionFontA(_In_ HIMC hIMC, _In_ LPLOGFONTA lplf);
BOOL WINAPI ImmSetCompositionFontW(_In_ HIMC hIMC, _In_ LPLOGFONTW lplf);
#ifdef UNICODE
#define ImmGetCompositionFont ImmGetCompositionFontW
#else
#define ImmGetCompositionFont ImmGetCompositionFontA
#endif
#endif
LONG
WINAPI
ImmGetCompositionStringA(
_In_ HIMC,
_In_ DWORD,
_In_ HIMC hIMC,
_In_ DWORD dwIndex,
_Out_writes_bytes_opt_(dwBufLen) LPVOID lpBuf,
_In_ DWORD dwBufLen);
LONG
WINAPI
ImmGetCompositionStringW(
_In_ HIMC,
_In_ DWORD,
_In_ HIMC hIMC,
_In_ DWORD dwIndex,
_Out_writes_bytes_opt_(dwBufLen) LPVOID lpBuf,
_In_ DWORD dwBufLen);
#define ImmGetCompositionString WINELIB_NAME_AW(ImmGetCompositionString)
BOOL WINAPI ImmGetCompositionWindow(_In_ HIMC, _Out_ LPCOMPOSITIONFORM);
HIMC WINAPI ImmGetContext(_In_ HWND);
BOOL WINAPI ImmGetCompositionWindow(_In_ HIMC hIMC, _Out_ LPCOMPOSITIONFORM lpCompForm);
HIMC WINAPI ImmGetContext(_In_ HWND hWnd);
DWORD
WINAPI
ImmGetConversionListA(
_In_ HKL,
_In_ HIMC,
_In_ HKL hKL,
_In_ HIMC hIMC,
_In_ LPCSTR lpSrc,
_Out_writes_bytes_(dwBufLen) LPCANDIDATELIST lpDst,
_In_ DWORD dwBufLen,
@ -731,44 +590,40 @@ ImmGetConversionListA(
DWORD
WINAPI
ImmGetConversionListW(
_In_ HKL,
_In_ HIMC,
_In_ HKL hKL,
_In_ HIMC hIMC,
_In_ LPCWSTR lpSrc,
_Out_writes_bytes_(dwBufLen) LPCANDIDATELIST lpDst,
_In_ DWORD dwBufLen,
_In_ UINT uFlag);
#define ImmGetConversionList WINELIB_NAME_AW(ImmGetConversionList)
BOOL
WINAPI
ImmGetConversionStatus(
_In_ HIMC,
_In_ HIMC hIMC,
_Out_opt_ LPDWORD lpfdwConversion,
_Out_opt_ LPDWORD lpfdwSentence);
HWND WINAPI ImmGetDefaultIMEWnd(_In_ HWND);
HWND WINAPI ImmGetDefaultIMEWnd(_In_ HWND hWnd);
UINT
WINAPI
ImmGetDescriptionA(
_In_ HKL,
_In_ HKL hKL,
_Out_writes_opt_(uBufLen) LPSTR lpszDescription,
_In_ UINT uBufLen);
UINT
WINAPI
ImmGetDescriptionW(
_In_ HKL,
_In_ HKL hKL,
_Out_writes_opt_(uBufLen) LPWSTR lpszDescription,
_In_ UINT uBufLen);
#define ImmGetDescription WINELIB_NAME_AW(ImmGetDescription)
DWORD
WINAPI
ImmGetGuideLineA(
_In_ HIMC,
_In_ HIMC hIMC,
_In_ DWORD dwIndex,
_Out_writes_bytes_opt_(dwBufLen) LPSTR lpBuf,
_In_ DWORD dwBufLen);
@ -776,35 +631,33 @@ ImmGetGuideLineA(
DWORD
WINAPI
ImmGetGuideLineW(
_In_ HIMC,
_In_ HIMC hIMC,
_In_ DWORD dwIndex,
_Out_writes_bytes_opt_(dwBufLen) LPWSTR lpBuf,
_In_ DWORD dwBufLen);
#define ImmGetGuideLine WINELIB_NAME_AW(ImmGetGuideLine)
UINT
WINAPI
ImmGetIMEFileNameA(
_In_ HKL,
_In_ HKL hKL,
_Out_writes_opt_(uBufLen) LPSTR lpszFileName,
_In_ UINT uBufLen);
UINT
WINAPI
ImmGetIMEFileNameW(
_In_ HKL,
_In_ HKL hKL,
_Out_writes_opt_(uBufLen) LPWSTR lpszFileName,
_In_ UINT uBufLen);
#define ImmGetIMEFileName WINELIB_NAME_AW(ImmGetIMEFileName)
#if (WINVER >= 0x040A)
DWORD
WINAPI
ImmGetImeMenuItemsA(
_In_ HIMC,
_In_ DWORD,
_In_ DWORD,
_In_ HIMC hIMC,
_In_ DWORD dwFlags,
_In_ DWORD dwType,
_Out_opt_ LPIMEMENUITEMINFOA lpImeParentMenu,
_Out_writes_bytes_opt_(dwSize) LPIMEMENUITEMINFOA lpImeMenu,
_In_ DWORD dwSize);
@ -812,76 +665,90 @@ ImmGetImeMenuItemsA(
DWORD
WINAPI
ImmGetImeMenuItemsW(
_In_ HIMC,
_In_ DWORD,
_In_ DWORD,
_In_ HIMC hIMC,
_In_ DWORD dwFlags,
_In_ DWORD dwType,
_Out_opt_ LPIMEMENUITEMINFOW lpImeParentMenu,
_Out_writes_bytes_opt_(dwSize) LPIMEMENUITEMINFOW lpImeMenu,
_In_ DWORD dwSize);
#define ImmGetImeMenuItems WINELIB_NAME_AW(ImmGetImeMenuItems)
#ifdef UNICODE
#define ImmGetImeMenuItems ImmGetImeMenuItemsW
#else
#define ImmGetImeMenuItems ImmGetImeMenuItemsA
#endif
BOOL WINAPI ImmGetOpenStatus(_In_ HIMC);
DWORD WINAPI ImmGetProperty(_In_ HKL, _In_ DWORD);
#endif /* WINVER >= 0x040A */
BOOL WINAPI ImmGetOpenStatus(_In_ HIMC hIMC);
DWORD WINAPI ImmGetProperty(_In_ HKL hKL, _In_ DWORD fdwIndex);
UINT
WINAPI
ImmGetRegisterWordStyleA(
_In_ HKL,
_In_ HKL hKL,
_In_ UINT nItem,
_Out_writes_(nItem) LPSTYLEBUFA lpStyleBuf);
UINT
WINAPI
ImmGetRegisterWordStyleW(
_In_ HKL,
_In_ HKL hKL,
_In_ UINT nItem,
_Out_writes_(nItem) LPSTYLEBUFW lpStyleBuf);
#define ImmGetRegisterWordStyle WINELIB_NAME_AW(ImmGetRegisterWordStyle)
BOOL WINAPI ImmGetStatusWindowPos(_In_ HIMC hIMC, _Out_ LPPOINT lpptPos);
UINT WINAPI ImmGetVirtualKey(_In_ HWND hWnd);
BOOL WINAPI ImmGetStatusWindowPos(_In_ HIMC, _Out_ LPPOINT);
UINT WINAPI ImmGetVirtualKey(_In_ HWND);
HKL WINAPI ImmInstallIMEA(_In_ LPCSTR lpszIMEFileName, _In_ LPCSTR lpszLayoutText);
HKL WINAPI ImmInstallIMEW(_In_ LPCWSTR lpszIMEFileName, _In_ LPCWSTR lpszLayoutText);
HKL WINAPI ImmInstallIMEA(_In_ LPCSTR, _In_ LPCSTR);
HKL WINAPI ImmInstallIMEW(_In_ LPCWSTR, _In_ LPCWSTR);
#define ImmInstallIME WINELIB_NAME_AW(ImmInstallIME)
BOOL WINAPI ImmIsIME(_In_ HKL hKL);
BOOL WINAPI ImmIsIME(_In_ HKL);
BOOL WINAPI
ImmIsUIMessageA(
_In_ HWND hWndIME,
_In_ UINT msg,
_In_ WPARAM wParam,
_In_ LPARAM lParam);
BOOL WINAPI ImmIsUIMessageA(_In_ HWND, _In_ UINT, _In_ WPARAM, _In_ LPARAM);
BOOL WINAPI ImmIsUIMessageW(_In_ HWND, _In_ UINT, _In_ WPARAM, _In_ LPARAM);
#define ImmIsUIMessage WINELIB_NAME_AW(ImmIsUIMessage)
BOOL WINAPI
ImmIsUIMessageW(
_In_ HWND hWndIME,
_In_ UINT msg,
_In_ WPARAM wParam,
_In_ LPARAM lParam);
BOOL WINAPI ImmNotifyIME(_In_ HIMC, _In_ DWORD, _In_ DWORD, _In_ DWORD_PTR);
DWORD WINAPI ImmProcessKey(HWND, HKL, UINT, LPARAM, DWORD);
BOOL WINAPI
ImmNotifyIME(
_In_ HIMC hIMC,
_In_ DWORD dwAction,
_In_ DWORD dwIndex,
_In_ DWORD_PTR dwValue);
BOOL
WINAPI
ImmRegisterWordA(
_In_ HKL,
_In_ HKL hKL,
_In_ LPCSTR lpszReading,
_In_ DWORD,
_In_ DWORD dwStyle,
_In_ LPCSTR lpszRegister);
BOOL
WINAPI
ImmRegisterWordW(
_In_ HKL,
_In_ HKL hKL,
_In_ LPCWSTR lpszReading,
_In_ DWORD,
_In_ DWORD dwStyle,
_In_ LPCWSTR lpszRegister);
#define ImmRegisterWord WINELIB_NAME_AW(ImmRegisterWord)
BOOL WINAPI ImmReleaseContext(_In_ HWND, _In_ HIMC);
BOOL WINAPI ImmSetCandidateWindow(_In_ HIMC, _In_ LPCANDIDATEFORM);
BOOL WINAPI ImmReleaseContext(_In_ HWND hWnd, _In_ HIMC hIMC);
BOOL WINAPI ImmSetCandidateWindow(_In_ HIMC hIMC, _In_ LPCANDIDATEFORM lpCandidate);
BOOL
WINAPI
ImmSetCompositionStringA(
_In_ HIMC,
_In_ HIMC hIMC,
_In_ DWORD dwIndex,
_Inout_updates_bytes_opt_(dwCompLen) LPVOID lpComp,
_In_ DWORD dwCompLen,
@ -891,39 +758,88 @@ ImmSetCompositionStringA(
BOOL
WINAPI
ImmSetCompositionStringW(
_In_ HIMC,
_In_ HIMC hIMC,
_In_ DWORD dwIndex,
_Inout_updates_bytes_opt_(dwCompLen) LPVOID lpComp,
_In_ DWORD dwCompLen,
_Inout_updates_bytes_opt_(dwReadLen) LPVOID lpRead,
_In_ DWORD dwReadLen);
#define ImmSetCompositionString WINELIB_NAME_AW(ImmSetCompositionString)
BOOL WINAPI ImmSetCompositionWindow(_In_ HIMC hIMC, _In_ LPCOMPOSITIONFORM lpCompForm);
BOOL WINAPI ImmSetCompositionWindow(_In_ HIMC, _In_ LPCOMPOSITIONFORM);
BOOL WINAPI ImmSetConversionStatus(_In_ HIMC, _In_ DWORD, _In_ DWORD);
BOOL WINAPI ImmSetOpenStatus(_In_ HIMC, _In_ BOOL);
BOOL WINAPI ImmSetStatusWindowPos(_In_ HIMC, _In_ LPPOINT);
BOOL WINAPI ImmSimulateHotKey(_In_ HWND, _In_ DWORD);
BOOL WINAPI
ImmSetConversionStatus(
_In_ HIMC hIMC,
_In_ DWORD fdwConversion,
_In_ DWORD fdwSentence);
BOOL WINAPI ImmSetOpenStatus(_In_ HIMC hIMC, _In_ BOOL fOpen);
BOOL WINAPI ImmSetStatusWindowPos(_In_ HIMC hIMC, _In_ LPPOINT lpptPos);
BOOL WINAPI ImmSimulateHotKey(_In_ HWND hWnd, _In_ DWORD dwHotKeyID);
BOOL
WINAPI
ImmUnregisterWordA(
_In_ HKL,
_In_ HKL hKL,
_In_ LPCSTR lpszReading,
_In_ DWORD,
_In_ DWORD dwStyle,
_In_ LPCSTR lpszUnregister);
BOOL
WINAPI
ImmUnregisterWordW(
_In_ HKL,
_In_ HKL hKL,
_In_ LPCWSTR lpszReading,
_In_ DWORD,
_In_ DWORD dwStyle,
_In_ LPCWSTR lpszUnregister);
#define ImmUnregisterWord WINELIB_NAME_AW(ImmUnregisterWord)
#ifdef UNICODE
#define ImmConfigureIME ImmConfigureIMEW
#define ImmEnumRegisterWord ImmEnumRegisterWordW
#define ImmEscape ImmEscapeW
#define ImmGetCandidateList ImmGetCandidateListW
#define ImmGetCandidateListCount ImmGetCandidateListCountW
#define ImmGetCompositionString ImmGetCompositionStringW
#define ImmGetConversionList ImmGetConversionListW
#define ImmGetDescription ImmGetDescriptionW
#define ImmGetGuideLine ImmGetGuideLineW
#define ImmGetIMEFileName ImmGetIMEFileNameW
#define ImmGetRegisterWordStyle ImmGetRegisterWordStyleW
#define ImmInstallIME ImmInstallIMEW
#define ImmIsUIMessage ImmIsUIMessageW
#define ImmRegisterWord ImmRegisterWordW
#define ImmSetCompositionFont ImmSetCompositionFontW
#define ImmSetCompositionString ImmSetCompositionStringW
#define ImmUnregisterWord ImmUnregisterWordW
typedef LPSTYLEBUFW LPSTYLEBUF;
typedef NPSTYLEBUFW NPSTYLEBUF;
typedef PSTYLEBUFW PSTYLEBUF;
typedef REGISTERWORDENUMPROCW REGISTERWORDENUMPROC;
typedef STYLEBUFW STYLEBUF;
#else
#define ImmConfigureIME ImmConfigureIMEA
#define ImmEnumRegisterWord ImmEnumRegisterWordA
#define ImmEscape ImmEscapeA
#define ImmGetCandidateList ImmGetCandidateListA
#define ImmGetCandidateListCount ImmGetCandidateListCountA
#define ImmGetCompositionString ImmGetCompositionStringA
#define ImmGetConversionList ImmGetConversionListA
#define ImmGetDescription ImmGetDescriptionA
#define ImmGetGuideLine ImmGetGuideLineA
#define ImmGetIMEFileName ImmGetIMEFileNameA
#define ImmGetRegisterWordStyle ImmGetRegisterWordStyleA
#define ImmInstallIME ImmInstallIMEA
#define ImmIsUIMessage ImmIsUIMessageA
#define ImmRegisterWord ImmRegisterWordA
#define ImmSetCompositionFont ImmSetCompositionFontA
#define ImmSetCompositionString ImmSetCompositionStringA
#define ImmUnregisterWord ImmUnregisterWordA
typedef LPSTYLEBUFA LPSTYLEBUF;
typedef NPSTYLEBUFA NPSTYLEBUF;
typedef PSTYLEBUFA PSTYLEBUF;
typedef REGISTERWORDENUMPROCA REGISTERWORDENUMPROC;
typedef STYLEBUFA STYLEBUF;
#endif
#ifdef __cplusplus
}

211
sdk/include/reactos/imm32_undoc.h
View file

@ -11,18 +11,210 @@
extern "C" {
#endif
#include <immdev.h>
#define IS_IME_HKL(hkl) ((((ULONG_PTR)(hkl)) & 0xF0000000) == 0xE0000000)
typedef struct tagIMEINFOEX
{
HKL hkl;
IMEINFO ImeInfo;
WCHAR wszUIClass[16];
ULONG fdwInitConvMode;
INT fInitOpen;
INT fLoadFlag;
DWORD dwProdVersion;
DWORD dwImeWinVersion;
WCHAR wszImeDescription[50];
WCHAR wszImeFile[80];
struct
{
INT fSysWow64Only:1;
INT fCUASLayer:1;
};
} IMEINFOEX, *PIMEINFOEX, NEAR *NPIMEINFOEX, FAR *LPIMEINFOEX;
typedef enum IMEINFOEXCLASS
{
ImeInfoExKeyboardLayout,
ImeInfoExKeyboardLayoutTFS,
ImeInfoExImeWindow,
ImeInfoExImeFileName
} IMEINFOEXCLASS;
#define DEFINE_IME_ENTRY(type, name, params, extended) typedef type (WINAPI *FN_##name) params;
#include <imetable.h>
#undef DEFINE_IME_ENTRY
typedef struct IMEDPI
{
struct IMEDPI *pNext;
HINSTANCE hInst;
HKL hKL;
IMEINFO ImeInfo;
UINT uCodePage;
WCHAR szUIClass[16];
DWORD cLockObj;
DWORD dwFlags;
#define DEFINE_IME_ENTRY(type, name, params, extended) FN_##name name;
#include <imetable.h>
#undef DEFINE_IME_ENTRY
} IMEDPI, *PIMEDPI, NEAR *NPIMEDPI, FAR *LPIMEDPI;
#ifndef _WIN64
C_ASSERT(offsetof(IMEDPI, pNext) == 0x0);
C_ASSERT(offsetof(IMEDPI, hInst) == 0x4);
C_ASSERT(offsetof(IMEDPI, hKL) == 0x8);
C_ASSERT(offsetof(IMEDPI, ImeInfo) == 0xc);
C_ASSERT(offsetof(IMEDPI, uCodePage) == 0x28);
C_ASSERT(offsetof(IMEDPI, szUIClass) == 0x2c);
C_ASSERT(offsetof(IMEDPI, cLockObj) == 0x4c);
C_ASSERT(offsetof(IMEDPI, dwFlags) == 0x50);
C_ASSERT(offsetof(IMEDPI, ImeInquire) == 0x54);
C_ASSERT(offsetof(IMEDPI, ImeConversionList) == 0x58);
C_ASSERT(offsetof(IMEDPI, ImeRegisterWord) == 0x5c);
C_ASSERT(offsetof(IMEDPI, ImeUnregisterWord) == 0x60);
C_ASSERT(offsetof(IMEDPI, ImeGetRegisterWordStyle) == 0x64);
C_ASSERT(offsetof(IMEDPI, ImeEnumRegisterWord) == 0x68);
C_ASSERT(offsetof(IMEDPI, ImeConfigure) == 0x6c);
C_ASSERT(offsetof(IMEDPI, ImeDestroy) == 0x70);
C_ASSERT(offsetof(IMEDPI, ImeEscape) == 0x74);
C_ASSERT(offsetof(IMEDPI, ImeProcessKey) == 0x78);
C_ASSERT(offsetof(IMEDPI, ImeSelect) == 0x7c);
C_ASSERT(offsetof(IMEDPI, ImeSetActiveContext) == 0x80);
C_ASSERT(offsetof(IMEDPI, ImeToAsciiEx) == 0x84);
C_ASSERT(offsetof(IMEDPI, NotifyIME) == 0x88);
C_ASSERT(offsetof(IMEDPI, ImeSetCompositionString) == 0x8c);
C_ASSERT(offsetof(IMEDPI, ImeGetImeMenuItems) == 0x90);
C_ASSERT(offsetof(IMEDPI, CtfImeInquireExW) == 0x94);
C_ASSERT(offsetof(IMEDPI, CtfImeSelectEx) == 0x98);
C_ASSERT(offsetof(IMEDPI, CtfImeEscapeEx) == 0x9c);
C_ASSERT(offsetof(IMEDPI, CtfImeGetGuidAtom) == 0xa0);
C_ASSERT(offsetof(IMEDPI, CtfImeIsGuidMapEnable) == 0xa4);
C_ASSERT(sizeof(IMEDPI) == 0xa8);
#endif
/* flags for IMEDPI.dwFlags */
#define IMEDPI_FLAG_UNLOADED 0x1
#define IMEDPI_FLAG_LOCKED 0x2
PIMEDPI WINAPI ImmLockImeDpi(_In_ HKL hKL);
VOID WINAPI ImmUnlockImeDpi(_Inout_ PIMEDPI pImeDpi);
/* unconfirmed */
typedef struct tagCLIENTIMC
{
HANDLE hInputContext; /* LocalAlloc'ed LHND */
LONG cLockObj;
DWORD dwFlags;
DWORD dwCompatFlags;
RTL_CRITICAL_SECTION cs;
UINT uCodePage;
HKL hKL;
BOOL bCtfIme;
} CLIENTIMC, *PCLIENTIMC, NEAR *NPCLIENTIMC, FAR *LPCLIENTIMC;
#ifndef _WIN64
C_ASSERT(offsetof(CLIENTIMC, hInputContext) == 0x0);
C_ASSERT(offsetof(CLIENTIMC, cLockObj) == 0x4);
C_ASSERT(offsetof(CLIENTIMC, dwFlags) == 0x8);
C_ASSERT(offsetof(CLIENTIMC, dwCompatFlags) == 0xc);
C_ASSERT(offsetof(CLIENTIMC, cs) == 0x10);
C_ASSERT(offsetof(CLIENTIMC, uCodePage) == 0x28);
C_ASSERT(offsetof(CLIENTIMC, hKL) == 0x2c);
C_ASSERT(sizeof(CLIENTIMC) == 0x34);
#endif
/* flags for CLIENTIMC */
#define CLIENTIMC_WIDE 0x1
#define CLIENTIMC_ACTIVE 0x2
#define CLIENTIMC_UNKNOWN4 0x20
#define CLIENTIMC_DESTROY 0x40
#define CLIENTIMC_DISABLEIME 0x80
#define CLIENTIMC_UNKNOWN2 0x100
PCLIENTIMC WINAPI ImmLockClientImc(_In_ HIMC hImc);
VOID WINAPI ImmUnlockClientImc(_Inout_ PCLIENTIMC pClientImc);
struct IME_STATE;
/* unconfirmed */
#ifdef __cplusplus
typedef struct INPUTCONTEXTDX : INPUTCONTEXT
{
#else
typedef struct INPUTCONTEXTDX
{
INPUTCONTEXT;
#endif
UINT nVKey; // +0x140
BOOL bNeedsTrans; // +0x144
DWORD dwUnknown1;
DWORD dwUIFlags; // +0x14c
DWORD dwUnknown2;
struct IME_STATE *pState; // +0x154
DWORD dwChange; // +0x158
HIMCC hCtfImeContext;
} INPUTCONTEXTDX, *PINPUTCONTEXTDX, NEAR *NPINPUTCONTEXTDX, FAR *LPINPUTCONTEXTDX;
typedef struct IME_SUBSTATE
{
struct IME_SUBSTATE *pNext;
HKL hKL;
DWORD dwValue;
} IME_SUBSTATE, *PIME_SUBSTATE, NEAR *NPIME_SUBSTATE, FAR *PIME_SUBSTATE;
#ifndef _WIN64
C_ASSERT(sizeof(IME_SUBSTATE) == 0xc);
#endif
typedef struct IME_STATE
{
struct IME_STATE *pNext;
WORD wLang;
WORD fOpen;
DWORD dwConversion;
DWORD dwSentence;
DWORD dwInit;
PIME_SUBSTATE pSubState;
} IME_STATE, *PIME_STATE, NEAR *NPIME_STATE, FAR *LPIME_STATE;
#ifndef _WIN64
C_ASSERT(sizeof(IME_STATE) == 0x18);
#endif
/* for WM_IME_REPORT IR_UNDETERMINE */
typedef struct tagUNDETERMINESTRUCT
{
DWORD dwSize;
UINT uDefIMESize;
UINT uDefIMEPos;
UINT uUndetTextLen;
UINT uUndetTextPos;
UINT uUndetAttrPos;
UINT uCursorPos;
UINT uDeltaStart;
UINT uDetermineTextLen;
UINT uDetermineTextPos;
UINT uDetermineDelimPos;
UINT uYomiTextLen;
UINT uYomiTextPos;
UINT uYomiDelimPos;
} UNDETERMINESTRUCT, *PUNDETERMINESTRUCT, *LPUNDETERMINESTRUCT;
UINT WINAPI GetKeyboardLayoutCP(_In_ LANGID wLangId);
BOOL WINAPI
ImmGetImeInfoEx(PIMEINFOEX pImeInfoEx, IMEINFOEXCLASS SearchType, PVOID pvSearchKey);
ImmGetImeInfoEx(
_Out_ PIMEINFOEX pImeInfoEx,
_In_ IMEINFOEXCLASS SearchType,
_In_ PVOID pvSearchKey);
BOOL WINAPI ImmLoadLayout(HKL hKL, PIMEINFOEX pImeInfoEx);
PCLIENTIMC WINAPI ImmLockClientImc(HIMC hImc);
VOID WINAPI ImmUnlockClientImc(PCLIENTIMC pClientImc);
PIMEDPI WINAPI ImmLockImeDpi(HKL hKL);
VOID WINAPI ImmUnlockImeDpi(PIMEDPI pImeDpi);
HRESULT WINAPI CtfImmTIMActivate(HKL hKL);
DWORD WINAPI ImmGetAppCompatFlags(HIMC hIMC);
BOOL WINAPI ImmLoadLayout(_In_ HKL hKL, _Inout_ PIMEINFOEX pImeInfoEx);
DWORD WINAPI ImmGetAppCompatFlags(_In_ HIMC hIMC);
BOOL WINAPI ImmSetActiveContext(_In_ HWND hwnd, _In_ HIMC hIMC, _In_ BOOL fFlag);
BOOL WINAPI ImmLoadIME(_In_ HKL hKL);
DWORD WINAPI ImmProcessKey(_In_ HWND, _In_ HKL, _In_ UINT, _In_ LPARAM, _In_ DWORD);
HRESULT WINAPI CtfAImmActivate(_Out_opt_ HINSTANCE *phinstCtfIme);
HRESULT WINAPI CtfAImmDeactivate(_In_ BOOL bDestroy);
@ -37,6 +229,9 @@ VOID WINAPI CtfImmCoUninitialize(VOID);
VOID WINAPI CtfImmEnterCoInitCountSkipMode(VOID);
BOOL WINAPI CtfImmLeaveCoInitCountSkipMode(VOID);
HRESULT WINAPI CtfImmLastEnabledWndDestroy(_In_ BOOL bCreate);
BOOL WINAPI CtfImmIsCiceroStartedInThread(VOID);
HRESULT WINAPI CtfImmTIMActivate(_In_ HKL hKL);
BOOL WINAPI CtfImmIsTextFrameServiceDisabled(VOID);
LRESULT WINAPI
CtfImmDispatchDefImeMessage(

28
win32ss/include/ntuser.h
View file

@ -1206,34 +1206,6 @@ typedef struct tagCURSORDATA
#define CURSORF_LINKED 0x0100
#define CURSORF_CURRENT 0x0200
typedef struct tagIMEINFOEX
{
HKL hkl;
IMEINFO ImeInfo;
WCHAR wszUIClass[16];
ULONG fdwInitConvMode;
INT fInitOpen;
INT fLoadFlag;
DWORD dwProdVersion;
DWORD dwImeWinVersion;
WCHAR wszImeDescription[50];
WCHAR wszImeFile[80];
struct
{
INT fSysWow64Only:1;
INT fCUASLayer:1;
};
} IMEINFOEX, *PIMEINFOEX;
typedef enum IMEINFOEXCLASS
{
ImeInfoExKeyboardLayout,
ImeInfoExKeyboardLayoutTFS,
ImeInfoExImeWindow,
ImeInfoExImeFileName
} IMEINFOEXCLASS;
#define IS_IME_HKL(hkl) ((((ULONG_PTR)(hkl)) & 0xF0000000) == 0xE0000000)
#define IS_IMM_MODE() (gpsi && (gpsi->dwSRVIFlags & SRVINFO_IMM32))
#define IS_CICERO_MODE() (gpsi && (gpsi->dwSRVIFlags & SRVINFO_CICERO_ENABLED))
#define IS_16BIT_MODE() (GetWin32ClientInfo()->dwTIFlags & TIF_16BIT)

3
win32ss/pch.h
View file

@ -59,10 +59,13 @@ typedef struct _SECURITY_ATTRIBUTES SECURITY_ATTRIBUTES, *LPSECURITY_ATTRIBUTES;
#include <winddi.h>
#define OEMRESOURCE
#include <winuser.h>
#include <ndk/rtltypes.h>
#include <prntfont.h>
#define _NOCSECT_TYPE
#include <ddrawi.h>
#include <imm.h>
#include <immdev.h>
#include <imm32_undoc.h>
#include <dbt.h>
/* NDK headers */

2
win32ss/user/ntuser/focus.c
View file

@ -7,7 +7,7 @@
*/
#include <win32k.h>
#include <ddk/immdev.h>
#include <immdev.h>
DBG_DEFAULT_CHANNEL(UserFocus);
PUSER_MESSAGE_QUEUE gpqForeground = NULL;

2
win32ss/user/ntuser/kbdlayout.c
View file

@ -10,7 +10,7 @@
*/
#include <win32k.h>
#include <ddk/immdev.h>
#include <immdev.h>
// Was included only because of CP_ACP and required the
// definition of SYSTEMTIME in ndk\rtltypes.h

2
win32ss/user/ntuser/window.c
View file

@ -8,7 +8,7 @@
*/
#include <win32k.h>
#include <ddk/immdev.h>
#include <immdev.h>
DBG_DEFAULT_CHANNEL(UserWnd);
INT gNestedWindowLimit = 50;

2
win32ss/user/ntuser/winpos.c
View file

@ -7,7 +7,7 @@
*/
#include <win32k.h>
#include <ddk/immdev.h>
#include <immdev.h>
DBG_DEFAULT_CHANNEL(UserWinpos);
/* GLOBALS *******************************************************************/

2
win32ss/user/user32/include/user32.h
View file

@ -28,6 +28,8 @@
#include <winreg.h>
#include <winuser.h>
#include <imm.h>
#include <immdev.h>
#include <imm32_undoc.h>
#include <ddeml.h>
#include <dde.h>
#include <windowsx.h>

2
win32ss/user/user32/misc/imm.c
View file

@ -9,7 +9,7 @@
#include <user32.h>
#include <strsafe.h>
#include <ddk/immdev.h>
#include <immdev.h>
WINE_DEFAULT_DEBUG_CHANNEL(user32);

2
win32ss/user/user32/windows/defwnd.c
View file

@ -10,7 +10,7 @@
*/
#include <user32.h>
#include <ddk/immdev.h>
#include <immdev.h>
WINE_DEFAULT_DEBUG_CHANNEL(user32);

2
win32ss/user/winsrv/winsrv.h
View file

@ -23,6 +23,8 @@
#include <winreg.h>
#include <winuser.h>
#include <imm.h>
#include <immdev.h>
#include <imm32_undoc.h>
/* Undocumented user definitions */
#include <undocuser.h>