#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:

Classes
struct	tagIMEINFOEX

struct	IMEDPI

struct	tagCLIENTIMC

struct	INPUTCONTEXTDX

struct	IME_SUBSTATE

struct	IME_STATE

struct	tagUNDETERMINESTRUCT

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	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_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_UNKNOWN4 0x20

#define	CLIENTIMC_DESTROY 0x40

#define	CLIENTIMC_DISABLEIME 0x80

#define	CLIENTIMC_UNKNOWN2 0x100

#define	ImmIMPGetIME ImmIMPGetIMEA

#define	ImmIMPQueryIME ImmIMPQueryIMEA

#define	ImmIMPSetIME ImmIMPSetIMEA

#define	ImmSendIMEMessageEx ImmSendIMEMessageExA

Typedefs
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

typedef struct tagUNDETERMINESTRUCT	UNDETERMINESTRUCT

typedef struct tagUNDETERMINESTRUCT *	PUNDETERMINESTRUCT

typedef struct tagUNDETERMINESTRUCT *	LPUNDETERMINESTRUCT

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)

LRESULT 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	ImmWINNLSEnableIME (_In_opt_ HWND hWnd, _In_ BOOL enable)

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

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)

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

WORD 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)

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

Macro Definition Documentation

◆ CLIENTIMC_ACTIVE

#define CLIENTIMC_ACTIVE 0x2

Definition at line 170 of file imm32_undoc.h.

◆ CLIENTIMC_DESTROY

#define CLIENTIMC_DESTROY 0x40

Definition at line 172 of file imm32_undoc.h.

◆ CLIENTIMC_DISABLEIME

#define CLIENTIMC_DISABLEIME 0x80

Definition at line 173 of file imm32_undoc.h.

◆ CLIENTIMC_UNKNOWN2

#define CLIENTIMC_UNKNOWN2 0x100

Definition at line 174 of file imm32_undoc.h.

◆ CLIENTIMC_UNKNOWN4

#define CLIENTIMC_UNKNOWN4 0x20

Definition at line 171 of file imm32_undoc.h.

◆ CLIENTIMC_WIDE

#define CLIENTIMC_WIDE 0x1

Definition at line 169 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 99 of file imm32_undoc.h.

◆ DEFINE_IME_ENTRY [2/2]

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

Definition at line 99 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 139 of file imm32_undoc.h.

◆ IMEDPI_FLAG_UNLOADED

#define IMEDPI_FLAG_UNLOADED 0x1

Definition at line 138 of file imm32_undoc.h.

◆ ImmIMPGetIME

#define ImmIMPGetIME ImmIMPGetIMEA

Definition at line 322 of file imm32_undoc.h.

◆ ImmIMPQueryIME

#define ImmIMPQueryIME ImmIMPQueryIMEA

Definition at line 323 of file imm32_undoc.h.

◆ ImmIMPSetIME

#define ImmIMPSetIME ImmIMPSetIMEA

Definition at line 324 of file imm32_undoc.h.

◆ ImmSendIMEMessageEx

#define ImmSendIMEMessageEx ImmSendIMEMessageExA

Definition at line 325 of file imm32_undoc.h.

◆ IMS_ACTIVATELAYOUT

#define IMS_ACTIVATELAYOUT 0x19

Definition at line 48 of file imm32_undoc.h.

◆ IMS_COMPLETECOMPSTR

#define IMS_COMPLETECOMPSTR 0x20

Definition at line 53 of file imm32_undoc.h.

◆ IMS_CONFIGURE

#define IMS_CONFIGURE 0x0D

Definition at line 40 of file imm32_undoc.h.

◆ IMS_FREELAYOUT

#define IMS_FREELAYOUT 0x11

Definition at line 42 of file imm32_undoc.h.

◆ IMS_GETCONTEXT

#define IMS_GETCONTEXT 0x1E

Definition at line 51 of file imm32_undoc.h.

◆ IMS_GETCONVSTATUS

#define IMS_GETCONVSTATUS 0x14

Definition at line 44 of file imm32_undoc.h.

◆ IMS_GETIMEMENU

#define IMS_GETIMEMENU 0x1C

Definition at line 49 of file imm32_undoc.h.

◆ IMS_IMEACTIVATE

#define IMS_IMEACTIVATE 0x17

Definition at line 46 of file imm32_undoc.h.

◆ IMS_IMEDEACTIVATE

#define IMS_IMEDEACTIVATE 0x18

Definition at line 47 of file imm32_undoc.h.

◆ IMS_IMEHELP

#define IMS_IMEHELP 0x15

Definition at line 45 of file imm32_undoc.h.

◆ IMS_IMEMENUITEMSELECTED

#define IMS_IMEMENUITEMSELECTED 0x1D

Definition at line 50 of file imm32_undoc.h.

◆ IMS_LOADTHREADLAYOUT

#define IMS_LOADTHREADLAYOUT 0x21

Definition at line 54 of file imm32_undoc.h.

◆ IMS_NOTIFYIMESHOW

#define IMS_NOTIFYIMESHOW 0x05

Definition at line 35 of file imm32_undoc.h.

◆ IMS_SENDNOTIFICATION

#define IMS_SENDNOTIFICATION 0x1F

Definition at line 52 of file imm32_undoc.h.

◆ IMS_SETCANDFORM

#define IMS_SETCANDFORM 0x09

Definition at line 37 of file imm32_undoc.h.

◆ IMS_SETCOMPFONT

#define IMS_SETCOMPFONT 0x0A

Definition at line 38 of file imm32_undoc.h.

◆ IMS_SETCOMPFORM

#define IMS_SETCOMPFORM 0x0B

Definition at line 39 of file imm32_undoc.h.

◆ IMS_SETLANGBAND

#define IMS_SETLANGBAND 0x23

Definition at line 55 of file imm32_undoc.h.

◆ IMS_SETOPENSTATUS

#define IMS_SETOPENSTATUS 0x0F

Definition at line 41 of file imm32_undoc.h.

◆ IMS_SOFTKBDONOFF

#define IMS_SOFTKBDONOFF 0x13

Definition at line 43 of file imm32_undoc.h.

◆ IMS_UNSETLANGBAND

#define IMS_UNSETLANGBAND 0x24

Definition at line 56 of file imm32_undoc.h.

◆ IMS_UPDATEIMEUI

#define IMS_UPDATEIMEUI 0x06

Definition at line 36 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

◆ 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

◆ LPIME_STATE

typedef struct IME_STATE* LPIME_STATE

◆ LPIMEDPI

typedef struct IMEDPI* LPIMEDPI

◆ LPIMEINFOEX

typedef struct tagIMEINFOEX* LPIMEINFOEX

◆ LPINPUTCONTEXTDX

typedef struct INPUTCONTEXTDX* LPINPUTCONTEXTDX

◆ LPUNDETERMINESTRUCT

typedef struct tagUNDETERMINESTRUCT * LPUNDETERMINESTRUCT

◆ 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

◆ 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

◆ PUNDETERMINESTRUCT

typedef struct tagUNDETERMINESTRUCT * PUNDETERMINESTRUCT

◆ UNDETERMINESTRUCT

typedef struct tagUNDETERMINESTRUCT UNDETERMINESTRUCT

Enumeration Type Documentation

◆ IMEINFOEXCLASS

enum IMEINFOEXCLASS

Enumerator
ImeInfoExKeyboardLayout
ImeInfoExKeyboardLayoutTFS
ImeInfoExImeWindow
ImeInfoExImeFileName

Definition at line 77 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().

◆ 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 1287 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().

◆ 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.

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

Referenced by ImmProcessKey().

◆ 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 611 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 954 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_UNKNOWN2;
 
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 531 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 743 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) & 0x10000))
    {
        /* 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()

LRESULT WINAPI ImmPutImeMenuItemsIntoMappedFile ( _In_ HIMC hIMC )

Definition at line 377 of file imemenu.c.

{
    /* Open the existing file mapping */
    HANDLE hMapping = OpenFileMappingW(FILE_MAP_ALL_ACCESS, FALSE, L"ImmMenuInfo");
    if (!hMapping)
    {
        ERR("!hMapping\n");
        return 0;
    }
 
    /* Map the view */
    PIMEMENUINFO pView = MapViewOfFile(hMapping, FILE_MAP_ALL_ACCESS, 0, 0, 0);
    if (!pView)
    {
        ERR("!pView\n");
        CloseHandle(hMapping);
        return 0;
    }
 
    /* Get parent menu info */
    PVOID lpImeParentMenu = NULL;
    if (pView->dwParentOffset)
        lpImeParentMenu = PTR_FROM_OFFSET(pView, pView->dwParentOffset);
 
    /* Serialize the IME menu */
    DWORD dwItemCount = Imm32SerializeImeMenu(pView, hIMC, lpImeParentMenu, !pView->dwItemCount);
 
    /* Clean up */
    UnmapViewOfFile(pView);
    CloseHandle(hMapping);
 
    return dwItemCount;
}

Referenced by ImeWnd_OnImeSystem().

◆ ImmSendIMEMessageExA()

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

Definition at line 215 of file win3.c.

{
    FIXME("(%p, %p)\n", hWnd, lParam);
    return 0;
}

Referenced by SendIMEMessageExA().

◆ ImmSendIMEMessageExW()

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

Definition at line 227 of file win3.c.

{
    FIXME("(%p, %p)\n", hWnd, lParam);
    return 0;
}

Referenced by SendIMEMessageExW().

◆ ImmSetActiveContext()

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

Definition at line 1155 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 & 2)
            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 1271 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);
}

◆ ImmSystemHandler()

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

Definition at line 847 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 1001 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 561 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 1717 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 1256 of file imm.c.

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

Referenced by WINNLSGetEnableStatus().

Classes

Macros

Typedefs

Enumerations

Functions

Macro Definition Documentation

◆ CLIENTIMC_ACTIVE

◆ CLIENTIMC_DESTROY

◆ CLIENTIMC_DISABLEIME

◆ CLIENTIMC_UNKNOWN2

◆ CLIENTIMC_UNKNOWN4

◆ CLIENTIMC_WIDE

◆ DEFINE_IME_ENTRY [1/2]

◆ DEFINE_IME_ENTRY [2/2]

◆ HKL_RELEASE_IME

◆ HKL_SWITCH_TO_NON_IME

◆ IME_MASK

◆ IMEDPI_FLAG_LOCKED

◆ IMEDPI_FLAG_UNLOADED

◆ ImmIMPGetIME

◆ ImmIMPQueryIME

◆ ImmIMPSetIME

◆ ImmSendIMEMessageEx

◆ IMS_ACTIVATELAYOUT

◆ IMS_COMPLETECOMPSTR

◆ IMS_CONFIGURE

◆ IMS_FREELAYOUT

◆ IMS_GETCONTEXT

◆ IMS_GETCONVSTATUS

◆ IMS_GETIMEMENU

◆ IMS_IMEACTIVATE

◆ IMS_IMEDEACTIVATE

◆ IMS_IMEHELP

◆ IMS_IMEMENUITEMSELECTED

◆ IMS_LOADTHREADLAYOUT

◆ IMS_NOTIFYIMESHOW

◆ IMS_SENDNOTIFICATION

◆ IMS_SETCANDFORM

◆ IMS_SETCOMPFONT

◆ IMS_SETCOMPFORM

◆ IMS_SETLANGBAND

◆ IMS_SETOPENSTATUS

◆ IMS_SOFTKBDONOFF

◆ IMS_UNSETLANGBAND

◆ IMS_UPDATEIMEUI

◆ IS_IME_HKL

◆ IS_IME_KLID

◆ IS_SPECIAL_HKL

◆ IS_SUBST_KLID

◆ SPECIAL_MASK

◆ SPECIALIDFROMHKL

◆ SUBST_MASK

◆ WM_IME_SYSTEM

Typedef Documentation

◆ CLIENTIMC

◆ IME_STATE

◆ IME_SUBSTATE

◆ IMEDPI

◆ IMEINFOEX

◆ IMEINFOEXCLASS

◆ INPUTCONTEXTDX

◆ LPCLIENTIMC

◆ LPIME_STATE

◆ LPIMEDPI

◆ LPIMEINFOEX

◆ LPINPUTCONTEXTDX

◆ LPUNDETERMINESTRUCT

◆ NPCLIENTIMC

◆ NPIME_STATE

◆ NPIME_SUBSTATE

◆ NPIMEDPI

◆ NPIMEINFOEX

◆ NPINPUTCONTEXTDX

◆ PCLIENTIMC

◆ PIME_STATE

◆ PIME_SUBSTATE

◆ PIMEDPI

◆ PIMEINFOEX

◆ PINPUTCONTEXTDX

◆ PUNDETERMINESTRUCT