ReactOS 0.4.16-dev-1484-g212a1a5
ime.c File Reference
#include "precomp.h"
#include <imetable.h>
Include dependency graph for ime.c:

Go to the source code of this file.

Macros

#define VALID_IME_PROP
 
#define VALID_CMODE_CAPS
 
#define VALID_SMODE_CAPS
 
#define VALID_UI_CAPS
 
#define VALID_SCS_CAPS
 
#define VALID_SELECT_CAPS   (SELECT_CAP_CONVERSION | SELECT_CAP_SENTENCE)
 
#define DEFINE_IME_ENTRY(type, name, params, optional)
 
#define DEFINE_IME_ENTRY(type, name, params, optional)   pImeDpi->name = Stub##name;
 
#define DEFINE_IME_ENTRY(type, name, params, optional)
 
#define CHECK_IME_FN(name)
 

Functions

 WINE_DEFAULT_DEBUG_CHANNEL (imm)
 
PIMEDPI Imm32FindImeDpi (HKL hKL)
 
VOID Imm32FreeIME (PIMEDPI pImeDpi, BOOL bDestroy)
 
BOOL Imm32InquireIme (PIMEDPI pImeDpi)
 
static BOOL Imm32LoadIME (PIMEINFOEX pImeInfoEx, PIMEDPI pImeDpi)
 
static PIMEDPI Imm32LoadImeDpi (HKL hKL, BOOL bLock)
 
PIMEDPI Imm32FindOrLoadImeDpi (HKL hKL)
 
static LRESULT ImeDpi_Escape (PIMEDPI pImeDpi, HIMC hIMC, UINT uSubFunc, LPVOID lpData, HKL hKL)
 
BOOL Imm32ReleaseIME (_In_ HKL hKL)
 
BOOL WINAPI ImmIsIME (_In_ HKL hKL)
 
HWND WINAPI ImmGetDefaultIMEWnd (_In_opt_ HWND hWnd)
 
BOOL WINAPI ImmNotifyIME (_In_ HIMC hIMC, _In_ DWORD dwAction, _In_ DWORD dwIndex, _In_ DWORD_PTR dwValue)
 
BOOL WINAPI ImmGetImeInfoEx (PIMEINFOEX pImeInfoEx, IMEINFOEXCLASS SearchType, PVOID pvSearchKey)
 
PIMEDPI WINAPI ImmLockImeDpi (_In_ HKL hKL)
 
VOID WINAPI ImmUnlockImeDpi (_Inout_opt_ PIMEDPI pImeDpi)
 
BOOL WINAPI ImmLoadIME (_In_ HKL hKL)
 
BOOL WINAPI ImmDisableIME (_In_ DWORD dwThreadId)
 
UINT WINAPI ImmGetDescriptionA (_In_ HKL hKL, _Out_writes_opt_(uBufLen) LPSTR lpszDescription, _In_ UINT uBufLen)
 
UINT WINAPI ImmGetDescriptionW (_In_ HKL hKL, _Out_writes_opt_(uBufLen) LPWSTR lpszDescription, _In_ UINT uBufLen)
 
UINT WINAPI ImmGetIMEFileNameA (_In_ HKL hKL, _Out_writes_opt_(uBufLen) LPSTR lpszFileName, _In_ UINT uBufLen)
 
UINT WINAPI ImmGetIMEFileNameW (_In_ HKL hKL, _Out_writes_opt_(uBufLen) LPWSTR lpszFileName, _In_ UINT uBufLen)
 
DWORD WINAPI ImmGetProperty (_In_ HKL hKL, _In_ DWORD fdwIndex)
 
LRESULT WINAPI ImmEscapeA (_In_ HKL hKL, _In_ HIMC hIMC, _In_ UINT uSubFunc, _Inout_opt_ LPVOID lpData)
 
LRESULT WINAPI ImmEscapeW (_In_ HKL hKL, _In_ HIMC hIMC, _In_ UINT uSubFunc, _Inout_opt_ LPVOID lpData)
 
BOOL WINAPI ImmGetOpenStatus (_In_ HIMC hIMC)
 
BOOL WINAPI ImmSetOpenStatus (_In_ HIMC hIMC, _In_ BOOL fOpen)
 
BOOL WINAPI ImmGetStatusWindowPos (_In_ HIMC hIMC, _Out_ LPPOINT lpptPos)
 
BOOL WINAPI ImmSetStatusWindowPos (_In_ HIMC hIMC, _In_ LPPOINT lpptPos)
 
BOOL WINAPI ImmGetCompositionWindow (_In_ HIMC hIMC, _Out_ LPCOMPOSITIONFORM lpCompForm)
 
BOOL WINAPI ImmSetCompositionWindow (_In_ HIMC hIMC, _In_ LPCOMPOSITIONFORM lpCompForm)
 
BOOL WINAPI ImmGetCompositionFontA (_In_ HIMC hIMC, _Out_ LPLOGFONTA lplf)
 
BOOL WINAPI ImmGetCompositionFontW (_In_ HIMC hIMC, _Out_ LPLOGFONTW lplf)
 
BOOL WINAPI ImmSetCompositionFontA (_In_ HIMC hIMC, _In_ LPLOGFONTA lplf)
 
BOOL WINAPI ImmSetCompositionFontW (_In_ HIMC hIMC, _In_ LPLOGFONTW lplf)
 
DWORD WINAPI ImmGetConversionListA (_In_ HKL hKL, _In_ HIMC hIMC, _In_ LPCSTR pSrc, _Out_writes_bytes_(dwBufLen) LPCANDIDATELIST lpDst, _In_ DWORD dwBufLen, _In_ UINT uFlag)
 
DWORD WINAPI ImmGetConversionListW (_In_ HKL hKL, _In_ HIMC hIMC, _In_ LPCWSTR pSrc, _Out_writes_bytes_(dwBufLen) LPCANDIDATELIST lpDst, _In_ DWORD dwBufLen, _In_ UINT uFlag)
 
BOOL WINAPI ImmGetConversionStatus (_In_ HIMC hIMC, _Out_opt_ LPDWORD lpfdwConversion, _Out_opt_ LPDWORD lpfdwSentence)
 
BOOL WINAPI ImmSetConversionStatus (_In_ HIMC hIMC, _In_ DWORD fdwConversion, _In_ DWORD fdwSentence)
 
BOOL WINAPI ImmConfigureIMEA (_In_ HKL hKL, _In_ HWND hWnd, _In_ DWORD dwMode, _Inout_opt_ LPVOID lpData)
 
BOOL WINAPI ImmConfigureIMEW (_In_ HKL hKL, _In_ HWND hWnd, _In_ DWORD dwMode, _Inout_opt_ LPVOID lpData)
 
BOOL WINAPI ImmWINNLSEnableIME (_In_opt_ HWND hWnd, _In_ BOOL enable)
 

Variables

RTL_CRITICAL_SECTION gcsImeDpi
 
PIMEDPI gpImeDpiList = NULL
 

Macro Definition Documentation

◆ CHECK_IME_FN

#define CHECK_IME_FN (   name)
Value:
do { \
if (!pImeDpi->name) { \
ERR("'%s' not found in Cicero IME module %s.\n", #name, debugstr_w(szPath)); \
goto Failed; \
} \
} while(0)
#define debugstr_w
Definition: kernel32.h:32
LPCWSTR szPath
Definition: env.c:37
@ Failed
Definition: arc.h:79
Definition: name.c:39

◆ DEFINE_IME_ENTRY [1/3]

#define DEFINE_IME_ENTRY (   type,
  name,
  params,
  optional 
)
Value:
FIXME("%s: Why stub called?\n", #name); \
return (type)0; \
}
#define APIENTRY
Definition: api.h:79
GLuint GLuint GLsizei GLenum type
Definition: gl.h:1545
GLenum const GLfloat * params
Definition: glext.h:5645

Definition at line 186 of file ime.c.

◆ DEFINE_IME_ENTRY [2/3]

#define DEFINE_IME_ENTRY (   type,
  name,
  params,
  optional 
)    pImeDpi->name = Stub##name;

Definition at line 186 of file ime.c.

◆ DEFINE_IME_ENTRY [3/3]

#define DEFINE_IME_ENTRY (   type,
  name,
  params,
  optional 
)
Value:
do { \
fn = GetProcAddress(hIME, #name); \
if (fn) pImeDpi->name = (FN_##name)fn; \
else if (!(optional)) { \
ERR("'%s' not found in IME module %s.\n", #name, debugstr_w(szPath)); \
goto Failed; \
} \
} while (0);
@ optional
Definition: SystemMenu.c:34
#define GetProcAddress(x, y)
Definition: compat.h:753
static GLenum _GLUfuncptr fn
Definition: wgl_font.c:159

Definition at line 186 of file ime.c.

◆ VALID_CMODE_CAPS

#define VALID_CMODE_CAPS
Value:
#define IME_CMODE_KATAKANA
Definition: imm.h:343
#define IME_CMODE_ROMAN
Definition: imm.h:346
#define IME_CMODE_NATIVE
Definition: imm.h:337
#define IME_CMODE_LANGUAGE
Definition: imm.h:344
#define IME_CMODE_SYMBOL
Definition: imm.h:352
#define IME_CMODE_HANJACONVERT
Definition: imm.h:348
#define IME_CMODE_EUDC
Definition: imm.h:351
#define IME_CMODE_SOFTKBD
Definition: imm.h:349
#define IME_CMODE_NOCONVERSION
Definition: imm.h:350
#define IME_CMODE_FIXED
Definition: imm.h:353
#define IME_CMODE_CHARCODE
Definition: imm.h:347
#define IME_CMODE_ALPHANUMERIC
Definition: imm.h:336
#define IME_CMODE_FULLSHAPE
Definition: imm.h:345

◆ VALID_IME_PROP

#define VALID_IME_PROP
Value:
#define IME_PROP_CANDLIST_START_FROM_1
Definition: imm.h:248
#define IME_PROP_AT_CARET
Definition: imm.h:246
#define IME_PROP_UNICODE
Definition: imm.h:249
#define IME_PROP_SPECIAL_UI
Definition: imm.h:247
#define IME_PROP_COMPLETE_ON_UNSELECT
Definition: imm.h:250
#define IME_PROP_ACCEPT_WIDE_VKEY
Definition: immdev.h:367
#define IME_PROP_NEED_ALTKEY
Definition: immdev.h:365
#define IME_PROP_NO_KEYS_ON_CLOSE
Definition: immdev.h:366
#define IME_PROP_END_UNLOAD
Definition: immdev.h:362
#define IME_PROP_KBD_CHAR_FIRST
Definition: immdev.h:363
#define IME_PROP_IGNORE_UPKEYS
Definition: immdev.h:364

◆ VALID_SCS_CAPS

#define VALID_SCS_CAPS
Value:
#define SCS_CAP_COMPSTR
Definition: imm.h:259
#define SCS_CAP_SETRECONVERTSTRING
Definition: imm.h:261
#define SCS_CAP_MAKEREAD
Definition: imm.h:260

◆ VALID_SELECT_CAPS

#define VALID_SELECT_CAPS   (SELECT_CAP_CONVERSION | SELECT_CAP_SENTENCE)

◆ VALID_SMODE_CAPS

#define VALID_SMODE_CAPS
Value:
#define IME_SMODE_CONVERSATION
Definition: imm.h:361
#define IME_SMODE_PLAURALCLAUSE
Definition: imm.h:357
#define IME_SMODE_SINGLECONVERT
Definition: imm.h:358
#define IME_SMODE_PHRASEPREDICT
Definition: imm.h:360
#define IME_SMODE_AUTOMATIC
Definition: imm.h:359
#define IME_SMODE_NONE
Definition: imm.h:356

◆ VALID_UI_CAPS

#define VALID_UI_CAPS
Value:
#define UI_CAP_SOFTKBD
Definition: imm.h:256
#define UI_CAP_ROTANY
Definition: imm.h:255
#define UI_CAP_2700
Definition: imm.h:253
#define UI_CAP_ROT90
Definition: imm.h:254

Function Documentation

◆ ImeDpi_Escape()

static LRESULT ImeDpi_Escape ( PIMEDPI  pImeDpi,
HIMC  hIMC,
UINT  uSubFunc,
LPVOID  lpData,
HKL  hKL 
)
static

Definition at line 367 of file ime.c.

368{
369 if (IS_IME_HKL(hKL))
370 return pImeDpi->ImeEscape(hIMC, uSubFunc, lpData);
371 if (IS_CICERO_MODE() && !IS_16BIT_MODE())
372 return pImeDpi->CtfImeEscapeEx(hIMC, uSubFunc, lpData, hKL);
373
374 return 0;
375}
#define IS_IME_HKL(hKL)
Definition: imm32_undoc.h:21
#define IS_16BIT_MODE()
Definition: ntuser.h:1214
#define IS_CICERO_MODE()
Definition: ntuser.h:1213

Referenced by ImmEscapeA(), and ImmEscapeW().

◆ Imm32FindImeDpi()

PIMEDPI Imm32FindImeDpi ( HKL  hKL)

Definition at line 19 of file ime.c.

20{
21 PIMEDPI pImeDpi;
22
24 for (pImeDpi = gpImeDpiList; pImeDpi != NULL; pImeDpi = pImeDpi->pNext)
25 {
26 if (pImeDpi->hKL == hKL)
27 break;
28 }
30
31 return pImeDpi;
32}
#define NULL
Definition: types.h:112
RTL_CRITICAL_SECTION gcsImeDpi
Definition: ime.c:16
PIMEDPI gpImeDpiList
Definition: ime.c:17
NTSYSAPI NTSTATUS NTAPI RtlEnterCriticalSection(_In_ PRTL_CRITICAL_SECTION CriticalSection)
NTSYSAPI NTSTATUS NTAPI RtlLeaveCriticalSection(_In_ PRTL_CRITICAL_SECTION CriticalSection)
HKL hKL
Definition: imm32_undoc.h:93
struct IMEDPI * pNext
Definition: imm32_undoc.h:91

Referenced by Imm32LoadImeDpi(), and ImmLoadIME().

◆ Imm32FindOrLoadImeDpi()

PIMEDPI Imm32FindOrLoadImeDpi ( HKL  hKL)

Definition at line 350 of file ime.c.

351{
352 PIMEDPI pImeDpi;
353
354 if (!IS_IME_HKL(hKL) && (!IS_CICERO_MODE() || IS_16BIT_MODE()))
355 {
356 TRACE("\n");
357 return NULL;
358 }
359
360 pImeDpi = ImmLockImeDpi(hKL);
361 if (pImeDpi == NULL)
362 pImeDpi = Imm32LoadImeDpi(hKL, TRUE);
363 return pImeDpi;
364}
#define TRUE
Definition: types.h:120
static PIMEDPI Imm32LoadImeDpi(HKL hKL, BOOL bLock)
Definition: ime.c:281
PIMEDPI WINAPI ImmLockImeDpi(_In_ HKL hKL)
Definition: ime.c:531
#define TRACE(s)
Definition: solgame.cpp:4

Referenced by CtfImmGetGuidAtom(), CtfImmIsGuidMapEnable(), Imm32InternalLockIMC(), ImmConfigureIMEA(), ImmConfigureIMEW(), ImmEnumRegisterWordA(), ImmEnumRegisterWordW(), ImmEscapeA(), ImmEscapeW(), ImmGetConversionListA(), ImmGetConversionListW(), ImmGetProperty(), ImmGetRegisterWordStyleA(), ImmGetRegisterWordStyleW(), ImmRegisterWordA(), ImmRegisterWordW(), ImmUnregisterWordA(), and ImmUnregisterWordW().

◆ Imm32FreeIME()

VOID Imm32FreeIME ( PIMEDPI  pImeDpi,
BOOL  bDestroy 
)

Definition at line 34 of file ime.c.

35{
36 if (pImeDpi->hInst == NULL)
37 return;
38 if (bDestroy)
39 pImeDpi->ImeDestroy(0);
40 FreeLibrary(pImeDpi->hInst);
41 pImeDpi->hInst = NULL;
42}
#define FreeLibrary(x)
Definition: compat.h:748
HINSTANCE hInst
Definition: imm32_undoc.h:92

Referenced by Imm32LoadImeDpi(), Imm32ReleaseIME(), and ImmUnlockImeDpi().

◆ Imm32InquireIme()

BOOL Imm32InquireIme ( PIMEDPI  pImeDpi)

Definition at line 44 of file ime.c.

45{
46 WCHAR szUIClass[64];
47 WNDCLASSW wcW;
48 DWORD dwSysInfoFlags = 0;
49 LPIMEINFO pImeInfo = &pImeDpi->ImeInfo;
50
52 dwSysInfoFlags |= IME_SYSINFO_WINLOGON;
53
54 if (GetWin32ClientInfo()->dwTIFlags & TIF_16BIT)
55 dwSysInfoFlags |= IME_SYSINFO_WOW16;
56
57 if (IS_IME_HKL(pImeDpi->hKL))
58 {
59 if (!pImeDpi->ImeInquire(pImeInfo, szUIClass, dwSysInfoFlags))
60 {
61 ERR("\n");
62 return FALSE;
63 }
64 }
65 else if (IS_CICERO_MODE() && !IS_16BIT_MODE())
66 {
67 if (pImeDpi->CtfImeInquireExW(pImeInfo, szUIClass, dwSysInfoFlags, pImeDpi->hKL) != S_OK)
68 {
69 ERR("\n");
70 return FALSE;
71 }
72 }
73 else
74 {
75 ERR("\n");
76 return FALSE;
77 }
78
79 szUIClass[_countof(szUIClass) - 1] = UNICODE_NULL; /* Avoid buffer overrun */
80
81 if (pImeInfo->dwPrivateDataSize < sizeof(DWORD))
82 pImeInfo->dwPrivateDataSize = sizeof(DWORD);
83
84#define VALID_IME_PROP (IME_PROP_AT_CARET | \
85 IME_PROP_SPECIAL_UI | \
86 IME_PROP_CANDLIST_START_FROM_1 | \
87 IME_PROP_UNICODE | \
88 IME_PROP_COMPLETE_ON_UNSELECT | \
89 IME_PROP_END_UNLOAD | \
90 IME_PROP_KBD_CHAR_FIRST | \
91 IME_PROP_IGNORE_UPKEYS | \
92 IME_PROP_NEED_ALTKEY | \
93 IME_PROP_NO_KEYS_ON_CLOSE | \
94 IME_PROP_ACCEPT_WIDE_VKEY)
95#define VALID_CMODE_CAPS (IME_CMODE_ALPHANUMERIC | \
96 IME_CMODE_NATIVE | \
97 IME_CMODE_KATAKANA | \
98 IME_CMODE_LANGUAGE | \
99 IME_CMODE_FULLSHAPE | \
100 IME_CMODE_ROMAN | \
101 IME_CMODE_CHARCODE | \
102 IME_CMODE_HANJACONVERT | \
103 IME_CMODE_SOFTKBD | \
104 IME_CMODE_NOCONVERSION | \
105 IME_CMODE_EUDC | \
106 IME_CMODE_SYMBOL | \
107 IME_CMODE_FIXED)
108#define VALID_SMODE_CAPS (IME_SMODE_NONE | \
109 IME_SMODE_PLAURALCLAUSE | \
110 IME_SMODE_SINGLECONVERT | \
111 IME_SMODE_AUTOMATIC | \
112 IME_SMODE_PHRASEPREDICT | \
113 IME_SMODE_CONVERSATION)
114#define VALID_UI_CAPS (UI_CAP_2700 | \
115 UI_CAP_ROT90 | \
116 UI_CAP_ROTANY | \
117 UI_CAP_SOFTKBD)
118#define VALID_SCS_CAPS (SCS_CAP_COMPSTR | \
119 SCS_CAP_MAKEREAD | \
120 SCS_CAP_SETRECONVERTSTRING)
121#define VALID_SELECT_CAPS (SELECT_CAP_CONVERSION | SELECT_CAP_SENTENCE)
122
123 if (pImeInfo->fdwProperty & ~VALID_IME_PROP)
124 {
125 ERR("Bad flags\n");
126 return FALSE;
127 }
128 if (pImeInfo->fdwConversionCaps & ~VALID_CMODE_CAPS)
129 {
130 ERR("Bad flags\n");
131 return FALSE;
132 }
133 if (pImeInfo->fdwSentenceCaps & ~VALID_SMODE_CAPS)
134 {
135 ERR("Bad flags\n");
136 return FALSE;
137 }
138 if (pImeInfo->fdwUICaps & ~VALID_UI_CAPS)
139 {
140 ERR("Bad flags\n");
141 return FALSE;
142 }
143 if (pImeInfo->fdwSCSCaps & ~VALID_SCS_CAPS)
144 {
145 ERR("Bad flags\n");
146 return FALSE;
147 }
148 if (pImeInfo->fdwSelectCaps & ~VALID_SELECT_CAPS)
149 {
150 ERR("Bad flags\n");
151 return FALSE;
152 }
153
154#undef VALID_IME_PROP
155#undef VALID_CMODE_CAPS
156#undef VALID_SMODE_CAPS
157#undef VALID_UI_CAPS
158#undef VALID_SCS_CAPS
159#undef VALID_SELECT_CAPS
160
161 if (pImeInfo->fdwProperty & IME_PROP_UNICODE)
162 {
163 StringCchCopyW(pImeDpi->szUIClass, _countof(pImeDpi->szUIClass), szUIClass);
164 }
165 else
166 {
167 if (pImeDpi->uCodePage != GetACP() && pImeDpi->uCodePage != CP_ACP)
168 return FALSE;
169
171 pImeDpi->szUIClass, _countof(pImeDpi->szUIClass));
172
173 pImeDpi->szUIClass[_countof(pImeDpi->szUIClass) - 1] = UNICODE_NULL;
174 }
175
176 if (!GetClassInfoW(pImeDpi->hInst, pImeDpi->szUIClass, &wcW))
177 {
178 ERR("\n");
179 return FALSE;
180 }
181
182 return TRUE;
183}
#define ERR(fmt,...)
Definition: precomp.h:57
#define FALSE
Definition: types.h:117
#define CP_ACP
Definition: compat.h:109
#define MultiByteToWideChar
Definition: compat.h:110
UINT WINAPI GetACP(void)
Definition: locale.c:2023
unsigned long DWORD
Definition: ntddk_ex.h:95
#define VALID_IME_PROP
#define VALID_SELECT_CAPS
#define VALID_SCS_CAPS
#define VALID_SMODE_CAPS
#define VALID_UI_CAPS
#define VALID_CMODE_CAPS
#define IME_SYSINFO_WINLOGON
Definition: immdev.h:387
#define IME_SYSINFO_WOW16
Definition: immdev.h:388
@ THREADSTATE_ISWINLOGON
Definition: ntuser.h:2500
#define TIF_16BIT
Definition: ntuser.h:264
#define GetWin32ClientInfo()
Definition: ntuser.h:352
DWORD_PTR NTAPI NtUserGetThreadState(DWORD Routine)
Definition: misc.c:240
#define S_OK
Definition: intsafe.h:52
#define DWORD
Definition: nt_native.h:44
#define UNICODE_NULL
#define _countof(array)
Definition: sndvol32.h:70
STRSAFEAPI StringCchCopyW(STRSAFE_LPWSTR pszDest, size_t cchDest, STRSAFE_LPCWSTR pszSrc)
Definition: strsafe.h:149
IMEINFO ImeInfo
Definition: imm32_undoc.h:94
WCHAR szUIClass[16]
Definition: imm32_undoc.h:96
UINT uCodePage
Definition: imm32_undoc.h:95
DWORD fdwSelectCaps
Definition: immdev.h:27
DWORD fdwSentenceCaps
Definition: immdev.h:24
DWORD fdwConversionCaps
Definition: immdev.h:23
DWORD fdwSCSCaps
Definition: immdev.h:26
DWORD fdwProperty
Definition: immdev.h:22
DWORD dwPrivateDataSize
Definition: immdev.h:21
DWORD fdwUICaps
Definition: immdev.h:25
#define MB_PRECOMPOSED
Definition: winnls.h:299
BOOL WINAPI GetClassInfoW(_In_opt_ HINSTANCE, _In_ LPCWSTR, _Out_ LPWNDCLASSW)
char * LPSTR
Definition: xmlstorage.h:182
__wchar_t WCHAR
Definition: xmlstorage.h:180

Referenced by Imm32LoadIME().

◆ Imm32LoadIME()

static BOOL Imm32LoadIME ( PIMEINFOEX  pImeInfoEx,
PIMEDPI  pImeDpi 
)
static

Definition at line 195 of file ime.c.

196{
198 HINSTANCE hIME;
199 FARPROC fn;
200 BOOL ret = FALSE;
201
203 return FALSE;
204
205 pImeDpi->hInst = hIME = LoadLibraryW(szPath);
206 if (hIME == NULL)
207 {
208 ERR("LoadLibraryW(%s) failed\n", debugstr_w(szPath));
209 return FALSE;
210 }
211
212 /* Populate the table by stub IME functions */
213#define DEFINE_IME_ENTRY(type, name, params, optional) pImeDpi->name = Stub##name;
214#include <imetable.h>
215#undef DEFINE_IME_ENTRY
216
217 /* Populate the table by real IME functions */
218#define DEFINE_IME_ENTRY(type, name, params, optional) \
219 do { \
220 fn = GetProcAddress(hIME, #name); \
221 if (fn) pImeDpi->name = (FN_##name)fn; \
222 else if (!(optional)) { \
223 ERR("'%s' not found in IME module %s.\n", #name, debugstr_w(szPath)); \
224 goto Failed; \
225 } \
226 } while (0);
227#include <imetable.h>
228#undef DEFINE_IME_ENTRY
229
230 /* Check for Cicero IMEs */
231 if (!IS_IME_HKL(pImeDpi->hKL) && IS_CICERO_MODE() && !IS_CICERO_COMPAT_DISABLED())
232 {
233#define CHECK_IME_FN(name) do { \
234 if (!pImeDpi->name) { \
235 ERR("'%s' not found in Cicero IME module %s.\n", #name, debugstr_w(szPath)); \
236 goto Failed; \
237 } \
238} while(0)
244#undef CHECK_IME_FN
245 }
246
247 if (Imm32InquireIme(pImeDpi))
248 {
249 ret = TRUE;
250 }
251 else
252 {
253Failed:
254 ret = FALSE;
255 FreeLibrary(pImeDpi->hInst);
256 pImeDpi->hInst = NULL;
257 }
258
259 if (pImeInfoEx->fLoadFlag == 0)
260 {
261 if (ret)
262 {
263 C_ASSERT(sizeof(pImeInfoEx->wszUIClass) == sizeof(pImeDpi->szUIClass));
264 pImeInfoEx->ImeInfo = pImeDpi->ImeInfo;
265 RtlCopyMemory(pImeInfoEx->wszUIClass, pImeDpi->szUIClass,
266 sizeof(pImeInfoEx->wszUIClass));
267 pImeInfoEx->fLoadFlag = 2;
268 }
269 else
270 {
271 pImeInfoEx->fLoadFlag = 1;
272 }
273
274 NtUserSetImeInfoEx(pImeInfoEx);
275 }
276
277 return ret;
278}
int(* FARPROC)()
Definition: compat.h:36
#define MAX_PATH
Definition: compat.h:34
#define LoadLibraryW(x)
Definition: compat.h:747
return ret
Definition: mutex.c:146
unsigned int BOOL
Definition: ntddk_ex.h:94
#define CHECK_IME_FN(name)
BOOL Imm32InquireIme(PIMEDPI pImeDpi)
Definition: ime.c:44
#define IS_CICERO_COMPAT_DISABLED()
Definition: ntuser.h:1215
BOOL NTAPI NtUserSetImeInfoEx(_In_ const IMEINFOEX *pImeInfoEx)
Definition: ime.c:1194
#define C_ASSERT(e)
Definition: intsafe.h:73
EXTERN_C HRESULT WINAPI CtfImeInquireExW(_Out_ LPIMEINFO lpIMEInfo, _Out_ LPWSTR lpszWndClass, _In_ DWORD dwSystemInfoFlags, _In_ HKL hKL)
Definition: msctfime.cpp:542
EXTERN_C BOOL WINAPI CtfImeIsGuidMapEnable(_In_ HIMC hIMC)
Definition: msctfime.cpp:647
EXTERN_C BOOL WINAPI CtfImeSelectEx(_In_ HIMC hIMC, _In_ BOOL fSelect, _In_ HKL hKL)
Definition: msctfime.cpp:571
EXTERN_C LRESULT WINAPI CtfImeEscapeEx(_In_ HIMC hIMC, _In_ UINT uSubFunc, _Inout_opt_ LPVOID lpData, _In_ HKL hKL)
Definition: msctfime.cpp:596
EXTERN_C HRESULT WINAPI CtfImeGetGuidAtom(_In_ HIMC hIMC, _In_ DWORD dwUnknown, _Out_opt_ LPDWORD pdwGuidAtom)
Definition: msctfime.cpp:620
IMEINFO ImeInfo
Definition: imm32_undoc.h:61
WCHAR wszImeFile[80]
Definition: imm32_undoc.h:69
WCHAR wszUIClass[16]
Definition: imm32_undoc.h:62
#define RtlCopyMemory(Destination, Source, Length)
Definition: typedefs.h:263
BOOL Imm32GetSystemLibraryPath(LPWSTR pszPath, DWORD cchPath, LPCWSTR pszFileName)
Definition: utils.c:152

Referenced by Imm32LoadImeDpi().

◆ Imm32LoadImeDpi()

static PIMEDPI Imm32LoadImeDpi ( HKL  hKL,
BOOL  bLock 
)
static

Definition at line 281 of file ime.c.

282{
283 IMEINFOEX ImeInfoEx;
284 CHARSETINFO ci;
285 PIMEDPI pImeDpiNew, pImeDpiFound;
286 UINT uCodePage;
287 LCID lcid;
288
289 if (!ImmGetImeInfoEx(&ImeInfoEx, ImeInfoExKeyboardLayout, &hKL))
290 {
291 ERR("\n");
292 return NULL;
293 }
294
295 if (ImeInfoEx.fLoadFlag == 1)
296 {
297 ERR("\n");
298 return NULL;
299 }
300
301 pImeDpiNew = ImmLocalAlloc(HEAP_ZERO_MEMORY, sizeof(IMEDPI));
302 if (IS_NULL_UNEXPECTEDLY(pImeDpiNew))
303 return NULL;
304
305 pImeDpiNew->hKL = hKL;
306
307 lcid = LOWORD(hKL);
309 uCodePage = ci.ciACP;
310 else
311 uCodePage = CP_ACP;
312 pImeDpiNew->uCodePage = uCodePage;
313
314 if (!Imm32LoadIME(&ImeInfoEx, pImeDpiNew))
315 {
316 ERR("\n");
317 ImmLocalFree(pImeDpiNew);
318 return FALSE;
319 }
320
322
323 pImeDpiFound = Imm32FindImeDpi(hKL);
324 if (pImeDpiFound)
325 {
326 if (!bLock)
327 pImeDpiFound->dwFlags &= ~IMEDPI_FLAG_LOCKED;
328
330 Imm32FreeIME(pImeDpiNew, FALSE);
331 ImmLocalFree(pImeDpiNew);
332 return pImeDpiFound;
333 }
334 else
335 {
336 if (bLock)
337 {
338 pImeDpiNew->dwFlags |= IMEDPI_FLAG_LOCKED;
339 pImeDpiNew->cLockObj = 1;
340 }
341
342 pImeDpiNew->pNext = gpImeDpiList;
343 gpImeDpiList = pImeDpiNew;
344
346 return pImeDpiNew;
347 }
348}
#define HEAP_ZERO_MEMORY
Definition: compat.h:134
LCID lcid
Definition: locale.c:5656
#define UlongToPtr(u)
Definition: config.h:106
static BOOL Imm32LoadIME(PIMEINFOEX pImeInfoEx, PIMEDPI pImeDpi)
Definition: ime.c:195
PIMEDPI Imm32FindImeDpi(HKL hKL)
Definition: ime.c:19
BOOL WINAPI ImmGetImeInfoEx(PIMEINFOEX pImeInfoEx, IMEINFOEXCLASS SearchType, PVOID pvSearchKey)
Definition: ime.c:491
VOID Imm32FreeIME(PIMEDPI pImeDpi, BOOL bDestroy)
Definition: ime.c:34
#define IMEDPI_FLAG_LOCKED
Definition: imm32_undoc.h:139
@ ImeInfoExKeyboardLayout
Definition: imm32_undoc.h:79
unsigned int UINT
Definition: ndis.h:50
#define LOWORD(l)
Definition: pedump.c:82
DWORD LCID
Definition: nls.h:13
DWORD dwFlags
Definition: imm32_undoc.h:98
DWORD cLockObj
Definition: imm32_undoc.h:97
#define ImmLocalFree(lpData)
Definition: precomp.h:105
#define IS_NULL_UNEXPECTEDLY(p)
Definition: precomp.h:66
LPVOID ImmLocalAlloc(_In_ DWORD dwFlags, _In_ DWORD dwBytes)
Definition: utils.c:275
#define TCI_SRCLOCALE
Definition: wingdi.h:964
BOOL WINAPI TranslateCharsetInfo(_Inout_ PDWORD, _Out_ LPCHARSETINFO, _In_ DWORD)

Referenced by Imm32FindOrLoadImeDpi(), and ImmLoadIME().

◆ Imm32ReleaseIME()

BOOL Imm32ReleaseIME ( _In_ HKL  hKL)

Definition at line 378 of file ime.c.

379{
380 BOOL ret = TRUE;
381 PIMEDPI pImeDpi0, pImeDpi1;
382
384
385 for (pImeDpi0 = gpImeDpiList; pImeDpi0; pImeDpi0 = pImeDpi0->pNext)
386 {
387 if (pImeDpi0->hKL == hKL)
388 break;
389 }
390
391 if (!pImeDpi0)
392 goto Quit;
393
394 if (pImeDpi0->cLockObj)
395 {
396 pImeDpi0->dwFlags |= IMEDPI_FLAG_UNLOADED;
397 ret = FALSE;
398 goto Quit;
399 }
400
401 if (gpImeDpiList == pImeDpi0)
402 {
403 gpImeDpiList = pImeDpi0->pNext;
404 }
405 else if (gpImeDpiList)
406 {
407 for (pImeDpi1 = gpImeDpiList; pImeDpi1; pImeDpi1 = pImeDpi1->pNext)
408 {
409 if (pImeDpi1->pNext == pImeDpi0)
410 {
411 pImeDpi1->pNext = pImeDpi0->pNext;
412 break;
413 }
414 }
415 }
416
417 Imm32FreeIME(pImeDpi0, TRUE);
418 ImmLocalFree(pImeDpi0);
419
420Quit:
422 return ret;
423}
#define IMEDPI_FLAG_UNLOADED
Definition: imm32_undoc.h:138

Referenced by ImmFreeLayout().

◆ ImmConfigureIMEA()

BOOL WINAPI ImmConfigureIMEA ( _In_ HKL  hKL,
_In_ HWND  hWnd,
_In_ DWORD  dwMode,
_Inout_opt_ LPVOID  lpData 
)

Definition at line 1597 of file ime.c.

1602{
1603 BOOL ret = FALSE;
1604 PIMEDPI pImeDpi;
1605 REGISTERWORDW RegWordW;
1606 LPREGISTERWORDA pRegWordA;
1607
1608 TRACE("(%p, %p, 0x%lX, %p)\n", hKL, hWnd, dwMode, lpData);
1609
1611 return FALSE;
1612
1613 pImeDpi = Imm32FindOrLoadImeDpi(hKL);
1614 if (IS_NULL_UNEXPECTEDLY(pImeDpi))
1615 return FALSE;
1616
1617 RtlZeroMemory(&RegWordW, sizeof(RegWordW));
1618
1619 if (!ImeDpi_IsUnicode(pImeDpi) || !lpData || dwMode != IME_CONFIG_REGISTERWORD)
1620 goto DoIt; /* No conversion needed */
1621
1622 pRegWordA = lpData;
1623
1624 if (pRegWordA->lpReading)
1625 {
1626 RegWordW.lpReading = Imm32WideFromAnsi(pImeDpi->uCodePage, pRegWordA->lpReading);
1627 if (IS_NULL_UNEXPECTEDLY(RegWordW.lpReading))
1628 goto Quit;
1629 }
1630
1631 if (pRegWordA->lpWord)
1632 {
1633 RegWordW.lpWord = Imm32WideFromAnsi(pImeDpi->uCodePage, pRegWordA->lpWord);
1634 if (IS_NULL_UNEXPECTEDLY(RegWordW.lpWord))
1635 goto Quit;
1636 }
1637
1638 lpData = &RegWordW;
1639
1640DoIt:
1641 SendMessageW(hWnd, WM_IME_SYSTEM, 0x1B, 0);
1642 ret = pImeDpi->ImeConfigure(hKL, hWnd, dwMode, lpData);
1643 SendMessageW(hWnd, WM_IME_SYSTEM, 0x1A, 0);
1644
1645Quit:
1646 ImmLocalFree(RegWordW.lpReading);
1647 ImmLocalFree(RegWordW.lpWord);
1648 ImmUnlockImeDpi(pImeDpi);
1649 TRACE("ret: %d\n", ret);
1650 return ret;
1651}
HWND hWnd
Definition: settings.c:17
PIMEDPI Imm32FindOrLoadImeDpi(HKL hKL)
Definition: ime.c:350
VOID WINAPI ImmUnlockImeDpi(_Inout_opt_ PIMEDPI pImeDpi)
Definition: ime.c:561
#define WM_IME_SYSTEM
Definition: imm32_undoc.h:32
#define IME_CONFIG_REGISTERWORD
Definition: imm.h:406
LPWSTR lpWord
Definition: dimm.idl:36
LPWSTR lpReading
Definition: dimm.idl:35
LPSTR lpReading
Definition: imm.h:28
LPSTR lpWord
Definition: imm.h:29
#define RtlZeroMemory(Destination, Length)
Definition: typedefs.h:262
#define ValidateHwnd(hwnd)
Definition: precomp.h:101
LPWSTR Imm32WideFromAnsi(UINT uCodePage, LPCSTR pszA)
Definition: utils.c:96
#define IS_CROSS_PROCESS_HWND(hWnd)
Definition: precomp.h:73
#define ImeDpi_IsUnicode(pImeDpi)
Definition: precomp.h:120
LRESULT WINAPI SendMessageW(_In_ HWND, _In_ UINT, _In_ WPARAM, _In_ LPARAM)

Referenced by ActiveIMMApp_ConfigureIMEA(), and test_ImmIME().

◆ ImmConfigureIMEW()

BOOL WINAPI ImmConfigureIMEW ( _In_ HKL  hKL,
_In_ HWND  hWnd,
_In_ DWORD  dwMode,
_Inout_opt_ LPVOID  lpData 
)

Definition at line 1657 of file ime.c.

1662{
1663 BOOL ret = FALSE;
1664 PIMEDPI pImeDpi;
1665 REGISTERWORDA RegWordA;
1666 LPREGISTERWORDW pRegWordW;
1667
1668 TRACE("(%p, %p, 0x%lX, %p)\n", hKL, hWnd, dwMode, lpData);
1669
1671 return FALSE;
1672
1673 pImeDpi = Imm32FindOrLoadImeDpi(hKL);
1674 if (IS_NULL_UNEXPECTEDLY(pImeDpi))
1675 return FALSE;
1676
1677 RtlZeroMemory(&RegWordA, sizeof(RegWordA));
1678
1679 if (ImeDpi_IsUnicode(pImeDpi) || !lpData || dwMode != IME_CONFIG_REGISTERWORD)
1680 goto DoIt; /* No conversion needed */
1681
1682 pRegWordW = lpData;
1683
1684 if (pRegWordW->lpReading)
1685 {
1686 RegWordA.lpReading = Imm32AnsiFromWide(pImeDpi->uCodePage, pRegWordW->lpReading);
1687 if (IS_NULL_UNEXPECTEDLY(RegWordA.lpReading))
1688 goto Quit;
1689 }
1690
1691 if (pRegWordW->lpWord)
1692 {
1693 RegWordA.lpWord = Imm32AnsiFromWide(pImeDpi->uCodePage, pRegWordW->lpWord);
1694 if (IS_NULL_UNEXPECTEDLY(RegWordA.lpWord))
1695 goto Quit;
1696 }
1697
1698 lpData = &RegWordA;
1699
1700DoIt:
1701 SendMessageW(hWnd, WM_IME_SYSTEM, 0x1B, 0);
1702 ret = pImeDpi->ImeConfigure(hKL, hWnd, dwMode, lpData);
1703 SendMessageW(hWnd, WM_IME_SYSTEM, 0x1A, 0);
1704
1705Quit:
1706 ImmLocalFree(RegWordA.lpReading);
1707 ImmLocalFree(RegWordA.lpWord);
1708 ImmUnlockImeDpi(pImeDpi);
1709 TRACE("ret: %d\n", ret);
1710 return ret;
1711}
LPSTR lpReading
Definition: dimm.idl:30
LPSTR lpWord
Definition: dimm.idl:31
LPWSTR lpReading
Definition: imm.h:33
LPWSTR lpWord
Definition: imm.h:34
LPSTR Imm32AnsiFromWide(UINT uCodePage, LPCWSTR pszW)
Definition: utils.c:107

Referenced by ActiveIMMApp_ConfigureIMEW(), ImeWnd_OnImeSystem(), and test_ImmIME().

◆ ImmDisableIME()

BOOL WINAPI ImmDisableIME ( _In_ DWORD  dwThreadId)

Definition at line 631 of file ime.c.

632{
634}
DWORD dwThreadId
Definition: fdebug.c:31
BOOL NTAPI NtUserDisableThreadIme(_In_ DWORD dwThreadID)
Definition: ime.c:903

Referenced by ActiveIMMApp_DisableIME(), and test_default_ime_disabled_cb().

◆ ImmEscapeA()

LRESULT WINAPI ImmEscapeA ( _In_ HKL  hKL,
_In_ HIMC  hIMC,
_In_ UINT  uSubFunc,
_Inout_opt_ LPVOID  lpData 
)

Definition at line 820 of file ime.c.

825{
826 LRESULT ret;
827 PIMEDPI pImeDpi;
828 INT cch;
831
832 TRACE("(%p, %p, %u, %p)\n", hKL, hIMC, uSubFunc, lpData);
833
834 pImeDpi = Imm32FindOrLoadImeDpi(hKL);
835 if (IS_NULL_UNEXPECTEDLY(pImeDpi))
836 return 0;
837
838 if (!ImeDpi_IsUnicode(pImeDpi) || !lpData) /* No conversion needed */
839 {
840 ret = ImeDpi_Escape(pImeDpi, hIMC, uSubFunc, lpData, hKL);
841 ImmUnlockImeDpi(pImeDpi);
842 return ret;
843 }
844
845 switch (uSubFunc)
846 {
848 ret = ImeDpi_Escape(pImeDpi, hIMC, uSubFunc, lpData, hKL);
849
850 cch = 0;
851 if (HIWORD(ret))
852 szW[cch++] = HIWORD(ret);
853 if (LOWORD(ret))
854 szW[cch++] = LOWORD(ret);
855
856 cch = WideCharToMultiByte(pImeDpi->uCodePage, 0, szW, cch, szA, _countof(szA),
857 NULL, NULL);
858 switch (cch)
859 {
860 case 1:
861 ret = MAKEWORD(szA[0], 0);
862 break;
863 case 2:
864 ret = MAKEWORD(szA[1], szA[0]);
865 break;
866 case 3:
867 ret = MAKELONG(MAKEWORD(szA[2], szA[1]), MAKEWORD(szA[0], 0));
868 break;
869 case 4:
870 ret = MAKELONG(MAKEWORD(szA[3], szA[2]), MAKEWORD(szA[1], szA[0]));
871 break;
872 default:
873 ret = 0;
874 break;
875 }
876 break;
877
879 case IME_ESC_IME_NAME:
881 ret = ImeDpi_Escape(pImeDpi, hIMC, uSubFunc, szW, hKL);
882 if (ret)
883 {
884 szW[_countof(szW) - 1] = UNICODE_NULL; /* Avoid buffer overrun */
885 WideCharToMultiByte(pImeDpi->uCodePage, 0, szW, -1,
886 lpData, MAX_IMM_FILENAME, NULL, NULL);
887 ((LPSTR)lpData)[MAX_IMM_FILENAME - 1] = ANSI_NULL; // Avoid buffer overrun
888 }
889 break;
890
894 lpData, -1, szW, _countof(szW));
895 szW[_countof(szW) - 1] = UNICODE_NULL; /* Avoid buffer overrun */
896 ret = ImeDpi_Escape(pImeDpi, hIMC, uSubFunc, szW, hKL);
897 break;
898
899 default:
900 ret = ImeDpi_Escape(pImeDpi, hIMC, uSubFunc, lpData, hKL);
901 break;
902 }
903
904 ImmUnlockImeDpi(pImeDpi);
905 TRACE("ret: %p\n", ret);
906 return ret;
907}
#define WideCharToMultiByte
Definition: compat.h:111
static LRESULT ImeDpi_Escape(PIMEDPI pImeDpi, HIMC hIMC, UINT uSubFunc, LPVOID lpData, HKL hKL)
Definition: ime.c:367
#define IME_ESC_SET_EUDC_DICTIONARY
Definition: imm.h:417
#define IME_ESC_HANJA_MODE
Definition: imm.h:421
#define IME_ESC_GETHELPFILENAME
Definition: imm.h:424
#define IME_ESC_GET_EUDC_DICTIONARY
Definition: imm.h:416
#define IME_ESC_IME_NAME
Definition: imm.h:419
#define IME_ESC_SEQUENCE_TO_INTERNAL
Definition: imm.h:415
static DWORD DWORD void LPSTR DWORD cch
Definition: str.c:202
#define ANSI_NULL
#define MAKEWORD(a, b)
Definition: typedefs.h:248
int32_t INT
Definition: typedefs.h:58
#define MAKELONG(a, b)
Definition: typedefs.h:249
#define HIWORD(l)
Definition: typedefs.h:247
#define MAX_IMM_FILENAME
Definition: precomp.h:79
LONG_PTR LRESULT
Definition: windef.h:209
char CHAR
Definition: xmlstorage.h:175

Referenced by ActiveIMMApp_EscapeA().

◆ ImmEscapeW()

LRESULT WINAPI ImmEscapeW ( _In_ HKL  hKL,
_In_ HIMC  hIMC,
_In_ UINT  uSubFunc,
_Inout_opt_ LPVOID  lpData 
)

Definition at line 913 of file ime.c.

918{
919 LRESULT ret;
920 PIMEDPI pImeDpi;
921 INT cch;
924 WORD word;
925
926 TRACE("(%p, %p, %u, %p)\n", hKL, hIMC, uSubFunc, lpData);
927
928 pImeDpi = Imm32FindOrLoadImeDpi(hKL);
929 if (IS_NULL_UNEXPECTEDLY(pImeDpi))
930 return 0;
931
932 if (ImeDpi_IsUnicode(pImeDpi) || !lpData) /* No conversion needed */
933 {
934 ret = ImeDpi_Escape(pImeDpi, hIMC, uSubFunc, lpData, hKL);
935 ImmUnlockImeDpi(pImeDpi);
936 return ret;
937 }
938
939 switch (uSubFunc)
940 {
942 ret = ImeDpi_Escape(pImeDpi, hIMC, uSubFunc, lpData, hKL);
943
944 word = LOWORD(ret);
945 cch = 0;
946 if (HIBYTE(word))
947 szA[cch++] = HIBYTE(word);
948 if (LOBYTE(word))
949 szA[cch++] = LOBYTE(word);
950
952 szA, cch, szW, _countof(szW));
953 switch (cch)
954 {
955 case 1: ret = szW[0]; break;
956 case 2: ret = MAKELONG(szW[1], szW[0]); break;
957 default: ret = 0; break;
958 }
959 break;
960
962 case IME_ESC_IME_NAME:
964 ret = ImeDpi_Escape(pImeDpi, hIMC, uSubFunc, szA, hKL);
965 if (ret)
966 {
967 szA[_countof(szA) - 1] = ANSI_NULL; // Avoid buffer overrun
969 szA, -1, lpData, MAX_IMM_FILENAME);
970 ((LPWSTR)lpData)[MAX_IMM_FILENAME - 1] = UNICODE_NULL; /* Avoid buffer overrun */
971 }
972 break;
973
976 WideCharToMultiByte(pImeDpi->uCodePage, 0,
977 lpData, -1, szA, _countof(szA), NULL, NULL);
978 szA[_countof(szA) - 1] = ANSI_NULL; // Avoid buffer overrun
979 ret = ImeDpi_Escape(pImeDpi, hIMC, uSubFunc, szA, hKL);
980 break;
981
982 default:
983 ret = ImeDpi_Escape(pImeDpi, hIMC, uSubFunc, lpData, hKL);
984 break;
985 }
986
987 ImmUnlockImeDpi(pImeDpi);
988 TRACE("ret: %p\n", ret);
989 return ret;
990}
unsigned short WORD
Definition: ntddk_ex.h:93
#define LOBYTE(W)
Definition: jmemdos.c:487
#define HIBYTE(W)
Definition: jmemdos.c:486
const WCHAR * word
Definition: lex.c:36
WCHAR * LPWSTR
Definition: xmlstorage.h:184

Referenced by ActiveIMMApp_EscapeW(), and User32DoImeHelp().

◆ ImmGetCompositionFontA()

BOOL WINAPI ImmGetCompositionFontA ( _In_ HIMC  hIMC,
_Out_ LPLOGFONTA  lplf 
)

Definition at line 1184 of file ime.c.

1187{
1188 PCLIENTIMC pClientImc;
1189 BOOL ret = FALSE, bWide;
1190 LPINPUTCONTEXT pIC;
1191
1192 TRACE("(%p, %p)\n", hIMC, lplf);
1193
1194 pClientImc = ImmLockClientImc(hIMC);
1195 if (IS_NULL_UNEXPECTEDLY(pClientImc))
1196 return FALSE;
1197
1198 bWide = (pClientImc->dwFlags & CLIENTIMC_WIDE);
1199 ImmUnlockClientImc(pClientImc);
1200
1201 pIC = ImmLockIMC(hIMC);
1202 if (IS_NULL_UNEXPECTEDLY(pIC))
1203 return FALSE;
1204
1205 if (pIC->fdwInit & INIT_LOGFONT)
1206 {
1207 if (bWide)
1208 LogFontWideToAnsi(&pIC->lfFont.W, lplf);
1209 else
1210 *lplf = pIC->lfFont.A;
1211
1212 ret = TRUE;
1213 }
1214
1215 ImmUnlockIMC(hIMC);
1216 return ret;
1217}
PCLIENTIMC WINAPI ImmLockClientImc(_In_ HIMC hImc)
Definition: imm.c:954
VOID WINAPI ImmUnlockClientImc(_Inout_ PCLIENTIMC pClientImc)
Definition: imm.c:1001
#define CLIENTIMC_WIDE
Definition: imm32_undoc.h:169
LPINPUTCONTEXT WINAPI ImmLockIMC(_In_ HIMC hIMC)
Definition: imm.c:1079
#define INIT_LOGFONT
Definition: immdev.h:154
BOOL WINAPI ImmUnlockIMC(_In_ HIMC hIMC)
Definition: imm.c:1089
union _tagINPUTCONTEXT::@2224 lfFont
DWORD fdwInit
Definition: immdev.h:125
LOGFONTA A
Definition: immdev.h:114
LOGFONTW W
Definition: immdev.h:115
VOID LogFontWideToAnsi(const LOGFONTW *plfW, LPLOGFONTA plfA)
Definition: utils.c:176

Referenced by ActiveIMMApp_GetCompositionFontA(), ImeWnd_OnImeControl(), test_ImmThreads(), and test_InvalidIMC().

◆ ImmGetCompositionFontW()

BOOL WINAPI ImmGetCompositionFontW ( _In_ HIMC  hIMC,
_Out_ LPLOGFONTW  lplf 
)

Definition at line 1223 of file ime.c.

1226{
1227 PCLIENTIMC pClientImc;
1228 BOOL bWide;
1229 LPINPUTCONTEXT pIC;
1230 BOOL ret = FALSE;
1231
1232 TRACE("(%p, %p)\n", hIMC, lplf);
1233
1234 pClientImc = ImmLockClientImc(hIMC);
1235 if (IS_NULL_UNEXPECTEDLY(pClientImc))
1236 return FALSE;
1237
1238 bWide = (pClientImc->dwFlags & CLIENTIMC_WIDE);
1239 ImmUnlockClientImc(pClientImc);
1240
1241 pIC = ImmLockIMC(hIMC);
1242 if (IS_NULL_UNEXPECTEDLY(pIC))
1243 return FALSE;
1244
1245 if (pIC->fdwInit & INIT_LOGFONT)
1246 {
1247 if (bWide)
1248 *lplf = pIC->lfFont.W;
1249 else
1250 LogFontAnsiToWide(&pIC->lfFont.A, lplf);
1251
1252 ret = TRUE;
1253 }
1254
1255 ImmUnlockIMC(hIMC);
1256 return ret;
1257}
VOID LogFontAnsiToWide(const LOGFONTA *plfA, LPLOGFONTW plfW)
Definition: utils.c:164

Referenced by ActiveIMMApp_GetCompositionFontW(), and ImeWnd_OnImeControl().

◆ ImmGetCompositionWindow()

BOOL WINAPI ImmGetCompositionWindow ( _In_ HIMC  hIMC,
_Out_ LPCOMPOSITIONFORM  lpCompForm 
)

Definition at line 1122 of file ime.c.

1125{
1126 LPINPUTCONTEXT pIC;
1127 BOOL ret = FALSE;
1128
1129 TRACE("(%p, %p)\n", hIMC, lpCompForm);
1130
1131 pIC = ImmLockIMC(hIMC);
1132 if (IS_NULL_UNEXPECTEDLY(pIC))
1133 return FALSE;
1134
1135 if (pIC->fdwInit & INIT_COMPFORM)
1136 {
1137 *lpCompForm = pIC->cfCompForm;
1138 ret = TRUE;
1139 }
1140
1141 ImmUnlockIMC(hIMC);
1142 return ret;
1143}
#define INIT_COMPFORM
Definition: immdev.h:155
COMPOSITIONFORM cfCompForm
Definition: immdev.h:117

Referenced by ActiveIMMApp_GetCompositionWindow(), ImeWnd_OnImeSystem(), test_ImmThreads(), and test_InvalidIMC().

◆ ImmGetConversionListA()

DWORD WINAPI ImmGetConversionListA ( _In_ HKL  hKL,
_In_ HIMC  hIMC,
_In_ LPCSTR  pSrc,
_Out_writes_bytes_(dwBufLen) LPCANDIDATELIST  lpDst,
_In_ DWORD  dwBufLen,
_In_ UINT  uFlag 
)

Definition at line 1381 of file ime.c.

1388{
1389 DWORD ret = 0;
1390 UINT cb;
1391 LPWSTR pszSrcW = NULL;
1392 LPCANDIDATELIST pCL = NULL;
1393 PIMEDPI pImeDpi;
1394
1395 TRACE("(%p, %p, %s, %p, %lu, 0x%lX)\n", hKL, hIMC, debugstr_a(pSrc), lpDst, dwBufLen, uFlag);
1396
1397 pImeDpi = Imm32FindOrLoadImeDpi(hKL);
1398 if (IS_NULL_UNEXPECTEDLY(pImeDpi))
1399 return 0;
1400
1401 if (!ImeDpi_IsUnicode(pImeDpi)) /* No conversion needed */
1402 {
1403 ret = pImeDpi->ImeConversionList(hIMC, pSrc, lpDst, dwBufLen, uFlag);
1404 ImmUnlockImeDpi(pImeDpi);
1405 return ret;
1406 }
1407
1408 if (pSrc)
1409 {
1410 pszSrcW = Imm32WideFromAnsi(pImeDpi->uCodePage, pSrc);
1411 if (IS_NULL_UNEXPECTEDLY(pszSrcW))
1412 goto Quit;
1413 }
1414
1415 cb = pImeDpi->ImeConversionList(hIMC, pszSrcW, NULL, 0, uFlag);
1417 goto Quit;
1418
1419 pCL = ImmLocalAlloc(0, cb);
1420 if (IS_NULL_UNEXPECTEDLY(pCL))
1421 goto Quit;
1422
1423 cb = pImeDpi->ImeConversionList(hIMC, pszSrcW, pCL, cb, uFlag);
1425 goto Quit;
1426
1427 ret = CandidateListWideToAnsi(pCL, lpDst, dwBufLen, pImeDpi->uCodePage);
1428
1429Quit:
1430 ImmLocalFree(pszSrcW);
1431 ImmLocalFree(pCL);
1432 ImmUnlockImeDpi(pImeDpi);
1433 TRACE("ret: 0x%X\n", ret);
1434 return ret;
1435}
DWORD CandidateListWideToAnsi(const CANDIDATELIST *pWideCL, LPCANDIDATELIST pAnsiCL, DWORD dwBufLen, UINT uCodePage)
Definition: candidate.c:15
#define debugstr_a
Definition: kernel32.h:31
static HMODULE MODULEINFO DWORD cb
Definition: module.c:33
#define IS_ZERO_UNEXPECTEDLY(p)
Definition: precomp.h:67

Referenced by ActiveIMMApp_GetConversionListA().

◆ ImmGetConversionListW()

DWORD WINAPI ImmGetConversionListW ( _In_ HKL  hKL,
_In_ HIMC  hIMC,
_In_ LPCWSTR  pSrc,
_Out_writes_bytes_(dwBufLen) LPCANDIDATELIST  lpDst,
_In_ DWORD  dwBufLen,
_In_ UINT  uFlag 
)

Definition at line 1441 of file ime.c.

1448{
1449 DWORD ret = 0;
1450 INT cb;
1451 PIMEDPI pImeDpi;
1452 LPCANDIDATELIST pCL = NULL;
1453 LPSTR pszSrcA = NULL;
1454
1455 TRACE("(%p, %p, %s, %p, %lu, 0x%lX)\n", hKL, hIMC, debugstr_w(pSrc), lpDst, dwBufLen, uFlag);
1456
1457 pImeDpi = Imm32FindOrLoadImeDpi(hKL);
1458 if (IS_NULL_UNEXPECTEDLY(pImeDpi))
1459 return 0;
1460
1461 if (ImeDpi_IsUnicode(pImeDpi)) /* No conversion needed */
1462 {
1463 ret = pImeDpi->ImeConversionList(hIMC, pSrc, lpDst, dwBufLen, uFlag);
1464 ImmUnlockImeDpi(pImeDpi);
1465 return ret;
1466 }
1467
1468 if (pSrc)
1469 {
1470 pszSrcA = Imm32AnsiFromWide(pImeDpi->uCodePage, pSrc);
1471 if (IS_NULL_UNEXPECTEDLY(pszSrcA))
1472 goto Quit;
1473 }
1474
1475 cb = pImeDpi->ImeConversionList(hIMC, pszSrcA, NULL, 0, uFlag);
1477 goto Quit;
1478
1479 pCL = ImmLocalAlloc(0, cb);
1480 if (IS_NULL_UNEXPECTEDLY(pCL))
1481 goto Quit;
1482
1483 cb = pImeDpi->ImeConversionList(hIMC, pszSrcA, pCL, cb, uFlag);
1485 goto Quit;
1486
1487 ret = CandidateListAnsiToWide(pCL, lpDst, dwBufLen, pImeDpi->uCodePage);
1488
1489Quit:
1490 ImmLocalFree(pszSrcA);
1491 ImmLocalFree(pCL);
1492 ImmUnlockImeDpi(pImeDpi);
1493 TRACE("ret: 0x%X\n", ret);
1494 return ret;
1495}
DWORD CandidateListAnsiToWide(const CANDIDATELIST *pAnsiCL, LPCANDIDATELIST pWideCL, DWORD dwBufLen, UINT uCodePage)
Definition: candidate.c:84

Referenced by ActiveIMMApp_GetConversionListW().

◆ ImmGetConversionStatus()

BOOL WINAPI ImmGetConversionStatus ( _In_ HIMC  hIMC,
_Out_opt_ LPDWORD  lpfdwConversion,
_Out_opt_ LPDWORD  lpfdwSentence 
)

Definition at line 1501 of file ime.c.

1505{
1506 LPINPUTCONTEXT pIC;
1507
1508 TRACE("(%p %p %p)\n", hIMC, lpfdwConversion, lpfdwSentence);
1509
1510 pIC = ImmLockIMC(hIMC);
1511 if (IS_NULL_UNEXPECTEDLY(pIC))
1512 return FALSE;
1513
1514 if (lpfdwConversion)
1515 {
1516 *lpfdwConversion = pIC->fdwConversion;
1517 TRACE("0x%X\n", *lpfdwConversion);
1518 }
1519
1520 if (lpfdwSentence)
1521 {
1522 *lpfdwSentence = pIC->fdwSentence;
1523 TRACE("0x%X\n", *lpfdwSentence);
1524 }
1525
1526 ImmUnlockIMC(hIMC);
1527 return TRUE;
1528}
DWORD fdwConversion
Definition: immdev.h:111
DWORD fdwSentence
Definition: immdev.h:112

Referenced by ActiveIMMApp_GetConversionStatus(), GetImeStatus(), ImeWnd_OnImeControl(), ImeWnd_OnImeSystem(), ImeWnd_SwitchSoftKbdProc(), OnTimer(), and test_ImmThreads().

◆ ImmGetDefaultIMEWnd()

◆ ImmGetDescriptionA()

UINT WINAPI ImmGetDescriptionA ( _In_ HKL  hKL,
_Out_writes_opt_(uBufLen) LPSTR  lpszDescription,
_In_ UINT  uBufLen 
)

Definition at line 640 of file ime.c.

644{
646 size_t cch;
647
648 TRACE("(%p,%p,%d)\n", hKL, lpszDescription, uBufLen);
649
651 {
652 ERR("\n");
653 return 0;
654 }
655
656 StringCchLengthW(info.wszImeDescription, _countof(info.wszImeDescription), &cch);
657 cch = WideCharToMultiByte(CP_ACP, 0, info.wszImeDescription, (INT)cch,
658 lpszDescription, uBufLen, NULL, NULL);
659 if (uBufLen)
660 lpszDescription[cch] = ANSI_NULL;
661 return (UINT)cch;
662}
STRSAFEAPI StringCchLengthW(STRSAFE_LPCWSTR psz, size_t cchMax, size_t *pcchLength)
Definition: strsafe.h:842

Referenced by ActiveIMMApp_GetDescriptionA(), and test_ImmGetDescription().

◆ ImmGetDescriptionW()

UINT WINAPI ImmGetDescriptionW ( _In_ HKL  hKL,
_Out_writes_opt_(uBufLen) LPWSTR  lpszDescription,
_In_ UINT  uBufLen 
)

Definition at line 668 of file ime.c.

672{
674 size_t cch;
675
676 TRACE("(%p, %p, %d)\n", hKL, lpszDescription, uBufLen);
677
679 {
680 ERR("\n");
681 return 0;
682 }
683
684 if (uBufLen != 0)
685 StringCchCopyW(lpszDescription, uBufLen, info.wszImeDescription);
686
687 StringCchLengthW(info.wszImeDescription, _countof(info.wszImeDescription), &cch);
688 return (UINT)cch;
689}

Referenced by ActiveIMMApp_GetDescriptionW(), GetHKLDesctription(), and test_ImmGetDescription().

◆ ImmGetIMEFileNameA()

UINT WINAPI ImmGetIMEFileNameA ( _In_ HKL  hKL,
_Out_writes_opt_(uBufLen) LPSTR  lpszFileName,
_In_ UINT  uBufLen 
)

Definition at line 695 of file ime.c.

699{
700 BOOL bDefUsed;
702 size_t cch;
703
704 TRACE("(%p, %p, %u)\n", hKL, lpszFileName, uBufLen);
705
707 {
708 ERR("\n");
709 if (uBufLen > 0)
710 lpszFileName[0] = ANSI_NULL;
711 return 0;
712 }
713
714 StringCchLengthW(info.wszImeFile, _countof(info.wszImeFile), &cch);
715
716 cch = WideCharToMultiByte(CP_ACP, 0, info.wszImeFile, (INT)cch,
717 lpszFileName, uBufLen, NULL, &bDefUsed);
718 if (uBufLen == 0)
719 return (UINT)cch;
720
721 if (cch > uBufLen - 1)
722 cch = uBufLen - 1;
723
724 lpszFileName[cch] = ANSI_NULL;
725 return (UINT)cch;
726}

Referenced by ActiveIMMApp_GetIMEFileNameA().

◆ ImmGetIMEFileNameW()

UINT WINAPI ImmGetIMEFileNameW ( _In_ HKL  hKL,
_Out_writes_opt_(uBufLen) LPWSTR  lpszFileName,
_In_ UINT  uBufLen 
)

Definition at line 732 of file ime.c.

736{
738 size_t cch;
739
740 TRACE("(%p, %p, %u)\n", hKL, lpszFileName, uBufLen);
741
743 {
744 ERR("\n");
745 if (uBufLen > 0)
746 lpszFileName[0] = UNICODE_NULL;
747 return 0;
748 }
749
750 StringCchLengthW(info.wszImeFile, _countof(info.wszImeFile), &cch);
751 if (uBufLen == 0)
752 return (UINT)cch;
753
754 StringCchCopyNW(lpszFileName, uBufLen, info.wszImeFile, cch);
755
756 if (cch > uBufLen - 1)
757 cch = uBufLen - 1;
758
759 lpszFileName[cch] = UNICODE_NULL;
760 return (UINT)cch;
761}
STRSAFEAPI StringCchCopyNW(STRSAFE_LPWSTR pszDest, size_t cchDest, STRSAFE_LPCWSTR pszSrc, size_t cchToCopy)
Definition: strsafe.h:236

Referenced by ActiveIMMApp_GetIMEFileNameW(), and GetHKLDesctription().

◆ ImmGetImeInfoEx()

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

Definition at line 491 of file ime.c.

492{
493 BOOL bTextServiceDisabled = FALSE;
494
495 if (SearchType == ImeInfoExKeyboardLayoutTFS)
496 {
497 SearchType = ImeInfoExKeyboardLayout;
498 bTextServiceDisabled = CtfImmIsTextFrameServiceDisabled();
499 }
500
501 if (SearchType == ImeInfoExKeyboardLayout)
502 {
503 HKL hKL = *(HKL *)pvSearchKey;
504 pImeInfoEx->hkl = hKL;
505
506 if (!IS_IME_HKL(hKL) &&
507 (!IS_CICERO_MODE() || IS_CICERO_COMPAT_DISABLED() || bTextServiceDisabled))
508 {
509 TRACE("IME is disabled\n");
510 return FALSE;
511 }
512
513 return NtUserGetImeInfoEx(pImeInfoEx, SearchType);
514 }
515
516 if (SearchType == ImeInfoExImeFileName)
517 {
518 StringCchCopyW(pImeInfoEx->wszImeFile, _countof(pImeInfoEx->wszImeFile), pvSearchKey);
519 return NtUserGetImeInfoEx(pImeInfoEx, SearchType);
520 }
521
522 /* NOTE: ImeInfoExImeWindow is ignored */
523 ERR("SearchType: %d\n", SearchType);
524 return FALSE;
525}
BOOL WINAPI CtfImmIsTextFrameServiceDisabled(VOID)
Definition: ctf.c:1079
@ ImeInfoExImeFileName
Definition: imm32_undoc.h:82
@ ImeInfoExKeyboardLayoutTFS
Definition: imm32_undoc.h:80
BOOL NTAPI NtUserGetImeInfoEx(_Inout_ PIMEINFOEX pImeInfoEx, _In_ IMEINFOEXCLASS SearchType)
Definition: ime.c:1067
UINT_PTR HKL
Definition: msctf.idl:125

Referenced by Imm32LoadImeDpi(), ImmGetDescriptionA(), ImmGetDescriptionW(), ImmGetIMEFileNameA(), ImmGetIMEFileNameW(), ImmGetProperty(), and ImmIsIME().

◆ ImmGetOpenStatus()

BOOL WINAPI ImmGetOpenStatus ( _In_ HIMC  hIMC)

Definition at line 996 of file ime.c.

997{
998 BOOL ret;
999 LPINPUTCONTEXT pIC;
1000
1001 TRACE("(%p)\n", hIMC);
1002
1003 if (IS_NULL_UNEXPECTEDLY(hIMC))
1004 return FALSE;
1005
1006 pIC = ImmLockIMC(hIMC);
1007 if (IS_NULL_UNEXPECTEDLY(pIC))
1008 return FALSE;
1009
1010 ret = pIC->fOpen;
1011 ImmUnlockIMC(hIMC);
1012 TRACE("ret: %d\n", ret);
1013 return ret;
1014}

Referenced by ActiveIMMApp_GetOpenStatus(), GetImeStatus(), ImeWnd_OnImeControl(), Imm32JCloseOpen(), test_ImmThreads(), and test_InvalidIMC().

◆ ImmGetProperty()

DWORD WINAPI ImmGetProperty ( _In_ HKL  hKL,
_In_ DWORD  fdwIndex 
)

Definition at line 767 of file ime.c.

770{
771 IMEINFOEX ImeInfoEx;
772 LPIMEINFO pImeInfo;
773 DWORD dwValue;
774 PIMEDPI pImeDpi = NULL;
775
776 TRACE("(%p, %lu)\n", hKL, fdwIndex);
777
778 if (!ImmGetImeInfoEx(&ImeInfoEx, ImeInfoExKeyboardLayout, &hKL))
779 {
780 ERR("\n");
781 return FALSE;
782 }
783
784 if (fdwIndex == IGP_GETIMEVERSION)
785 return ImeInfoEx.dwImeWinVersion;
786
787 if (ImeInfoEx.fLoadFlag != 2)
788 {
789 pImeDpi = Imm32FindOrLoadImeDpi(hKL);
790 if (IS_NULL_UNEXPECTEDLY(pImeDpi))
791 return FALSE;
792
793 pImeInfo = &pImeDpi->ImeInfo;
794 }
795 else
796 {
797 pImeInfo = &ImeInfoEx.ImeInfo;
798 }
799
800 switch (fdwIndex)
801 {
802 case IGP_PROPERTY: dwValue = pImeInfo->fdwProperty; break;
803 case IGP_CONVERSION: dwValue = pImeInfo->fdwConversionCaps; break;
804 case IGP_SENTENCE: dwValue = pImeInfo->fdwSentenceCaps; break;
805 case IGP_UI: dwValue = pImeInfo->fdwUICaps; break;
806 case IGP_SETCOMPSTR: dwValue = pImeInfo->fdwSCSCaps; break;
807 case IGP_SELECT: dwValue = pImeInfo->fdwSelectCaps; break;
808 default: dwValue = 0; break;
809 }
810
811 if (pImeDpi)
812 ImmUnlockImeDpi(pImeDpi);
813 return dwValue;
814}
#define IGP_SELECT
Definition: imm.h:305
#define IGP_SETCOMPSTR
Definition: imm.h:304
#define IGP_GETIMEVERSION
Definition: imm.h:299
#define IGP_PROPERTY
Definition: imm.h:300
#define IGP_SENTENCE
Definition: imm.h:302
#define IGP_CONVERSION
Definition: imm.h:301
#define IGP_UI
Definition: imm.h:303
DWORD dwImeWinVersion
Definition: imm32_undoc.h:67

Referenced by ActiveIMMApp_GetProperty(), KbSwitch_OnPenIconMsg(), and test_ImmGetCompositionString().

◆ ImmGetStatusWindowPos()

BOOL WINAPI ImmGetStatusWindowPos ( _In_ HIMC  hIMC,
_Out_ LPPOINT  lpptPos 
)

Definition at line 1066 of file ime.c.

1069{
1070 LPINPUTCONTEXT pIC;
1071 BOOL ret;
1072
1073 TRACE("(%p, %p)\n", hIMC, lpptPos);
1074
1075 pIC = ImmLockIMC(hIMC);
1076 if (IS_NULL_UNEXPECTEDLY(pIC))
1077 return FALSE;
1078
1079 ret = !!(pIC->fdwInit & INIT_STATUSWNDPOS);
1080 if (ret)
1081 *lpptPos = pIC->ptStatusWndPos;
1082
1083 ImmUnlockIMC(hIMC);
1084 return ret;
1085}
#define INIT_STATUSWNDPOS
Definition: immdev.h:151
POINT ptStatusWndPos
Definition: immdev.h:109

Referenced by ActiveIMMApp_GetStatusWindowPos(), test_ImmThreads(), and test_InvalidIMC().

◆ ImmIsIME()

◆ ImmLoadIME()

BOOL WINAPI ImmLoadIME ( _In_ HKL  hKL)

Definition at line 611 of file ime.c.

612{
613 PIMEDPI pImeDpi;
614
615 if (!IS_IME_HKL(hKL) && (!IS_CICERO_MODE() || IS_16BIT_MODE()))
616 {
617 TRACE("\n");
618 return FALSE;
619 }
620
621 pImeDpi = Imm32FindImeDpi(hKL);
622 if (pImeDpi == NULL)
623 pImeDpi = Imm32LoadImeDpi(hKL, FALSE);
624 return (pImeDpi != NULL);
625}

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

◆ ImmLockImeDpi()

PIMEDPI WINAPI ImmLockImeDpi ( _In_ HKL  hKL)

Definition at line 531 of file ime.c.

532{
533 PIMEDPI pImeDpi = NULL;
534
535 TRACE("(%p)\n", hKL);
536
538
539 /* Find by hKL */
540 for (pImeDpi = gpImeDpiList; pImeDpi; pImeDpi = pImeDpi->pNext)
541 {
542 if (pImeDpi->hKL == hKL) /* found */
543 {
544 /* lock if possible */
545 if (pImeDpi->dwFlags & IMEDPI_FLAG_UNLOADED)
546 pImeDpi = NULL;
547 else
548 ++(pImeDpi->cLockObj);
549 break;
550 }
551 }
552
554 return pImeDpi;
555}

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

◆ ImmNotifyIME()

BOOL WINAPI ImmNotifyIME ( _In_ HIMC  hIMC,
_In_ DWORD  dwAction,
_In_ DWORD  dwIndex,
_In_ DWORD_PTR  dwValue 
)

Definition at line 458 of file ime.c.

463{
464 HKL hKL;
465 PIMEDPI pImeDpi;
466 BOOL ret;
467
468 TRACE("(%p, %lu, %lu, %lu)\n", hIMC, dwAction, dwIndex, dwValue);
469
470 if (hIMC && IS_CROSS_THREAD_HIMC(hIMC))
471 return FALSE;
472
473 hKL = GetKeyboardLayout(0);
474 pImeDpi = ImmLockImeDpi(hKL);
475 if (IS_NULL_UNEXPECTEDLY(pImeDpi))
476 return FALSE;
477
478 TRACE("NotifyIME(%p, %lu, %lu, %p)\n", hIMC, dwAction, dwIndex, dwValue);
479 ret = pImeDpi->NotifyIME(hIMC, dwAction, dwIndex, dwValue);
480 if (!ret)
481 WARN("NotifyIME(%p, %lu, %lu, %p) failed\n", hIMC, dwAction, dwIndex, dwValue);
482
483 ImmUnlockImeDpi(pImeDpi);
484 return ret;
485}
#define WARN(fmt,...)
Definition: precomp.h:61
#define IS_CROSS_THREAD_HIMC(hIMC)
Definition: precomp.h:72
HKL WINAPI GetKeyboardLayout(_In_ DWORD)

Referenced by ActiveIMMApp_NotifyIME(), EDIT_WindowProc(), editor_handle_message(), Imm32NotifyIMEProc(), ImmSystemHandler(), CicBridge::SetActiveContextAlways(), CicBridge::SetCompositionString(), test_ImmGetCompositionString(), test_ImmNotifyIME(), and User32ImeMenuItemSelected().

◆ ImmSetCompositionFontA()

BOOL WINAPI ImmSetCompositionFontA ( _In_ HIMC  hIMC,
_In_ LPLOGFONTA  lplf 
)

Definition at line 1263 of file ime.c.

1266{
1267 LOGFONTW lfW;
1268 PCLIENTIMC pClientImc;
1269 BOOL bWide;
1270 LPINPUTCONTEXTDX pIC;
1271 LANGID LangID;
1272 HWND hWnd;
1273
1274 TRACE("(%p, %p)\n", hIMC, lplf);
1275
1276 if (IS_CROSS_THREAD_HIMC(hIMC))
1277 return FALSE;
1278
1279 pClientImc = ImmLockClientImc(hIMC);
1280 if (IS_NULL_UNEXPECTEDLY(pClientImc))
1281 return FALSE;
1282
1283 bWide = (pClientImc->dwFlags & CLIENTIMC_WIDE);
1284 ImmUnlockClientImc(pClientImc);
1285
1286 if (bWide)
1287 {
1288 LogFontAnsiToWide(lplf, &lfW);
1289 return ImmSetCompositionFontW(hIMC, &lfW);
1290 }
1291
1292 pIC = (LPINPUTCONTEXTDX)ImmLockIMC(hIMC);
1293 if (IS_NULL_UNEXPECTEDLY(pIC))
1294 return FALSE;
1295
1296 if (GetWin32ClientInfo()->dwExpWinVer < _WIN32_WINNT_NT4) /* old version (3.x)? */
1297 {
1300 !(pIC->dwUIFlags & 2) &&
1301 pIC->cfCompForm.dwStyle != CFS_DEFAULT)
1302 {
1304 }
1305 }
1306
1307 pIC->lfFont.A = *lplf;
1308 pIC->fdwInit |= INIT_LOGFONT;
1309 hWnd = pIC->hWnd;
1310
1311 ImmUnlockIMC(hIMC);
1312
1315 return TRUE;
1316}
LCID WINAPI GetSystemDefaultLCID(void)
Definition: locale.c:1235
BOOL WINAPI ImmSetCompositionFontW(_In_ HIMC hIMC, _In_ LPLOGFONTW lplf)
Definition: ime.c:1322
struct INPUTCONTEXTDX * LPINPUTCONTEXTDX
#define IMN_SETCOMPOSITIONFONT
Definition: imm.h:381
#define CFS_DEFAULT
Definition: imm.h:323
#define IMC_SETCOMPOSITIONFONT
Definition: imm.h:151
#define WM_IME_REPORT
Definition: immdev.h:166
#define NI_CONTEXTUPDATED
Definition: immdev.h:375
#define IR_CHANGECONVERT
Definition: immdev.h:173
USHORT LANGID
Definition: mui.h:9
#define LANGIDFROMLCID(l)
Definition: nls.h:18
#define LANG_JAPANESE
Definition: nls.h:76
#define PRIMARYLANGID(l)
Definition: nls.h:16
#define _WIN32_WINNT_NT4
Definition: sdkddkver.h:20
_Must_inspect_result_ _In_ WDFUSBDEVICE _In_opt_ WDFREQUEST _In_opt_ PWDF_REQUEST_SEND_OPTIONS _Out_writes_opt_ NumCharacters PUSHORT _Inout_ PUSHORT _In_ UCHAR _In_opt_ USHORT LangID
Definition: wdfusb.h:1083
BOOL Imm32MakeIMENotify(_In_ HIMC hIMC, _In_ HWND hwnd, _In_ DWORD dwAction, _In_ DWORD dwIndex, _Inout_opt_ DWORD_PTR dwValue, _In_ DWORD dwCommand, _Inout_opt_ DWORD_PTR dwData)
Definition: utils.c:287
BOOL WINAPI PostMessageA(_In_opt_ HWND, _In_ UINT, _In_ WPARAM, _In_ LPARAM)

Referenced by ActiveIMMApp_SetCompositionFontA(), ImeWnd_OnImeControl(), ImmSetCompositionFontW(), test_ImmThreads(), and test_InvalidIMC().

◆ ImmSetCompositionFontW()

BOOL WINAPI ImmSetCompositionFontW ( _In_ HIMC  hIMC,
_In_ LPLOGFONTW  lplf 
)

Definition at line 1322 of file ime.c.

1325{
1326 LOGFONTA lfA;
1327 PCLIENTIMC pClientImc;
1328 BOOL bWide;
1329 HWND hWnd;
1330 LPINPUTCONTEXTDX pIC;
1331 LANGID LangID;
1332
1333 TRACE("(%p, %p)\n", hIMC, lplf);
1334
1335 if (IS_CROSS_THREAD_HIMC(hIMC))
1336 return FALSE;
1337
1338 pClientImc = ImmLockClientImc(hIMC);
1339 if (IS_NULL_UNEXPECTEDLY(pClientImc))
1340 return FALSE;
1341
1342 bWide = (pClientImc->dwFlags & CLIENTIMC_WIDE);
1343 ImmUnlockClientImc(pClientImc);
1344
1345 if (!bWide)
1346 {
1347 LogFontWideToAnsi(lplf, &lfA);
1348 return ImmSetCompositionFontA(hIMC, &lfA);
1349 }
1350
1351 pIC = (LPINPUTCONTEXTDX)ImmLockIMC(hIMC);
1352 if (IS_NULL_UNEXPECTEDLY(pIC))
1353 return FALSE;
1354
1355 if (GetWin32ClientInfo()->dwExpWinVer < _WIN32_WINNT_NT4) /* old version (3.x)? */
1356 {
1359 !(pIC->dwUIFlags & 2) &&
1360 pIC->cfCompForm.dwStyle != CFS_DEFAULT)
1361 {
1363 }
1364 }
1365
1366 pIC->lfFont.W = *lplf;
1367 pIC->fdwInit |= INIT_LOGFONT;
1368 hWnd = pIC->hWnd;
1369
1370 ImmUnlockIMC(hIMC);
1371
1374 return TRUE;
1375}
BOOL WINAPI ImmSetCompositionFontA(_In_ HIMC hIMC, _In_ LPLOGFONTA lplf)
Definition: ime.c:1263
BOOL WINAPI PostMessageW(_In_opt_ HWND, _In_ UINT, _In_ WPARAM, _In_ LPARAM)

Referenced by ActiveIMMApp_SetCompositionFontW(), EDIT_WM_SetFont(), editor_handle_message(), ImeWnd_OnImeControl(), ImeWnd_OnImeSystem(), ImmSetCompositionFontA(), and update_caret().

◆ ImmSetCompositionWindow()

BOOL WINAPI ImmSetCompositionWindow ( _In_ HIMC  hIMC,
_In_ LPCOMPOSITIONFORM  lpCompForm 
)

Definition at line 1149 of file ime.c.

1152{
1153 LPINPUTCONTEXTDX pIC;
1154 HWND hWnd;
1155
1156 if (Imm32IsCrossThreadAccess(hIMC))
1157 return FALSE;
1158
1159 pIC = (LPINPUTCONTEXTDX)ImmLockIMC(hIMC);
1160 if (IS_NULL_UNEXPECTEDLY(pIC))
1161 return FALSE;
1162
1163 pIC->cfCompForm = *lpCompForm;
1164 pIC->fdwInit |= INIT_COMPFORM;
1165
1166 if (pIC->dwUIFlags & 0x8)
1167 pIC->dwUIFlags &= ~0x8;
1168 else
1169 pIC->dwUIFlags &= ~0x2;
1170
1171 hWnd = pIC->hWnd;
1172
1173 ImmUnlockIMC(hIMC);
1174
1177 return TRUE;
1178}
#define IMC_SETCOMPOSITIONWINDOW
Definition: imm.h:153
#define IMN_SETCOMPOSITIONWINDOW
Definition: imm.h:382
BOOL Imm32IsCrossThreadAccess(HIMC hIMC)
Definition: utils.c:25

Referenced by ActiveIMMApp_SetCompositionWindow(), ImeWnd_OnImeControl(), ImeWnd_OnImeSetContext(), ImeWnd_OnImeSystem(), ImmGetContextThreadFunc(), test_ImmThreads(), test_InvalidIMC(), and update_caret().

◆ ImmSetConversionStatus()

BOOL WINAPI ImmSetConversionStatus ( _In_ HIMC  hIMC,
_In_ DWORD  fdwConversion,
_In_ DWORD  fdwSentence 
)

Definition at line 1534 of file ime.c.

1538{
1539 HKL hKL;
1540 LPINPUTCONTEXT pIC;
1541 DWORD dwOldConversion, dwOldSentence;
1542 BOOL fOpen = FALSE, fConversionChange = FALSE, fSentenceChange = FALSE, fUseCicero = FALSE;
1543 HWND hWnd;
1544
1545 TRACE("(%p, 0x%lX, 0x%lX)\n", hIMC, fdwConversion, fdwSentence);
1546
1547 hKL = GetKeyboardLayout(0);
1548 if (!IS_IME_HKL(hKL) && IS_CICERO_MODE() && !IS_16BIT_MODE())
1549 fUseCicero = TRUE;
1550
1551 if (IS_CROSS_THREAD_HIMC(hIMC))
1552 return FALSE;
1553
1554 pIC = ImmLockIMC(hIMC);
1555 if (IS_NULL_UNEXPECTEDLY(pIC))
1556 return FALSE;
1557
1558 if (pIC->fdwConversion != fdwConversion)
1559 {
1560 dwOldConversion = pIC->fdwConversion;
1561 pIC->fdwConversion = fdwConversion;
1562 fConversionChange = TRUE;
1563 }
1564
1565 if (pIC->fdwSentence != fdwSentence)
1566 {
1567 dwOldSentence = pIC->fdwSentence;
1568 pIC->fdwSentence = fdwSentence;
1569 fSentenceChange = TRUE;
1570 }
1571
1572 hWnd = pIC->hWnd;
1573 fOpen = pIC->fOpen;
1574 ImmUnlockIMC(hIMC);
1575
1576 if (fConversionChange || fUseCicero)
1577 {
1578 Imm32MakeIMENotify(hIMC, hWnd, NI_CONTEXTUPDATED, dwOldConversion,
1580 if (fConversionChange)
1581 NtUserNotifyIMEStatus(hWnd, fOpen, fdwConversion);
1582 }
1583
1584 if (fSentenceChange || fUseCicero)
1585 {
1586 Imm32MakeIMENotify(hIMC, hWnd, NI_CONTEXTUPDATED, dwOldSentence,
1588 }
1589
1590 return TRUE;
1591}
#define IMN_SETSENTENCEMODE
Definition: imm.h:378
#define IMN_SETCONVERSIONMODE
Definition: imm.h:377
#define IMC_SETCONVERSIONMODE
Definition: immdev.h:370
#define IMC_SETSENTENCEMODE
Definition: immdev.h:371
DWORD NTAPI NtUserNotifyIMEStatus(_In_ HWND hwnd, _In_ BOOL fOpen, _In_ DWORD dwConversion)
Definition: ime.c:848

Referenced by ActiveIMMApp_SetConversionStatus(), ImeWnd_OnImeControl(), ImeWnd_SwitchSoftKbdProc(), Imm32CShapeToggle(), Imm32CSymbolToggle(), Imm32KEnglish(), Imm32KHanjaConvert(), Imm32KShapeToggle(), OnTimer(), test_ImmThreads(), and test_InvalidIMC().

◆ ImmSetOpenStatus()

BOOL WINAPI ImmSetOpenStatus ( _In_ HIMC  hIMC,
_In_ BOOL  fOpen 
)

Definition at line 1020 of file ime.c.

1023{
1024 DWORD dwConversion;
1025 LPINPUTCONTEXT pIC;
1026 HWND hWnd;
1027 BOOL bHasChange = FALSE;
1028
1029 TRACE("(%p, %d)\n", hIMC, fOpen);
1030
1031 if (IS_CROSS_THREAD_HIMC(hIMC))
1032 return FALSE;
1033
1034 pIC = ImmLockIMC(hIMC);
1035 if (IS_NULL_UNEXPECTEDLY(pIC))
1036 return FALSE;
1037
1038 if (pIC->fOpen != fOpen)
1039 {
1040 pIC->fOpen = fOpen;
1041 hWnd = pIC->hWnd;
1042 dwConversion = pIC->fdwConversion;
1043 bHasChange = TRUE;
1044 }
1045
1046 ImmUnlockIMC(hIMC);
1047
1048 if (bHasChange)
1049 {
1052 NtUserNotifyIMEStatus(hWnd, fOpen, dwConversion);
1053 }
1054 else
1055 {
1056 TRACE("No change.\n");
1057 }
1058
1059 return TRUE;
1060}
#define IMN_SETOPENSTATUS
Definition: imm.h:379
#define IMC_SETOPENSTATUS
Definition: immdev.h:372

Referenced by ActiveIMMApp_SetOpenStatus(), ImeWnd_OnImeControl(), ImeWnd_OnImeSystem(), Imm32CImeNonImeToggle(), Imm32CShapeToggle(), Imm32CSymbolToggle(), Imm32JCloseOpen(), Imm32KEnglish(), Imm32KShapeToggle(), ImmGetContextThreadFunc(), KbSwitch_OnPenIconMsg(), OnTimer(), Test1(), test_ime_processkey(), test_ImmDefaultHwnd(), test_ImmMessages(), test_ImmThreads(), and test_InvalidIMC().

◆ ImmSetStatusWindowPos()

BOOL WINAPI ImmSetStatusWindowPos ( _In_ HIMC  hIMC,
_In_ LPPOINT  lpptPos 
)

Definition at line 1091 of file ime.c.

1094{
1095 LPINPUTCONTEXT pIC;
1096 HWND hWnd;
1097
1098 TRACE("(%p, {%ld, %ld})\n", hIMC, lpptPos->x, lpptPos->y);
1099
1100 if (IS_CROSS_THREAD_HIMC(hIMC))
1101 return FALSE;
1102
1103 pIC = ImmLockIMC(hIMC);
1104 if (IS_NULL_UNEXPECTEDLY(pIC))
1105 return FALSE;
1106
1107 hWnd = pIC->hWnd;
1108 pIC->ptStatusWndPos = *lpptPos;
1109 pIC->fdwInit |= INIT_STATUSWNDPOS;
1110
1111 ImmUnlockIMC(hIMC);
1112
1115 return TRUE;
1116}
#define IMN_SETSTATUSWINDOWPOS
Definition: imm.h:383
#define IMC_SETSTATUSWINDOWPOS
Definition: imm.h:155

Referenced by ActiveIMMApp_SetStatusWindowPos(), ImeWnd_OnImeControl(), ImmGetContextThreadFunc(), test_ImmThreads(), and test_InvalidIMC().

◆ ImmUnlockImeDpi()

VOID WINAPI ImmUnlockImeDpi ( _Inout_opt_ PIMEDPI  pImeDpi)

Definition at line 561 of file ime.c.

563{
564 PIMEDPI *ppEntry;
565
566 TRACE("(%p)\n", pImeDpi);
567
568 if (pImeDpi == NULL)
569 return;
570
572
573 /* unlock */
574 --(pImeDpi->cLockObj);
575 if (pImeDpi->cLockObj != 0)
576 {
578 return;
579 }
580
581 if ((pImeDpi->dwFlags & IMEDPI_FLAG_UNLOADED) == 0)
582 {
583 if ((pImeDpi->dwFlags & IMEDPI_FLAG_LOCKED) == 0 ||
584 (pImeDpi->ImeInfo.fdwProperty & IME_PROP_END_UNLOAD) == 0)
585 {
587 return;
588 }
589 }
590
591 /* Remove from list */
592 for (ppEntry = &gpImeDpiList; *ppEntry; ppEntry = &((*ppEntry)->pNext))
593 {
594 if (*ppEntry == pImeDpi) /* found */
595 {
596 *ppEntry = pImeDpi->pNext;
597 break;
598 }
599 }
600
601 Imm32FreeIME(pImeDpi, TRUE);
602 ImmLocalFree(pImeDpi);
603
605}

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.

1720{
1721 HIMC hIMC;
1722 PCLIENTIMC pClientImc;
1723 HWND hImeWnd;
1724 BOOL bImeWnd, ret;
1725
1726 TRACE("(%p, %d)\n", hWnd, enable);
1727
1729 {
1731 return FALSE;
1732 }
1733
1735 if (IS_NULL_UNEXPECTEDLY(hIMC))
1736 return FALSE;
1737
1738 pClientImc = ImmLockClientImc(hIMC);
1739 if (IS_NULL_UNEXPECTEDLY(pClientImc))
1740 return FALSE;
1741
1742 ret = !(pClientImc->dwFlags & CLIENTIMC_DISABLEIME);
1743 if (!!enable == ret)
1744 {
1745 TRACE("Same\n");
1746 ImmUnlockClientImc(pClientImc);
1747 return ret;
1748 }
1749
1750 if (!IsWindow(hWnd))
1751 hWnd = GetFocus();
1752
1753 hImeWnd = ImmGetDefaultIMEWnd(hWnd);
1754 bImeWnd = IsWindow(hImeWnd);
1755 if (bImeWnd)
1757
1758 if (enable)
1759 pClientImc->dwFlags &= ~CLIENTIMC_DISABLEIME;
1760 else
1761 pClientImc->dwFlags |= CLIENTIMC_DISABLEIME;
1762
1763 ImmUnlockClientImc(pClientImc);
1764
1765 if (bImeWnd)
1766 ImmSetActiveContext(hWnd, (enable ? hIMC : NULL), TRUE);
1767
1768 return ret;
1769}
DWORD HIMC
Definition: dimm.idl:75
#define ERROR_CALL_NOT_IMPLEMENTED
Definition: compat.h:102
#define SetLastError(x)
Definition: compat.h:752
GLboolean enable
Definition: glext.h:11120
HWND WINAPI ImmGetDefaultIMEWnd(_In_opt_ HWND hWnd)
Definition: ime.c:440
#define CLIENTIMC_DISABLEIME
Definition: imm32_undoc.h:173
BOOL WINAPI ImmSetActiveContext(_In_ HWND hwnd, _In_opt_ HIMC hIMC, _In_ BOOL fFlag)
Definition: imm.c:1155
@ THREADSTATE_DEFAULTINPUTCONTEXT
Definition: ntuser.h:2489
BOOL Imm32IsSystemJapaneseOrKorean(VOID)
Definition: utils.c:72
HWND WINAPI GetFocus(void)
Definition: window.c:1863
BOOL WINAPI IsWindow(_In_opt_ HWND)

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

◆ WINE_DEFAULT_DEBUG_CHANNEL()

WINE_DEFAULT_DEBUG_CHANNEL ( imm  )

Variable Documentation

◆ gcsImeDpi

◆ gpImeDpiList

PIMEDPI gpImeDpiList = NULL