ReactOS 0.4.15-dev-7085-g12a5971
imm.c
Go to the documentation of this file.
1/*
2 * PROJECT: ReactOS IMM32
3 * LICENSE: LGPL-2.1-or-later (https://spdx.org/licenses/LGPL-2.1-or-later)
4 * PURPOSE: Implementing Far-Eastern languages input
5 * COPYRIGHT: Copyright 1998 Patrik Stridvall
6 * Copyright 2002, 2003, 2007 CodeWeavers, Aric Stewart
7 * Copyright 2017 James Tabor <james.tabor@reactos.org>
8 * Copyright 2018 Amine Khaldi <amine.khaldi@reactos.org>
9 * Copyright 2020-2022 Katayama Hirofumi MZ <katayama.hirofumi.mz@gmail.com>
10 */
11
12#include "precomp.h"
13#include <ndk/exfuncs.h>
14
16
17HMODULE ghImm32Inst = NULL; // Win: ghInst
18PSERVERINFO gpsi = NULL; // Win: gpsi
19SHAREDINFO gSharedInfo = { NULL }; // Win: gSharedInfo
20BYTE gfImmInitialized = FALSE; // Win: gfInitialized
22
23// Win: ImmInitializeGlobals
25{
28
29 if (hMod)
30 ghImm32Inst = hMod;
31
33 return TRUE;
34
36 if (NT_ERROR(status))
37 {
38 ERR("\n");
39 return FALSE;
40 }
41
42 status = NtQuerySystemInformation(SystemBasicInformation, &SysInfo, sizeof(SysInfo), NULL);
43 if (NT_ERROR(status))
44 {
45 ERR("\n");
46 return FALSE;
47 }
49
51 return TRUE;
52}
53
54/***********************************************************************
55 * ImmRegisterClient(IMM32.@)
56 * ( Undocumented, called from user32.dll )
57 */
59{
62 return ImmInitializeGlobals(hMod);
63}
64
65/***********************************************************************
66 * ImmLoadLayout (IMM32.@)
67 */
69{
70 DWORD cbData, dwType;
71 HKEY hLayoutKey;
72 LONG error;
73 WCHAR szLayout[MAX_PATH];
74
75 TRACE("(%p, %p)\n", hKL, pImeInfoEx);
76
77 ZeroMemory(pImeInfoEx, sizeof(IMEINFOEX));
78
79 if (IS_IME_HKL(hKL) || !IS_CICERO_MODE() || IS_16BIT_MODE())
80 {
81 StringCchPrintfW(szLayout, _countof(szLayout), L"%s\\%08lX",
83
84 error = RegOpenKeyExW(HKEY_LOCAL_MACHINE, szLayout, 0, KEY_READ, &hLayoutKey);
86 return FALSE;
87 }
88 else
89 {
92 return FALSE;
93 }
94
95 cbData = sizeof(pImeInfoEx->wszImeFile);
96 error = RegQueryValueExW(hLayoutKey, L"Ime File", NULL, &dwType,
97 (LPBYTE)pImeInfoEx->wszImeFile, &cbData);
98 pImeInfoEx->wszImeFile[_countof(pImeInfoEx->wszImeFile) - 1] = UNICODE_NULL;
99
100 RegCloseKey(hLayoutKey);
101
102 pImeInfoEx->fLoadFlag = 0;
103
105 return FALSE;
106
107 if (dwType != REG_SZ)
108 {
109 ERR("\n");
110 return FALSE;
111 }
112
113 pImeInfoEx->hkl = hKL;
114 return Imm32LoadImeVerInfo(pImeInfoEx);
115}
116
117/***********************************************************************
118 * ImmFreeLayout (IMM32.@)
119 */
121{
122 WCHAR szKBD[KL_NAMELENGTH];
123 UINT iKL, cKLs;
124 HKL hOldKL, hNewKL, *pList;
125 PIMEDPI pImeDpi;
127
128 TRACE("(0x%lX)\n", dwUnknown);
129
130 hOldKL = GetKeyboardLayout(0);
131
132 if (dwUnknown == 1)
133 {
134 if (!IS_IME_HKL(hOldKL))
135 return TRUE;
136
138
139 cKLs = GetKeyboardLayoutList(0, NULL);
140 if (cKLs)
141 {
142 pList = ImmLocalAlloc(0, cKLs * sizeof(HKL));
144 return FALSE;
145
146 cKLs = GetKeyboardLayoutList(cKLs, pList);
147 for (iKL = 0; iKL < cKLs; ++iKL)
148 {
149 if (!IS_IME_HKL(pList[iKL]))
150 {
151 LangID = LOWORD(pList[iKL]);
152 break;
153 }
154 }
155
157 }
158
159 StringCchPrintfW(szKBD, _countof(szKBD), L"%08X", LangID);
161 {
162 WARN("Default to English US\n");
163 LoadKeyboardLayoutW(L"00000409", KLF_ACTIVATE | 0x200);
164 }
165 }
166 else if (dwUnknown == 2)
167 {
169Retry:
170 for (pImeDpi = gpImeDpiList; pImeDpi; pImeDpi = pImeDpi->pNext)
171 {
172 if (Imm32ReleaseIME(pImeDpi->hKL))
173 goto Retry;
174 }
176 }
177 else
178 {
179 hNewKL = (HKL)(DWORD_PTR)dwUnknown;
180 if (IS_IME_HKL(hNewKL) && hNewKL != hOldKL)
181 Imm32ReleaseIME(hNewKL);
182 }
183
184 return TRUE;
185}
186
187// Win: SelectInputContext
189{
190 PCLIENTIMC pClientImc;
192 LPGUIDELINE pGL;
193 LPCANDIDATEINFO pCI;
195 LOGFONTA LogFontA;
196 LOGFONTW LogFontW;
197 BOOL fOldOpen, bIsNewHKLIme = TRUE, bIsOldHKLIme = TRUE, bClientWide, bNewDpiWide;
198 DWORD cbNewPrivate = 0, cbOldPrivate = 0, dwOldConversion, dwOldSentence, dwSize, dwNewSize;
199 PIMEDPI pNewImeDpi = NULL, pOldImeDpi = NULL;
200 HANDLE hPrivate;
201 PIME_STATE pNewState = NULL, pOldState = NULL;
202
203 pClientImc = ImmLockClientImc(hIMC);
204 if (IS_NULL_UNEXPECTEDLY(pClientImc))
205 return;
206
207 pNewImeDpi = ImmLockImeDpi(hNewKL);
208
209 if (hNewKL != hOldKL)
210 pOldImeDpi = ImmLockImeDpi(hOldKL);
211
212 if (pNewImeDpi)
213 {
214 cbNewPrivate = pNewImeDpi->ImeInfo.dwPrivateDataSize;
215 pClientImc->uCodePage = pNewImeDpi->uCodePage;
216 }
217 else
218 {
219 pClientImc->uCodePage = CP_ACP;
220 }
221
222 if (pOldImeDpi)
223 cbOldPrivate = pOldImeDpi->ImeInfo.dwPrivateDataSize;
224
225 cbNewPrivate = max(cbNewPrivate, sizeof(DWORD));
226 cbOldPrivate = max(cbOldPrivate, sizeof(DWORD));
227
228 if (pClientImc->hKL == hOldKL)
229 {
230 if (pOldImeDpi)
231 {
232 if (IS_IME_HKL(hOldKL))
233 pOldImeDpi->ImeSelect(hIMC, FALSE);
234 else if (IS_CICERO_MODE() && !IS_16BIT_MODE())
235 pOldImeDpi->CtfImeSelectEx(hIMC, FALSE, hOldKL);
236 }
237 pClientImc->hKL = NULL;
238 }
239
241 {
242 bIsNewHKLIme = IS_IME_HKL(hNewKL);
243 bIsOldHKLIme = IS_IME_HKL(hOldKL);
244 }
245
247 if (!pIC)
248 {
249 if (pNewImeDpi)
250 {
251 if (IS_IME_HKL(hNewKL))
252 pNewImeDpi->ImeSelect(hIMC, TRUE);
253 else if (IS_CICERO_MODE() && !IS_16BIT_MODE())
254 pNewImeDpi->CtfImeSelectEx(hIMC, TRUE, hNewKL);
255
256 pClientImc->hKL = hNewKL;
257 }
258 }
259 else
260 {
261 dwOldConversion = pIC->fdwConversion;
262 dwOldSentence = pIC->fdwSentence;
263 fOldOpen = pIC->fOpen;
264
265 if (pNewImeDpi)
266 {
267 bClientWide = (pClientImc->dwFlags & CLIENTIMC_WIDE);
268 bNewDpiWide = ImeDpi_IsUnicode(pNewImeDpi);
269 if (bClientWide && !bNewDpiWide)
270 {
271 if (pIC->fdwInit & INIT_LOGFONT)
272 {
273 LogFontWideToAnsi(&pIC->lfFont.W, &LogFontA);
274 pIC->lfFont.A = LogFontA;
275 }
276 pClientImc->dwFlags &= ~CLIENTIMC_WIDE;
277 }
278 else if (!bClientWide && bNewDpiWide)
279 {
280 if (pIC->fdwInit & INIT_LOGFONT)
281 {
282 LogFontAnsiToWide(&pIC->lfFont.A, &LogFontW);
283 pIC->lfFont.W = LogFontW;
284 }
285 pClientImc->dwFlags |= CLIENTIMC_WIDE;
286 }
287 }
288
289 if (cbOldPrivate != cbNewPrivate)
290 {
291 hPrivate = ImmReSizeIMCC(pIC->hPrivate, cbNewPrivate);
292 if (!hPrivate)
293 {
294 ImmDestroyIMCC(pIC->hPrivate);
295 hPrivate = ImmCreateIMCC(cbNewPrivate);
296 }
297 pIC->hPrivate = hPrivate;
298 }
299
300#define MAX_IMCC_SIZE 0x1000
301 dwSize = ImmGetIMCCSize(pIC->hMsgBuf);
302 if (ImmGetIMCCLockCount(pIC->hMsgBuf) || dwSize > MAX_IMCC_SIZE)
303 {
304 ImmDestroyIMCC(pIC->hMsgBuf);
305 pIC->hMsgBuf = ImmCreateIMCC(sizeof(UINT));
306 pIC->dwNumMsgBuf = 0;
307 }
308
309 dwSize = ImmGetIMCCSize(pIC->hGuideLine);
310 dwNewSize = sizeof(GUIDELINE);
311 if (ImmGetIMCCLockCount(pIC->hGuideLine) ||
312 dwSize < dwNewSize || dwSize > MAX_IMCC_SIZE)
313 {
314 ImmDestroyIMCC(pIC->hGuideLine);
315 pIC->hGuideLine = ImmCreateIMCC(dwNewSize);
316 pGL = ImmLockIMCC(pIC->hGuideLine);
317 if (pGL)
318 {
319 pGL->dwSize = dwNewSize;
320 ImmUnlockIMCC(pIC->hGuideLine);
321 }
322 }
323
324 dwSize = ImmGetIMCCSize(pIC->hCandInfo);
325 dwNewSize = sizeof(CANDIDATEINFO);
326 if (ImmGetIMCCLockCount(pIC->hCandInfo) ||
327 dwSize < dwNewSize || dwSize > MAX_IMCC_SIZE)
328 {
329 ImmDestroyIMCC(pIC->hCandInfo);
330 pIC->hCandInfo = ImmCreateIMCC(dwNewSize);
331 pCI = ImmLockIMCC(pIC->hCandInfo);
332 if (pCI)
333 {
334 pCI->dwSize = dwNewSize;
335 ImmUnlockIMCC(pIC->hCandInfo);
336 }
337 }
338
339 dwSize = ImmGetIMCCSize(pIC->hCompStr);
340 dwNewSize = sizeof(COMPOSITIONSTRING);
341 if (ImmGetIMCCLockCount(pIC->hCompStr) ||
342 dwSize < dwNewSize || dwSize > MAX_IMCC_SIZE)
343 {
344 ImmDestroyIMCC(pIC->hCompStr);
345 pIC->hCompStr = ImmCreateIMCC(dwNewSize);
346 pCS = ImmLockIMCC(pIC->hCompStr);
347 if (pCS)
348 {
349 pCS->dwSize = dwNewSize;
350 ImmUnlockIMCC(pIC->hCompStr);
351 }
352 }
353#undef MAX_IMCC_SIZE
354
355 if (pOldImeDpi && bIsOldHKLIme)
356 {
357 pOldState = Imm32FetchImeState(pIC, hOldKL);
358 if (pOldState)
359 Imm32SaveImeStateSentence(pIC, pOldState, hOldKL);
360 }
361
362 if (pNewImeDpi && bIsNewHKLIme)
363 pNewState = Imm32FetchImeState(pIC, hNewKL);
364
365 if (pOldState != pNewState)
366 {
367 if (pOldState)
368 {
369 pOldState->fOpen = !!pIC->fOpen;
370 pOldState->dwConversion = pIC->fdwConversion;
371 pOldState->dwConversion &= ~IME_CMODE_EUDC;
372 pOldState->dwSentence = pIC->fdwSentence;
373 pOldState->dwInit = pIC->fdwInit;
374 }
375
376 if (pNewState)
377 {
379 {
380 pIC->dwChange &= ~INPUTCONTEXTDX_CHANGE_FORCE_OPEN;
381 pIC->fOpen = TRUE;
382 }
383 else
384 {
385 pIC->fOpen = pNewState->fOpen;
386 }
387
388 pIC->fdwConversion = pNewState->dwConversion;
389 pIC->fdwConversion &= ~IME_CMODE_EUDC;
390 pIC->fdwSentence = pNewState->dwSentence;
391 pIC->fdwInit = pNewState->dwInit;
392 }
393 }
394
395 if (pNewState)
396 Imm32LoadImeStateSentence(pIC, pNewState, hNewKL);
397
398 if (pNewImeDpi)
399 {
400 if (IS_IME_HKL(hNewKL))
401 pNewImeDpi->ImeSelect(hIMC, TRUE);
402 else if (IS_CICERO_MODE() && !IS_16BIT_MODE())
403 pNewImeDpi->CtfImeSelectEx(hIMC, TRUE, hNewKL);
404
405 pClientImc->hKL = hNewKL;
406 }
407
408 pIC->dwChange = 0;
409 if (pIC->fOpen != fOldOpen)
411 if (pIC->fdwConversion != dwOldConversion)
413 if (pIC->fdwSentence != dwOldSentence)
415
416 ImmUnlockIMC(hIMC);
417 }
418
419 ImmUnlockImeDpi(pOldImeDpi);
420 ImmUnlockImeDpi(pNewImeDpi);
421 ImmUnlockClientImc(pClientImc);
422}
423
424typedef struct SELECT_LAYOUT
425{
429
430// Win: SelectContextProc
432{
434 Imm32SelectInputContext(pSelect->hNewKL, pSelect->hOldKL, hIMC);
435 return TRUE;
436}
437
438// Win: NotifyIMEProc
440{
442 return TRUE;
443}
444
445/***********************************************************************
446 * ImmActivateLayout (IMM32.@)
447 */
449{
450 PIMEDPI pImeDpi;
451 HKL hOldKL;
453 HWND hwndDefIME = NULL;
454 SELECT_LAYOUT SelectLayout;
455
456 hOldKL = GetKeyboardLayout(0);
457
458 if (hOldKL == hKL && !(GetWin32ClientInfo()->CI_flags & CI_IMMACTIVATE))
459 return TRUE;
460
461 ImmLoadIME(hKL);
462
463 if (hOldKL != hKL)
464 {
465 pImeDpi = ImmLockImeDpi(hOldKL);
466 if (pImeDpi)
467 {
470 else
472 ImmUnlockImeDpi(pImeDpi);
473
475 }
476
477 hwndDefIME = ImmGetDefaultIMEWnd(NULL);
478 if (IsWindow(hwndDefIME))
479 SendMessageW(hwndDefIME, WM_IME_SELECT, FALSE, (LPARAM)hOldKL);
480
481 NtUserSetThreadLayoutHandles(hKL, hOldKL);
482 }
483
484 SelectLayout.hNewKL = hKL;
485 SelectLayout.hOldKL = hOldKL;
487
488 if (IsWindow(hwndDefIME))
489 SendMessageW(hwndDefIME, WM_IME_SELECT, TRUE, (LPARAM)hKL);
490
491 return TRUE;
492}
493
494/* Win: Internal_CtfImeSetActiveContextAlways */
496{
497 TRACE("We have to do something\n");
498}
499
500/***********************************************************************
501 * ImmAssociateContext (IMM32.@)
502 */
504{
505 PWND pWnd;
506 HWND hwndFocus;
507 DWORD dwValue;
508 HIMC hOldIMC;
509
510 TRACE("(%p, %p)\n", hWnd, hIMC);
511
512 if (!IS_IMM_MODE())
513 {
514 TRACE("\n");
515 return NULL;
516 }
517
518 pWnd = ValidateHwnd(hWnd);
519 if (IS_NULL_UNEXPECTEDLY(pWnd))
520 return NULL;
521
522 if (hIMC && IS_CROSS_THREAD_HIMC(hIMC))
523 return NULL;
524
525 hOldIMC = pWnd->hImc;
526 if (hOldIMC == hIMC)
527 return hIMC;
528
529 dwValue = NtUserAssociateInputContext(hWnd, hIMC, 0);
530 switch (dwValue)
531 {
532 case 0:
533 return hOldIMC;
534
535 case 1:
537 if (hwndFocus == hWnd)
538 {
539 ImmSetActiveContext(hWnd, hOldIMC, FALSE);
541 }
542 return hOldIMC;
543
544 default:
545 return NULL;
546 }
547}
548
549/***********************************************************************
550 * ImmAssociateContextEx (IMM32.@)
551 */
553{
554 HWND hwndFocus;
556 HIMC hOldIMC = NULL;
557 DWORD dwValue;
558
559 TRACE("(%p, %p, 0x%lX)\n", hWnd, hIMC, dwFlags);
560
561 if (!IS_IMM_MODE())
562 {
563 TRACE("\n");
564 return FALSE;
565 }
566
567 if (hIMC && !(dwFlags & IACE_DEFAULT) && IS_CROSS_THREAD_HIMC(hIMC))
568 return FALSE;
569
571 pFocusWnd = ValidateHwnd(hwndFocus);
572 if (pFocusWnd)
573 hOldIMC = pFocusWnd->hImc;
574
575 dwValue = NtUserAssociateInputContext(hWnd, hIMC, dwFlags);
576 switch (dwValue)
577 {
578 case 0:
579 return TRUE;
580
581 case 1:
582 pFocusWnd = ValidateHwnd(hwndFocus);
583 if (pFocusWnd)
584 {
585 hIMC = pFocusWnd->hImc;
586 if (hIMC != hOldIMC)
587 {
588 ImmSetActiveContext(hwndFocus, hOldIMC, FALSE);
589 ImmSetActiveContext(hwndFocus, hIMC, TRUE);
590 }
591 }
592 return TRUE;
593
594 default:
595 return FALSE;
596 }
597}
598
599/***********************************************************************
600 * ImmCreateContext (IMM32.@)
601 */
603{
604 PCLIENTIMC pClientImc;
605 HIMC hIMC;
606
607 TRACE("()\n");
608
609 if (!IS_IMM_MODE())
610 {
611 TRACE("\n");
612 return NULL;
613 }
614
615 pClientImc = ImmLocalAlloc(HEAP_ZERO_MEMORY, sizeof(CLIENTIMC));
616 if (IS_NULL_UNEXPECTEDLY(pClientImc))
617 return NULL;
618
619 hIMC = NtUserCreateInputContext((ULONG_PTR)pClientImc);
620 if (IS_NULL_UNEXPECTEDLY(hIMC))
621 {
622 ImmLocalFree(pClientImc);
623 return NULL;
624 }
625
626 RtlInitializeCriticalSection(&pClientImc->cs);
627
629
630 return hIMC;
631}
632
633// Win: DestroyImeModeSaver
635{
636 PIME_STATE pState, pNext;
637 PIME_SUBSTATE pSubState, pSubNext;
638
639 for (pState = pIC->pState; pState; pState = pNext)
640 {
641 pNext = pState->pNext;
642
643 for (pSubState = pState->pSubState; pSubState; pSubState = pSubNext)
644 {
645 pSubNext = pSubState->pNext;
646 ImmLocalFree(pSubState);
647 }
648
649 ImmLocalFree(pState);
650 }
651
652 pIC->pState = NULL;
653}
654
655// Win: DestroyInputContext
657{
658 PIMEDPI pImeDpi;
660 PCLIENTIMC pClientImc;
661 PIMC pIMC;
662
663 if (hIMC == NULL)
664 return FALSE;
665
666 if (!IS_IMM_MODE())
667 {
668 TRACE("\n");
669 return FALSE;
670 }
671
672 pIMC = ValidateHandle(hIMC, TYPE_INPUTCONTEXT);
673 if (IS_NULL_UNEXPECTEDLY(pIMC))
674 return FALSE;
675
676 if (pIMC->head.pti != Imm32CurrentPti())
677 {
678 ERR("Thread mismatch\n");
679 return FALSE;
680 }
681
682 pClientImc = (PCLIENTIMC)pIMC->dwClientImcData;
683 if (pClientImc == NULL)
684 {
685 TRACE("pClientImc == NULL\n");
686 goto Finish;
687 }
688
689 if ((pClientImc->dwFlags & CLIENTIMC_UNKNOWN2) && !bKeep)
690 {
691 ERR("Can't destroy for CLIENTIMC_UNKNOWN2\n");
692 return FALSE;
693 }
694
695 if (pClientImc->dwFlags & CLIENTIMC_DESTROY)
696 return TRUE;
697
698 InterlockedIncrement(&pClientImc->cLockObj);
699
700 if (IS_NULL_UNEXPECTEDLY(pClientImc->hInputContext))
701 goto Quit;
702
703 pIC = (LPINPUTCONTEXTDX)ImmLockIMC(hIMC);
704 if (IS_NULL_UNEXPECTEDLY(pIC))
705 {
706 ImmUnlockClientImc(pClientImc);
707 return FALSE;
708 }
709
711
712 if (pClientImc->hKL == hKL)
713 {
714 pImeDpi = ImmLockImeDpi(hKL);
715 if (pImeDpi)
716 {
717 if (IS_IME_HKL(hKL))
718 pImeDpi->ImeSelect(hIMC, FALSE);
719 else if (IS_CICERO_MODE() && !IS_16BIT_MODE())
720 pImeDpi->CtfImeSelectEx(hIMC, FALSE, hKL);
721
722 ImmUnlockImeDpi(pImeDpi);
723 }
724
725 pClientImc->hKL = NULL;
726 }
727
728 ImmDestroyIMCC(pIC->hPrivate);
729 ImmDestroyIMCC(pIC->hMsgBuf);
730 ImmDestroyIMCC(pIC->hGuideLine);
731 ImmDestroyIMCC(pIC->hCandInfo);
732 ImmDestroyIMCC(pIC->hCompStr);
734 ImmUnlockIMC(hIMC);
735
736Quit:
737 pClientImc->dwFlags |= CLIENTIMC_DESTROY;
738 ImmUnlockClientImc(pClientImc);
739
740Finish:
741 if (bKeep)
742 return TRUE;
743 return NtUserDestroyInputContext(hIMC);
744}
745
746// NOTE: Windows does recursive call ImmLockIMC here but we don't do so.
747// Win: BOOL CreateInputContext(HIMC hIMC, HKL hKL, BOOL fSelect)
749Imm32CreateInputContext(HIMC hIMC, LPINPUTCONTEXT pIC, PCLIENTIMC pClientImc, HKL hKL, BOOL fSelect)
750{
751 DWORD dwIndex, cbPrivate;
752 PIMEDPI pImeDpi = NULL;
754 LPCANDIDATEINFO pCI;
755 LPGUIDELINE pGL;
756
757 /* Create IC components */
759 pIC->hCandInfo = ImmCreateIMCC(sizeof(CANDIDATEINFO));
760 pIC->hGuideLine = ImmCreateIMCC(sizeof(GUIDELINE));
761 pIC->hMsgBuf = ImmCreateIMCC(sizeof(UINT));
762 if (IS_NULL_UNEXPECTEDLY(pIC->hCompStr) ||
766 {
767 goto Fail;
768 }
769
770 /* Initialize IC components */
771 pCS = ImmLockIMCC(pIC->hCompStr);
772 if (IS_NULL_UNEXPECTEDLY(pCS))
773 goto Fail;
774 pCS->dwSize = sizeof(COMPOSITIONSTRING);
776
777 pCI = ImmLockIMCC(pIC->hCandInfo);
778 if (IS_NULL_UNEXPECTEDLY(pCI))
779 goto Fail;
780 pCI->dwSize = sizeof(CANDIDATEINFO);
782
783 pGL = ImmLockIMCC(pIC->hGuideLine);
784 if (IS_NULL_UNEXPECTEDLY(pGL))
785 goto Fail;
786 pGL->dwSize = sizeof(GUIDELINE);
788
789 pIC->dwNumMsgBuf = 0;
790 pIC->fOpen = FALSE;
791 pIC->fdwConversion = pIC->fdwSentence = 0;
792
793 for (dwIndex = 0; dwIndex < MAX_CANDIDATEFORM; ++dwIndex)
795
796 /* Get private data size */
797 pImeDpi = ImmLockImeDpi(hKL);
798 if (!pImeDpi)
799 {
800 cbPrivate = sizeof(DWORD);
801 }
802 else
803 {
804 /* Update CLIENTIMC */
805 pClientImc->uCodePage = pImeDpi->uCodePage;
806 if (ImeDpi_IsUnicode(pImeDpi))
807 pClientImc->dwFlags |= CLIENTIMC_WIDE;
808
809 cbPrivate = pImeDpi->ImeInfo.dwPrivateDataSize;
810 }
811
812 /* Create private data */
813 pIC->hPrivate = ImmCreateIMCC(cbPrivate);
815 goto Fail;
816
818
819 if (pImeDpi)
820 {
821 /* Select the IME */
822 if (fSelect)
823 {
824 if (IS_IME_HKL(hKL))
825 pImeDpi->ImeSelect(hIMC, TRUE);
826 else if (IS_CICERO_MODE() && !IS_16BIT_MODE())
827 pImeDpi->CtfImeSelectEx(hIMC, TRUE, hKL);
828 }
829
830 /* Set HKL */
831 pClientImc->hKL = hKL;
832
833 ImmUnlockImeDpi(pImeDpi);
834 }
835
836 return TRUE;
837
838Fail:
839 if (pImeDpi)
840 ImmUnlockImeDpi(pImeDpi);
841
842 pIC->hMsgBuf = ImmDestroyIMCC(pIC->hMsgBuf);
845 pIC->hCompStr = ImmDestroyIMCC(pIC->hCompStr);
846 return FALSE;
847}
848
849// Win: InternalImmLockIMC
851{
852 HANDLE hIC;
853 LPINPUTCONTEXT pIC = NULL;
854 PCLIENTIMC pClientImc;
855 WORD LangID;
857 HKL hOldKL, hNewKL;
858 PIMEDPI pImeDpi = NULL;
859
860 pClientImc = ImmLockClientImc(hIMC);
861 if (IS_NULL_UNEXPECTEDLY(pClientImc))
862 return NULL;
863
864 RtlEnterCriticalSection(&pClientImc->cs);
865
866 if (pClientImc->hInputContext)
867 {
868 pIC = LocalLock(pClientImc->hInputContext);
869 if (IS_NULL_UNEXPECTEDLY(pIC))
870 goto Failure;
871
873 goto Success;
874 }
875
878 {
879 hOldKL = GetKeyboardLayout(0);
880 LangID = LOWORD(hOldKL);
881 hNewKL = (HKL)(DWORD_PTR)MAKELONG(LangID, LangID);
882
883 pImeDpi = Imm32FindOrLoadImeDpi(hNewKL);
884 if (pImeDpi)
885 {
886 CtfImmTIMActivate(hNewKL);
887 }
888 }
889
891 {
892 ERR("No default IME window\n");
893 goto Failure;
894 }
895
896 hIC = LocalAlloc(LHND, sizeof(INPUTCONTEXTDX));
897 pIC = LocalLock(hIC);
898 if (IS_NULL_UNEXPECTEDLY(pIC))
899 {
900 LocalFree(hIC);
901 goto Failure;
902 }
903 pClientImc->hInputContext = hIC;
904
906 if (!Imm32CreateInputContext(hIMC, pIC, pClientImc, hNewKL, fSelect))
907 {
908 LocalUnlock(hIC);
909 pClientImc->hInputContext = LocalFree(hIC);
910 goto Failure;
911 }
912
913Success:
914 RtlLeaveCriticalSection(&pClientImc->cs);
915 InterlockedIncrement(&pClientImc->cLockObj);
916 ImmUnlockClientImc(pClientImc);
917 return pIC;
918
919Failure:
920 RtlLeaveCriticalSection(&pClientImc->cs);
921 ImmUnlockClientImc(pClientImc);
922 return NULL;
923}
924
925/***********************************************************************
926 * ImmDestroyContext (IMM32.@)
927 */
929{
930 HKL hKL;
931
932 TRACE("(%p)\n", hIMC);
933
934 if (!IS_IMM_MODE())
935 {
936 TRACE("\n");
937 return FALSE;
938 }
939
940 if (IS_CROSS_THREAD_HIMC(hIMC))
941 return FALSE;
942
943 hKL = GetKeyboardLayout(0);
944 return Imm32DestroyInputContext(hIMC, hKL, FALSE);
945}
946
947/***********************************************************************
948 * ImmLockClientImc (IMM32.@)
949 */
951{
952 PIMC pIMC;
953 PCLIENTIMC pClientImc;
954
955 TRACE("(%p)\n", hImc);
956
957 if (IS_NULL_UNEXPECTEDLY(hImc))
958 return NULL;
959
960 pIMC = ValidateHandle(hImc, TYPE_INPUTCONTEXT);
961 if (IS_NULL_UNEXPECTEDLY(pIMC) || !Imm32CheckImcProcess(pIMC))
962 return NULL;
963
964 pClientImc = (PCLIENTIMC)pIMC->dwClientImcData;
965 if (pClientImc)
966 {
967 if (pClientImc->dwFlags & CLIENTIMC_DESTROY)
968 return NULL;
969 goto Finish;
970 }
971
972 pClientImc = ImmLocalAlloc(HEAP_ZERO_MEMORY, sizeof(CLIENTIMC));
973 if (IS_NULL_UNEXPECTEDLY(pClientImc))
974 return NULL;
975
976 RtlInitializeCriticalSection(&pClientImc->cs);
978
980 {
981 ERR("\n");
982 ImmLocalFree(pClientImc);
983 return NULL;
984 }
985
986 pClientImc->dwFlags |= CLIENTIMC_UNKNOWN2;
987
988Finish:
989 InterlockedIncrement(&pClientImc->cLockObj);
990 return pClientImc;
991}
992
993/***********************************************************************
994 * ImmUnlockClientImc (IMM32.@)
995 */
997{
998 LONG cLocks;
999 HANDLE hInputContext;
1000
1001 TRACE("(%p)\n", pClientImc);
1002
1003 cLocks = InterlockedDecrement(&pClientImc->cLockObj);
1004 if (cLocks != 0 || !(pClientImc->dwFlags & CLIENTIMC_DESTROY))
1005 return;
1006
1007 hInputContext = pClientImc->hInputContext;
1008 if (hInputContext)
1009 LocalFree(hInputContext);
1010
1011 RtlDeleteCriticalSection(&pClientImc->cs);
1012 ImmLocalFree(pClientImc);
1013}
1014
1015// Win: ImmGetSaveContext
1017{
1018 HIMC hIMC;
1019 PCLIENTIMC pClientImc;
1020 PWND pWnd;
1021
1022 if (!IS_IMM_MODE())
1023 {
1024 TRACE("Not IMM mode.\n");
1025 return NULL;
1026 }
1027
1028 if (!hWnd)
1029 {
1031 goto Quit;
1032 }
1033
1034 pWnd = ValidateHwnd(hWnd);
1036 return NULL;
1037
1038 hIMC = pWnd->hImc;
1039 if (!hIMC && (dwContextFlags & 1))
1041
1042Quit:
1043 pClientImc = ImmLockClientImc(hIMC);
1044 if (IS_NULL_UNEXPECTEDLY(pClientImc))
1045 return NULL;
1046
1047 if ((dwContextFlags & 2) && (pClientImc->dwFlags & CLIENTIMC_DISABLEIME))
1048 hIMC = NULL;
1049
1050 ImmUnlockClientImc(pClientImc);
1051 return hIMC;
1052}
1053
1054/***********************************************************************
1055 * ImmGetContext (IMM32.@)
1056 */
1058{
1059 TRACE("(%p)\n", hWnd);
1061 return NULL;
1062 return ImmGetSaveContext(hWnd, 2);
1063}
1064
1065/***********************************************************************
1066 * ImmLockIMC(IMM32.@)
1067 *
1068 * NOTE: This is not ImmLockIMCC. Don't confuse.
1069 */
1071{
1072 TRACE("(%p)\n", hIMC);
1073 return Imm32InternalLockIMC(hIMC, TRUE);
1074}
1075
1076/***********************************************************************
1077* ImmUnlockIMC(IMM32.@)
1078*/
1080{
1081 PCLIENTIMC pClientImc;
1082
1083 pClientImc = ImmLockClientImc(hIMC);
1084 if (IS_NULL_UNEXPECTEDLY(pClientImc))
1085 return FALSE;
1086
1087 if (pClientImc->hInputContext)
1088 LocalUnlock(pClientImc->hInputContext);
1089
1090 InterlockedDecrement(&pClientImc->cLockObj);
1091 ImmUnlockClientImc(pClientImc);
1092 return TRUE;
1093}
1094
1095/***********************************************************************
1096 * ImmReleaseContext (IMM32.@)
1097 */
1099{
1100 TRACE("(%p, %p)\n", hWnd, hIMC);
1103 return TRUE; // Do nothing. This is correct.
1104}
1105
1106/***********************************************************************
1107* ImmDisableTextFrameService(IMM32.@)
1108*/
1110{
1111 FIXME("Stub\n");
1112 return FALSE;
1113}
1114
1115/***********************************************************************
1116 * ImmEnumInputContext(IMM32.@)
1117 */
1119{
1120 HIMC *phList;
1121 DWORD dwIndex, dwCount;
1122 BOOL ret = TRUE;
1123 HIMC hIMC;
1124
1125 TRACE("(%lu, %p, %p)\n", dwThreadId, lpfn, lParam);
1126
1127 dwCount = Imm32BuildHimcList(dwThreadId, &phList);
1128 if (IS_ZERO_UNEXPECTEDLY(dwCount))
1129 return FALSE;
1130
1131 for (dwIndex = 0; dwIndex < dwCount; ++dwIndex)
1132 {
1133 hIMC = phList[dwIndex];
1134 ret = (*lpfn)(hIMC, lParam);
1135 if (!ret)
1136 break;
1137 }
1138
1139 ImmLocalFree(phList);
1140 return ret;
1141}
1142
1143/***********************************************************************
1144 * ImmSetActiveContext(IMM32.@)
1145 */
1147{
1148 PCLIENTIMC pClientImc;
1149 LPINPUTCONTEXTDX pIC;
1150 PIMEDPI pImeDpi;
1151 HIMC hOldIMC;
1152 HKL hKL;
1153 BOOL fOpen = FALSE;
1154 DWORD dwConversion = 0, dwShowFlags = ISC_SHOWUIALL;
1155 HWND hwndDefIME;
1156
1157 TRACE("(%p, %p, %d)\n", hWnd, hIMC, fActive);
1158
1159 if (!IS_IMM_MODE())
1160 {
1161 TRACE("\n");
1162 return FALSE;
1163 }
1164
1165 pClientImc = ImmLockClientImc(hIMC);
1166
1167 if (!fActive)
1168 {
1169 if (pClientImc)
1170 pClientImc->dwFlags &= ~CLIENTIMC_ACTIVE;
1171 }
1172 else if (hIMC)
1173 {
1174 if (IS_NULL_UNEXPECTEDLY(pClientImc))
1175 return FALSE;
1176
1177 pIC = (LPINPUTCONTEXTDX)ImmLockIMC(hIMC);
1178 if (IS_NULL_UNEXPECTEDLY(pIC))
1179 {
1180 ImmUnlockClientImc(pClientImc);
1181 return FALSE;
1182 }
1183
1184 pIC->hWnd = hWnd;
1185 pClientImc->dwFlags |= CLIENTIMC_ACTIVE;
1186
1187 if (pIC->dwUIFlags & 2)
1189
1190 fOpen = pIC->fOpen;
1191 dwConversion = pIC->fdwConversion;
1192
1193 ImmUnlockIMC(hIMC);
1194 }
1195 else
1196 {
1197 hOldIMC = ImmGetSaveContext(hWnd, 1);
1198 pIC = (LPINPUTCONTEXTDX)ImmLockIMC(hOldIMC);
1199 if (pIC)
1200 {
1201 pIC->hWnd = hWnd;
1202 ImmUnlockIMC(hOldIMC);
1203 }
1204 }
1205
1206 hKL = GetKeyboardLayout(0);
1207 if (IS_CICERO_MODE() && !IS_16BIT_MODE())
1208 {
1209 Imm32CiceroSetActiveContext(hIMC, fActive, hWnd, hKL);
1210 hKL = GetKeyboardLayout(0);
1211 }
1212
1213 pImeDpi = ImmLockImeDpi(hKL);
1214 if (pImeDpi)
1215 {
1216 if (IS_IME_HKL(hKL))
1217 pImeDpi->ImeSetActiveContext(hIMC, fActive);
1218 ImmUnlockImeDpi(pImeDpi);
1219 }
1220
1221 if (IsWindow(hWnd))
1222 {
1223 SendMessageW(hWnd, WM_IME_SETCONTEXT, fActive, dwShowFlags);
1224 if (fActive)
1225 NtUserNotifyIMEStatus(hWnd, fOpen, dwConversion);
1226 }
1227 else if (!fActive)
1228 {
1229 hwndDefIME = ImmGetDefaultIMEWnd(NULL);
1230 if (hwndDefIME)
1231 SendMessageW(hwndDefIME, WM_IME_SETCONTEXT, 0, dwShowFlags);
1232 }
1233
1234 if (pClientImc)
1235 ImmUnlockClientImc(pClientImc);
1236
1237 return TRUE;
1238}
1239
1240/***********************************************************************
1241 * ImmWINNLSGetEnableStatus (IMM32.@)
1242 */
1243
1245{
1247 {
1249 return FALSE;
1250 }
1251
1252 return !!ImmGetSaveContext(hWnd, 2);
1253}
1254
1255/***********************************************************************
1256 * ImmSetActiveContextConsoleIME(IMM32.@)
1257 */
1259{
1260 HIMC hIMC;
1261 TRACE("(%p, %d)\n", hwnd, fFlag);
1262
1263 hIMC = ImmGetContext(hwnd);
1264 if (IS_NULL_UNEXPECTEDLY(hIMC))
1265 return FALSE;
1266 return ImmSetActiveContext(hwnd, hIMC, fFlag);
1267}
1268
1269#ifndef NDEBUG
1271{
1272 if (0)
1273 {
1274 DWORD dwValue;
1275 WCHAR szText[64];
1276
1277 Imm32StrToUInt(L"123", &dwValue, 10);
1278 ASSERT(dwValue == 123);
1279 Imm32StrToUInt(L"100", &dwValue, 16);
1280 ASSERT(dwValue == 0x100);
1281
1282 Imm32UIntToStr(123, 10, szText, _countof(szText));
1283 ASSERT(lstrcmpW(szText, L"123") == 0);
1284 Imm32UIntToStr(0x100, 16, szText, _countof(szText));
1285 ASSERT(lstrcmpW(szText, L"100") == 0);
1286 }
1287}
1288#endif
1289
1291
1292BOOL
1293WINAPI
1295 _In_ HINSTANCE hDll,
1297 _In_opt_ PVOID pReserved)
1298{
1299 HKL hKL;
1300 HIMC hIMC;
1301
1302 TRACE("(%p, 0x%X, %p)\n", hDll, dwReason, pReserved);
1303
1304 switch (dwReason)
1305 {
1306 case DLL_PROCESS_ATTACH:
1307 if (!ImmInitializeGlobals(hDll))
1308 {
1309 ERR("ImmInitializeGlobals failed\n");
1310 return FALSE;
1311 }
1313 {
1314 ERR("User32InitializeImmEntryTable failed\n");
1315 return FALSE;
1316 }
1317#ifndef NDEBUG
1318 Imm32UnitTest();
1319#endif
1320 break;
1321
1322 case DLL_THREAD_ATTACH:
1323 break;
1324
1325 case DLL_THREAD_DETACH:
1326 if (!IS_IMM_MODE() || NtCurrentTeb()->Win32ThreadInfo == NULL)
1327 return TRUE;
1328
1329 hKL = GetKeyboardLayout(0);
1331 Imm32DestroyInputContext(hIMC, hKL, TRUE);
1332 break;
1333
1334 case DLL_PROCESS_DETACH:
1336 TRACE("imm32.dll is unloaded\n");
1337 break;
1338 }
1339
1340 return TRUE;
1341}
#define InterlockedIncrement
Definition: armddk.h:53
#define InterlockedDecrement
Definition: armddk.h:52
HWND hWnd
Definition: settings.c:17
#define WINE_DEFAULT_DEBUG_CHANNEL(t)
Definition: precomp.h:23
LONG NTSTATUS
Definition: precomp.h:26
DWORD dwReason
Definition: misc.cpp:154
#define HandleToUlong(h)
Definition: basetsd.h:79
#define FIXME(fmt,...)
Definition: debug.h:111
#define WARN(fmt,...)
Definition: debug.h:112
#define ERR(fmt,...)
Definition: debug.h:110
#define RegCloseKey(hKey)
Definition: registry.h:49
_In_ PSCSI_REQUEST_BLOCK _Out_ NTSTATUS _Inout_ BOOLEAN * Retry
Definition: classpnp.h:312
LPARAM lParam
Definition: combotst.c:139
HRESULT WINAPI CtfImmTIMActivate(_In_ HKL hKL)
Definition: ctf.c:546
HRESULT CtfImmTIMCreateInputContext(_In_ HIMC hIMC)
Definition: ctf.c:410
BOOL WINAPI CtfImmIsTextFrameServiceDisabled(VOID)
Definition: ctf.c:537
HRESULT CtfImmTIMDestroyInputContext(_In_ HIMC hIMC)
Definition: ctf.c:400
DWORD HIMC
Definition: dimm.idl:75
#define NULL
Definition: types.h:112
#define TRUE
Definition: types.h:120
#define FALSE
Definition: types.h:117
#define APIENTRY
Definition: api.h:79
LONG WINAPI RegOpenKeyExW(HKEY hKey, LPCWSTR lpSubKey, DWORD ulOptions, REGSAM samDesired, PHKEY phkResult)
Definition: reg.c:3353
LONG WINAPI RegQueryValueExW(_In_ HKEY hkeyorg, _In_ LPCWSTR name, _In_ LPDWORD reserved, _In_ LPDWORD type, _In_ LPBYTE data, _In_ LPDWORD count)
Definition: reg.c:4123
#define ERROR_CALL_NOT_IMPLEMENTED
Definition: compat.h:102
#define DLL_THREAD_DETACH
Definition: compat.h:133
#define DLL_PROCESS_ATTACH
Definition: compat.h:131
#define DLL_PROCESS_DETACH
Definition: compat.h:130
#define CP_ACP
Definition: compat.h:109
#define SetLastError(x)
Definition: compat.h:752
HANDLE HWND
Definition: compat.h:19
#define MAX_PATH
Definition: compat.h:34
#define CALLBACK
Definition: compat.h:35
#define DLL_THREAD_ATTACH
Definition: compat.h:132
#define HEAP_ZERO_MEMORY
Definition: compat.h:134
HWND WINAPI ImmGetDefaultIMEWnd(HWND hWnd)
Definition: ime.c:890
PIMEDPI WINAPI ImmLockImeDpi(HKL hKL)
Definition: ime.c:987
VOID WINAPI ImmUnlockImeDpi(PIMEDPI pImeDpi)
Definition: ime.c:1016
RTL_CRITICAL_SECTION gcsImeDpi
Definition: ime.c:16
PIMEDPI gpImeDpiList
Definition: ime.c:17
PIMEDPI APIENTRY Imm32FindOrLoadImeDpi(HKL hKL)
Definition: ime.c:343
BOOL WINAPI ImmNotifyIME(HIMC hIMC, DWORD dwAction, DWORD dwIndex, DWORD dwValue)
Definition: ime.c:907
BOOL WINAPI ImmLoadIME(HKL hKL)
Definition: ime.c:1064
BOOL APIENTRY Imm32ReleaseIME(HKL hKL)
Definition: ime.c:371
LPINPUTCONTEXT APIENTRY Imm32InternalLockIMC(HIMC hIMC, BOOL fSelect)
Definition: imm.c:850
static BOOL APIENTRY ImmInitializeGlobals(HMODULE hMod)
Definition: imm.c:24
BOOL WINAPI ImmUnlockIMC(HIMC hIMC)
Definition: imm.c:1079
HIMC WINAPI ImmCreateContext(void)
Definition: imm.c:602
BOOL WINAPI ImmDisableTextFrameService(DWORD dwThreadId)
Definition: imm.c:1109
static VOID APIENTRY Imm32CiceroSetActiveContext(HIMC hIMC, BOOL fActive, HWND hWnd, HKL hKL)
Definition: imm.c:495
HIMC WINAPI ImmGetContext(HWND hWnd)
Definition: imm.c:1057
static HIMC APIENTRY ImmGetSaveContext(HWND hWnd, DWORD dwContextFlags)
Definition: imm.c:1016
BOOL WINAPI ImmAssociateContextEx(HWND hWnd, HIMC hIMC, DWORD dwFlags)
Definition: imm.c:552
static BOOL CALLBACK Imm32SelectContextProc(HIMC hIMC, LPARAM lParam)
Definition: imm.c:431
BOOL WINAPI ImmDestroyContext(HIMC hIMC)
Definition: imm.c:928
#define MAX_IMCC_SIZE
BOOL WINAPI ImmFreeLayout(DWORD dwUnknown)
Definition: imm.c:120
BOOL APIENTRY Imm32DestroyInputContext(HIMC hIMC, HKL hKL, BOOL bKeep)
Definition: imm.c:656
HMODULE ghImm32Inst
Definition: imm.c:17
BOOL WINAPI ImmLoadLayout(HKL hKL, PIMEINFOEX pImeInfoEx)
Definition: imm.c:68
BOOL WINAPI ImmDllInitialize(_In_ HINSTANCE hDll, _In_ ULONG dwReason, _In_opt_ PVOID pReserved)
Definition: imm.c:1294
static VOID APIENTRY Imm32DestroyImeModeSaver(LPINPUTCONTEXTDX pIC)
Definition: imm.c:634
BOOL WINAPI User32InitializeImmEntryTable(DWORD)
Definition: imm.c:126
VOID WINAPI ImmUnlockClientImc(PCLIENTIMC pClientImc)
Definition: imm.c:996
VOID APIENTRY Imm32UnitTest(VOID)
Definition: imm.c:1270
static BOOL CALLBACK Imm32NotifyIMEProc(HIMC hIMC, LPARAM lParam)
Definition: imm.c:439
struct SELECT_LAYOUT * LPSELECT_LAYOUT
BOOL WINAPI ImmReleaseContext(HWND hWnd, HIMC hIMC)
Definition: imm.c:1098
BOOL APIENTRY Imm32CreateInputContext(HIMC hIMC, LPINPUTCONTEXT pIC, PCLIENTIMC pClientImc, HKL hKL, BOOL fSelect)
Definition: imm.c:749
BOOL WINAPI ImmSetActiveContext(HWND hWnd, HIMC hIMC, BOOL fActive)
Definition: imm.c:1146
PCLIENTIMC WINAPI ImmLockClientImc(HIMC hImc)
Definition: imm.c:950
LPINPUTCONTEXT WINAPI ImmLockIMC(HIMC hIMC)
Definition: imm.c:1070
SHAREDINFO gSharedInfo
Definition: imm.c:19
BOOL WINAPI ImmEnumInputContext(DWORD dwThreadId, IMCENUMPROC lpfn, LPARAM lParam)
Definition: imm.c:1118
BOOL WINAPI ImmRegisterClient(PSHAREDINFO ptr, HINSTANCE hMod)
Definition: imm.c:58
HIMC WINAPI ImmAssociateContext(HWND hWnd, HIMC hIMC)
Definition: imm.c:503
BYTE gfImmInitialized
Definition: imm.c:20
PSERVERINFO gpsi
Definition: imm.c:18
BOOL WINAPI ImmActivateLayout(HKL hKL)
Definition: imm.c:448
BOOL WINAPI ImmSetActiveContextConsoleIME(HWND hwnd, BOOL fFlag)
Definition: imm.c:1258
ULONG_PTR gHighestUserAddress
Definition: imm.c:21
VOID APIENTRY Imm32SelectInputContext(HKL hNewKL, HKL hOldKL, HIMC hIMC)
Definition: imm.c:188
BOOL WINAPI ImmWINNLSGetEnableStatus(HWND hWnd)
Definition: imm.c:1244
VOID APIENTRY LogFontAnsiToWide(const LOGFONTA *plfA, LPLOGFONTW plfW)
Definition: utils.c:299
#define IS_ZERO_UNEXPECTEDLY(p)
Definition: precomp.h:125
LPVOID APIENTRY ImmLocalAlloc(DWORD dwFlags, DWORD dwBytes)
Definition: utils.c:415
HRESULT APIENTRY Imm32StrToUInt(LPCWSTR pszText, LPDWORD pdwValue, ULONG nBase)
Definition: utils.c:43
VOID APIENTRY LogFontWideToAnsi(const LOGFONTW *plfW, LPLOGFONTA plfA)
Definition: utils.c:312
#define ValidateHwnd(hwnd)
Definition: precomp.h:86
#define ImmLocalFree(lpData)
Definition: precomp.h:90
BOOL APIENTRY Imm32CheckImcProcess(PIMC pIMC)
Definition: utils.c:391
BOOL APIENTRY Imm32LoadImeVerInfo(PIMEINFOEX pImeInfoEx)
Definition: utils.c:845
#define IS_CROSS_THREAD_HIMC(hIMC)
Definition: precomp.h:144
#define IMM_INVALID_CANDFORM
Definition: precomp.h:51
PTHREADINFO FASTCALL Imm32CurrentPti(VOID)
Definition: utils.c:19
#define IMM_INIT_MAGIC
Definition: precomp.h:50
#define REGKEY_KEYBOARD_LAYOUTS
Definition: precomp.h:60
#define IS_ERROR_UNEXPECTEDLY(x)
Definition: precomp.h:137
#define IS_NULL_UNEXPECTEDLY(p)
Definition: precomp.h:121
DWORD APIENTRY Imm32BuildHimcList(DWORD dwThreadId, HIMC **pphList)
Definition: utils.c:460
#define MAX_CANDIDATEFORM
Definition: precomp.h:53
LPVOID FASTCALL ValidateHandle(HANDLE hObject, UINT uType)
Definition: utils.c:377
#define IS_CROSS_PROCESS_HWND(hWnd)
Definition: precomp.h:145
#define REGKEY_IMM
Definition: precomp.h:61
PIME_STATE APIENTRY Imm32FetchImeState(LPINPUTCONTEXTDX pIC, HKL hKL)
Definition: utils.c:552
BOOL APIENTRY Imm32SaveImeStateSentence(LPINPUTCONTEXTDX pIC, PIME_STATE pState, HKL hKL)
Definition: utils.c:608
HRESULT APIENTRY Imm32UIntToStr(DWORD dwValue, ULONG nBase, LPWSTR pszBuff, USHORT cchBuff)
Definition: utils.c:56
BOOL APIENTRY Imm32IsSystemJapaneseOrKorean(VOID)
Definition: utils.c:69
#define ImeDpi_IsUnicode(pImeDpi)
Definition: precomp.h:146
BOOL APIENTRY Imm32LoadImeStateSentence(LPINPUTCONTEXTDX pIC, PIME_STATE pState, HKL hKL)
Definition: utils.c:596
BOOL WINAPI ImmUnlockIMCC(HIMCC imcc)
Definition: utils.c:1208
DWORD WINAPI ImmGetIMCCLockCount(HIMCC imcc)
Definition: utils.c:1218
HIMCC WINAPI ImmCreateIMCC(DWORD size)
Definition: utils.c:1178
DWORD WINAPI ImmGetIMCCSize(HIMCC imcc)
Definition: utils.c:1236
HIMCC WINAPI ImmReSizeIMCC(HIMCC imcc, DWORD size)
Definition: utils.c:1226
LPVOID WINAPI ImmLockIMCC(HIMCC imcc)
Definition: utils.c:1198
HIMCC WINAPI ImmDestroyIMCC(HIMCC block)
Definition: utils.c:1188
LPFN_SELECT pSelect
Definition: handle.c:32
int Fail
Definition: ehthrow.cxx:24
@ Success
Definition: eventcreate.c:712
DWORD dwThreadId
Definition: fdebug.c:31
unsigned int BOOL
Definition: ntddk_ex.h:94
unsigned long DWORD
Definition: ntddk_ex.h:95
@ SystemBasicInformation
Definition: ntddk_ex.h:11
unsigned short WORD
Definition: ntddk_ex.h:93
FxChildList * pList
HLOCAL NTAPI LocalAlloc(UINT uFlags, SIZE_T dwBytes)
Definition: heapmem.c:1390
LPVOID NTAPI LocalLock(HLOCAL hMem)
Definition: heapmem.c:1616
BOOL NTAPI LocalUnlock(HLOCAL hMem)
Definition: heapmem.c:1805
HLOCAL NTAPI LocalFree(HLOCAL hMem)
Definition: heapmem.c:1594
#define CPS_CANCEL
Definition: imm.h:328
struct tagGUIDELINE GUIDELINE
#define NI_COMPOSITIONSTR
Definition: imm.h:311
#define ISC_SHOWUIGUIDELINE
Definition: imm.h:319
#define ISC_SHOWUIALLCANDIDATEWINDOW
Definition: imm.h:320
#define IACE_DEFAULT
Definition: imm.h:595
#define CPS_COMPLETE
Definition: imm.h:325
struct tagCANDIDATEINFO CANDIDATEINFO
BOOL(CALLBACK * IMCENUMPROC)(HIMC, LPARAM)
Definition: imm.h:147
#define ISC_SHOWUIALL
Definition: imm.h:321
#define IME_PROP_COMPLETE_ON_UNSELECT
Definition: imm.h:407
struct tagCOMPOSITIONSTRING COMPOSITIONSTRING
struct tagCLIENTIMC * PCLIENTIMC
#define INPUTCONTEXTDX_CHANGE_OPEN
Definition: immdev.h:171
#define INPUTCONTEXTDX_CHANGE_SENTENCE
Definition: immdev.h:173
#define INIT_LOGFONT
Definition: immdev.h:166
#define CLIENTIMC_DESTROY
Definition: immdev.h:338
#define CLIENTIMC_DISABLEIME
Definition: immdev.h:339
struct INPUTCONTEXTDX * LPINPUTCONTEXTDX
#define INPUTCONTEXTDX_CHANGE_FORCE_OPEN
Definition: immdev.h:174
#define CLIENTIMC_UNKNOWN2
Definition: immdev.h:340
#define INPUTCONTEXTDX_CHANGE_CONVERSION
Definition: immdev.h:172
#define CLIENTIMC_ACTIVE
Definition: immdev.h:336
#define CLIENTIMC_WIDE
Definition: immdev.h:335
#define QUERY_WINDOW_DEFAULT_ICONTEXT
Definition: ntuser.h:2859
#define QUERY_WINDOW_FOCUS
Definition: ntuser.h:2854
DWORD NTAPI NtUserSetThreadLayoutHandles(HKL hNewKL, HKL hOldKL)
Definition: ime.c:508
DWORD NTAPI NtUserNotifyIMEStatus(HWND hwnd, BOOL fOpen, DWORD dwConversion)
Definition: ime.c:803
BOOL NTAPI NtUserDestroyInputContext(HIMC hIMC)
Definition: ime.c:1535
@ THREADSTATE_DEFAULTINPUTCONTEXT
Definition: ntuser.h:2500
@ THREADSTATE_IMECOMPATFLAGS
Definition: ntuser.h:2509
#define CI_IMMACTIVATE
Definition: ntuser.h:305
#define IS_IMM_MODE()
Definition: ntuser.h:1233
DWORD_PTR NTAPI NtUserQueryInputContext(HIMC hIMC, DWORD dwType)
Definition: ime.c:1791
@ TYPE_INPUTCONTEXT
Definition: ntuser.h:57
#define IS_16BIT_MODE()
Definition: ntuser.h:1235
DWORD_PTR NTAPI NtUserQueryWindow(HWND hWnd, DWORD Index)
Definition: window.c:4199
#define IS_CICERO_MODE()
Definition: ntuser.h:1234
HIMC NTAPI NtUserCreateInputContext(ULONG_PTR dwClientImcData)
Definition: ime.c:1606
BOOL NTAPI NtUserUpdateInputContext(HIMC hIMC, DWORD dwType, DWORD_PTR dwValue)
Definition: ime.c:1762
#define GetWin32ClientInfo()
Definition: ntuser.h:348
DWORD_PTR NTAPI NtUserGetThreadState(DWORD Routine)
Definition: misc.c:240
DWORD NTAPI NtUserAssociateInputContext(HWND hWnd, HIMC hIMC, DWORD dwFlags)
Definition: ime.c:1702
#define NtCurrentTeb
#define IS_IME_HKL(hKL)
Definition: kbswitch.c:32
LCID WINAPI GetSystemDefaultLCID(void)
Definition: lang.c:797
#define REG_SZ
Definition: layer.c:22
if(dx< 0)
Definition: linetemp.h:194
int WINAPI lstrcmpW(LPCWSTR lpString1, LPCWSTR lpString2)
Definition: lstring.c:170
HWND pFocusWnd
Definition: magnifier.c:66
#define error(str)
Definition: mkdosfs.c:1605
#define ASSERT(a)
Definition: mode.c:44
PSDBQUERYRESULT_VISTA PVOID DWORD * dwSize
Definition: env.c:56
static PVOID ptr
Definition: dispmode.c:27
static LONG cLocks
Definition: compobj.c:119
#define _In_
Definition: ms_sal.h:308
#define _In_opt_
Definition: ms_sal.h:309
UINT_PTR HKL
Definition: msctf.idl:104
unsigned int UINT
Definition: ndis.h:50
NTSYSAPI NTSTATUS NTAPI RtlDeleteCriticalSection(_In_ PRTL_CRITICAL_SECTION CriticalSection)
NTSYSAPI NTSTATUS NTAPI RtlEnterCriticalSection(_In_ PRTL_CRITICAL_SECTION CriticalSection)
NTSYSAPI NTSTATUS NTAPI RtlLeaveCriticalSection(_In_ PRTL_CRITICAL_SECTION CriticalSection)
NTSYSAPI NTSTATUS NTAPI RtlInitializeCriticalSection(_In_ PRTL_CRITICAL_SECTION CriticalSection)
#define KEY_READ
Definition: nt_native.h:1023
#define DWORD
Definition: nt_native.h:44
#define UNICODE_NULL
#define UNREFERENCED_PARAMETER(P)
Definition: ntbasedef.h:317
#define L(x)
Definition: ntvdm.h:50
#define LOWORD(l)
Definition: pedump.c:82
long LONG
Definition: pedump.c:60
#define LANGIDFROMLCID(l)
Definition: nls.h:18
#define _countof(array)
Definition: sndvol32.h:68
#define TRACE(s)
Definition: solgame.cpp:4
NTSYSAPI NTSTATUS NTAPI NtQuerySystemInformation(IN SYSTEM_INFORMATION_CLASS SystemInfoClass, OUT PVOID SystemInfoBuffer, IN ULONG SystemInfoBufferSize, OUT PULONG BytesReturned OPTIONAL)
STRSAFEAPI StringCchPrintfW(STRSAFE_LPWSTR pszDest, size_t cchDest, STRSAFE_LPCWSTR pszFormat,...)
Definition: strsafe.h:530
DWORD dwIndex
Definition: dimm.idl:79
Definition: immdev.h:259
IMEINFO ImeInfo
Definition: immdev.h:263
HKL hKL
Definition: immdev.h:262
struct IMEDPI * pNext
Definition: immdev.h:260
UINT uCodePage
Definition: immdev.h:264
DWORD dwConversion
Definition: immdev.h:231
WORD fOpen
Definition: immdev.h:230
PIME_SUBSTATE pSubState
Definition: immdev.h:234
DWORD dwInit
Definition: immdev.h:233
DWORD dwSentence
Definition: immdev.h:232
struct IME_STATE * pNext
Definition: immdev.h:228
struct IME_SUBSTATE * pNext
Definition: immdev.h:217
struct IME_STATE * pState
Definition: immdev.h:148
DWORD dwChange
Definition: immdev.h:149
DWORD dwUIFlags
Definition: immdev.h:146
HKL hNewKL
Definition: imm.c:426
HKL hOldKL
Definition: imm.c:427
PSERVERINFO psi
Definition: ntuser.h:1126
Definition: ntuser.h:690
HIMC hImc
Definition: ntuser.h:736
DWORD fdwProperty
Definition: imm.h:158
DWORD dwPrivateDataSize
Definition: imm.h:157
HIMCC hPrivate
Definition: immdev.h:85
CANDIDATEFORM cfCandForm[4]
Definition: immdev.h:81
HIMCC hMsgBuf
Definition: immdev.h:87
HIMCC hCompStr
Definition: immdev.h:82
DWORD fdwConversion
Definition: immdev.h:74
HIMCC hCandInfo
Definition: immdev.h:83
HIMCC hGuideLine
Definition: immdev.h:84
DWORD fdwSentence
Definition: immdev.h:75
DWORD dwNumMsgBuf
Definition: immdev.h:86
Definition: ps.c:97
DWORD dwSize
Definition: imm.h:205
RTL_CRITICAL_SECTION cs
Definition: immdev.h:317
UINT uCodePage
Definition: immdev.h:318
DWORD dwCompatFlags
Definition: immdev.h:316
DWORD dwFlags
Definition: immdev.h:315
HANDLE hInputContext
Definition: immdev.h:313
LONG cLockObj
Definition: immdev.h:314
DWORD dwSize
Definition: imm.h:195
Definition: ntuser.h:199
THRDESKHEAD head
Definition: ntuser.h:200
ULONG_PTR dwClientImcData
Definition: ntuser.h:202
INT fLoadFlag
Definition: ntuser.h:1212
WCHAR wszImeFile[80]
Definition: ntuser.h:1216
#define max(a, b)
Definition: svc.c:63
WORD LANGID
Definition: typedefs.h:81
uint32_t DWORD_PTR
Definition: typedefs.h:65
unsigned char * LPBYTE
Definition: typedefs.h:53
uint32_t ULONG_PTR
Definition: typedefs.h:65
#define MAKELONG(a, b)
Definition: typedefs.h:249
uint32_t ULONG
Definition: typedefs.h:59
#define NT_ERROR(Status)
Definition: umtypes.h:106
@ UIC_CLIENTIMCDATA
Definition: undocuser.h:303
@ QIC_DEFAULTWINDOWIME
Definition: undocuser.h:394
@ QIC_INPUTTHREADID
Definition: undocuser.h:393
int ret
_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 ZeroMemory
Definition: winbase.h:1712
DWORD WINAPI GetCurrentThreadId(void)
Definition: thread.c:459
#define LHND
Definition: winbase.h:382
_In_ PCCERT_CONTEXT _In_ DWORD dwFlags
Definition: wincrypt.h:1176
_In_ LONG _In_ HWND hwnd
Definition: winddi.h:4023
LONG_PTR LPARAM
Definition: windef.h:208
#define WINAPI
Definition: msvc.h:6
#define HKEY_LOCAL_MACHINE
Definition: winreg.h:12
BOOL WINAPI IsWindow(_In_opt_ HWND)
HKL WINAPI GetKeyboardLayout(_In_ DWORD)
#define KL_NAMELENGTH
Definition: winuser.h:122
#define KLF_ACTIVATE
Definition: winuser.h:111
#define WM_IME_SETCONTEXT
Definition: winuser.h:1828
HKL WINAPI LoadKeyboardLayoutW(_In_ LPCWSTR, _In_ UINT)
UINT WINAPI GetKeyboardLayoutList(_In_ int nBuff, _Out_writes_to_opt_(nBuff, return) HKL FAR *lpList)
#define WM_IME_SELECT
Definition: winuser.h:1832
LRESULT WINAPI SendMessageW(_In_ HWND, _In_ UINT, _In_ WPARAM, _In_ LPARAM)
__wchar_t WCHAR
Definition: xmlstorage.h:180
unsigned char BYTE
Definition: xxhash.c:193