imm32_undoc.h File Reference

#include <immdev.h>
#include <winnls32.h>
#include <imetable.h>

Include dependency graph for imm32_undoc.h:

This graph shows which files directly or indirectly include this file:

Go to the source code of this file.

Classes
struct	tagCOMPSTR_PRIVATE
struct	tagIMEINFOEX
struct	IMEDPI
struct	tagCLIENTIMC
struct	INPUTCONTEXTDX
struct	IME_SUBSTATE
struct	IME_STATE

Macros
#define	IME_MASK   (0xE0000000UL)
#define	SUBST_MASK   (0xD0000000UL)
#define	SPECIAL_MASK   (0xF0000000UL)
#define	IS_IME_HKL(hKL)   ((((ULONG_PTR)(hKL)) & 0xF0000000) == IME_MASK)
#define	IS_SPECIAL_HKL(hKL)   ((((ULONG_PTR)(hKL)) & 0xF0000000) == SPECIAL_MASK)
#define	SPECIALIDFROMHKL(hKL)   ((WORD)(HIWORD(hKL) & 0x0FFF))
#define	IS_IME_KLID(dwKLID)   ((((ULONG)(dwKLID)) & 0xF0000000) == IME_MASK)
#define	IS_SUBST_KLID(dwKLID)   ((((ULONG)(dwKLID)) & 0xF0000000) == SUBST_MASK)
#define	HKL_SWITCH_TO_NON_IME   ((HKL)UlongToHandle(1))
#define	HKL_RELEASE_IME   ((HKL)UlongToHandle(2))
#define	WM_IME_SYSTEM   0x00000287
#define	GCS_PRIVATE   0x8000
#define	IMS_NOTIFYIMESHOW   0x05
#define	IMS_UPDATEIMEUI   0x06
#define	IMS_SETCANDFORM   0x09
#define	IMS_SETCOMPFONT   0x0A
#define	IMS_SETCOMPFORM   0x0B
#define	IMS_CONFIGURE   0x0D
#define	IMS_SETOPENSTATUS   0x0F
#define	IMS_FREELAYOUT   0x11
#define	IMS_SOFTKBDONOFF   0x13
#define	IMS_GETCONVSTATUS   0x14
#define	IMS_IMEHELP   0x15
#define	IMS_IMEACTIVATE   0x17
#define	IMS_IMEDEACTIVATE   0x18
#define	IMS_ACTIVATELAYOUT   0x19
#define	IMS_CONSOLEIME_1A   0x1A /* Undocumented console IME WM_IME_SYSTEM subcommand (0x1A), used internally by conime for Windows compatibility. */
#define	IMS_CONSOLEIME_1B   0x1B /* Undocumented console IME WM_IME_SYSTEM subcommand (0x1B), used internally by conime for Windows compatibility. */
#define	IMS_GETIMEMENU   0x1C
#define	IMS_IMEMENUITEMSELECTED   0x1D
#define	IMS_GETCONTEXT   0x1E
#define	IMS_SENDNOTIFICATION   0x1F
#define	IMS_COMPLETECOMPSTR   0x20
#define	IMS_LOADTHREADLAYOUT   0x21
#define	IMS_SETLANGBAND   0x23
#define	IMS_UNSETLANGBAND   0x24
#define	DEFINE_IME_ENTRY(type, name, params, extended)   typedef type (WINAPI *FN_##name) params;
#define	DEFINE_IME_ENTRY(type, name, params, extended)   FN_##name name;
#define	IMEDPI_FLAG_UNLOADED   0x1
#define	IMEDPI_FLAG_LOCKED   0x2
#define	CLIENTIMC_WIDE   0x1
#define	CLIENTIMC_ACTIVE   0x2
#define	CLIENTIMC_DESTROY   0x40
#define	CLIENTIMC_DISABLEIME   0x80
#define	CLIENTIMC_LOCKED   0x100
#define	_IME_UI_HIDDEN   0x2
#define	_IME_UI_VERTICAL   0x4
#define	_IME_UI_NO_COMPFORM   0x8
#define	_IME_APP_COMPAT_DIRECT_IME_SYSTEM   0x1
#define	_IME_APP_COMPAT_DIRECT_IME_FONT   0x80
#define	_IME_APP_COMPAT_PROCESS_BY_IME   0x10000
#define	_IME_APP_COMPAT_SPECIAL_IME   0x80000000
#define	_IME_CMODE_EXTENDED   0x80000000
#define	_IME_MODE_KOR_SBCSCHAR   0x0002 /* For Korean */
#define	_IME_MODE_JPN_SBCSCHAR   0x0008 /* For Japanese */
#define	ImmIMPGetIME   ImmIMPGetIMEA
#define	ImmIMPQueryIME   ImmIMPQueryIMEA
#define	ImmIMPSetIME   ImmIMPSetIMEA
#define	ImmSendIMEMessageEx   ImmSendIMEMessageExA

Typedefs
typedef struct tagCOMPSTR_PRIVATE	COMPSTR_PRIVATE
typedef struct tagCOMPSTR_PRIVATE *	PCOMPSTR_PRIVATE
typedef struct tagCOMPSTR_PRIVATE *	LPCOMPSTR_PRIVATE
typedef struct tagIMEINFOEX	IMEINFOEX
typedef struct tagIMEINFOEX *	PIMEINFOEX
typedef struct tagIMEINFOEX *	NPIMEINFOEX
typedef struct tagIMEINFOEX *	LPIMEINFOEX
typedef enum IMEINFOEXCLASS	IMEINFOEXCLASS
typedef struct IMEDPI	IMEDPI
typedef struct IMEDPI *	PIMEDPI
typedef struct IMEDPI *	NPIMEDPI
typedef struct IMEDPI *	LPIMEDPI
typedef struct tagCLIENTIMC	CLIENTIMC
typedef struct tagCLIENTIMC *	PCLIENTIMC
typedef struct tagCLIENTIMC *	NPCLIENTIMC
typedef struct tagCLIENTIMC *	LPCLIENTIMC
typedef struct INPUTCONTEXTDX	INPUTCONTEXTDX
typedef struct INPUTCONTEXTDX *	PINPUTCONTEXTDX
typedef struct INPUTCONTEXTDX *	NPINPUTCONTEXTDX
typedef struct INPUTCONTEXTDX *	LPINPUTCONTEXTDX
typedef struct IME_SUBSTATE	IME_SUBSTATE
typedef struct IME_SUBSTATE *	PIME_SUBSTATE
typedef struct IME_SUBSTATE *	NPIME_SUBSTATE
typedef struct IME_STATE	IME_STATE
typedef struct IME_STATE *	PIME_STATE
typedef struct IME_STATE *	NPIME_STATE
typedef struct IME_STATE *	LPIME_STATE

Enumerations
enum	IMEINFOEXCLASS { ImeInfoExKeyboardLayout , ImeInfoExKeyboardLayoutTFS , ImeInfoExImeWindow , ImeInfoExImeFileName }

Functions
	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)
PIMEDPI WINAPI	ImmLockImeDpi (_In_ HKL hKL)
VOID WINAPI	ImmUnlockImeDpi (_Inout_opt_ PIMEDPI pImeDpi)
	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)
PCLIENTIMC WINAPI	ImmLockClientImc (_In_ HIMC hImc)
VOID WINAPI	ImmUnlockClientImc (_Inout_ PCLIENTIMC pClientImc)
	C_ASSERT (sizeof(IME_SUBSTATE)==0xc)
	C_ASSERT (sizeof(IME_STATE)==0x18)
UINT WINAPI	GetKeyboardLayoutCP (_In_ LANGID wLangId)
BOOL WINAPI	ImmGetImeInfoEx (_Out_ PIMEINFOEX pImeInfoEx, _In_ IMEINFOEXCLASS SearchType, _In_ PVOID pvSearchKey)
BOOL WINAPI	ImmLoadLayout (_In_ HKL hKL, _Inout_ PIMEINFOEX pImeInfoEx)
DWORD WINAPI	ImmGetAppCompatFlags (_In_ HIMC hIMC)
BOOL WINAPI	ImmSetActiveContext (_In_ HWND hwnd, _In_opt_ HIMC hIMC, _In_ BOOL fFlag)
BOOL WINAPI	ImmLoadIME (_In_ HKL hKL)
DWORD WINAPI	ImmProcessKey (_In_ HWND, _In_ HKL, _In_ UINT, _In_ LPARAM, _In_ DWORD)
BOOL WINAPI	ImmPutImeMenuItemsIntoMappedFile (_In_ HIMC hIMC)
BOOL WINAPI	ImmWINNLSGetEnableStatus (_In_opt_ HWND hWnd)
BOOL WINAPI	ImmSetActiveContextConsoleIME (_In_ HWND hwnd, _In_ BOOL fFlag)
BOOL WINAPI	ImmActivateLayout (_In_ HKL hKL)
BOOL WINAPI	ImmFreeLayout (_In_ HKL hKL)
BOOL WINAPI	ImmGetHotKey (_In_ DWORD dwHotKey, _Out_ LPUINT lpuModifiers, _Out_ LPUINT lpuVKey, _Out_opt_ LPHKL lphKL)
BOOL WINAPI	ImmSetHotKey (_In_ DWORD dwID, _In_ UINT uModifiers, _In_ UINT uVirtualKey, _In_opt_ _When_((dwAction==SETIMEHOTKEY_ADD) &&!(IME_HOTKEY_DSWITCH_FIRST<=dwHotKeyId &&dwHotKeyId<=IME_HOTKEY_DSWITCH_LAST), _Null_) HKL hKL)
BOOL WINAPI	ImmWINNLSEnableIME (_In_opt_ HWND hWnd, _In_ BOOL enable)
LRESULT WINAPI	ImmSystemHandler (_In_ HIMC hIMC, _Inout_opt_ WPARAM wParam, _Inout_opt_ LPARAM lParam)
DWORD WINAPI	ImmCallImeConsoleIME (_In_ HWND hWnd, _In_ UINT uMsg, _In_ WPARAM wParam, _In_ LPARAM lParam, _Out_ LPUINT puVK)
BOOL WINAPI	ImmIMPGetIMEA (_In_opt_ HWND hWnd, _Out_ LPIMEPROA pImePro)
BOOL WINAPI	ImmIMPGetIMEW (_In_opt_ HWND hWnd, _Out_ LPIMEPROW pImePro)
BOOL WINAPI	ImmIMPQueryIMEA (_Inout_ LPIMEPROA pImePro)
BOOL WINAPI	ImmIMPQueryIMEW (_Inout_ LPIMEPROW pImePro)
BOOL WINAPI	ImmIMPSetIMEA (_In_opt_ HWND hWnd, _Inout_ LPIMEPROA pImePro)
BOOL WINAPI	ImmIMPSetIMEW (_In_opt_ HWND hWnd, _Inout_ LPIMEPROW pImePro)
LRESULT WINAPI	ImmSendIMEMessageExA (_In_ HWND hWnd, _In_ LPARAM lParam)
LRESULT WINAPI	ImmSendIMEMessageExW (_In_ HWND hWnd, _In_ LPARAM lParam)
HRESULT WINAPI	CtfAImmActivate (_Out_opt_ HINSTANCE *phinstCtfIme)
HRESULT WINAPI	CtfAImmDeactivate (_In_ BOOL bDestroy)
BOOL WINAPI	CtfAImmIsIME (_In_ HKL hKL)
BOOL WINAPI	CtfImmIsCiceroStartedInThread (VOID)
VOID WINAPI	CtfImmSetCiceroStartInThread (_In_ BOOL bStarted)
VOID WINAPI	CtfImmSetAppCompatFlags (_In_ DWORD dwFlags)
DWORD WINAPI	CtfImmHideToolbarWnd (VOID)
VOID WINAPI	CtfImmRestoreToolbarWnd (_In_ LPVOID pUnused, _In_ DWORD dwShowFlags)
BOOL WINAPI	CtfImmGenerateMessage (_In_ HIMC hIMC, _In_ BOOL bSend)
VOID WINAPI	CtfImmCoUninitialize (VOID)
VOID WINAPI	CtfImmEnterCoInitCountSkipMode (VOID)
BOOL WINAPI	CtfImmLeaveCoInitCountSkipMode (VOID)
HRESULT WINAPI	CtfImmLastEnabledWndDestroy (_In_ BOOL bCreate)
HRESULT WINAPI	CtfImmTIMActivate (_In_ HKL hKL)
BOOL WINAPI	CtfImmIsTextFrameServiceDisabled (VOID)
BOOL WINAPI	CtfImmIsCiceroEnabled (VOID)
BOOL WINAPI	CtfImmIsGuidMapEnable (_In_ HIMC hIMC)
LRESULT WINAPI	CtfImmDispatchDefImeMessage (_In_ HWND hWnd, _In_ UINT uMsg, _In_ WPARAM wParam, _In_ LPARAM lParam)

Macro Definition Documentation

_IME_APP_COMPAT_DIRECT_IME_FONT

#define _IME_APP_COMPAT_DIRECT_IME_FONT   0x80

Definition at line 220 of file imm32_undoc.h.

_IME_APP_COMPAT_DIRECT_IME_SYSTEM

#define _IME_APP_COMPAT_DIRECT_IME_SYSTEM   0x1

Definition at line 219 of file imm32_undoc.h.

_IME_APP_COMPAT_PROCESS_BY_IME

#define _IME_APP_COMPAT_PROCESS_BY_IME   0x10000

Definition at line 221 of file imm32_undoc.h.

_IME_APP_COMPAT_SPECIAL_IME

#define _IME_APP_COMPAT_SPECIAL_IME   0x80000000

Definition at line 222 of file imm32_undoc.h.

_IME_CMODE_EXTENDED

#define _IME_CMODE_EXTENDED   0x80000000

Definition at line 225 of file imm32_undoc.h.

_IME_MODE_JPN_SBCSCHAR

#define _IME_MODE_JPN_SBCSCHAR   0x0008 /* For Japanese */

Definition at line 229 of file imm32_undoc.h.

_IME_MODE_KOR_SBCSCHAR

#define _IME_MODE_KOR_SBCSCHAR   0x0002 /* For Korean */

Definition at line 228 of file imm32_undoc.h.

_IME_UI_HIDDEN

#define _IME_UI_HIDDEN   0x2

Definition at line 214 of file imm32_undoc.h.

_IME_UI_NO_COMPFORM

#define _IME_UI_NO_COMPFORM   0x8

Definition at line 216 of file imm32_undoc.h.

_IME_UI_VERTICAL

#define _IME_UI_VERTICAL   0x4

Definition at line 215 of file imm32_undoc.h.

CLIENTIMC_ACTIVE

#define CLIENTIMC_ACTIVE   0x2

Definition at line 184 of file imm32_undoc.h.

CLIENTIMC_DESTROY

#define CLIENTIMC_DESTROY   0x40

Definition at line 185 of file imm32_undoc.h.

CLIENTIMC_DISABLEIME

#define CLIENTIMC_DISABLEIME   0x80

Definition at line 186 of file imm32_undoc.h.

CLIENTIMC_LOCKED

#define CLIENTIMC_LOCKED   0x100

Definition at line 187 of file imm32_undoc.h.

CLIENTIMC_WIDE

#define CLIENTIMC_WIDE   0x1

Definition at line 183 of file imm32_undoc.h.

DEFINE_IME_ENTRY [1/2]

#define DEFINE_IME_ENTRY	(		type,
			name,
			params,
			extended
	)		typedef type (WINAPI *FN_##name) params;

Definition at line 113 of file imm32_undoc.h.

DEFINE_IME_ENTRY [2/2]

#define DEFINE_IME_ENTRY	(		type,
			name,
			params,
			extended
	)		FN_##name name;

Definition at line 113 of file imm32_undoc.h.

GCS_PRIVATE

#define GCS_PRIVATE   0x8000

Definition at line 35 of file imm32_undoc.h.

HKL_RELEASE_IME

#define HKL_RELEASE_IME   ((HKL)UlongToHandle(2))

Definition at line 30 of file imm32_undoc.h.

HKL_SWITCH_TO_NON_IME

#define HKL_SWITCH_TO_NON_IME   ((HKL)UlongToHandle(1))

Definition at line 29 of file imm32_undoc.h.

IME_MASK

#define IME_MASK   (0xE0000000UL)

Definition at line 17 of file imm32_undoc.h.

IMEDPI_FLAG_LOCKED

#define IMEDPI_FLAG_LOCKED   0x2

Definition at line 153 of file imm32_undoc.h.

IMEDPI_FLAG_UNLOADED

#define IMEDPI_FLAG_UNLOADED   0x1

Definition at line 152 of file imm32_undoc.h.

ImmIMPGetIME

#define ImmIMPGetIME   ImmIMPGetIMEA

Definition at line 359 of file imm32_undoc.h.

ImmIMPQueryIME

#define ImmIMPQueryIME   ImmIMPQueryIMEA

Definition at line 360 of file imm32_undoc.h.

ImmIMPSetIME

#define ImmIMPSetIME   ImmIMPSetIMEA

Definition at line 361 of file imm32_undoc.h.

ImmSendIMEMessageEx

#define ImmSendIMEMessageEx   ImmSendIMEMessageExA

Definition at line 362 of file imm32_undoc.h.

IMS_ACTIVATELAYOUT

#define IMS_ACTIVATELAYOUT   0x19

Definition at line 60 of file imm32_undoc.h.

IMS_COMPLETECOMPSTR

#define IMS_COMPLETECOMPSTR   0x20

Definition at line 67 of file imm32_undoc.h.

IMS_CONFIGURE

#define IMS_CONFIGURE   0x0D

Definition at line 52 of file imm32_undoc.h.

IMS_CONSOLEIME_1A

#define IMS_CONSOLEIME_1A   0x1A /* Undocumented console IME WM_IME_SYSTEM subcommand (0x1A), used internally by conime for Windows compatibility. */

Definition at line 61 of file imm32_undoc.h.

IMS_CONSOLEIME_1B

#define IMS_CONSOLEIME_1B   0x1B /* Undocumented console IME WM_IME_SYSTEM subcommand (0x1B), used internally by conime for Windows compatibility. */

Definition at line 62 of file imm32_undoc.h.

IMS_FREELAYOUT

#define IMS_FREELAYOUT   0x11

Definition at line 54 of file imm32_undoc.h.

IMS_GETCONTEXT

#define IMS_GETCONTEXT   0x1E

Definition at line 65 of file imm32_undoc.h.

IMS_GETCONVSTATUS

#define IMS_GETCONVSTATUS   0x14

Definition at line 56 of file imm32_undoc.h.

IMS_GETIMEMENU

#define IMS_GETIMEMENU   0x1C

Definition at line 63 of file imm32_undoc.h.

IMS_IMEACTIVATE

#define IMS_IMEACTIVATE   0x17

Definition at line 58 of file imm32_undoc.h.

IMS_IMEDEACTIVATE

#define IMS_IMEDEACTIVATE   0x18

Definition at line 59 of file imm32_undoc.h.

IMS_IMEHELP

#define IMS_IMEHELP   0x15

Definition at line 57 of file imm32_undoc.h.

IMS_IMEMENUITEMSELECTED

#define IMS_IMEMENUITEMSELECTED   0x1D

Definition at line 64 of file imm32_undoc.h.

IMS_LOADTHREADLAYOUT

#define IMS_LOADTHREADLAYOUT   0x21

Definition at line 68 of file imm32_undoc.h.

IMS_NOTIFYIMESHOW

#define IMS_NOTIFYIMESHOW   0x05

Definition at line 47 of file imm32_undoc.h.

IMS_SENDNOTIFICATION

#define IMS_SENDNOTIFICATION   0x1F

Definition at line 66 of file imm32_undoc.h.

IMS_SETCANDFORM

#define IMS_SETCANDFORM   0x09

Definition at line 49 of file imm32_undoc.h.

IMS_SETCOMPFONT

#define IMS_SETCOMPFONT   0x0A

Definition at line 50 of file imm32_undoc.h.

IMS_SETCOMPFORM

#define IMS_SETCOMPFORM   0x0B

Definition at line 51 of file imm32_undoc.h.

IMS_SETLANGBAND

#define IMS_SETLANGBAND   0x23

Definition at line 69 of file imm32_undoc.h.

IMS_SETOPENSTATUS

#define IMS_SETOPENSTATUS   0x0F

Definition at line 53 of file imm32_undoc.h.

IMS_SOFTKBDONOFF

#define IMS_SOFTKBDONOFF   0x13

Definition at line 55 of file imm32_undoc.h.

IMS_UNSETLANGBAND

#define IMS_UNSETLANGBAND   0x24

Definition at line 70 of file imm32_undoc.h.

IMS_UPDATEIMEUI

#define IMS_UPDATEIMEUI   0x06

Definition at line 48 of file imm32_undoc.h.

IS_IME_HKL

#define IS_IME_HKL

(

hKL

)

((((ULONG_PTR)(hKL)) & 0xF0000000) == IME_MASK)

Definition at line 21 of file imm32_undoc.h.

IS_IME_KLID

#define IS_IME_KLID

(

dwKLID

)

((((ULONG)(dwKLID)) & 0xF0000000) == IME_MASK)

Definition at line 25 of file imm32_undoc.h.

IS_SPECIAL_HKL

#define IS_SPECIAL_HKL

(

hKL

)

((((ULONG_PTR)(hKL)) & 0xF0000000) == SPECIAL_MASK)

Definition at line 22 of file imm32_undoc.h.

IS_SUBST_KLID

#define IS_SUBST_KLID

(

dwKLID

)

((((ULONG)(dwKLID)) & 0xF0000000) == SUBST_MASK)

Definition at line 26 of file imm32_undoc.h.

SPECIAL_MASK

#define SPECIAL_MASK   (0xF0000000UL)

Definition at line 19 of file imm32_undoc.h.

SPECIALIDFROMHKL

#define SPECIALIDFROMHKL

(

hKL

)

((WORD)(HIWORD(hKL) & 0x0FFF))

Definition at line 23 of file imm32_undoc.h.

SUBST_MASK

#define SUBST_MASK   (0xD0000000UL)

Definition at line 18 of file imm32_undoc.h.

WM_IME_SYSTEM

#define WM_IME_SYSTEM   0x00000287

Definition at line 32 of file imm32_undoc.h.

Typedef Documentation

CLIENTIMC

typedef struct tagCLIENTIMC CLIENTIMC

COMPSTR_PRIVATE

typedef struct tagCOMPSTR_PRIVATE COMPSTR_PRIVATE

IME_STATE

typedef struct IME_STATE IME_STATE

IME_SUBSTATE

typedef struct IME_SUBSTATE IME_SUBSTATE

IMEDPI

typedef struct IMEDPI IMEDPI

IMEINFOEX

typedef struct tagIMEINFOEX IMEINFOEX

IMEINFOEXCLASS

typedef enum IMEINFOEXCLASS IMEINFOEXCLASS

INPUTCONTEXTDX

typedef struct INPUTCONTEXTDX INPUTCONTEXTDX

LPCLIENTIMC

typedef struct tagCLIENTIMC* LPCLIENTIMC

LPCOMPSTR_PRIVATE

typedef struct tagCOMPSTR_PRIVATE * LPCOMPSTR_PRIVATE

LPIME_STATE

typedef struct IME_STATE* LPIME_STATE

LPIMEDPI

typedef struct IMEDPI* LPIMEDPI

LPIMEINFOEX

typedef struct tagIMEINFOEX* LPIMEINFOEX

LPINPUTCONTEXTDX

typedef struct INPUTCONTEXTDX* LPINPUTCONTEXTDX

NPCLIENTIMC

typedef struct tagCLIENTIMC* NPCLIENTIMC

NPIME_STATE

typedef struct IME_STATE* NPIME_STATE

NPIME_SUBSTATE

typedef struct IME_SUBSTATE* NPIME_SUBSTATE

NPIMEDPI

typedef struct IMEDPI* NPIMEDPI

NPIMEINFOEX

typedef struct tagIMEINFOEX* NPIMEINFOEX

NPINPUTCONTEXTDX

typedef struct INPUTCONTEXTDX* NPINPUTCONTEXTDX

PCLIENTIMC

typedef struct tagCLIENTIMC * PCLIENTIMC

PCOMPSTR_PRIVATE

typedef struct tagCOMPSTR_PRIVATE * PCOMPSTR_PRIVATE

PIME_STATE

typedef struct IME_STATE * PIME_STATE

PIME_SUBSTATE

typedef struct IME_SUBSTATE * PIME_SUBSTATE

PIMEDPI

typedef struct IMEDPI * PIMEDPI

PIMEINFOEX

typedef struct tagIMEINFOEX * PIMEINFOEX

PINPUTCONTEXTDX

typedef struct INPUTCONTEXTDX * PINPUTCONTEXTDX

Enumeration Type Documentation

IMEINFOEXCLASS

enum IMEINFOEXCLASS

Enumerator
ImeInfoExKeyboardLayout
ImeInfoExKeyboardLayoutTFS
ImeInfoExImeWindow
ImeInfoExImeFileName

Definition at line 91 of file imm32_undoc.h.

{
    ImeInfoExKeyboardLayout,
    ImeInfoExKeyboardLayoutTFS,
    ImeInfoExImeWindow,
    ImeInfoExImeFileName
} IMEINFOEXCLASS;

Function Documentation

C_ASSERT() [1/40]

C_ASSERT

(

offsetof(CLIENTIMC, cLockObj)

= =0x4

)

C_ASSERT() [2/40]

C_ASSERT

(

offsetof(CLIENTIMC, cs)

= =0x10

)

C_ASSERT() [3/40]

C_ASSERT

(

offsetof(CLIENTIMC, dwCompatFlags)

= =0xc

)

C_ASSERT() [4/40]

C_ASSERT

(

offsetof(CLIENTIMC, dwFlags)

= =0x8

)

C_ASSERT() [5/40]

C_ASSERT

(

offsetof(CLIENTIMC, hInputContext)

= =0x0

)

C_ASSERT() [6/40]

C_ASSERT

(

offsetof(CLIENTIMC, hKL)

= =0x2c

)

C_ASSERT() [7/40]

C_ASSERT

(

offsetof(CLIENTIMC, uCodePage)

= =0x28

)

C_ASSERT() [8/40]

C_ASSERT

(

offsetof(IMEDPI, cLockObj)

= =0x4c

)

C_ASSERT() [9/40]

C_ASSERT

(

offsetof(IMEDPI, CtfImeEscapeEx)

= =0x9c

)

C_ASSERT() [10/40]

C_ASSERT

(

offsetof(IMEDPI, CtfImeGetGuidAtom)

= =0xa0

)

C_ASSERT() [11/40]

C_ASSERT

(

offsetof(IMEDPI, CtfImeInquireExW)

= =0x94

)

C_ASSERT() [12/40]

C_ASSERT

(

offsetof(IMEDPI, CtfImeIsGuidMapEnable)

= =0xa4

)

C_ASSERT() [13/40]

C_ASSERT

(

offsetof(IMEDPI, CtfImeSelectEx)

= =0x98

)

C_ASSERT() [14/40]

C_ASSERT

(

offsetof(IMEDPI, dwFlags)

= =0x50

)

C_ASSERT() [15/40]

C_ASSERT

(

offsetof(IMEDPI, hInst)

= =0x4

)

C_ASSERT() [16/40]

C_ASSERT

(

offsetof(IMEDPI, hKL)

= =0x8

)

C_ASSERT() [17/40]

C_ASSERT

(

offsetof(IMEDPI, ImeConfigure)

= =0x6c

)

C_ASSERT() [18/40]

C_ASSERT

(

offsetof(IMEDPI, ImeConversionList)

= =0x58

)

C_ASSERT() [19/40]

C_ASSERT

(

offsetof(IMEDPI, ImeDestroy)

= =0x70

)

C_ASSERT() [20/40]

C_ASSERT

(

offsetof(IMEDPI, ImeEnumRegisterWord)

= =0x68

)

C_ASSERT() [21/40]

C_ASSERT

(

offsetof(IMEDPI, ImeEscape)

= =0x74

)

C_ASSERT() [22/40]

C_ASSERT

(

offsetof(IMEDPI, ImeGetImeMenuItems)

= =0x90

)

C_ASSERT() [23/40]

C_ASSERT

(

offsetof(IMEDPI, ImeGetRegisterWordStyle)

= =0x64

)

C_ASSERT() [24/40]

C_ASSERT

(

offsetof(IMEDPI, ImeInfo)

= =0xc

)

C_ASSERT() [25/40]

C_ASSERT

(

offsetof(IMEDPI, ImeInquire)

= =0x54

)

C_ASSERT() [26/40]

C_ASSERT

(

offsetof(IMEDPI, ImeProcessKey)

= =0x78

)

C_ASSERT() [27/40]

C_ASSERT

(

offsetof(IMEDPI, ImeRegisterWord)

= =0x5c

)

C_ASSERT() [28/40]

C_ASSERT

(

offsetof(IMEDPI, ImeSelect)

= =0x7c

)

C_ASSERT() [29/40]

C_ASSERT

(

offsetof(IMEDPI, ImeSetActiveContext)

= =0x80

)

C_ASSERT() [30/40]

C_ASSERT

(

offsetof(IMEDPI, ImeSetCompositionString)

= =0x8c

)

C_ASSERT() [31/40]

C_ASSERT

(

offsetof(IMEDPI, ImeToAsciiEx)

= =0x84

)

C_ASSERT() [32/40]

C_ASSERT

(

offsetof(IMEDPI, ImeUnregisterWord)

= =0x60

)

C_ASSERT() [33/40]

C_ASSERT

(

offsetof(IMEDPI, NotifyIME)

= =0x88

)

C_ASSERT() [34/40]

C_ASSERT

(

offsetof(IMEDPI, pNext)

= =0x0

)

C_ASSERT() [35/40]

C_ASSERT

(

offsetof(IMEDPI, szUIClass)

= =0x2c

)

C_ASSERT() [36/40]

C_ASSERT

(

offsetof(IMEDPI, uCodePage)

= =0x28

)

C_ASSERT() [37/40]

C_ASSERT

(

sizeof(CLIENTIMC)

= =0x34

)

C_ASSERT() [38/40]

C_ASSERT

(

sizeof(IME_STATE)

= =0x18

)

C_ASSERT() [39/40]

C_ASSERT

(

sizeof(IME_SUBSTATE)

= =0xc

)

C_ASSERT() [40/40]

C_ASSERT

(

sizeof(IMEDPI)

= =0xa8

)

CtfAImmActivate()

HRESULT WINAPI CtfAImmActivate

(

_Out_opt_ HINSTANCE *

phinstCtfIme

)

Definition at line 1009 of file ctf.c.

{
    HRESULT hr;
    HINSTANCE hinstCtfIme;
 
    TRACE("(%p)\n", phinstCtfIme);
 
    /* Load a CTF IME file if necessary */
    hinstCtfIme = Imm32LoadCtfIme();
 
    /* Create a thread manager of the CTF IME */
    hr = CtfImeCreateThreadMgr();
    if (hr == S_OK)
    {
        /* Update CI_... flags of the thread client info */
        GetWin32ClientInfo()->CI_flags |= CI_AIMMACTIVATED; /* Activate AIMM */
        GetWin32ClientInfo()->CI_flags &= ~CI_TSFDISABLED;  /* Enable TSF */
 
        /* Create the CTF input contexts */
        ImmEnumInputContext(0, Imm32EnumCreateCtfICProc, 0);
    }
 
    if (phinstCtfIme)
        *phinstCtfIme = hinstCtfIme;
 
    return hr;
}

CtfAImmDeactivate()

HRESULT WINAPI CtfAImmDeactivate

(

_In_ BOOL

bDestroy

)

Definition at line 1044 of file ctf.c.

{
    HRESULT hr;
 
    if (!bDestroy)
        return E_FAIL;
 
    hr = CtfImeDestroyThreadMgr();
    if (hr == S_OK)
    {
        GetWin32ClientInfo()->CI_flags &= ~CI_AIMMACTIVATED; /* Deactivate AIMM */
        GetWin32ClientInfo()->CI_flags |= CI_TSFDISABLED;    /* Disable TSF */
    }
 
    return hr;
}

CtfAImmIsIME()

BOOL WINAPI CtfAImmIsIME

(

_In_ HKL

hKL

)

Definition at line 767 of file ctf.c.

{
    TRACE("(%p)\n", hKL);
    if (!Imm32LoadCtfIme())
        return ImmIsIME(hKL);
    return CTF_IME_FN(CtfImeIsIME)(hKL);
}

CtfImmCoUninitialize()

VOID WINAPI CtfImmCoUninitialize

(

VOID

)

Definition at line 614 of file ctf.c.

{
    IMMTLSDATA *pData;
 
    if (!(GetWin32ClientInfo()->CI_flags & CI_CTFCOINIT))
        return; /* Not CoInitialize'd */
 
    pData = Imm32GetTLS();
    if (pData)
    {
        pData->bUninitializing = TRUE;
        Imm32CoUninitialize(); /* Do CoUninitialize */
        pData->bUninitializing = FALSE;
 
        GetWin32ClientInfo()->CI_flags &= ~CI_CTFCOINIT;
    }
 
    pData = Imm32AllocateTLS();
    if (!pData || !pData->pSpy)
        return; /* There were no spy */
 
    /* Our work is done. We don't need spies like you anymore. */
    Imm32CoRevokeInitializeSpy(pData->uliCookie);
    ISPY_Release(pData->pSpy);
    pData->pSpy = NULL;
    pData->uliCookie.QuadPart = 0;
}

Referenced by ImmDisableTextFrameService(), and ISPY_PreInitialize().

CtfImmDispatchDefImeMessage()

LRESULT WINAPI CtfImmDispatchDefImeMessage	(	_In_ HWND	hWnd,
		_In_ UINT	uMsg,
		_In_ WPARAM	wParam,
		_In_ LPARAM	lParam
	)

Definition at line 1417 of file ctf.c.

{
    TRACE("(%p, %u, %p, %p)\n", hWnd, uMsg, wParam, lParam);
 
    if (RtlDllShutdownInProgress() || Imm32InsideLoaderLock() || !Imm32LoadCtfIme())
        return 0;
 
    return CTF_IME_FN(CtfImeDispatchDefImeMessage)(hWnd, uMsg, wParam, lParam);
}

Referenced by ImeWndProc_common().

CtfImmEnterCoInitCountSkipMode()

VOID WINAPI CtfImmEnterCoInitCountSkipMode

(

VOID

)

Definition at line 381 of file ctf.c.

{
    IMMTLSDATA *pData;
 
    TRACE("()\n");
 
    pData = Imm32GetTLS();
    if (pData)
        ++(pData->bDoCount);
}

CtfImmGenerateMessage()

BOOL WINAPI CtfImmGenerateMessage	(	_In_ HIMC	hIMC,
		_In_ BOOL	bSend
	)

Definition at line 1273 of file ctf.c.

{
    DWORD_PTR dwImeThreadId, dwCurrentThreadId;
    PCLIENTIMC pClientImc;
    BOOL bUnicode;
    LPINPUTCONTEXT pIC;
    DWORD iMsg, dwNumMsgBuf;
    LPTRANSMSG pOldTransMsg, pNewTransMsg;
    SIZE_T cbTransMsg;
 
    TRACE("(%p, %d)\n", hIMC, bSend);
 
    dwImeThreadId = NtUserQueryInputContext(hIMC, QIC_INPUTTHREADID);
    dwCurrentThreadId = GetCurrentThreadId();
    if (dwImeThreadId != dwCurrentThreadId)
    {
        ERR("%p vs %p\n", dwImeThreadId, dwCurrentThreadId);
        return FALSE;
    }
 
    pClientImc = ImmLockClientImc(hIMC);
    if (IS_NULL_UNEXPECTEDLY(pClientImc))
        return FALSE;
 
    bUnicode = !!(pClientImc->dwFlags & CLIENTIMC_WIDE);
    ImmUnlockClientImc(pClientImc);
 
    pIC = (LPINPUTCONTEXT)ImmLockIMC(hIMC);
    if (IS_NULL_UNEXPECTEDLY(pIC))
        return FALSE;
 
    dwNumMsgBuf = pIC->dwNumMsgBuf;
    pOldTransMsg = (LPTRANSMSG)ImmLockIMCC(pIC->hMsgBuf);
    if (IS_NULL_UNEXPECTEDLY(pOldTransMsg))
    {
        pIC->dwNumMsgBuf = 0;
        ImmUnlockIMC(hIMC);
        return TRUE;
    }
 
    cbTransMsg = sizeof(TRANSMSG) * dwNumMsgBuf;
    pNewTransMsg = (PTRANSMSG)ImmLocalAlloc(0, cbTransMsg);
    if (IS_NULL_UNEXPECTEDLY(pNewTransMsg))
    {
        ImmUnlockIMCC(pIC->hMsgBuf);
        pIC->dwNumMsgBuf = 0;
        ImmUnlockIMC(hIMC);
        return TRUE;
    }
 
    RtlCopyMemory(pNewTransMsg, pOldTransMsg, cbTransMsg);
 
    for (iMsg = 0; iMsg < dwNumMsgBuf; ++iMsg)
    {
        HWND hWnd = pIC->hWnd;
        UINT uMsg = pNewTransMsg[iMsg].message;
        WPARAM wParam = pNewTransMsg[iMsg].wParam;
        LPARAM lParam = pNewTransMsg[iMsg].lParam;
        if (bSend)
        {
            if (bUnicode)
                SendMessageW(hWnd, uMsg, wParam, lParam);
            else
                SendMessageA(hWnd, uMsg, wParam, lParam);
        }
        else
        {
            if (bUnicode)
                PostMessageW(hWnd, uMsg, wParam, lParam);
            else
                PostMessageA(hWnd, uMsg, wParam, lParam);
        }
    }
 
    ImmLocalFree(pNewTransMsg);
    ImmUnlockIMCC(pIC->hMsgBuf);
    pIC->dwNumMsgBuf = 0; /* Processed */
    ImmUnlockIMC(hIMC);
 
    return TRUE;
}

CtfImmHideToolbarWnd()

DWORD WINAPI CtfImmHideToolbarWnd

(

VOID

)

Definition at line 1363 of file ctf.c.

{
    ITfLangBarMgr *pBarMgr;
    DWORD dwShowFlags = 0;
    BOOL bShown;
 
    TRACE("()\n");
 
    if (FAILED(Imm32TF_CreateLangBarMgr(&pBarMgr)))
        return dwShowFlags;
 
    if (SUCCEEDED(pBarMgr->lpVtbl->GetShowFloatingStatus(pBarMgr, &dwShowFlags)))
    {
        bShown = !(dwShowFlags & 0x800);
        dwShowFlags &= 0xF;
        if (bShown)
            pBarMgr->lpVtbl->ShowFloating(pBarMgr, 8);
    }
 
    pBarMgr->lpVtbl->Release(pBarMgr);
    return dwShowFlags;
}

Referenced by ImeWnd_OnImeControl().

CtfImmIsCiceroEnabled()

BOOL WINAPI CtfImmIsCiceroEnabled

(

VOID

)

Definition at line 1068 of file ctf.c.

{
    return IS_CICERO_MODE();
}

CtfImmIsCiceroStartedInThread()

BOOL WINAPI CtfImmIsCiceroStartedInThread

(

VOID

)

Definition at line 781 of file ctf.c.

{
    TRACE("()\n");
    return !!(GetWin32ClientInfo()->CI_flags & CI_CICERO_STARTED);
}

Referenced by CtfImeProcessCicHotkey(), and ImmProcessKey().

CtfImmIsGuidMapEnable()

BOOL WINAPI CtfImmIsGuidMapEnable

(

_In_ HIMC

hIMC

)

Definition at line 1435 of file ctf.c.

{
    DWORD dwThreadId;
    HKL hKL;
    PIMEDPI pImeDpi;
    BOOL ret = FALSE;
 
    TRACE("(%p)\n", hIMC);
 
    if (!IS_CICERO_MODE() || IS_16BIT_MODE())
        return ret;
 
    dwThreadId = (DWORD)NtUserQueryInputContext(hIMC, QIC_INPUTTHREADID);
    hKL = GetKeyboardLayout(dwThreadId);
 
    if (IS_IME_HKL(hKL))
        return ret;
 
    pImeDpi = Imm32FindOrLoadImeDpi(hKL);
    if (IS_NULL_UNEXPECTEDLY(pImeDpi))
        return ret;
 
    ret = pImeDpi->CtfImeIsGuidMapEnable(hIMC);
 
    ImmUnlockImeDpi(pImeDpi);
    return ret;
}

Referenced by CS_DoPrivate().

CtfImmIsTextFrameServiceDisabled()

BOOL WINAPI CtfImmIsTextFrameServiceDisabled

(

VOID

)

Definition at line 1079 of file ctf.c.

{
    return !!(GetWin32ClientInfo()->CI_flags & CI_TSFDISABLED);
}

Referenced by Imm32SelectInputContext(), and ImmGetImeInfoEx().

CtfImmLastEnabledWndDestroy()

HRESULT WINAPI CtfImmLastEnabledWndDestroy

(

_In_ BOOL

bCreate

)

Definition at line 996 of file ctf.c.

{
    TRACE("(%d)\n", bCreate);
    return Imm32ActivateOrDeactivateTIM(bCreate);
}

CtfImmLeaveCoInitCountSkipMode()

BOOL WINAPI CtfImmLeaveCoInitCountSkipMode

(

VOID

)

Definition at line 395 of file ctf.c.

{
    IMMTLSDATA *pData;
 
    TRACE("()\n");
 
    pData = Imm32GetTLS();
    if (!pData || !pData->bDoCount)
        return FALSE;
 
    --(pData->bDoCount);
    return TRUE;
}

CtfImmRestoreToolbarWnd()

VOID WINAPI CtfImmRestoreToolbarWnd	(	_In_ LPVOID	pUnused,
		_In_ DWORD	dwShowFlags
	)

Definition at line 1392 of file ctf.c.

{
    HRESULT hr;
    ITfLangBarMgr *pBarMgr;
 
    UNREFERENCED_PARAMETER(pUnused);
 
    TRACE("(%p, 0x%X)\n", pUnused, dwShowFlags);
 
    hr = Imm32TF_CreateLangBarMgr(&pBarMgr);
    if (FAILED_UNEXPECTEDLY(hr))
        return;
 
    if (dwShowFlags)
        pBarMgr->lpVtbl->ShowFloating(pBarMgr, dwShowFlags);
 
    pBarMgr->lpVtbl->Release(pBarMgr);
}

Referenced by ImeWnd_OnImeControl().

CtfImmSetAppCompatFlags()

VOID WINAPI CtfImmSetAppCompatFlags

(

_In_ DWORD

dwFlags

)

Definition at line 805 of file ctf.c.

{
    TRACE("(0x%08X)\n", dwFlags);
    if (!(dwFlags & 0xF0FFFFFF))
        g_aimm_compat_flags = dwFlags;
}

CtfImmSetCiceroStartInThread()

VOID WINAPI CtfImmSetCiceroStartInThread

(

_In_ BOOL

bStarted

)

Definition at line 790 of file ctf.c.

{
    TRACE("(%d)\n", bStarted);
    if (bStarted)
        GetWin32ClientInfo()->CI_flags |= CI_CICERO_STARTED;
    else
        GetWin32ClientInfo()->CI_flags &= ~CI_CICERO_STARTED;
}

CtfImmTIMActivate()

HRESULT WINAPI CtfImmTIMActivate

(

_In_ HKL

hKL

)

Definition at line 1123 of file ctf.c.

{
    HRESULT hr = S_OK;
 
    TRACE("(%p)\n", hKL);
 
    if (g_disable_CUAS_flag)
    {
        TRACE("g_disable_CUAS_flag\n");
        GetWin32ClientInfo()->CI_flags |= CI_TSFDISABLED;
        return S_OK;
    }
 
    if (GetWin32ClientInfo()->CI_flags & CI_TSFDISABLED)
    {
        TRACE("CI_TSFDISABLED\n");
        return S_OK;
    }
 
    if (Imm32IsTIMDisabledInRegistry())
    {
        TRACE("TIM is disabled in registry\n");
        GetWin32ClientInfo()->CI_flags |= CI_TSFDISABLED;
        return S_OK;
    }
 
    if (!Imm32IsInteractiveUserLogon() || Imm32IsRunningInMsoobe())
    {
        TRACE("TIM is disabled due to LOGON or MSOBE\n");
        return S_OK;
    }
 
    if (!Imm32IsCUASEnabledInRegistry())
    {
        TRACE("CUAS is disabled in registry\n");
        GetWin32ClientInfo()->CI_flags |= CI_TSFDISABLED;
        return S_OK;
    }
 
    if (NtCurrentTeb()->ProcessEnvironmentBlock->AppCompatFlags.LowPart & 0x100)
    {
        TRACE("CUAS is disabled by AppCompatFlags\n");
        GetWin32ClientInfo()->CI_flags |= CI_TSFDISABLED;
        return S_OK;
    }
 
    if (RtlIsThreadWithinLoaderCallout() || Imm32InsideLoaderLock())
    {
        TRACE("TIM is disabled by Loader\n");
        return S_OK;
    }
 
    if (!IS_CICERO_MODE() || IS_16BIT_MODE())
    {
        TRACE("TIM is disabled because CICERO mode is unset\n");
        return S_OK;
    }
 
    if (IS_IME_HKL(hKL))
        hKL = UlongToHandle(MAKELONG(LOWORD(hKL), LOWORD(hKL)));
 
    if (!ImmLoadIME(hKL))
        Imm32TF_InvalidAssemblyListCacheIfExist();
 
    CtfImmCoInitialize();
 
    if ((GetWin32ClientInfo()->CI_flags & CI_CTFCOINIT) &&
        !(GetWin32ClientInfo()->CI_flags & CI_CTFTIM))
    {
        hr = CtfImeCreateThreadMgr();
        if (SUCCEEDED(hr))
            GetWin32ClientInfo()->CI_flags |= CI_CTFTIM;
    }
 
    return hr;
}

Referenced by CtfLoadThreadLayout(), and Imm32InternalLockIMC().

GetKeyboardLayoutCP()

UINT WINAPI GetKeyboardLayoutCP

(

_In_ LANGID

wLangId

)

Definition at line 1297 of file imm.c.

{
    WCHAR szText[8];
    static LANGID s_wKeyboardLangIdCache = 0;
    static UINT s_uKeyboardLayoutCPCache = 0;
 
    TRACE("(%u)\n", wLangId);
 
    if (wLangId == s_wKeyboardLangIdCache)
        return s_uKeyboardLayoutCPCache;
 
    if (!GetLocaleInfoW(wLangId, LOCALE_IDEFAULTANSICODEPAGE, szText, _countof(szText)))
        return 0;
 
    s_wKeyboardLangIdCache = wLangId;
    szText[_countof(szText) - 1] = UNICODE_NULL; /* Avoid buffer overrun */
    s_uKeyboardLayoutCPCache = wcstol(szText, NULL, 10);
    return s_uKeyboardLayoutCPCache;
}

ImmActivateLayout()

BOOL WINAPI ImmActivateLayout

(

_In_ HKL

hKL

)

Definition at line 450 of file imm.c.

{
    PIMEDPI pImeDpi;
    HKL hOldKL;
    LPARAM lParam;
    HWND hwndDefIME = NULL;
    SELECT_LAYOUT SelectLayout;
 
    hOldKL = GetKeyboardLayout(0);
 
    if (hOldKL == hKL && !(GetWin32ClientInfo()->CI_flags & CI_IMMACTIVATE))
        return TRUE;
 
    ImmLoadIME(hKL);
 
    if (hOldKL != hKL)
    {
        pImeDpi = ImmLockImeDpi(hOldKL);
        if (pImeDpi)
        {
            if (pImeDpi->ImeInfo.fdwProperty & IME_PROP_COMPLETE_ON_UNSELECT)
                lParam = CPS_COMPLETE;
            else
                lParam = CPS_CANCEL;
            ImmUnlockImeDpi(pImeDpi);
 
            ImmEnumInputContext(0, Imm32NotifyIMEProc, lParam);
        }
 
        hwndDefIME = ImmGetDefaultIMEWnd(NULL);
        if (IsWindow(hwndDefIME))
            SendMessageW(hwndDefIME, WM_IME_SELECT, FALSE, (LPARAM)hOldKL);
 
        NtUserSetThreadLayoutHandles(hKL, hOldKL);
    }
 
    SelectLayout.hNewKL = hKL;
    SelectLayout.hOldKL = hOldKL;
    ImmEnumInputContext(0, Imm32SelectContextProc, (LPARAM)&SelectLayout);
 
    if (IsWindow(hwndDefIME))
        SendMessageW(hwndDefIME, WM_IME_SELECT, TRUE, (LPARAM)hKL);
 
    return TRUE;
}

Referenced by ImeWnd_OnImeSystem().

ImmCallImeConsoleIME()

DWORD WINAPI ImmCallImeConsoleIME	(	_In_ HWND	hWnd,
		_In_ UINT	uMsg,
		_In_ WPARAM	wParam,
		_In_ LPARAM	lParam,
		_Out_ LPUINT	puVK
	)

Definition at line 1179 of file keymsg.c.

{
    DWORD dwThreadId, ret = 0;
    HKL hKL;
    PWND pWnd = NULL;
    HIMC hIMC;
    PIMEDPI pImeDpi;
    UINT uVK;
    PIMC pIMC;
 
    switch (uMsg)
    {
        case WM_KEYDOWN:
        case WM_KEYUP:
        case WM_SYSKEYDOWN:
        case WM_SYSKEYUP:
            break;
 
        default:
            return 0;
    }
 
    dwThreadId = GetWindowThreadProcessId(hWnd, NULL);
    hKL = GetKeyboardLayout(dwThreadId);
 
    if (hWnd && gpsi)
        pWnd = ValidateHwndNoErr(hWnd);
    if (IS_NULL_UNEXPECTEDLY(pWnd))
        return 0;
 
    hIMC = ImmGetContext(hWnd);
    if (IS_NULL_UNEXPECTEDLY(hIMC))
        return 0;
 
    uVK = *puVK = (wParam & 0xFF);
 
    pIMC = ValidateHandleNoErr(hIMC, TYPE_INPUTCONTEXT);
    if (IS_NULL_UNEXPECTEDLY(pIMC))
        return 0;
 
    pImeDpi = ImmLockImeDpi(hKL);
    if (IS_NULL_UNEXPECTEDLY(pImeDpi))
        return 0;
 
    if ((lParam & MAKELPARAM(0, KF_UP)) && (pImeDpi->ImeInfo.fdwProperty & IME_PROP_IGNORE_UPKEYS))
        goto Quit;
 
    switch (uVK)
    {
        case VK_DBE_ROMAN:
        case VK_DBE_NOROMAN:
        case VK_DBE_HIRAGANA:
        case VK_DBE_KATAKANA:
        case VK_DBE_CODEINPUT:
        case VK_DBE_NOCODEINPUT:
        case VK_DBE_ENTERWORDREGISTERMODE:
        case VK_DBE_ENTERIMECONFIGMODE:
            break;
 
        default:
        {
            if (uMsg == WM_SYSKEYDOWN || uMsg == WM_SYSKEYUP)
            {
                if (uVK != VK_MENU && uVK != VK_F10)
                    goto Quit;
            }
 
            if (!(pImeDpi->ImeInfo.fdwProperty & IME_PROP_NEED_ALTKEY))
            {
                if (uVK == VK_MENU || (lParam & MAKELPARAM(0, KF_ALTDOWN)))
                    goto Quit;
            }
        }
    }
 
    ret = ImmProcessKey(hWnd, hKL, uVK, lParam, INVALID_HOTKEY_ID);
 
Quit:
    ImmUnlockImeDpi(pImeDpi);
    return ret;
}

Referenced by ConIme_OnRoute().

ImmFreeLayout()

BOOL WINAPI ImmFreeLayout

(

_In_ HKL

hKL

)

Definition at line 124 of file imm.c.

{
    WCHAR szKBD[KL_NAMELENGTH];
    UINT iKL, cKLs;
    HKL hOldKL, *pList;
    PIMEDPI pImeDpi;
    LANGID LangID;
 
    TRACE("(%p)\n", hKL);
 
    hOldKL = GetKeyboardLayout(0);
 
    if (hKL == HKL_SWITCH_TO_NON_IME)
    {
        if (!IS_IME_HKL(hOldKL))
            return TRUE;
 
        LangID = LANGIDFROMLCID(GetSystemDefaultLCID());
 
        cKLs = GetKeyboardLayoutList(0, NULL);
        if (cKLs)
        {
            pList = ImmLocalAlloc(0, cKLs * sizeof(HKL));
            if (IS_NULL_UNEXPECTEDLY(pList))
                return FALSE;
 
            cKLs = GetKeyboardLayoutList(cKLs, pList);
            for (iKL = 0; iKL < cKLs; ++iKL)
            {
                if (!IS_IME_HKL(pList[iKL]))
                {
                    LangID = LOWORD(pList[iKL]);
                    break;
                }
            }
 
            ImmLocalFree(pList);
        }
 
        StringCchPrintfW(szKBD, _countof(szKBD), L"%08X", LangID);
        if (!LoadKeyboardLayoutW(szKBD, KLF_ACTIVATE))
        {
            WARN("Default to English US\n");
            LoadKeyboardLayoutW(L"00000409", KLF_ACTIVATE | 0x200);
        }
    }
    else if (hKL == HKL_RELEASE_IME)
    {
        RtlEnterCriticalSection(&gcsImeDpi);
Retry:
        for (pImeDpi = gpImeDpiList; pImeDpi; pImeDpi = pImeDpi->pNext)
        {
            if (Imm32ReleaseIME(pImeDpi->hKL))
                goto Retry;
        }
        RtlLeaveCriticalSection(&gcsImeDpi);
    }
    else
    {
        if (IS_IME_HKL(hKL) && hKL != hOldKL)
            Imm32ReleaseIME(hKL);
    }
 
    return TRUE;
}

Referenced by ImeWnd_OnImeSystem().

ImmGetAppCompatFlags()

DWORD WINAPI ImmGetAppCompatFlags

(

_In_ HIMC

hIMC

)

Definition at line 722 of file keymsg.c.

{
    TRACE("(%p)\n", hIMC);
 
    PCLIENTIMC pClientIMC = ImmLockClientImc(hIMC);
    if (IS_NULL_UNEXPECTEDLY(pClientIMC))
        return 0;
 
    DWORD dwCompatFlags = pClientIMC->dwCompatFlags;
    ImmUnlockClientImc(pClientIMC);
    return (dwCompatFlags | g_aimm_compat_flags);
}

Referenced by ImmProcessKey().

ImmGetHotKey()

BOOL WINAPI ImmGetHotKey	(	_In_ DWORD	dwHotKey,
		_Out_ LPUINT	lpuModifiers,
		_Out_ LPUINT	lpuVKey,
		_Out_opt_ LPHKL	lphKL
	)

Definition at line 648 of file keymsg.c.

{
    TRACE("(0x%lX, %p, %p, %p)\n", dwHotKey, lpuModifiers, lpuVKey, lphKL);
    if (lpuModifiers && lpuVKey)
        return NtUserGetImeHotKey(dwHotKey, lpuModifiers, lpuVKey, lphKL);
    return FALSE;
}

ImmGetImeInfoEx()

BOOL WINAPI ImmGetImeInfoEx	(	_Out_ PIMEINFOEX	pImeInfoEx,
		_In_ IMEINFOEXCLASS	SearchType,
		_In_ PVOID	pvSearchKey
	)

Referenced by Imm32IMPGetIME(), ImmIMPQueryIMEW(), ImmIMPSetIMEW(), ImmInstallIMEW(), and User32CreateImeUIWindow().

ImmIMPGetIMEA()

BOOL WINAPI ImmIMPGetIMEA	(	_In_opt_ HWND	hWnd,
		_Out_ LPIMEPROA	pImePro
	)

Definition at line 68 of file imepro.c.

{
    UNREFERENCED_PARAMETER(hWnd);
 
    TRACE("(%p, %p)\n", hWnd, pImePro);
 
    ASSERT(pImePro);
 
    if (!Imm32IsSystemJapaneseOrKorean())
    {
        SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
        return FALSE;
    }
 
    IMEPROW ImeProW;
    HKL hKL = GetKeyboardLayout(0);
    if (!Imm32IMPGetIME(hKL, &ImeProW))
        return FALSE;
 
    Imm32ConvertImeProWideToAnsi(&ImeProW, pImePro);
    return TRUE;
}

Referenced by IMPGetIMEA().

ImmIMPGetIMEW()

BOOL WINAPI ImmIMPGetIMEW	(	_In_opt_ HWND	hWnd,
		_Out_ LPIMEPROW	pImePro
	)

Definition at line 97 of file imepro.c.

{
    UNREFERENCED_PARAMETER(hWnd);
 
    TRACE("(%p, %p)\n", hWnd, pImePro);
 
    ASSERT(pImePro);
 
    if (!Imm32IsSystemJapaneseOrKorean())
    {
        SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
        return FALSE;
    }
 
    HKL hKL = GetKeyboardLayout(0);
    return Imm32IMPGetIME(hKL, pImePro);
}

Referenced by IMPGetIMEW().

ImmIMPQueryIMEA()

BOOL WINAPI ImmIMPQueryIMEA

(

_Inout_ LPIMEPROA

pImePro

)

Definition at line 121 of file imepro.c.

{
    TRACE("(%p)\n", pImePro);
 
    ASSERT(pImePro);
 
    if (!Imm32IsSystemJapaneseOrKorean())
    {
        SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
        return FALSE;
    }
 
    IMEPROW ProW;
    if (pImePro->szName[0])
    {
        /* pImePro->szName is BYTE[], so we need type cast */
        if (!MultiByteToWideChar(CP_ACP, MB_PRECOMPOSED, (PSTR)pImePro->szName, -1,
                                 ProW.szName, _countof(ProW.szName)))
        {
            ERR("szName: %s\n", debugstr_a((PSTR)pImePro->szName));
            return FALSE;
        }
        ProW.szName[_countof(ProW.szName) - 1] = UNICODE_NULL; /* Avoid buffer overrun */
    }
    else
    {
        ProW.szName[0] = UNICODE_NULL;
    }
 
    if (!ImmIMPQueryIMEW(&ProW))
        return FALSE;
 
    Imm32ConvertImeProWideToAnsi(&ProW, pImePro);
    return TRUE;
}

Referenced by IMPQueryIMEA().

ImmIMPQueryIMEW()

BOOL WINAPI ImmIMPQueryIMEW

(

_Inout_ LPIMEPROW

pImePro

)

Definition at line 161 of file imepro.c.

{
    TRACE("(%p)\n", pImePro);
 
    ASSERT(pImePro);
 
    if (!Imm32IsSystemJapaneseOrKorean())
    {
        SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
        return FALSE;
    }
 
    INT nLayouts = GetKeyboardLayoutList(0, NULL);
    if (nLayouts <= 0)
    {
        ERR("nLayouts: %d\n", nLayouts);
        return FALSE;
    }
 
    HKL *phKLs = ImmLocalAlloc(0, nLayouts * sizeof(HKL));
    if (!phKLs)
    {
        ERR("Out of memory\n");
        return FALSE;
    }
 
    if (GetKeyboardLayoutList(nLayouts, phKLs) != nLayouts)
    {
        ERR("KL count mismatch\n");
        ImmLocalFree(phKLs);
        return FALSE;
    }
 
    BOOL result = FALSE;
    if (pImePro->szName[0])
    {
        IMEINFOEX ImeInfoEx;
        if (ImmGetImeInfoEx(&ImeInfoEx, ImeInfoExImeFileName, pImePro->szName))
        {
            for (INT iKL = 0; iKL < nLayouts; ++iKL)
            {
                if (phKLs[iKL] == ImeInfoEx.hkl)
                {
                    result = Imm32IMPGetIME(phKLs[iKL], pImePro);
                    break;
                }
            }
        }
    }
    else
    {
        for (INT iKL = 0; iKL < nLayouts; ++iKL)
        {
            result = Imm32IMPGetIME(phKLs[iKL], pImePro);
            if (result)
                break;
        }
    }
 
    ImmLocalFree(phKLs);
    return result;
}

Referenced by ImmIMPQueryIMEA(), and IMPQueryIMEW().

ImmIMPSetIMEA()

BOOL WINAPI ImmIMPSetIMEA	(	_In_opt_ HWND	hWnd,
		_Inout_ LPIMEPROA	pImePro
	)

Definition at line 228 of file imepro.c.

{
    TRACE("(%p, %p)\n", hWnd, pImePro);
 
    ASSERT(pImePro);
 
    IMEPROW ProW;
    if (!Imm32IsSystemJapaneseOrKorean())
    {
        SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
        return FALSE;
    }
 
    if (pImePro->szName[0])
    {
        /* pImePro->szName is BYTE[], so we need type cast */
        if (!MultiByteToWideChar(CP_ACP, MB_PRECOMPOSED, (PSTR)pImePro->szName, -1,
                                 ProW.szName, _countof(ProW.szName)))
        {
            ERR("szName: %s\n", debugstr_a((PSTR)pImePro->szName));
            return FALSE;
        }
        ProW.szName[_countof(ProW.szName) - 1] = UNICODE_NULL; /* Avoid buffer overrun */
    }
    else
    {
        ProW.szName[0] = UNICODE_NULL;
    }
 
    return ImmIMPSetIMEW(hWnd, &ProW);
}

Referenced by IMPSetIMEA().

ImmIMPSetIMEW()

BOOL WINAPI ImmIMPSetIMEW	(	_In_opt_ HWND	hWnd,
		_Inout_ LPIMEPROW	pImePro
	)

Definition at line 266 of file imepro.c.

{
    UNREFERENCED_PARAMETER(hWnd);
 
    TRACE("(%p, %p)\n", hWnd, pImePro);
 
    ASSERT(pImePro);
 
    if (!Imm32IsSystemJapaneseOrKorean())
    {
        SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
        return FALSE;
    }
 
    HKL hTargetKL = NULL;
    if (pImePro->szName[0])
    {
        IMEINFOEX ImeInfoEx;
        if (!ImmGetImeInfoEx(&ImeInfoEx, ImeInfoExImeFileName, pImePro->szName))
            return FALSE;
 
        hTargetKL = ImeInfoEx.hkl;
    }
    else
    {
        INT nLayouts = GetKeyboardLayoutList(0, NULL);
        if (nLayouts <= 0)
        {
            ERR("nLayouts: %d\n", nLayouts);
            return FALSE;
        }
 
        HKL *phKLs = ImmLocalAlloc(0, nLayouts * sizeof(HKL));
        if (!phKLs)
        {
            ERR("Out of memory\n");
            return FALSE;
        }
 
        if (GetKeyboardLayoutList(nLayouts, phKLs) == nLayouts)
        {
            for (INT iKL = 0; iKL < nLayouts; ++iKL)
            {
                if (!ImmIsIME(phKLs[iKL]))
                {
                    hTargetKL = phKLs[iKL];
                    break;
                }
            }
        }
        else
        {
            ERR("KL count mismatch\n");
        }
 
        ImmLocalFree(phKLs);
    }
 
    if (hTargetKL && GetKeyboardLayout(0) != hTargetKL)
    {
        HWND hwndFocus = GetFocus();
        if (hwndFocus)
        {
            PostMessageW(hwndFocus, WM_INPUTLANGCHANGEREQUEST, INPUTLANGCHANGE_SYSCHARSET,
                         (LPARAM)hTargetKL);
            return TRUE;
        }
    }
 
    return FALSE;
}

Referenced by ImmIMPSetIMEA(), and IMPSetIMEW().

ImmLoadIME()

BOOL WINAPI ImmLoadIME

(

_In_ HKL

hKL

)

Definition at line 612 of file ime.c.

{
    PIMEDPI pImeDpi;
 
    if (!IS_IME_HKL(hKL) && (!IS_CICERO_MODE() || IS_16BIT_MODE()))
    {
        TRACE("\n");
        return FALSE;
    }
 
    pImeDpi = Imm32FindImeDpi(hKL);
    if (pImeDpi == NULL)
        pImeDpi = Imm32LoadImeDpi(hKL, FALSE);
    return (pImeDpi != NULL);
}

Referenced by CtfImmTIMActivate(), CtfLoadThreadLayout(), and ImmActivateLayout().

ImmLoadLayout()

BOOL WINAPI ImmLoadLayout	(	_In_ HKL	hKL,
		_Inout_ PIMEINFOEX	pImeInfoEx
	)

Definition at line 71 of file imm.c.

{
    DWORD cbData, dwType;
    HKEY hKey;
    LSTATUS error;
    WCHAR szLayout[MAX_PATH];
    LPCWSTR pszSubKey;
 
    TRACE("(%p, %p)\n", hKL, pImeInfoEx);
 
    /* Choose a key */
    if (IS_IME_HKL(hKL) || !IS_CICERO_MODE() || IS_16BIT_MODE()) /* Non-Cicero? */
    {
        StringCchPrintfW(szLayout, _countof(szLayout), L"%s\\%08lX",
                         REGKEY_KEYBOARD_LAYOUTS, HandleToUlong(hKL));
        pszSubKey = szLayout;
    }
    else /* Cicero */
    {
        pszSubKey = L"Software\\Microsoft\\Windows NT\\CurrentVersion\\IMM";
    }
 
    /* Open the key */
    error = RegOpenKeyExW(HKEY_LOCAL_MACHINE, pszSubKey, 0, KEY_READ, &hKey);
    if (IS_ERROR_UNEXPECTEDLY(error))
        return FALSE;
 
    /* Load "IME File" value */
    cbData = sizeof(pImeInfoEx->wszImeFile);
    error = RegQueryValueExW(hKey, L"IME File", NULL, &dwType,
                             (LPBYTE)pImeInfoEx->wszImeFile, &cbData);
 
    /* Avoid buffer overrun */
    pImeInfoEx->wszImeFile[_countof(pImeInfoEx->wszImeFile) - 1] = UNICODE_NULL;
 
    RegCloseKey(hKey);
 
    if (error != ERROR_SUCCESS || dwType != REG_SZ)
        return FALSE; /* Failed */
 
    pImeInfoEx->hkl = hKL;
    pImeInfoEx->fLoadFlag = 0;
    return Imm32LoadImeVerInfo(pImeInfoEx);
}

Referenced by Imm32LoadCtfIme(), and User32CallImmLoadLayoutFromKernel().

ImmLockClientImc()

PCLIENTIMC WINAPI ImmLockClientImc

(

_In_ HIMC

hImc

)

Definition at line 955 of file imm.c.

{
    PIMC pIMC;
    PCLIENTIMC pClientImc;
 
    TRACE("(%p)\n", hImc);
 
    if (IS_NULL_UNEXPECTEDLY(hImc))
        return NULL;
 
    pIMC = ValidateHandle(hImc, TYPE_INPUTCONTEXT);
    if (!pIMC || !Imm32CheckImcProcess(pIMC))
        return NULL;
 
    pClientImc = (PCLIENTIMC)pIMC->dwClientImcData;
    if (pClientImc)
    {
        if (pClientImc->dwFlags & CLIENTIMC_DESTROY)
            return NULL;
        goto Finish;
    }
 
    pClientImc = ImmLocalAlloc(HEAP_ZERO_MEMORY, sizeof(CLIENTIMC));
    if (IS_NULL_UNEXPECTEDLY(pClientImc))
        return NULL;
 
    RtlInitializeCriticalSection(&pClientImc->cs);
    pClientImc->dwCompatFlags = (DWORD)NtUserGetThreadState(THREADSTATE_IMECOMPATFLAGS);
 
    if (!NtUserUpdateInputContext(hImc, UIC_CLIENTIMCDATA, (DWORD_PTR)pClientImc))
    {
        ERR("\n");
        ImmLocalFree(pClientImc);
        return NULL;
    }
 
    pClientImc->dwFlags |= CLIENTIMC_LOCKED;
 
Finish:
    InterlockedIncrement(&pClientImc->cLockObj);
    return pClientImc;
}

Referenced by CtfImmGenerateMessage(), CtfImmTIMCreateInputContext(), Imm32InternalLockIMC(), Imm32IsImcAnsi(), Imm32ProcessRequest(), Imm32SelectInputContext(), ImmGenerateMessage(), ImmGetAppCompatFlags(), ImmGetCandidateListAW(), ImmGetCandidateListCountAW(), ImmGetCompositionFontA(), ImmGetCompositionFontW(), ImmGetCompositionStringA(), ImmGetCompositionStringW(), ImmGetGuideLineAW(), ImmGetIMCLockCount(), ImmGetSaveContext(), ImmPostMessages(), ImmSetActiveContext(), ImmSetCompositionFontA(), ImmSetCompositionFontW(), ImmUnlockIMC(), and ImmWINNLSEnableIME().

ImmLockImeDpi()

PIMEDPI WINAPI ImmLockImeDpi

(

_In_ HKL

hKL

)

Definition at line 532 of file ime.c.

{
    PIMEDPI pImeDpi = NULL;
 
    TRACE("(%p)\n", hKL);
 
    RtlEnterCriticalSection(&gcsImeDpi);
 
    /* Find by hKL */
    for (pImeDpi = gpImeDpiList; pImeDpi; pImeDpi = pImeDpi->pNext)
    {
        if (pImeDpi->hKL == hKL) /* found */
        {
            /* lock if possible */
            if (pImeDpi->dwFlags & IMEDPI_FLAG_UNLOADED)
                pImeDpi = NULL;
            else
                ++(pImeDpi->cLockObj);
            break;
        }
    }
 
    RtlLeaveCriticalSection(&gcsImeDpi);
    return pImeDpi;
}

Referenced by Imm32CreateInputContext(), Imm32DestroyInputContext(), Imm32FindOrLoadImeDpi(), Imm32MakeIMENotify(), Imm32ProcessHotKey(), Imm32SelectInputContext(), ImmActivateLayout(), ImmCallImeConsoleIME(), ImmCreateSoftKeyboard(), ImmGetImeMenuItemsAW(), ImmNotifyIME(), ImmProcessKey(), ImmSetActiveContext(), ImmSetCompositionStringAW(), ImmTranslateMessage(), and User32CreateImeUIWindow().

ImmProcessKey()

DWORD WINAPI ImmProcessKey	(	_In_	HWND,
		_In_	HKL,
		_In_	UINT,
		_In_	LPARAM,
		_In_	DWORD
	)

Definition at line 740 of file keymsg.c.

{
    DWORD ret = 0;
    HIMC hIMC;
    PIMEDPI pImeDpi;
    LPINPUTCONTEXTDX pIC;
    BYTE KeyState[256];
    BOOL bLowWordOnly = FALSE, bSkipThisKey = FALSE, bHotKeyDone = TRUE;
 
    TRACE("(%p, %p, 0x%X, %p, 0x%lX)\n", hWnd, hKL, vKey, lParam, dwHotKeyID);
 
    /* Process the key by the IME */
    hIMC = ImmGetContext(hWnd);
    pImeDpi = ImmLockImeDpi(hKL);
    if (pImeDpi)
    {
        pIC = (LPINPUTCONTEXTDX)ImmLockIMC(hIMC);
        if (pIC)
        {
            if ((LOBYTE(vKey) == VK_PACKET) &&
                !(pImeDpi->ImeInfo.fdwProperty & IME_PROP_ACCEPT_WIDE_VKEY))
            {
                if (ImeDpi_IsUnicode(pImeDpi))
                {
                    bLowWordOnly = TRUE;
                }
                else
                {
                    if (pIC->fOpen)
                        ret |= IPHK_SKIPTHISKEY;
 
                    bSkipThisKey = TRUE;
                }
            }
 
            if (!bSkipThisKey && GetKeyboardState(KeyState))
            {
                UINT vk = (bLowWordOnly ? LOWORD(vKey) : vKey);
                if (pImeDpi->ImeProcessKey(hIMC, vk, lParam, KeyState))
                {
                    pIC->bNeedsTrans = TRUE;
                    pIC->nVKey = vKey;
                    ret |= IPHK_PROCESSBYIME;
                }
            }
 
            ImmUnlockIMC(hIMC);
        }
 
        ImmUnlockImeDpi(pImeDpi);
    }
 
    /* Process the hot-key if necessary */
    if (!CtfImmIsCiceroStartedInThread()) /* Not Cicero? */
    {
        /* Process IMM IME hotkey */
        if ((dwHotKeyID == INVALID_HOTKEY_ID) || !Imm32ProcessHotKey(hWnd, hIMC, hKL, dwHotKeyID))
            bHotKeyDone = FALSE;
    }
    else if (!CtfImeProcessCicHotkey(hIMC, vKey, lParam)) /* CTF IME not processed the hotkey? */
    {
        /* Process IMM IME hotkey */
        if (!IS_IME_HKL(hKL) ||
            ((dwHotKeyID == INVALID_HOTKEY_ID) || !Imm32ProcessHotKey(hWnd, hIMC, hKL, dwHotKeyID)))
        {
            bHotKeyDone = FALSE;
        }
    }
 
    if (bHotKeyDone && ((vKey != VK_KANJI) || (dwHotKeyID != IME_JHOTKEY_CLOSE_OPEN)))
        ret |= IPHK_HOTKEY;
 
    if ((ret & IPHK_PROCESSBYIME) && (ImmGetAppCompatFlags(hIMC) & _IME_APP_COMPAT_PROCESS_BY_IME))
    {
        /* The key has been processed by IME's ImeProcessKey */
        LANGID wLangID = LANGIDFROMLCID(GetSystemDefaultLCID());
        if ((PRIMARYLANGID(wLangID) == LANG_KOREAN) &&
            ((vKey == VK_PROCESSKEY) || (ret & IPHK_HOTKEY)))
        {
            /* Korean don't want VK_PROCESSKEY and IME hot-keys */
        }
        else
        {
            /* Add WM_KEYDOWN:VK_PROCESSKEY message */
            ImmTranslateMessage(hWnd, WM_KEYDOWN, VK_PROCESSKEY, lParam);
 
            ret &= ~IPHK_PROCESSBYIME;
            ret |= IPHK_SKIPTHISKEY;
        }
    }
 
    ImmReleaseContext(hWnd, hIMC);
    return ret; /* Returns IPHK_... flags */
}

Referenced by ImmCallImeConsoleIME(), and User32CallImmProcessKeyFromKernel().

ImmPutImeMenuItemsIntoMappedFile()

BOOL WINAPI ImmPutImeMenuItemsIntoMappedFile

(

_In_ HIMC

hIMC

)

Definition at line 731 of file imemenu.c.

{
    /* Open the existing file mapping */
    HANDLE hMapping = OpenFileMappingW(FILE_MAP_ALL_ACCESS, FALSE, IMEMENUINFO_MAPPING_NAME);
    if (!hMapping)
    {
        ERR("OpenFileMappingW failed\n");
        return FALSE;
    }
 
    PIMEMENUINFO pView = MapViewOfFile(hMapping, FILE_MAP_ALL_ACCESS, 0, 0, 0);
    if (!pView)
    {
        ERR("MapViewOfFile failed\n");
        CloseHandle(hMapping);
        return FALSE;
    }
 
    BOOL ret = Imm32SerializeImeMenu(hIMC, pView);
    UnmapViewOfFile(pView);
    CloseHandle(hMapping);
    return ret;
}

Referenced by ImeWnd_OnImeSystem().

ImmSendIMEMessageExA()

LRESULT WINAPI ImmSendIMEMessageExA	(	_In_ HWND	hWnd,
		_In_ LPARAM	lParam
	)

Definition at line 1002 of file win3send.c.

{
#ifdef IMM_WIN3_SUPPORT
    return Imm32SendIMEMessageExAW(hWnd, (HGLOBAL)lParam, TRUE);
#else
    return 0;
#endif
}

Referenced by SendIMEMessageExA().

ImmSendIMEMessageExW()

LRESULT WINAPI ImmSendIMEMessageExW	(	_In_ HWND	hWnd,
		_In_ LPARAM	lParam
	)

Definition at line 1017 of file win3send.c.

{
#ifdef IMM_WIN3_SUPPORT
    return Imm32SendIMEMessageExAW(hWnd, (HGLOBAL)lParam, FALSE);
#else
    return 0;
#endif
}

Referenced by SendIMEMessageExW().

ImmSetActiveContext()

BOOL WINAPI ImmSetActiveContext	(	_In_ HWND	hwnd,
		_In_opt_ HIMC	hIMC,
		_In_ BOOL	fFlag
	)

Definition at line 1165 of file imm.c.

{
    PCLIENTIMC pClientImc;
    LPINPUTCONTEXTDX pIC;
    PIMEDPI pImeDpi;
    HIMC hOldIMC;
    HKL hKL;
    BOOL fOpen = FALSE;
    DWORD dwConversion = 0, dwShowFlags = ISC_SHOWUIALL;
    HWND hwndDefIME;
 
    TRACE("(%p, %p, %d)\n", hWnd, hIMC, fActive);
 
    if (!IS_IMM_MODE())
    {
        TRACE("\n");
        return FALSE;
    }
 
    pClientImc = ImmLockClientImc(hIMC);
 
    if (!fActive)
    {
        if (pClientImc)
            pClientImc->dwFlags &= ~CLIENTIMC_ACTIVE;
    }
    else if (hIMC)
    {
        if (IS_NULL_UNEXPECTEDLY(pClientImc))
            return FALSE;
 
        pIC = (LPINPUTCONTEXTDX)ImmLockIMC(hIMC);
        if (IS_NULL_UNEXPECTEDLY(pIC))
        {
            ImmUnlockClientImc(pClientImc);
            return FALSE;
        }
 
        pIC->hWnd = hWnd;
        pClientImc->dwFlags |= CLIENTIMC_ACTIVE;
 
        if (pIC->dwUIFlags & _IME_UI_HIDDEN)
            dwShowFlags = (ISC_SHOWUIGUIDELINE | ISC_SHOWUIALLCANDIDATEWINDOW);
 
        fOpen = pIC->fOpen;
        dwConversion = pIC->fdwConversion;
 
        ImmUnlockIMC(hIMC);
    }
    else
    {
        hOldIMC = ImmGetSaveContext(hWnd, 1);
        pIC = (LPINPUTCONTEXTDX)ImmLockIMC(hOldIMC);
        if (pIC)
        {
            pIC->hWnd = hWnd;
            ImmUnlockIMC(hOldIMC);
        }
    }
 
    hKL = GetKeyboardLayout(0);
    if (IS_CICERO_MODE() && !IS_16BIT_MODE())
    {
        CtfImeSetActiveContextAlways(hIMC, fActive, hWnd, hKL);
        hKL = GetKeyboardLayout(0);
    }
 
    pImeDpi = ImmLockImeDpi(hKL);
    if (pImeDpi)
    {
        if (IS_IME_HKL(hKL))
            pImeDpi->ImeSetActiveContext(hIMC, fActive);
        ImmUnlockImeDpi(pImeDpi);
    }
 
    if (IsWindow(hWnd))
    {
        SendMessageW(hWnd, WM_IME_SETCONTEXT, fActive, dwShowFlags);
        if (fActive)
            NtUserNotifyIMEStatus(hWnd, fOpen, dwConversion);
    }
    else if (!fActive)
    {
        hwndDefIME = ImmGetDefaultIMEWnd(NULL);
        if (hwndDefIME)
            SendMessageW(hwndDefIME, WM_IME_SETCONTEXT, 0, dwShowFlags);
    }
 
    if (pClientImc)
        ImmUnlockClientImc(pClientImc);
 
    return TRUE;
}

Referenced by ImmAssociateContext(), ImmAssociateContextEx(), ImmSetActiveContextConsoleIME(), ImmWINNLSEnableIME(), and User32SetImeActivenessOfWindow().

ImmSetActiveContextConsoleIME()

BOOL WINAPI ImmSetActiveContextConsoleIME	(	_In_ HWND	hwnd,
		_In_ BOOL	fFlag
	)

Definition at line 1281 of file imm.c.

{
    HIMC hIMC;
    TRACE("(%p, %d)\n", hwnd, fFlag);
 
    hIMC = ImmGetContext(hwnd);
    if (IS_NULL_UNEXPECTEDLY(hIMC))
        return FALSE;
    return ImmSetActiveContext(hwnd, hIMC, fFlag);
}

Referenced by ConIme_OnDeactivate(), ConIme_OnSwitchIme(), and IntSetImeState().

ImmSetHotKey()

BOOL WINAPI ImmSetHotKey	(	_In_ DWORD	dwID,
		_In_ UINT	uModifiers,
		_In_ UINT	uVirtualKey,
		_In_opt_ _When_((dwAction==SETIMEHOTKEY_ADD) &&!(IME_HOTKEY_DSWITCH_FIRST<=dwHotKeyId &&dwHotKeyId<=IME_HOTKEY_DSWITCH_LAST), _Null_) HKL	hKL
	)

ImmSystemHandler()

LRESULT WINAPI ImmSystemHandler	(	_In_ HIMC	hIMC,
		_Inout_opt_ WPARAM	wParam,
		_Inout_opt_ LPARAM	lParam
	)

Definition at line 844 of file keymsg.c.

{
    TRACE("(%p, %p, %p)\n", hIMC, wParam, lParam);
 
    switch (wParam)
    {
        case IMS_SENDNOTIFICATION:
            Imm32SendNotification((BOOL)lParam);
            return 0;
 
        case IMS_COMPLETECOMPSTR:
            ImmNotifyIME(hIMC, NI_COMPOSITIONSTR, CPS_COMPLETE, 0);
            return 0;
 
        case IMS_SETLANGBAND:
        case IMS_UNSETLANGBAND:
            return CtfImmSetLangBand((HWND)lParam, (wParam == IMS_SETLANGBAND));
 
        default:
            WARN("%p\n", wParam);
            return 0;
    }
}

Referenced by ImeWnd_OnImeSystem().

ImmUnlockClientImc()

VOID WINAPI ImmUnlockClientImc

(

_Inout_ PCLIENTIMC

pClientImc

)

Definition at line 1002 of file imm.c.

{
    LONG cLocks;
    HANDLE hInputContext;
 
    TRACE("(%p)\n", pClientImc);
 
    cLocks = InterlockedDecrement(&pClientImc->cLockObj);
    if (cLocks != 0 || !(pClientImc->dwFlags & CLIENTIMC_DESTROY))
        return;
 
    hInputContext = pClientImc->hInputContext;
    if (hInputContext)
        LocalFree(hInputContext);
 
    RtlDeleteCriticalSection(&pClientImc->cs);
    ImmLocalFree(pClientImc);
}

Referenced by CtfImmGenerateMessage(), CtfImmTIMCreateInputContext(), Imm32DestroyInputContext(), Imm32InternalLockIMC(), Imm32IsImcAnsi(), Imm32ProcessRequest(), Imm32SelectInputContext(), ImmGenerateMessage(), ImmGetAppCompatFlags(), ImmGetCandidateListAW(), ImmGetCandidateListCountAW(), ImmGetCompositionFontA(), ImmGetCompositionFontW(), ImmGetCompositionStringA(), ImmGetCompositionStringW(), ImmGetGuideLineAW(), ImmGetIMCLockCount(), ImmGetSaveContext(), ImmPostMessages(), ImmSetActiveContext(), ImmSetCompositionFontA(), ImmSetCompositionFontW(), ImmUnlockIMC(), ImmWINNLSEnableIME(), and START_TEST().

ImmUnlockImeDpi()

VOID WINAPI ImmUnlockImeDpi

(

_Inout_opt_ PIMEDPI

pImeDpi

)

Definition at line 562 of file ime.c.

{
    PIMEDPI *ppEntry;
 
    TRACE("(%p)\n", pImeDpi);
 
    if (pImeDpi == NULL)
        return;
 
    RtlEnterCriticalSection(&gcsImeDpi);
 
    /* unlock */
    --(pImeDpi->cLockObj);
    if (pImeDpi->cLockObj != 0)
    {
        RtlLeaveCriticalSection(&gcsImeDpi);
        return;
    }
 
    if ((pImeDpi->dwFlags & IMEDPI_FLAG_UNLOADED) == 0)
    {
        if ((pImeDpi->dwFlags & IMEDPI_FLAG_LOCKED) == 0 ||
            (pImeDpi->ImeInfo.fdwProperty & IME_PROP_END_UNLOAD) == 0)
        {
            RtlLeaveCriticalSection(&gcsImeDpi);
            return;
        }
    }
 
    /* Remove from list */
    for (ppEntry = &gpImeDpiList; *ppEntry; ppEntry = &((*ppEntry)->pNext))
    {
        if (*ppEntry == pImeDpi) /* found */
        {
            *ppEntry = pImeDpi->pNext;
            break;
        }
    }
 
    Imm32FreeIME(pImeDpi, TRUE);
    ImmLocalFree(pImeDpi);
 
    RtlLeaveCriticalSection(&gcsImeDpi);
}

Referenced by CtfImmGetGuidAtom(), CtfImmIsGuidMapEnable(), Imm32CreateInputContext(), Imm32DestroyInputContext(), Imm32MakeIMENotify(), Imm32ProcessHotKey(), Imm32SelectInputContext(), ImmActivateLayout(), ImmCallImeConsoleIME(), ImmConfigureIMEA(), ImmConfigureIMEW(), ImmCreateSoftKeyboard(), ImmEnumRegisterWordA(), ImmEnumRegisterWordW(), ImmEscapeA(), ImmEscapeW(), ImmGetConversionListA(), ImmGetConversionListW(), ImmGetImeMenuItemsAW(), ImmGetProperty(), ImmGetRegisterWordStyleA(), ImmGetRegisterWordStyleW(), ImmNotifyIME(), ImmProcessKey(), ImmRegisterWordA(), ImmRegisterWordW(), ImmSetActiveContext(), ImmSetCompositionStringAW(), ImmTranslateMessage(), ImmUnregisterWordA(), ImmUnregisterWordW(), and User32CreateImeUIWindow().

ImmWINNLSEnableIME()

BOOL WINAPI ImmWINNLSEnableIME	(	_In_opt_ HWND	hWnd,
		_In_ BOOL	enable
	)

Definition at line 1718 of file ime.c.

{
    HIMC hIMC;
    PCLIENTIMC pClientImc;
    HWND hImeWnd;
    BOOL bImeWnd, ret;
 
    TRACE("(%p, %d)\n", hWnd, enable);
 
    if (!Imm32IsSystemJapaneseOrKorean())
    {
        SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
        return FALSE;
    }
 
    hIMC = (HIMC)NtUserGetThreadState(THREADSTATE_DEFAULTINPUTCONTEXT);
    if (IS_NULL_UNEXPECTEDLY(hIMC))
        return FALSE;
 
    pClientImc = ImmLockClientImc(hIMC);
    if (IS_NULL_UNEXPECTEDLY(pClientImc))
        return FALSE;
 
    ret = !(pClientImc->dwFlags & CLIENTIMC_DISABLEIME);
    if (!!enable == ret)
    {
        TRACE("Same\n");
        ImmUnlockClientImc(pClientImc);
        return ret;
    }
 
    if (!IsWindow(hWnd))
        hWnd = GetFocus();
 
    hImeWnd = ImmGetDefaultIMEWnd(hWnd);
    bImeWnd = IsWindow(hImeWnd);
    if (bImeWnd)
        ImmSetActiveContext(hWnd, (enable ? NULL : hIMC), FALSE);
 
    if (enable)
        pClientImc->dwFlags &= ~CLIENTIMC_DISABLEIME;
    else
        pClientImc->dwFlags |= CLIENTIMC_DISABLEIME;
 
    ImmUnlockClientImc(pClientImc);
 
    if (bImeWnd)
        ImmSetActiveContext(hWnd, (enable ? hIMC : NULL), TRUE);
 
    return ret;
}

Referenced by IntInitializeImmEntryTable(), User32InitializeImmEntryTable(), and WINNLSEnableIME().

ImmWINNLSGetEnableStatus()

BOOL WINAPI ImmWINNLSGetEnableStatus

(

_In_opt_ HWND

hWnd

)

Definition at line 1266 of file imm.c.

{
    if (!Imm32IsSystemJapaneseOrKorean())
    {
        SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
        return FALSE;
    }
 
    return !!ImmGetSaveContext(hWnd, 2);
}

Referenced by WINNLSGetEnableStatus().