ReactOS 0.4.16-dev-1339-gd8bfa93
keymsg.c File Reference
#include "precomp.h"
#include <jpnvkeys.h>
Include dependency graph for keymsg.c:

Go to the source code of this file.

Macros

#define MSG_COUNT   0x100
 

Functions

 WINE_DEFAULT_DEBUG_CHANNEL (imm)
 
static BOOL Imm32ImeNonImeToggle (HIMC hIMC, HKL hKL, HWND hWnd, BOOL bNowIME, LANGID LangID)
 
static BOOL Imm32CImeNonImeToggle (HIMC hIMC, HKL hKL, HWND hWnd, LANGID LangID)
 
static BOOL Imm32CShapeToggle (HIMC hIMC, HKL hKL, HWND hWnd)
 
static BOOL Imm32CSymbolToggle (HIMC hIMC, HKL hKL, HWND hWnd)
 
static BOOL Imm32JCloseOpen (HIMC hIMC, HKL hKL, HWND hWnd)
 
static BOOL Imm32KShapeToggle (HIMC hIMC)
 
static BOOL Imm32KHanjaConvert (HIMC hIMC)
 
static BOOL Imm32KEnglish (HIMC hIMC)
 
static BOOL Imm32ProcessHotKey (HWND hWnd, HIMC hIMC, HKL hKL, DWORD dwHotKeyID)
 
static BOOL ImmIsUIMessageAW (_In_opt_ HWND hWndIME, _In_ UINT msg, _In_ WPARAM wParam, _In_ LPARAM lParam, _In_ BOOL bAnsi)
 
static BOOL CALLBACK Imm32SendNotificationProc (_In_ HIMC hIMC, _In_ LPARAM lParam)
 
BOOL Imm32SendNotification (BOOL bProcess)
 
static LRESULT Imm32ProcessRequest (HIMC hIMC, PWND pWnd, DWORD dwCommand, LPVOID pData, BOOL bAnsiAPI)
 
static LRESULT ImmRequestMessageAW (_In_ HIMC hIMC, _In_ WPARAM wParam, _In_ LPARAM lParam, _In_ BOOL bAnsi)
 
BOOL WINAPI ImmIsUIMessageA (_In_opt_ HWND hWndIME, _In_ UINT msg, _In_ WPARAM wParam, _In_ LPARAM lParam)
 
BOOL WINAPI ImmIsUIMessageW (_In_opt_ HWND hWndIME, _In_ UINT msg, _In_ WPARAM wParam, _In_ LPARAM lParam)
 
BOOL WINAPI ImmGetHotKey (_In_ DWORD dwHotKey, _Out_ LPUINT lpuModifiers, _Out_ LPUINT lpuVKey, _Out_ LPHKL lphKL)
 
UINT WINAPI ImmWINNLSGetIMEHotkey (_In_ HWND hwndIme)
 
BOOL WINAPI ImmSimulateHotKey (_In_ HWND hWnd, _In_ DWORD dwHotKeyID)
 
UINT WINAPI ImmGetVirtualKey (_In_ HWND hWnd)
 
DWORD WINAPI ImmGetAppCompatFlags (_In_ HIMC hIMC)
 
DWORD WINAPI ImmProcessKey (_In_ HWND hWnd, _In_ HKL hKL, _In_ UINT vKey, _In_ LPARAM lParam, _In_ DWORD dwHotKeyID)
 
LRESULT WINAPI ImmSystemHandler (_In_ HIMC hIMC, _Inout_opt_ WPARAM wParam, _Inout_opt_ LPARAM lParam)
 
BOOL WINAPI ImmGenerateMessage (_In_ HIMC hIMC)
 
static VOID ImmPostMessages (_In_ HWND hwnd, _In_ HIMC hIMC, _In_ DWORD dwCount, _In_ LPTRANSMSG lpTransMsg)
 
BOOL WINAPI ImmTranslateMessage (_In_ HWND hwnd, _In_ UINT msg, _In_ WPARAM wParam, _In_ LPARAM lKeyData)
 
LRESULT WINAPI ImmRequestMessageA (_In_ HIMC hIMC, _In_ WPARAM wParam, _In_ LPARAM lParam)
 
LRESULT WINAPI ImmRequestMessageW (_In_ HIMC hIMC, _In_ WPARAM wParam, _In_ LPARAM lParam)
 
DWORD WINAPI ImmCallImeConsoleIME (_In_ HWND hWnd, _In_ UINT uMsg, _In_ WPARAM wParam, _In_ LPARAM lParam, _Out_ LPUINT puVK)
 

Macro Definition Documentation

◆ MSG_COUNT

#define MSG_COUNT   0x100

Function Documentation

◆ Imm32CImeNonImeToggle()

static BOOL Imm32CImeNonImeToggle ( HIMC  hIMC,
HKL  hKL,
HWND  hWnd,
LANGID  LangID 
)
static

Definition at line 68 of file keymsg.c.

69{
71 BOOL fOpen;
72
74 return FALSE;
75
76 if (LOWORD(hKL) != LangID || !ImmIsIME(hKL))
77 {
79 return TRUE;
80 }
81
82 pIC = ImmLockIMC(hIMC);
83 if (IS_NULL_UNEXPECTEDLY(pIC))
84 return TRUE;
85
86 fOpen = pIC->fOpen;
87 ImmUnlockIMC(hIMC);
88
89 if (fOpen)
90 Imm32ImeNonImeToggle(hIMC, hKL, hWnd, TRUE, 0);
91 else
93
94 return TRUE;
95}
HWND hWnd
Definition: settings.c:17
#define TRUE
Definition: types.h:120
#define FALSE
Definition: types.h:117
unsigned int BOOL
Definition: ntddk_ex.h:94
BOOL WINAPI ImmIsIME(_In_ HKL hKL)
Definition: ime.c:429
BOOL WINAPI ImmSetOpenStatus(_In_ HIMC hIMC, _In_ BOOL fOpen)
Definition: ime.c:1020
LPINPUTCONTEXT WINAPI ImmLockIMC(_In_ HIMC hIMC)
Definition: imm.c:1079
BOOL WINAPI ImmUnlockIMC(_In_ HIMC hIMC)
Definition: imm.c:1089
static BOOL Imm32ImeNonImeToggle(HIMC hIMC, HKL hKL, HWND hWnd, BOOL bNowIME, LANGID LangID)
Definition: keymsg.c:18
#define LOWORD(l)
Definition: pedump.c:82
_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
#define IS_NULL_UNEXPECTEDLY(p)
Definition: precomp.h:66

Referenced by Imm32ProcessHotKey().

◆ Imm32CShapeToggle()

static BOOL Imm32CShapeToggle ( HIMC  hIMC,
HKL  hKL,
HWND  hWnd 
)
static

Definition at line 99 of file keymsg.c.

100{
101 LPINPUTCONTEXT pIC;
102 BOOL fOpen;
103 DWORD dwConversion, dwSentence;
104
105 if (hWnd == NULL || !ImmIsIME(hKL))
106 return FALSE;
107
108 pIC = ImmLockIMC(hIMC);
109 if (IS_NULL_UNEXPECTEDLY(pIC))
110 return TRUE;
111
112 fOpen = pIC->fOpen;
113 if (fOpen)
114 {
115 dwConversion = (pIC->fdwConversion ^ IME_CMODE_FULLSHAPE);
116 dwSentence = pIC->fdwSentence;
117 }
118
119 ImmUnlockIMC(hIMC);
120
121 if (fOpen)
122 ImmSetConversionStatus(hIMC, dwConversion, dwSentence);
123 else
124 ImmSetOpenStatus(hIMC, TRUE);
125
126 return TRUE;
127}
#define NULL
Definition: types.h:112
unsigned long DWORD
Definition: ntddk_ex.h:95
BOOL WINAPI ImmSetConversionStatus(_In_ HIMC hIMC, _In_ DWORD fdwConversion, _In_ DWORD fdwSentence)
Definition: ime.c:1534
#define IME_CMODE_FULLSHAPE
Definition: imm.h:345
DWORD fdwConversion
Definition: immdev.h:111
DWORD fdwSentence
Definition: immdev.h:112

Referenced by Imm32ProcessHotKey().

◆ Imm32CSymbolToggle()

static BOOL Imm32CSymbolToggle ( HIMC  hIMC,
HKL  hKL,
HWND  hWnd 
)
static

Definition at line 130 of file keymsg.c.

131{
132 LPINPUTCONTEXT pIC;
133 BOOL fOpen;
134 DWORD dwConversion, dwSentence;
135
136 if (hWnd == NULL || !ImmIsIME(hKL))
137 return FALSE;
138
139 pIC = ImmLockIMC(hIMC);
140 if (IS_NULL_UNEXPECTEDLY(pIC))
141 return TRUE;
142
143 fOpen = pIC->fOpen;
144 if (fOpen)
145 {
146 dwConversion = (pIC->fdwConversion ^ IME_CMODE_SYMBOL);
147 dwSentence = pIC->fdwSentence;
148 }
149
150 ImmUnlockIMC(hIMC);
151
152 if (fOpen)
153 ImmSetConversionStatus(hIMC, dwConversion, dwSentence);
154 else
155 ImmSetOpenStatus(hIMC, TRUE);
156
157 return TRUE;
158}
#define IME_CMODE_SYMBOL
Definition: imm.h:352

Referenced by Imm32ProcessHotKey().

◆ Imm32ImeNonImeToggle()

static BOOL Imm32ImeNonImeToggle ( HIMC  hIMC,
HKL  hKL,
HWND  hWnd,
BOOL  bNowIME,
LANGID  LangID 
)
static

Definition at line 18 of file keymsg.c.

19{
20 HKL hOldKL, LayoutList[32], hFoundKL = NULL;
21 UINT iLayout, nLayoutCount;
22
23 /* Get the previous layout */
25
26 /* Get the layout list */
27 nLayoutCount = GetKeyboardLayoutList(_countof(LayoutList), LayoutList);
28
29 /* Is there hOldKL in the list in the specified language ID? */
30 if (hOldKL && (LangID == 0 || LOWORD(hOldKL) == LangID))
31 {
32 for (iLayout = 0; iLayout < nLayoutCount; ++iLayout)
33 {
34 if (LayoutList[iLayout] == hOldKL)
35 {
36 hFoundKL = hOldKL;
37 break;
38 }
39 }
40 }
41
42 if (hFoundKL == NULL) /* Not found? */
43 {
44 /* Is there the keyboard layout of another kind in LangID? */
45 for (iLayout = 0; iLayout < nLayoutCount; ++iLayout)
46 {
47 if (bNowIME == ImmIsIME(LayoutList[iLayout])) /* Same kind? */
48 continue;
49
50 if (LangID == 0 || LangID == LOWORD(LayoutList[iLayout]))
51 {
52 hFoundKL = LayoutList[iLayout];
53 break;
54 }
55 }
56 }
57
58 if (hFoundKL && hKL != hFoundKL) /* Found and different layout */
59 {
60 PostMessageW(hWnd, WM_INPUTLANGCHANGEREQUEST, 1, (LPARAM)hFoundKL);
61 }
62
63 return ImmIsIME(hFoundKL);
64}
@ THREADSTATE_OLDKEYBOARDLAYOUT
Definition: ntuser.h:2499
DWORD_PTR NTAPI NtUserGetThreadState(DWORD Routine)
Definition: misc.c:240
UINT_PTR HKL
Definition: msctf.idl:125
unsigned int UINT
Definition: ndis.h:50
#define _countof(array)
Definition: sndvol32.h:70
LONG_PTR LPARAM
Definition: windef.h:208
BOOL WINAPI PostMessageW(_In_opt_ HWND, _In_ UINT, _In_ WPARAM, _In_ LPARAM)
UINT WINAPI GetKeyboardLayoutList(_In_ int nBuff, _Out_writes_to_opt_(nBuff, return) HKL FAR *lpList)

Referenced by Imm32CImeNonImeToggle(), and Imm32JCloseOpen().

◆ Imm32JCloseOpen()

static BOOL Imm32JCloseOpen ( HIMC  hIMC,
HKL  hKL,
HWND  hWnd 
)
static

Definition at line 162 of file keymsg.c.

163{
164 BOOL fOpen;
166
167 if (LOWORD(hKL) == LANGID_JAPANESE && ImmIsIME(hKL)) /* Japanese IME is selected */
168 {
169 fOpen = ImmGetOpenStatus(hIMC);
170 ImmSetOpenStatus(hIMC, !fOpen);
171 return TRUE;
172 }
173
174 /* Japanese IME is not selected. Select now */
176 {
177 pIC = (LPINPUTCONTEXTDX)ImmLockIMC(hIMC);
178 if (pIC)
179 {
181 ImmUnlockIMC(hIMC);
182 }
183 }
184
185 return TRUE;
186}
struct INPUTCONTEXTDX * LPINPUTCONTEXTDX
BOOL WINAPI ImmGetOpenStatus(_In_ HIMC hIMC)
Definition: ime.c:996
#define INPUTCONTEXTDX_CHANGE_FORCE_OPEN
Definition: immdev.h:163
#define LANGID_JAPANESE
Definition: kbswitch.h:24

Referenced by Imm32ProcessHotKey().

◆ Imm32KEnglish()

static BOOL Imm32KEnglish ( HIMC  hIMC)
static

Definition at line 230 of file keymsg.c.

231{
232 LPINPUTCONTEXT pIC;
233 DWORD dwConversion, dwSentence;
234 BOOL fOpen;
235
236 pIC = ImmLockIMC(hIMC);
237 if (IS_NULL_UNEXPECTEDLY(pIC))
238 return FALSE;
239
240 dwConversion = (pIC->fdwConversion ^ IME_CMODE_NATIVE);
241 dwSentence = pIC->fdwSentence;
242 ImmSetConversionStatus(hIMC, dwConversion, dwSentence);
243
244 fOpen = ((pIC->fdwConversion & (IME_CMODE_FULLSHAPE | IME_CMODE_NATIVE)) != 0);
245 ImmSetOpenStatus(hIMC, fOpen);
246
247 ImmUnlockIMC(hIMC);
248 return TRUE;
249}
#define IME_CMODE_NATIVE
Definition: imm.h:337

Referenced by Imm32ProcessHotKey().

◆ Imm32KHanjaConvert()

static BOOL Imm32KHanjaConvert ( HIMC  hIMC)
static

Definition at line 212 of file keymsg.c.

213{
214 LPINPUTCONTEXT pIC;
215 DWORD dwConversion, dwSentence;
216
217 pIC = ImmLockIMC(hIMC);
218 if (IS_NULL_UNEXPECTEDLY(pIC))
219 return FALSE;
220
221 dwConversion = (pIC->fdwConversion ^ IME_CMODE_HANJACONVERT);
222 dwSentence = pIC->fdwSentence;
223 ImmUnlockIMC(hIMC);
224
225 ImmSetConversionStatus(hIMC, dwConversion, dwSentence);
226 return TRUE;
227}
#define IME_CMODE_HANJACONVERT
Definition: imm.h:348

Referenced by Imm32ProcessHotKey().

◆ Imm32KShapeToggle()

static BOOL Imm32KShapeToggle ( HIMC  hIMC)
static

Definition at line 189 of file keymsg.c.

190{
191 LPINPUTCONTEXT pIC;
192 DWORD dwConversion, dwSentence;
193
194 pIC = ImmLockIMC(hIMC);
195 if (IS_NULL_UNEXPECTEDLY(pIC))
196 return FALSE;
197
198 dwConversion = (pIC->fdwConversion ^ IME_CMODE_FULLSHAPE);
199 dwSentence = pIC->fdwSentence;
200 ImmSetConversionStatus(hIMC, dwConversion, dwSentence);
201
203 ImmSetOpenStatus(hIMC, TRUE);
204 else
205 ImmSetOpenStatus(hIMC, FALSE);
206
207 ImmUnlockIMC(hIMC);
208 return TRUE;
209}

Referenced by Imm32ProcessHotKey().

◆ Imm32ProcessHotKey()

static BOOL Imm32ProcessHotKey ( HWND  hWnd,
HIMC  hIMC,
HKL  hKL,
DWORD  dwHotKeyID 
)
static

Definition at line 252 of file keymsg.c.

253{
254 PIMEDPI pImeDpi;
255 BOOL ret;
256
257 if (hIMC && IS_CROSS_THREAD_HIMC(hIMC))
258 return FALSE;
259
260 switch (dwHotKeyID)
261 {
264
266 return Imm32CShapeToggle(hIMC, hKL, hWnd);
267
269 return Imm32CSymbolToggle(hIMC, hKL, hWnd);
270
272 return Imm32JCloseOpen(hIMC, hKL, hWnd);
273
275 return Imm32KShapeToggle(hIMC);
276
278 return Imm32KHanjaConvert(hIMC);
279
281 return Imm32KEnglish(hIMC);
282
285
287 return Imm32CShapeToggle(hIMC, hKL, hWnd);
288
290 return Imm32CSymbolToggle(hIMC, hKL, hWnd);
291
292 default:
293 WARN("0x%X\n", dwHotKeyID);
294 break;
295 }
296
297 if (dwHotKeyID < IME_HOTKEY_PRIVATE_FIRST || IME_HOTKEY_PRIVATE_LAST < dwHotKeyID)
298 return FALSE;
299
300 pImeDpi = ImmLockImeDpi(hKL);
301 if (IS_NULL_UNEXPECTEDLY(pImeDpi))
302 return FALSE;
303
304 ret = (BOOL)pImeDpi->ImeEscape(hIMC, IME_ESC_PRIVATE_HOTKEY, &dwHotKeyID);
305 ImmUnlockImeDpi(pImeDpi);
306 return ret;
307}
#define WARN(fmt,...)
Definition: precomp.h:61
return ret
Definition: mutex.c:146
PIMEDPI WINAPI ImmLockImeDpi(_In_ HKL hKL)
Definition: ime.c:531
VOID WINAPI ImmUnlockImeDpi(_Inout_opt_ PIMEDPI pImeDpi)
Definition: ime.c:561
#define IME_HOTKEY_PRIVATE_LAST
Definition: imm.h:221
#define IME_JHOTKEY_CLOSE_OPEN
Definition: imm.h:200
#define IME_KHOTKEY_HANJACONVERT
Definition: imm.h:204
#define IME_THOTKEY_IME_NONIME_TOGGLE
Definition: imm.h:207
#define IME_CHOTKEY_SYMBOL_TOGGLE
Definition: imm.h:197
#define IME_CHOTKEY_IME_NONIME_TOGGLE
Definition: imm.h:195
#define IME_ESC_PRIVATE_HOTKEY
Definition: imm.h:423
#define IME_KHOTKEY_SHAPE_TOGGLE
Definition: imm.h:203
#define IME_THOTKEY_SHAPE_TOGGLE
Definition: imm.h:208
#define IME_HOTKEY_PRIVATE_FIRST
Definition: imm.h:216
#define IME_KHOTKEY_ENGLISH
Definition: imm.h:205
#define IME_THOTKEY_SYMBOL_TOGGLE
Definition: imm.h:209
#define IME_CHOTKEY_SHAPE_TOGGLE
Definition: imm.h:196
#define LANGID_CHINESE_SIMPLIFIED
Definition: kbswitch.h:22
#define LANGID_CHINESE_TRADITIONAL
Definition: kbswitch.h:23
static BOOL Imm32KShapeToggle(HIMC hIMC)
Definition: keymsg.c:189
static BOOL Imm32JCloseOpen(HIMC hIMC, HKL hKL, HWND hWnd)
Definition: keymsg.c:162
static BOOL Imm32KHanjaConvert(HIMC hIMC)
Definition: keymsg.c:212
static BOOL Imm32CShapeToggle(HIMC hIMC, HKL hKL, HWND hWnd)
Definition: keymsg.c:99
static BOOL Imm32CImeNonImeToggle(HIMC hIMC, HKL hKL, HWND hWnd, LANGID LangID)
Definition: keymsg.c:68
static BOOL Imm32CSymbolToggle(HIMC hIMC, HKL hKL, HWND hWnd)
Definition: keymsg.c:130
static BOOL Imm32KEnglish(HIMC hIMC)
Definition: keymsg.c:230
#define BOOL
Definition: nt_native.h:43
#define IS_CROSS_THREAD_HIMC(hIMC)
Definition: precomp.h:72

Referenced by ImmProcessKey(), and ImmSimulateHotKey().

◆ Imm32ProcessRequest()

static LRESULT Imm32ProcessRequest ( HIMC  hIMC,
PWND  pWnd,
DWORD  dwCommand,
LPVOID  pData,
BOOL  bAnsiAPI 
)
static

Definition at line 378 of file keymsg.c.

379{
380 HWND hWnd;
381 DWORD ret = 0, dwCharPos, cchCompStr, dwSize;
382 LPVOID pCS, pTempData = pData;
383 LPRECONVERTSTRING pRS;
384 LPIMECHARPOSITION pICP;
385 PCLIENTIMC pClientImc;
386 UINT uCodePage = CP_ACP;
387 BOOL bAnsiWnd = !!(pWnd->state & WNDS_ANSIWINDOWPROC);
388 static const size_t acbData[7 * 2] =
389 {
390 /* UNICODE */
391 sizeof(COMPOSITIONFORM), sizeof(CANDIDATEFORM), sizeof(LOGFONTW),
392 sizeof(RECONVERTSTRING), sizeof(RECONVERTSTRING),
393 sizeof(IMECHARPOSITION), sizeof(RECONVERTSTRING),
394 /* ANSI */
395 sizeof(COMPOSITIONFORM), sizeof(CANDIDATEFORM), sizeof(LOGFONTA),
396 sizeof(RECONVERTSTRING), sizeof(RECONVERTSTRING),
397 sizeof(IMECHARPOSITION), sizeof(RECONVERTSTRING),
398 };
399
400 if (dwCommand == 0 || dwCommand > IMR_DOCUMENTFEED)
401 {
402 ERR("Out of boundary\n");
403 return 0; /* Out of range */
404 }
405
406 dwSize = acbData[bAnsiAPI * 7 + dwCommand - 1];
408 {
409 ERR("\n");
410 return 0; /* Invalid pointer */
411 }
412
413 /* Sanity check */
414 switch (dwCommand)
415 {
416 case IMR_RECONVERTSTRING: case IMR_DOCUMENTFEED:
417 pRS = pData;
418 if (pRS && (pRS->dwVersion != 0 || pRS->dwSize < sizeof(RECONVERTSTRING)))
419 {
420 ERR("Invalid pRS\n");
421 return 0;
422 }
423 break;
424
425 case IMR_CONFIRMRECONVERTSTRING:
426 pRS = pData;
427 if (!pRS || pRS->dwVersion != 0)
428 {
429 ERR("Invalid pRS\n");
430 return 0;
431 }
432 break;
433
434 default:
436 return 0;
437 break;
438 }
439
440 pClientImc = ImmLockClientImc(hIMC);
441 if (pClientImc)
442 {
443 uCodePage = pClientImc->uCodePage;
444 ImmUnlockClientImc(pClientImc);
445 }
446
447 /* Prepare */
448 switch (dwCommand)
449 {
450 case IMR_COMPOSITIONFONT:
451 if (bAnsiAPI == bAnsiWnd)
452 goto DoIt; /* No conversion needed */
453
454 if (bAnsiWnd)
455 pTempData = ImmLocalAlloc(0, sizeof(LOGFONTA));
456 else
457 pTempData = ImmLocalAlloc(0, sizeof(LOGFONTW));
458
459 if (IS_NULL_UNEXPECTEDLY(pTempData))
460 return 0;
461 break;
462
463 case IMR_RECONVERTSTRING: case IMR_CONFIRMRECONVERTSTRING: case IMR_DOCUMENTFEED:
464 if (bAnsiAPI == bAnsiWnd || !pData)
465 goto DoIt; /* No conversion needed */
466
467 if (bAnsiWnd)
469 else
471
472 pTempData = ImmLocalAlloc(0, ret + sizeof(WCHAR));
473 if (IS_NULL_UNEXPECTEDLY(pTempData))
474 return 0;
475
476 pRS = pTempData;
477 pRS->dwSize = ret;
478 pRS->dwVersion = 0;
479
480 if (dwCommand == IMR_CONFIRMRECONVERTSTRING)
481 {
482 if (bAnsiWnd)
483 ret = Imm32ReconvertAnsiFromWide(pTempData, pData, uCodePage);
484 else
485 ret = Imm32ReconvertWideFromAnsi(pTempData, pData, uCodePage);
486 }
487 break;
488
489 case IMR_QUERYCHARPOSITION:
490 if (bAnsiAPI == bAnsiWnd)
491 goto DoIt; /* No conversion needed */
492
493 pICP = pData;
494 dwCharPos = pICP->dwCharPos;
495
496 if (bAnsiAPI)
497 {
498 cchCompStr = ImmGetCompositionStringA(hIMC, GCS_COMPSTR, NULL, 0);
499 if (IS_ZERO_UNEXPECTEDLY(cchCompStr))
500 return 0;
501
502 pCS = ImmLocalAlloc(0, (cchCompStr + 1) * sizeof(CHAR));
503 if (IS_NULL_UNEXPECTEDLY(pCS))
504 return 0;
505
506 ImmGetCompositionStringA(hIMC, GCS_COMPSTR, pCS, cchCompStr);
507 pICP->dwCharPos = IchWideFromAnsi(pICP->dwCharPos, pCS, uCodePage);
508 }
509 else
510 {
511 cchCompStr = ImmGetCompositionStringW(hIMC, GCS_COMPSTR, NULL, 0);
512 if (IS_ZERO_UNEXPECTEDLY(cchCompStr))
513 return 0;
514
515 pCS = ImmLocalAlloc(0, (cchCompStr + 1) * sizeof(WCHAR));
516 if (IS_NULL_UNEXPECTEDLY(pCS))
517 return 0;
518
519 ImmGetCompositionStringW(hIMC, GCS_COMPSTR, pCS, cchCompStr);
520 pICP->dwCharPos = IchAnsiFromWide(pICP->dwCharPos, pCS, uCodePage);
521 }
522
523 ImmLocalFree(pCS);
524 break;
525
526 default:
527 WARN("0x%X\n", dwCommand);
528 break;
529 }
530
531DoIt:
532 /* The main task */
533 hWnd = pWnd->head.h;
534 if (bAnsiWnd)
535 ret = SendMessageA(hWnd, WM_IME_REQUEST, dwCommand, (LPARAM)pTempData);
536 else
537 ret = SendMessageW(hWnd, WM_IME_REQUEST, dwCommand, (LPARAM)pTempData);
538
539 if (bAnsiAPI == bAnsiWnd)
540 goto Quit; /* No conversion needed */
541
542 /* Get back to caller */
543 switch (dwCommand)
544 {
545 case IMR_COMPOSITIONFONT:
546 if (bAnsiAPI)
547 LogFontWideToAnsi(pTempData, pData);
548 else
549 LogFontAnsiToWide(pTempData, pData);
550 break;
551
552 case IMR_RECONVERTSTRING: case IMR_DOCUMENTFEED:
553 if (!ret)
554 break;
555
556 if (ret < sizeof(RECONVERTSTRING))
557 {
558 ret = 0;
559 break;
560 }
561
562 if (pTempData)
563 {
564 if (bAnsiWnd)
565 ret = Imm32ReconvertWideFromAnsi(pData, pTempData, uCodePage);
566 else
567 ret = Imm32ReconvertAnsiFromWide(pData, pTempData, uCodePage);
568 }
569 break;
570
571 case IMR_QUERYCHARPOSITION:
572 pICP->dwCharPos = dwCharPos;
573 break;
574
575 default:
576 WARN("0x%X\n", dwCommand);
577 break;
578 }
579
580Quit:
581 if (pTempData != pData)
582 ImmLocalFree(pTempData);
583 return ret;
584}
#define ERR(fmt,...)
Definition: precomp.h:57
#define CP_ACP
Definition: compat.h:109
BOOL NTAPI IsBadWritePtr(IN LPVOID lp, IN UINT_PTR ucb)
Definition: except.c:883
PCLIENTIMC WINAPI ImmLockClientImc(_In_ HIMC hImc)
Definition: imm.c:954
VOID WINAPI ImmUnlockClientImc(_Inout_ PCLIENTIMC pClientImc)
Definition: imm.c:1001
LONG WINAPI ImmGetCompositionStringA(_In_ HIMC hIMC, _In_ DWORD dwIndex, _Out_writes_bytes_opt_(dwBufLen) LPVOID lpBuf, _In_ DWORD dwBufLen)
Definition: compstr.c:860
#define GCS_COMPSTR
Definition: imm.h:227
LONG WINAPI ImmGetCompositionStringW(_In_ HIMC hIMC, _In_ DWORD dwIndex, _Out_writes_bytes_opt_(dwBufLen) LPVOID lpBuf, _In_ DWORD dwBufLen)
Definition: compstr.c:908
#define WNDS_ANSIWINDOWPROC
Definition: ntuser.h:624
PSDBQUERYRESULT_VISTA PVOID DWORD * dwSize
Definition: env.c:56
THRDESKHEAD head
Definition: ntuser.h:695
DWORD state
Definition: ntuser.h:701
TW_UINT32 TW_UINT16 TW_UINT16 TW_MEMREF pData
Definition: twain.h:1830
#define IS_ZERO_UNEXPECTEDLY(p)
Definition: precomp.h:67
LONG IchAnsiFromWide(LONG cchWide, LPCWSTR pchWide, UINT uCodePage)
Definition: utils.c:140
DWORD Imm32ReconvertWideFromAnsi(LPRECONVERTSTRING pDest, const RECONVERTSTRING *pSrc, UINT uCodePage)
Definition: utils.c:451
#define ImmLocalFree(lpData)
Definition: precomp.h:105
LONG IchWideFromAnsi(LONG cchAnsi, LPCSTR pchAnsi, UINT uCodePage)
Definition: utils.c:120
VOID LogFontAnsiToWide(const LOGFONTA *plfA, LPLOGFONTW plfW)
Definition: utils.c:164
DWORD Imm32ReconvertAnsiFromWide(LPRECONVERTSTRING pDest, const RECONVERTSTRING *pSrc, UINT uCodePage)
Definition: utils.c:514
LPVOID ImmLocalAlloc(_In_ DWORD dwFlags, _In_ DWORD dwBytes)
Definition: utils.c:275
VOID LogFontWideToAnsi(const LOGFONTW *plfW, LPLOGFONTA plfA)
Definition: utils.c:176
#define WM_IME_REQUEST
Definition: winuser.h:1855
LRESULT WINAPI SendMessageA(_In_ HWND, _In_ UINT, _In_ WPARAM, _In_ LPARAM)
LRESULT WINAPI SendMessageW(_In_ HWND, _In_ UINT, _In_ WPARAM, _In_ LPARAM)
__wchar_t WCHAR
Definition: xmlstorage.h:180
char CHAR
Definition: xmlstorage.h:175

Referenced by ImmRequestMessageAW().

◆ Imm32SendNotification()

BOOL Imm32SendNotification ( BOOL  bProcess)

Definition at line 372 of file keymsg.c.

373{
374 return ImmEnumInputContext((bProcess ? -1 : 0), Imm32SendNotificationProc, 0);
375}
BOOL WINAPI ImmEnumInputContext(_In_ DWORD dwThreadId, _In_ IMCENUMPROC lpfn, _In_ LPARAM lParam)
Definition: imm.c:1123
static BOOL CALLBACK Imm32SendNotificationProc(_In_ HIMC hIMC, _In_ LPARAM lParam)
Definition: keymsg.c:339

Referenced by ImmSystemHandler().

◆ Imm32SendNotificationProc()

static BOOL CALLBACK Imm32SendNotificationProc ( _In_ HIMC  hIMC,
_In_ LPARAM  lParam 
)
static

Definition at line 339 of file keymsg.c.

342{
343 HWND hWnd;
345
347
348 pIC = (LPINPUTCONTEXTDX)ImmLockIMC(hIMC);
349 if (IS_NULL_UNEXPECTEDLY(pIC))
350 return TRUE;
351
352 hWnd = pIC->hWnd;
353 if (!IsWindow(hWnd))
354 goto Quit;
355
356 TRACE("dwChange: 0x%08X\n", pIC->dwChange);
357
363 NtUserNotifyIMEStatus(hWnd, pIC->fOpen, pIC->fdwConversion);
366Quit:
367 pIC->dwChange = 0;
368 ImmUnlockIMC(hIMC); // ??? Windows doesn't unlock here
369 return TRUE;
370}
LPARAM lParam
Definition: combotst.c:139
#define IMN_SETSENTENCEMODE
Definition: imm.h:378
#define IMN_SETOPENSTATUS
Definition: imm.h:379
#define IMN_SETCONVERSIONMODE
Definition: imm.h:377
#define INPUTCONTEXTDX_CHANGE_OPEN
Definition: immdev.h:160
#define INPUTCONTEXTDX_CHANGE_SENTENCE
Definition: immdev.h:162
#define INPUTCONTEXTDX_CHANGE_CONVERSION
Definition: immdev.h:161
DWORD NTAPI NtUserNotifyIMEStatus(_In_ HWND hwnd, _In_ BOOL fOpen, _In_ DWORD dwConversion)
Definition: ime.c:848
#define UNREFERENCED_PARAMETER(P)
Definition: ntbasedef.h:329
#define TRACE(s)
Definition: solgame.cpp:4
BOOL WINAPI IsWindow(_In_opt_ HWND)
#define WM_IME_NOTIFY
Definition: winuser.h:1849

Referenced by Imm32SendNotification().

◆ ImmCallImeConsoleIME()

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

Definition at line 1188 of file keymsg.c.

1194{
1195 DWORD dwThreadId, ret = 0;
1196 HKL hKL;
1197 PWND pWnd = NULL;
1198 HIMC hIMC;
1199 PIMEDPI pImeDpi;
1200 UINT uVK;
1201 PIMC pIMC;
1202
1203 switch (uMsg)
1204 {
1205 case WM_KEYDOWN:
1206 case WM_KEYUP:
1207 case WM_SYSKEYDOWN:
1208 case WM_SYSKEYUP:
1209 break;
1210
1211 default:
1212 return 0;
1213 }
1214
1217
1218 if (hWnd && gpsi)
1219 pWnd = ValidateHwndNoErr(hWnd);
1220 if (IS_NULL_UNEXPECTEDLY(pWnd))
1221 return 0;
1222
1223 hIMC = ImmGetContext(hWnd);
1224 if (IS_NULL_UNEXPECTEDLY(hIMC))
1225 return 0;
1226
1227 uVK = *puVK = (wParam & 0xFF);
1228
1230 if (IS_NULL_UNEXPECTEDLY(pIMC))
1231 return 0;
1232
1233 pImeDpi = ImmLockImeDpi(hKL);
1234 if (IS_NULL_UNEXPECTEDLY(pImeDpi))
1235 return 0;
1236
1238 goto Quit;
1239
1240 switch (uVK)
1241 {
1242 case VK_DBE_ROMAN:
1243 case VK_DBE_NOROMAN:
1244 case VK_DBE_HIRAGANA:
1245 case VK_DBE_KATAKANA:
1246 case VK_DBE_CODEINPUT:
1247 case VK_DBE_NOCODEINPUT:
1250 break;
1251
1252 default:
1253 {
1254 if (uMsg == WM_SYSKEYDOWN || uMsg == WM_SYSKEYUP)
1255 {
1256 if (uVK != VK_MENU && uVK != VK_F10)
1257 goto Quit;
1258 }
1259
1260 if (!(pImeDpi->ImeInfo.fdwProperty & IME_PROP_NEED_ALTKEY))
1261 {
1262 if (uVK == VK_MENU || (lParam & MAKELPARAM(0, KF_ALTDOWN)))
1263 goto Quit;
1264 }
1265 }
1266 }
1267
1269
1270Quit:
1271 ImmUnlockImeDpi(pImeDpi);
1272 return ret;
1273}
WPARAM wParam
Definition: combotst.c:138
DWORD HIMC
Definition: dimm.idl:75
DWORD dwThreadId
Definition: fdebug.c:31
PSERVERINFO gpsi
Definition: imm.c:18
HIMC WINAPI ImmGetContext(_In_ HWND hWnd)
Definition: imm.c:1065
#define IME_PROP_NEED_ALTKEY
Definition: immdev.h:365
#define IME_PROP_IGNORE_UPKEYS
Definition: immdev.h:364
@ TYPE_INPUTCONTEXT
Definition: ntuser.h:57
#define VK_DBE_ROMAN
Definition: jpnvkeys.h:19
#define VK_DBE_HIRAGANA
Definition: jpnvkeys.h:16
#define VK_DBE_CODEINPUT
Definition: jpnvkeys.h:24
#define VK_DBE_NOROMAN
Definition: jpnvkeys.h:20
#define VK_DBE_KATAKANA
Definition: jpnvkeys.h:15
#define VK_DBE_ENTERCONFIGMODE
Definition: jpnvkeys.h:22
#define VK_DBE_ENTERWORDREGISTERMODE
Definition: jpnvkeys.h:21
#define VK_DBE_NOCODEINPUT
Definition: jpnvkeys.h:25
DWORD WINAPI ImmProcessKey(_In_ HWND hWnd, _In_ HKL hKL, _In_ UINT vKey, _In_ LPARAM lParam, _In_ DWORD dwHotKeyID)
Definition: keymsg.c:743
IMEINFO ImeInfo
Definition: imm32_undoc.h:94
Definition: ntuser.h:694
DWORD fdwProperty
Definition: immdev.h:22
Definition: ntuser.h:199
LPVOID FASTCALL ValidateHandleNoErr(HANDLE hObject, UINT uType)
Definition: utils.c:201
#define ValidateHwndNoErr(hwnd)
Definition: precomp.h:100
#define INVALID_HOTKEY_ID
Definition: precomp.h:77
DWORD WINAPI GetWindowThreadProcessId(HWND hWnd, PDWORD lpdwProcessId)
HKL WINAPI GetKeyboardLayout(_In_ DWORD)
#define MAKELPARAM(l, h)
Definition: winuser.h:4084
#define WM_KEYUP
Definition: winuser.h:1735
#define VK_F10
Definition: winuser.h:2283
#define KF_ALTDOWN
Definition: winuser.h:2468
#define KF_UP
Definition: winuser.h:2470
#define WM_SYSKEYUP
Definition: winuser.h:1739
#define WM_KEYDOWN
Definition: winuser.h:1734
#define WM_SYSKEYDOWN
Definition: winuser.h:1738
#define VK_MENU
Definition: winuser.h:2223

◆ ImmGenerateMessage()

BOOL WINAPI ImmGenerateMessage ( _In_ HIMC  hIMC)

Definition at line 878 of file keymsg.c.

879{
880 PCLIENTIMC pClientImc;
881 LPINPUTCONTEXT pIC;
882 LPTRANSMSG pMsgs, pTrans = NULL, pItem;
883 HWND hWnd;
884 DWORD dwIndex, dwCount, cbTrans;
885 HIMCC hMsgBuf = NULL;
886 BOOL bAnsi;
887
888 TRACE("(%p)\n", hIMC);
889
890 if (IS_CROSS_THREAD_HIMC(hIMC))
891 return FALSE;
892
893 pClientImc = ImmLockClientImc(hIMC);
894 if (IS_NULL_UNEXPECTEDLY(pClientImc))
895 return FALSE;
896
897 bAnsi = !(pClientImc->dwFlags & CLIENTIMC_WIDE);
898 ImmUnlockClientImc(pClientImc);
899
900 pIC = ImmLockIMC(hIMC);
901 if (IS_NULL_UNEXPECTEDLY(pIC))
902 return FALSE;
903
904 dwCount = pIC->dwNumMsgBuf;
905 if (dwCount == 0)
906 goto Quit;
907
908 hMsgBuf = pIC->hMsgBuf;
909 pMsgs = ImmLockIMCC(hMsgBuf);
910 if (IS_NULL_UNEXPECTEDLY(pMsgs))
911 goto Quit;
912
913 cbTrans = dwCount * sizeof(TRANSMSG);
914 pTrans = ImmLocalAlloc(0, cbTrans);
915 if (IS_NULL_UNEXPECTEDLY(pTrans))
916 goto Quit;
917
918 RtlCopyMemory(pTrans, pMsgs, cbTrans);
919
920#ifdef IMM_WIN3_SUPPORT
921 if (GetWin32ClientInfo()->dwExpWinVer < _WIN32_WINNT_NT4) /* old version (3.x)? */
922 {
924 WORD wLang = PRIMARYLANGID(LangID);
925
926 /* translate the messages if Japanese or Korean */
927 if (wLang == LANG_JAPANESE ||
928 (wLang == LANG_KOREAN && NtUserGetAppImeLevel(pIC->hWnd) == 3))
929 {
930 dwCount = WINNLSTranslateMessage(dwCount, pTrans, hIMC, bAnsi, wLang);
931 }
932 }
933#endif
934
935 /* send them */
936 hWnd = pIC->hWnd;
937 pItem = pTrans;
938 for (dwIndex = 0; dwIndex < dwCount; ++dwIndex, ++pItem)
939 {
940 if (bAnsi)
941 SendMessageA(hWnd, pItem->message, pItem->wParam, pItem->lParam);
942 else
943 SendMessageW(hWnd, pItem->message, pItem->wParam, pItem->lParam);
944 }
945
946Quit:
947 ImmLocalFree(pTrans);
948 if (hMsgBuf)
949 ImmUnlockIMCC(hMsgBuf);
950 pIC->dwNumMsgBuf = 0; /* done */
951 ImmUnlockIMC(hIMC);
952 return TRUE;
953}
DWORD HIMCC
Definition: dimm.idl:76
LCID WINAPI GetSystemDefaultLCID(void)
Definition: locale.c:1235
unsigned short WORD
Definition: ntddk_ex.h:93
struct _tagTRANSMSG TRANSMSG
#define CLIENTIMC_WIDE
Definition: imm32_undoc.h:169
BOOL WINAPI ImmUnlockIMCC(_In_ HIMCC imcc)
Definition: utils.c:615
LPVOID WINAPI ImmLockIMCC(_In_ HIMCC imcc)
Definition: utils.c:604
#define GetWin32ClientInfo()
Definition: ntuser.h:352
DWORD NTAPI NtUserGetAppImeLevel(_In_ HWND hWnd)
Definition: ime.c:971
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 LANG_KOREAN
Definition: nls.h:84
#define _WIN32_WINNT_NT4
Definition: sdkddkver.h:20
HIMCC hMsgBuf
Definition: immdev.h:124
DWORD dwNumMsgBuf
Definition: immdev.h:123
#define RtlCopyMemory(Destination, Source, Length)
Definition: typedefs.h:263

Referenced by test_ImmMessages(), and test_InvalidIMC().

◆ ImmGetAppCompatFlags()

DWORD WINAPI ImmGetAppCompatFlags ( _In_ HIMC  hIMC)

Definition at line 722 of file keymsg.c.

723{
724 PCLIENTIMC pClientIMC;
726
727 TRACE("(%p)\n", hIMC);
728
729 pClientIMC = ImmLockClientImc(hIMC);
730 if (IS_NULL_UNEXPECTEDLY(pClientIMC))
731 return 0;
732
733 dwFlags = pClientIMC->dwCompatFlags;
734 ImmUnlockClientImc(pClientIMC);
735 return (dwFlags | g_aimm_compat_flags);
736}
DWORD g_aimm_compat_flags
Definition: ctf.c:204
DWORD dwCompatFlags
Definition: imm32_undoc.h:150
_In_ PCCERT_CONTEXT _In_ DWORD dwFlags
Definition: wincrypt.h:1176

Referenced by ImmProcessKey().

◆ ImmGetHotKey()

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

Definition at line 648 of file keymsg.c.

653{
654 TRACE("(0x%lX, %p, %p, %p)\n", dwHotKey, lpuModifiers, lpuVKey, lphKL);
655 if (lpuModifiers && lpuVKey)
656 return NtUserGetImeHotKey(dwHotKey, lpuModifiers, lpuVKey, lphKL);
657 return FALSE;
658}
BOOL NTAPI NtUserGetImeHotKey(_In_ DWORD dwHotKeyId, _Out_ PUINT lpuModifiers, _Out_ PUINT lpuVirtualKey, _Out_ LPHKL lphKL)
Definition: ime.c:427

◆ ImmGetVirtualKey()

UINT WINAPI ImmGetVirtualKey ( _In_ HWND  hWnd)

Definition at line 698 of file keymsg.c.

699{
700 HIMC hIMC;
703
704 TRACE("(%p)\n", hWnd);
705
706 hIMC = ImmGetContext(hWnd);
707 pIC = (LPINPUTCONTEXTDX)ImmLockIMC(hIMC);
708 if (IS_NULL_UNEXPECTEDLY(pIC))
709 return ret;
710
711 if (pIC->bNeedsTrans)
712 ret = pIC->nVKey;
713
714 ImmUnlockIMC(hIMC);
715 return ret;
716}
#define VK_PROCESSKEY
Definition: winuser.h:2346

Referenced by ActiveIMMApp_GetVirtualKey().

◆ ImmIsUIMessageA()

BOOL WINAPI ImmIsUIMessageA ( _In_opt_ HWND  hWndIME,
_In_ UINT  msg,
_In_ WPARAM  wParam,
_In_ LPARAM  lParam 
)

Definition at line 620 of file keymsg.c.

625{
626 TRACE("(%p, 0x%X, %p, %p)\n", hWndIME, msg, wParam, lParam);
627 return ImmIsUIMessageAW(hWndIME, msg, wParam, lParam, TRUE);
628}
#define msg(x)
Definition: auth_time.c:54
static BOOL ImmIsUIMessageAW(_In_opt_ HWND hWndIME, _In_ UINT msg, _In_ WPARAM wParam, _In_ LPARAM lParam, _In_ BOOL bAnsi)
Definition: keymsg.c:310

Referenced by ActiveIMMApp_IsUIMessageA(), and START_TEST().

◆ ImmIsUIMessageAW()

static BOOL ImmIsUIMessageAW ( _In_opt_ HWND  hWndIME,
_In_ UINT  msg,
_In_ WPARAM  wParam,
_In_ LPARAM  lParam,
_In_ BOOL  bAnsi 
)
static

Definition at line 310 of file keymsg.c.

316{
317 switch (msg)
318 {
319 case WM_IME_STARTCOMPOSITION: case WM_IME_ENDCOMPOSITION:
320 case WM_IME_COMPOSITION: case WM_IME_SETCONTEXT: case WM_IME_NOTIFY:
322 break;
323 default:
324 return FALSE;
325 }
326
327 if (IS_NULL_UNEXPECTEDLY(hWndIME))
328 return TRUE;
329
330 if (bAnsi)
331 SendMessageA(hWndIME, msg, wParam, lParam);
332 else
333 SendMessageW(hWndIME, msg, wParam, lParam);
334
335 return TRUE;
336}
#define WM_IME_SYSTEM
Definition: imm32_undoc.h:32
#define WM_IME_SETCONTEXT
Definition: winuser.h:1848
#define WM_IME_COMPOSITIONFULL
Definition: winuser.h:1851
#define WM_IME_SELECT
Definition: winuser.h:1852

Referenced by ImmIsUIMessageA(), and ImmIsUIMessageW().

◆ ImmIsUIMessageW()

BOOL WINAPI ImmIsUIMessageW ( _In_opt_ HWND  hWndIME,
_In_ UINT  msg,
_In_ WPARAM  wParam,
_In_ LPARAM  lParam 
)

Definition at line 634 of file keymsg.c.

639{
640 TRACE("(%p, 0x%X, %p, %p)\n", hWndIME, msg, wParam, lParam);
641 return ImmIsUIMessageAW(hWndIME, msg, wParam, lParam, FALSE);
642}

Referenced by ActiveIMMApp_IsUIMessageW().

◆ ImmPostMessages()

static VOID ImmPostMessages ( _In_ HWND  hwnd,
_In_ HIMC  hIMC,
_In_ DWORD  dwCount,
_In_ LPTRANSMSG  lpTransMsg 
)
static

Definition at line 956 of file keymsg.c.

961{
962 DWORD dwIndex;
963 PCLIENTIMC pClientImc;
964 LPTRANSMSG pNewTransMsg = lpTransMsg, pItem;
965 BOOL bAnsi;
966
967 pClientImc = ImmLockClientImc(hIMC);
968 if (IS_NULL_UNEXPECTEDLY(pClientImc))
969 return;
970
971 bAnsi = !(pClientImc->dwFlags & CLIENTIMC_WIDE);
972 ImmUnlockClientImc(pClientImc);
973
974#ifdef IMM_WIN3_SUPPORT
975 if (GetWin32ClientInfo()->dwExpWinVer < _WIN32_WINNT_NT4) /* old version (3.x)? */
976 {
978 WORD Lang = PRIMARYLANGID(LangID);
979
980 /* translate the messages if Japanese or Korean */
981 if (Lang == LANG_JAPANESE ||
982 (Lang == LANG_KOREAN && NtUserGetAppImeLevel(hwnd) == 3))
983 {
984 DWORD cbTransMsg = dwCount * sizeof(TRANSMSG);
985 pNewTransMsg = ImmLocalAlloc(0, cbTransMsg);
986 if (pNewTransMsg)
987 {
988 RtlCopyMemory(pNewTransMsg, lpTransMsg, cbTransMsg);
989 dwCount = WINNLSTranslateMessage(dwCount, pNewTransMsg, hIMC, bAnsi, Lang);
990 }
991 else
992 {
993 pNewTransMsg = lpTransMsg;
994 }
995 }
996 }
997#endif
998
999 /* post them */
1000 pItem = pNewTransMsg;
1001 for (dwIndex = 0; dwIndex < dwCount; ++dwIndex, ++pItem)
1002 {
1003 if (bAnsi)
1004 PostMessageA(hwnd, pItem->message, pItem->wParam, pItem->lParam);
1005 else
1006 PostMessageW(hwnd, pItem->message, pItem->wParam, pItem->lParam);
1007 }
1008
1009#ifdef IMM_WIN3_SUPPORT
1010 if (pNewTransMsg != lpTransMsg)
1011 ImmLocalFree(pNewTransMsg);
1012#endif
1013}
_In_ LONG _In_ HWND hwnd
Definition: winddi.h:4023
BOOL WINAPI PostMessageA(_In_opt_ HWND, _In_ UINT, _In_ WPARAM, _In_ LPARAM)

Referenced by ImmTranslateMessage().

◆ ImmProcessKey()

DWORD WINAPI ImmProcessKey ( _In_ HWND  hWnd,
_In_ HKL  hKL,
_In_ UINT  vKey,
_In_ LPARAM  lParam,
_In_ DWORD  dwHotKeyID 
)

Definition at line 743 of file keymsg.c.

749{
750 DWORD ret = 0;
751 HIMC hIMC;
752 PIMEDPI pImeDpi;
754 BYTE KeyState[256];
755 BOOL bLowWordOnly = FALSE, bSkipThisKey = FALSE, bHotKeyDone = TRUE;
756
757 TRACE("(%p, %p, 0x%X, %p, 0x%lX)\n", hWnd, hKL, vKey, lParam, dwHotKeyID);
758
759 /* Process the key by the IME */
760 hIMC = ImmGetContext(hWnd);
761 pImeDpi = ImmLockImeDpi(hKL);
762 if (pImeDpi)
763 {
764 pIC = (LPINPUTCONTEXTDX)ImmLockIMC(hIMC);
765 if (pIC)
766 {
767 if ((LOBYTE(vKey) == VK_PACKET) &&
769 {
770 if (ImeDpi_IsUnicode(pImeDpi))
771 {
772 bLowWordOnly = TRUE;
773 }
774 else
775 {
776 if (pIC->fOpen)
778
779 bSkipThisKey = TRUE;
780 }
781 }
782
783 if (!bSkipThisKey && GetKeyboardState(KeyState))
784 {
785 UINT vk = (bLowWordOnly ? LOWORD(vKey) : vKey);
786 if (pImeDpi->ImeProcessKey(hIMC, vk, lParam, KeyState))
787 {
788 pIC->bNeedsTrans = TRUE;
789 pIC->nVKey = vKey;
791 }
792 }
793
794 ImmUnlockIMC(hIMC);
795 }
796
797 ImmUnlockImeDpi(pImeDpi);
798 }
799
800 /* Process the hot-key if necessary */
801 if (!CtfImmIsCiceroStartedInThread()) /* Not Cicero? */
802 {
803 /* Process IMM IME hotkey */
804 if ((dwHotKeyID == INVALID_HOTKEY_ID) || !Imm32ProcessHotKey(hWnd, hIMC, hKL, dwHotKeyID))
805 bHotKeyDone = FALSE;
806 }
807 else if (!CtfImeProcessCicHotkey(hIMC, vKey, lParam)) /* CTF IME not processed the hotkey? */
808 {
809 /* Process IMM IME hotkey */
810 if (!IS_IME_HKL(hKL) ||
811 ((dwHotKeyID == INVALID_HOTKEY_ID) || !Imm32ProcessHotKey(hWnd, hIMC, hKL, dwHotKeyID)))
812 {
813 bHotKeyDone = FALSE;
814 }
815 }
816
817 if (bHotKeyDone && ((vKey != VK_KANJI) || (dwHotKeyID != IME_JHOTKEY_CLOSE_OPEN)))
818 ret |= IPHK_HOTKEY;
819
820 if ((ret & IPHK_PROCESSBYIME) && (ImmGetAppCompatFlags(hIMC) & 0x10000))
821 {
822 /* The key has been processed by IME's ImeProcessKey */
824 if ((PRIMARYLANGID(wLangID) == LANG_KOREAN) &&
825 ((vKey == VK_PROCESSKEY) || (ret & IPHK_HOTKEY)))
826 {
827 /* Korean don't want VK_PROCESSKEY and IME hot-keys */
828 }
829 else
830 {
831 /* Add WM_KEYDOWN:VK_PROCESSKEY message */
833
834 ret &= ~IPHK_PROCESSBYIME;
836 }
837 }
838
839 ImmReleaseContext(hWnd, hIMC);
840 return ret; /* Returns IPHK_... flags */
841}
BOOL WINAPI CtfImmIsCiceroStartedInThread(VOID)
Definition: ctf.c:781
#define IS_IME_HKL(hKL)
Definition: imm32_undoc.h:21
BOOL WINAPI ImmReleaseContext(_In_ HWND hWnd, _In_ HIMC hIMC)
Definition: imm.c:1109
#define IME_PROP_ACCEPT_WIDE_VKEY
Definition: immdev.h:367
#define LOBYTE(W)
Definition: jmemdos.c:487
static BOOL Imm32ProcessHotKey(HWND hWnd, HIMC hIMC, HKL hKL, DWORD dwHotKeyID)
Definition: keymsg.c:252
DWORD WINAPI ImmGetAppCompatFlags(_In_ HIMC hIMC)
Definition: keymsg.c:722
BOOL WINAPI ImmTranslateMessage(_In_ HWND hwnd, _In_ UINT msg, _In_ WPARAM wParam, _In_ LPARAM lKeyData)
Definition: keymsg.c:1020
WORD vk
Definition: input.c:77
EXTERN_C HRESULT WINAPI CtfImeProcessCicHotkey(_In_ HIMC hIMC, _In_ UINT vKey, _In_ LPARAM lParam)
Definition: msctfime.cpp:795
#define IPHK_SKIPTHISKEY
Definition: undocuser.h:143
#define IPHK_HOTKEY
Definition: undocuser.h:140
#define IPHK_PROCESSBYIME
Definition: undocuser.h:141
#define ImeDpi_IsUnicode(pImeDpi)
Definition: precomp.h:120
_Check_return_ BOOL WINAPI GetKeyboardState(_Out_writes_(256) PBYTE lpKeyState)
#define VK_KANJI
Definition: winuser.h:2232
unsigned char BYTE
Definition: xxhash.c:193

Referenced by ImmCallImeConsoleIME(), and User32CallImmProcessKeyFromKernel().

◆ ImmRequestMessageA()

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

Definition at line 1162 of file keymsg.c.

1166{
1167 TRACE("(%p, %p, %p)\n", hIMC, wParam, lParam);
1168 return ImmRequestMessageAW(hIMC, wParam, lParam, TRUE);
1169}
static LRESULT ImmRequestMessageAW(_In_ HIMC hIMC, _In_ WPARAM wParam, _In_ LPARAM lParam, _In_ BOOL bAnsi)
Definition: keymsg.c:587

Referenced by test_InvalidIMC().

◆ ImmRequestMessageAW()

static LRESULT ImmRequestMessageAW ( _In_ HIMC  hIMC,
_In_ WPARAM  wParam,
_In_ LPARAM  lParam,
_In_ BOOL  bAnsi 
)
static

Definition at line 587 of file keymsg.c.

592{
593 LRESULT ret = 0;
594 LPINPUTCONTEXT pIC;
595 HWND hWnd;
596 PWND pWnd = NULL;
597
599 return FALSE;
600
601 pIC = ImmLockIMC(hIMC);
602 if (IS_NULL_UNEXPECTEDLY(pIC))
603 return FALSE;
604
605 hWnd = pIC->hWnd;
606 if (hWnd)
607 pWnd = ValidateHwnd(hWnd);
608
609 if (pWnd && pWnd->head.pti == Imm32CurrentPti())
610 ret = Imm32ProcessRequest(hIMC, pWnd, (DWORD)wParam, (LPVOID)lParam, bAnsi);
611
612 ImmUnlockIMC(hIMC);
613 return ret;
614}
static LRESULT Imm32ProcessRequest(HIMC hIMC, PWND pWnd, DWORD dwCommand, LPVOID pData, BOOL bAnsiAPI)
Definition: keymsg.c:378
#define ValidateHwnd(hwnd)
Definition: precomp.h:101
PTHREADINFO FASTCALL Imm32CurrentPti(VOID)
Definition: utils.c:18
LONG_PTR LRESULT
Definition: windef.h:209

Referenced by ImmRequestMessageA(), and ImmRequestMessageW().

◆ ImmRequestMessageW()

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

Definition at line 1175 of file keymsg.c.

1179{
1180 TRACE("(%p, %p, %p)\n", hIMC, wParam, lParam);
1181 return ImmRequestMessageAW(hIMC, wParam, lParam, FALSE);
1182}

◆ ImmSimulateHotKey()

BOOL WINAPI ImmSimulateHotKey ( _In_ HWND  hWnd,
_In_ DWORD  dwHotKeyID 
)

Definition at line 675 of file keymsg.c.

678{
679 HIMC hIMC;
681 HKL hKL;
682 BOOL ret;
683
684 TRACE("(%p, 0x%lX)\n", hWnd, dwHotKeyID);
685
686 hIMC = ImmGetContext(hWnd);
689 ret = Imm32ProcessHotKey(hWnd, hIMC, hKL, dwHotKeyID);
690 ImmReleaseContext(hWnd, hIMC);
691 return ret;
692}

Referenced by ActiveIMMApp_SimulateHotKey().

◆ ImmSystemHandler()

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

Definition at line 847 of file keymsg.c.

851{
852 TRACE("(%p, %p, %p)\n", hIMC, wParam, lParam);
853
854 switch (wParam)
855 {
858 return 0;
859
862 return 0;
863
864 case IMS_SETLANGBAND:
867
868 default:
869 WARN("%p\n", wParam);
870 return 0;
871 }
872}
LRESULT CtfImmSetLangBand(_In_ HWND hWnd, _In_ BOOL fSet)
Definition: ctf.c:1234
#define IMS_SETLANGBAND
Definition: imm32_undoc.h:55
#define IMS_COMPLETECOMPSTR
Definition: imm32_undoc.h:53
#define IMS_UNSETLANGBAND
Definition: imm32_undoc.h:56
#define IMS_SENDNOTIFICATION
Definition: imm32_undoc.h:52
#define CPS_COMPLETE
Definition: imm.h:178
BOOL WINAPI ImmNotifyIME(_In_ HIMC hIMC, _In_ DWORD dwAction, _In_ DWORD dwIndex, _In_ DWORD_PTR dwValue)
Definition: ime.c:458
#define NI_COMPOSITIONSTR
Definition: immdev.h:381
BOOL Imm32SendNotification(BOOL bProcess)
Definition: keymsg.c:372

Referenced by ImeWnd_OnImeSystem().

◆ ImmTranslateMessage()

BOOL WINAPI ImmTranslateMessage ( _In_ HWND  hwnd,
_In_ UINT  msg,
_In_ WPARAM  wParam,
_In_ LPARAM  lKeyData 
)

Definition at line 1020 of file keymsg.c.

1025{
1026#define MSG_COUNT 0x100
1027 BOOL ret = FALSE;
1028 INT kret;
1029 LPINPUTCONTEXTDX pIC;
1030 PIMEDPI pImeDpi = NULL;
1032 LPTRANSMSG pTransMsg;
1033 BYTE abKeyState[256];
1034 HIMC hIMC;
1035 HKL hKL;
1036 UINT vk;
1037 DWORD dwThreadId, dwCount, cbList;
1038 WCHAR wch;
1039 WORD wChar;
1040
1041 TRACE("(%p, 0x%X, %p, %p)\n", hwnd, msg, wParam, lKeyData);
1042
1043 /* filter the message */
1044 switch (msg)
1045 {
1046 case WM_KEYDOWN: case WM_KEYUP: case WM_SYSKEYDOWN: case WM_SYSKEYUP:
1047 break;
1048 default:
1049 return FALSE;
1050 }
1051
1052 hIMC = ImmGetContext(hwnd);
1053 pIC = (LPINPUTCONTEXTDX)ImmLockIMC(hIMC);
1054 if (IS_NULL_UNEXPECTEDLY(pIC))
1055 {
1056 ImmReleaseContext(hwnd, hIMC);
1057 return FALSE;
1058 }
1059
1060 if (!pIC->bNeedsTrans) /* is translation needed? */
1061 {
1062 /* directly post them */
1063 dwCount = pIC->dwNumMsgBuf;
1064 if (dwCount == 0)
1065 goto Quit;
1066
1067 pTransMsg = ImmLockIMCC(pIC->hMsgBuf);
1068 if (pTransMsg)
1069 {
1070 ImmPostMessages(hwnd, hIMC, dwCount, pTransMsg);
1071 ImmUnlockIMCC(pIC->hMsgBuf);
1072 ret = TRUE;
1073 }
1074 pIC->dwNumMsgBuf = 0; /* done */
1075 goto Quit;
1076 }
1077 pIC->bNeedsTrans = FALSE; /* clear the flag */
1078
1081 pImeDpi = ImmLockImeDpi(hKL);
1082 if (IS_NULL_UNEXPECTEDLY(pImeDpi))
1083 goto Quit;
1084
1085 if (!GetKeyboardState(abKeyState)) /* get keyboard ON/OFF status */
1086 {
1087 WARN("\n");
1088 goto Quit;
1089 }
1090
1091 /* convert a virtual key if IME_PROP_KBD_CHAR_FIRST */
1092 vk = pIC->nVKey;
1094 {
1095 if (ImeDpi_IsUnicode(pImeDpi))
1096 {
1097 wch = 0;
1098 kret = ToUnicode(vk, HIWORD(lKeyData), abKeyState, &wch, 1, 0);
1099 if (kret == 1)
1100 vk = MAKELONG(LOBYTE(vk), wch);
1101 }
1102 else
1103 {
1104 wChar = 0;
1105 kret = ToAsciiEx(vk, HIWORD(lKeyData), abKeyState, &wChar, 0, hKL);
1106 if (kret > 0)
1107 {
1108 if ((BYTE)vk == VK_PACKET)
1109 {
1110 vk &= 0xFF;
1111 vk |= (wChar << 8);
1112 }
1113 else
1114 {
1115 vk = MAKEWORD(vk, wChar);
1116 }
1117 }
1118 }
1119 }
1120
1121 /* allocate a list */
1122 cbList = offsetof(TRANSMSGLIST, TransMsg) + MSG_COUNT * sizeof(TRANSMSG);
1123 pList = ImmLocalAlloc(0, cbList);
1125 goto Quit;
1126
1127 /* use IME conversion engine and convert the list */
1128 pList->uMsgCount = MSG_COUNT;
1129 kret = pImeDpi->ImeToAsciiEx(vk, HIWORD(lKeyData), abKeyState, pList, 0, hIMC);
1130 if (kret <= 0)
1131 goto Quit;
1132
1133 /* post them */
1134 if (kret <= MSG_COUNT)
1135 {
1136 ImmPostMessages(hwnd, hIMC, kret, pList->TransMsg);
1137 ret = TRUE;
1138 }
1139 else
1140 {
1141 pTransMsg = ImmLockIMCC(pIC->hMsgBuf);
1142 if (IS_NULL_UNEXPECTEDLY(pTransMsg))
1143 goto Quit;
1144 ImmPostMessages(hwnd, hIMC, kret, pTransMsg);
1145 ImmUnlockIMCC(pIC->hMsgBuf);
1146 }
1147
1148Quit:
1150 ImmUnlockImeDpi(pImeDpi);
1151 ImmUnlockIMC(hIMC);
1152 ImmReleaseContext(hwnd, hIMC);
1153 TRACE("ret: %d\n", ret);
1154 return ret;
1155#undef MSG_COUNT
1156}
FxChildList * pList
#define IME_PROP_KBD_CHAR_FIRST
Definition: immdev.h:363
static VOID ImmPostMessages(_In_ HWND hwnd, _In_ HIMC hIMC, _In_ DWORD dwCount, _In_ LPTRANSMSG lpTransMsg)
Definition: keymsg.c:956
#define MSG_COUNT
#define offsetof(TYPE, MEMBER)
#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
int WINAPI ToUnicode(_In_ UINT wVirtKey, _In_ UINT wScanCode, _In_reads_bytes_opt_(256) CONST BYTE *lpKeyState, _Out_writes_(cchBuff) LPWSTR pwszBuff, _In_ int cchBuff, _In_ UINT wFlags)
int WINAPI ToAsciiEx(_In_ UINT, _In_ UINT, _In_reads_opt_(256) CONST BYTE *, _Out_ LPWORD, _In_ UINT, _In_opt_ HKL)

Referenced by ImmProcessKey(), and TranslateMessage().

◆ ImmWINNLSGetIMEHotkey()

UINT WINAPI ImmWINNLSGetIMEHotkey ( _In_ HWND  hwndIme)

Definition at line 664 of file keymsg.c.

665{
666 TRACE("(%p)\n", hwndIme);
667 UNREFERENCED_PARAMETER(hwndIme);
668 return 0; /* This is correct. This function of Windows just returns zero. */
669}

◆ WINE_DEFAULT_DEBUG_CHANNEL()

WINE_DEFAULT_DEBUG_CHANNEL ( imm  )