xref: /reactos/dll/win32/imm32/imm.c (revision e59e6ba0) 
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 
14 WINE_DEFAULT_DEBUG_CHANNEL(imm);
15 
16 HMODULE ghImm32Inst = NULL; // Win: ghInst
17 PSERVERINFO gpsi = NULL; // Win: gpsi
18 SHAREDINFO gSharedInfo = { NULL }; // Win: gSharedInfo
19 BYTE gfImmInitialized = FALSE; // Win: gfInitialized
20 
21 // Win: ImmInitializeGlobals
22 static BOOL APIENTRY ImmInitializeGlobals(HMODULE hMod)
23 {
24     NTSTATUS status;
25 
26     if (hMod)
27         ghImm32Inst = hMod;
28 
29     if (gfImmInitialized)
30         return TRUE;
31 
32     status = RtlInitializeCriticalSection(&gcsImeDpi);
33     if (NT_ERROR(status))
34         return FALSE;
35 
36     gfImmInitialized = TRUE;
37     return TRUE;
38 }
39 
40 /***********************************************************************
41  *		ImmRegisterClient(IMM32.@)
42  *       ( Undocumented, called from user32.dll )
43  */
44 BOOL WINAPI ImmRegisterClient(PSHAREDINFO ptr, HINSTANCE hMod)
45 {
46     gSharedInfo = *ptr;
47     gpsi = gSharedInfo.psi;
48     return ImmInitializeGlobals(hMod);
49 }
50 
51 /***********************************************************************
52  *		ImmLoadLayout (IMM32.@)
53  */
54 BOOL WINAPI ImmLoadLayout(HKL hKL, PIMEINFOEX pImeInfoEx)
55 {
56     DWORD cbData;
57     HKEY hLayoutKey = NULL, hLayoutsKey = NULL;
58     LONG error;
59     WCHAR szLayout[MAX_PATH];
60 
61     TRACE("(%p, %p)\n", hKL, pImeInfoEx);
62 
63     if (IS_IME_HKL(hKL) || !Imm32IsCiceroMode() || Imm32Is16BitMode())
64     {
65         Imm32UIntToStr((DWORD)(DWORD_PTR)hKL, 16, szLayout, _countof(szLayout));
66 
67         error = RegOpenKeyW(HKEY_LOCAL_MACHINE, REGKEY_KEYBOARD_LAYOUTS, &hLayoutsKey);
68         if (error)
69         {
70             ERR("RegOpenKeyW: 0x%08lX\n", error);
71             return FALSE;
72         }
73 
74         error = RegOpenKeyW(hLayoutsKey, szLayout, &hLayoutKey);
75         if (error)
76         {
77             ERR("RegOpenKeyW: 0x%08lX\n", error);
78             RegCloseKey(hLayoutsKey);
79             return FALSE;
80         }
81     }
82     else
83     {
84         error = RegOpenKeyW(HKEY_LOCAL_MACHINE, REGKEY_IMM, &hLayoutKey);
85         if (error)
86         {
87             ERR("RegOpenKeyW: 0x%08lX\n", error);
88             return FALSE;
89         }
90     }
91 
92     cbData = sizeof(pImeInfoEx->wszImeFile);
93     error = RegQueryValueExW(hLayoutKey, L"Ime File", 0, 0,
94                              (LPBYTE)pImeInfoEx->wszImeFile, &cbData);
95     pImeInfoEx->wszImeFile[_countof(pImeInfoEx->wszImeFile) - 1] = 0;
96 
97     RegCloseKey(hLayoutKey);
98     if (hLayoutsKey)
99         RegCloseKey(hLayoutsKey);
100 
101     pImeInfoEx->fLoadFlag = 0;
102 
103     if (error)
104     {
105         ERR("RegQueryValueExW: 0x%08lX\n", error);
106         pImeInfoEx->hkl = NULL;
107         return FALSE;
108     }
109 
110     pImeInfoEx->hkl = hKL;
111     return Imm32LoadImeVerInfo(pImeInfoEx);
112 }
113 
114 /***********************************************************************
115  *		ImmFreeLayout (IMM32.@)
116  */
117 BOOL WINAPI ImmFreeLayout(DWORD dwUnknown)
118 {
119     WCHAR szKBD[9];
120     UINT iKL, cKLs;
121     HKL hOldKL, hNewKL, *pList;
122     PIMEDPI pImeDpi;
123     LANGID LangID;
124 
125     TRACE("(0x%lX)\n", dwUnknown);
126 
127     hOldKL = GetKeyboardLayout(0);
128 
129     if (dwUnknown == 1)
130     {
131         if (!IS_IME_HKL(hOldKL))
132             return TRUE;
133 
134         LangID = LANGIDFROMLCID(GetSystemDefaultLCID());
135 
136         cKLs = GetKeyboardLayoutList(0, NULL);
137         if (cKLs)
138         {
139             pList = ImmLocalAlloc(0, cKLs * sizeof(HKL));
140             if (pList == NULL)
141                 return FALSE;
142 
143             cKLs = GetKeyboardLayoutList(cKLs, pList);
144             for (iKL = 0; iKL < cKLs; ++iKL)
145             {
146                 if (!IS_IME_HKL(pList[iKL]))
147                 {
148                     LangID = LOWORD(pList[iKL]);
149                     break;
150                 }
151             }
152 
153             ImmLocalFree(pList);
154         }
155 
156         StringCchPrintfW(szKBD, _countof(szKBD), L"%08X", LangID);
157         if (!LoadKeyboardLayoutW(szKBD, KLF_ACTIVATE))
158             LoadKeyboardLayoutW(L"00000409", KLF_ACTIVATE | 0x200);
159     }
160     else if (dwUnknown == 2)
161     {
162         RtlEnterCriticalSection(&gcsImeDpi);
163 Retry:
164         for (pImeDpi = gpImeDpiList; pImeDpi; pImeDpi = pImeDpi->pNext)
165         {
166             if (Imm32ReleaseIME(pImeDpi->hKL))
167                 goto Retry;
168         }
169         RtlLeaveCriticalSection(&gcsImeDpi);
170     }
171     else
172     {
173         hNewKL = (HKL)(DWORD_PTR)dwUnknown;
174         if (IS_IME_HKL(hNewKL) && hNewKL != hOldKL)
175             Imm32ReleaseIME(hNewKL);
176     }
177 
178     return TRUE;
179 }
180 
181 // Win: SelectInputContext
182 VOID APIENTRY Imm32SelectInputContext(HKL hNewKL, HKL hOldKL, HIMC hIMC)
183 {
184     PCLIENTIMC pClientImc;
185     LPINPUTCONTEXTDX pIC;
186     LPGUIDELINE pGL;
187     LPCANDIDATEINFO pCI;
188     LPCOMPOSITIONSTRING pCS;
189     LOGFONTA LogFontA;
190     LOGFONTW LogFontW;
191     BOOL fOpen, bIsNewHKLIme = TRUE, bIsOldHKLIme = TRUE, bClientWide, bNewDpiWide;
192     DWORD cbNewPrivate = 0, cbOldPrivate = 0, dwConversion, dwSentence, dwSize, dwNewSize;
193     PIMEDPI pNewImeDpi = NULL, pOldImeDpi = NULL;
194     HANDLE hPrivate;
195     PIME_STATE pNewState = NULL, pOldState = NULL;
196 
197     pClientImc = ImmLockClientImc(hIMC);
198     if (!pClientImc)
199         return;
200 
201     pNewImeDpi = ImmLockImeDpi(hNewKL);
202 
203     if (hNewKL != hOldKL)
204         pOldImeDpi = ImmLockImeDpi(hOldKL);
205 
206     if (pNewImeDpi)
207     {
208         cbNewPrivate = pNewImeDpi->ImeInfo.dwPrivateDataSize;
209         pClientImc->uCodePage = pNewImeDpi->uCodePage;
210     }
211     else
212     {
213         pClientImc->uCodePage = CP_ACP;
214     }
215 
216     if (cbNewPrivate < sizeof(DWORD))
217         cbNewPrivate = sizeof(DWORD);
218 
219     if (pOldImeDpi)
220         cbOldPrivate = pOldImeDpi->ImeInfo.dwPrivateDataSize;
221 
222     if (cbOldPrivate < sizeof(DWORD))
223         cbOldPrivate = sizeof(DWORD);
224 
225     if (pClientImc->hKL == hOldKL)
226     {
227         if (pOldImeDpi)
228         {
229             if (IS_IME_HKL(hOldKL))
230                 pOldImeDpi->ImeSelect(hIMC, FALSE);
231             else if (Imm32IsCiceroMode() && !Imm32Is16BitMode() && pOldImeDpi->CtfImeSelectEx)
232                 pOldImeDpi->CtfImeSelectEx(hIMC, FALSE, hOldKL);
233         }
234         pClientImc->hKL = NULL;
235     }
236 
237     if (CtfImmIsTextFrameServiceDisabled())
238     {
239         if (IS_IMM_MODE() && !Imm32IsCiceroMode())
240         {
241             bIsNewHKLIme = IS_IME_HKL(hNewKL);
242             bIsOldHKLIme = IS_IME_HKL(hOldKL);
243         }
244     }
245 
246     pIC = (LPINPUTCONTEXTDX)Imm32InternalLockIMC(hIMC, FALSE);
247     if (!pIC)
248     {
249         if (pNewImeDpi)
250         {
251             if (IS_IME_HKL(hNewKL))
252                 pNewImeDpi->ImeSelect(hIMC, TRUE);
253             else if (Imm32IsCiceroMode() && !Imm32Is16BitMode() && pNewImeDpi->CtfImeSelectEx)
254                 pNewImeDpi->CtfImeSelectEx(hIMC, TRUE, hNewKL);
255 
256             pClientImc->hKL = hNewKL;
257         }
258     }
259     else
260     {
261         dwConversion = pIC->fdwConversion;
262         dwSentence = pIC->fdwSentence;
263         fOpen = 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 & ~IME_CMODE_EUDC);
371                 pOldState->dwSentence = pIC->fdwSentence;
372                 pOldState->dwInit = pIC->fdwInit;
373             }
374 
375             if (pNewState)
376             {
377                 if (pIC->dwChange & INPUTCONTEXTDX_CHANGE_FORCE_OPEN)
378                 {
379                     pIC->dwChange &= ~INPUTCONTEXTDX_CHANGE_FORCE_OPEN;
380                     pIC->fOpen = TRUE;
381                 }
382                 else
383                 {
384                     pIC->fOpen = pNewState->fOpen;
385                 }
386 
387                 pIC->fdwConversion = (pNewState->dwConversion & ~IME_CMODE_EUDC);
388                 pIC->fdwSentence = pNewState->dwSentence;
389                 pIC->fdwInit = pNewState->dwInit;
390             }
391         }
392 
393         if (pNewState)
394             Imm32LoadImeStateSentence(pIC, pNewState, hNewKL);
395 
396         if (pNewImeDpi)
397         {
398             if (IS_IME_HKL(hNewKL))
399                 pNewImeDpi->ImeSelect(hIMC, TRUE);
400             else if (Imm32IsCiceroMode() && !Imm32Is16BitMode() && pNewImeDpi->CtfImeSelectEx)
401                 pNewImeDpi->CtfImeSelectEx(hIMC, TRUE, hNewKL);
402 
403             pClientImc->hKL = hNewKL;
404         }
405 
406         pIC->dwChange = 0;
407         if (pIC->fOpen != fOpen)
408             pIC->dwChange |= INPUTCONTEXTDX_CHANGE_OPEN;
409         if (pIC->fdwConversion != dwConversion)
410             pIC->dwChange |= INPUTCONTEXTDX_CHANGE_CONVERSION;
411         if (pIC->fdwSentence != dwSentence)
412             pIC->dwChange |= INPUTCONTEXTDX_CHANGE_SENTENCE;
413 
414         ImmUnlockIMC(hIMC);
415     }
416 
417     ImmUnlockImeDpi(pOldImeDpi);
418     ImmUnlockImeDpi(pNewImeDpi);
419     ImmUnlockClientImc(pClientImc);
420 }
421 
422 typedef struct SELECT_LAYOUT
423 {
424     HKL hNewKL;
425     HKL hOldKL;
426 } SELECT_LAYOUT, *LPSELECT_LAYOUT;
427 
428 // Win: SelectContextProc
429 static BOOL CALLBACK Imm32SelectContextProc(HIMC hIMC, LPARAM lParam)
430 {
431     LPSELECT_LAYOUT pSelect = (LPSELECT_LAYOUT)lParam;
432     Imm32SelectInputContext(pSelect->hNewKL, pSelect->hOldKL, hIMC);
433     return TRUE;
434 }
435 
436 // Win: NotifyIMEProc
437 static BOOL CALLBACK Imm32NotifyIMEProc(HIMC hIMC, LPARAM lParam)
438 {
439     ImmNotifyIME(hIMC, NI_COMPOSITIONSTR, (DWORD)lParam, 0);
440     return TRUE;
441 }
442 
443 /***********************************************************************
444  *		ImmActivateLayout (IMM32.@)
445  */
446 BOOL WINAPI ImmActivateLayout(HKL hKL)
447 {
448     PIMEDPI pImeDpi;
449     HKL hOldKL;
450     LPARAM lParam;
451     HWND hwndDefIME = NULL;
452     SELECT_LAYOUT SelectLayout;
453 
454     hOldKL = GetKeyboardLayout(0);
455 
456     if (hOldKL == hKL && !(GetWin32ClientInfo()->CI_flags & CI_IMMACTIVATE))
457         return TRUE;
458 
459     ImmLoadIME(hKL);
460 
461     if (hOldKL != hKL)
462     {
463         pImeDpi = ImmLockImeDpi(hOldKL);
464         if (pImeDpi)
465         {
466             if (pImeDpi->ImeInfo.fdwProperty & IME_PROP_COMPLETE_ON_UNSELECT)
467                 lParam = CPS_COMPLETE;
468             else
469                 lParam = CPS_CANCEL;
470             ImmUnlockImeDpi(pImeDpi);
471 
472             ImmEnumInputContext(0, Imm32NotifyIMEProc, lParam);
473         }
474 
475         hwndDefIME = ImmGetDefaultIMEWnd(NULL);
476         if (IsWindow(hwndDefIME))
477             SendMessageW(hwndDefIME, WM_IME_SELECT, FALSE, (LPARAM)hOldKL);
478 
479         NtUserSetThreadLayoutHandles(hKL, hOldKL);
480     }
481 
482     SelectLayout.hNewKL = hKL;
483     SelectLayout.hOldKL = hOldKL;
484     ImmEnumInputContext(0, Imm32SelectContextProc, (LPARAM)&SelectLayout);
485 
486     if (IsWindow(hwndDefIME))
487         SendMessageW(hwndDefIME, WM_IME_SELECT, TRUE, (LPARAM)hKL);
488 
489     return TRUE;
490 }
491 
492 static VOID APIENTRY Imm32CiceroSetActiveContext(HIMC hIMC, BOOL fActive, HWND hWnd, HKL hKL)
493 {
494     TRACE("We have to do something\n");
495 }
496 
497 /***********************************************************************
498  *		ImmAssociateContext (IMM32.@)
499  */
500 HIMC WINAPI ImmAssociateContext(HWND hWnd, HIMC hIMC)
501 {
502     PWND pWnd;
503     HWND hwndFocus;
504     DWORD dwValue;
505     HIMC hOldIMC;
506 
507     TRACE("(%p, %p)\n", hWnd, hIMC);
508 
509     if (!IS_IMM_MODE())
510         return NULL;
511 
512     pWnd = ValidateHwnd(hWnd);
513     if (!pWnd)
514         return NULL;
515 
516     if (hIMC && Imm32IsCrossThreadAccess(hIMC))
517         return NULL;
518 
519     hOldIMC = pWnd->hImc;
520     if (hOldIMC == hIMC)
521         return hIMC;
522 
523     dwValue = NtUserAssociateInputContext(hWnd, hIMC, 0);
524     if (dwValue == 0)
525         return hOldIMC;
526     if (dwValue != 1)
527         return NULL;
528 
529     hwndFocus = (HWND)NtUserQueryWindow(hWnd, QUERY_WINDOW_FOCUS);
530     if (hwndFocus == hWnd)
531     {
532         ImmSetActiveContext(hWnd, hOldIMC, FALSE);
533         ImmSetActiveContext(hWnd, hIMC, TRUE);
534     }
535 
536     return hOldIMC;
537 }
538 
539 /***********************************************************************
540  *              ImmAssociateContextEx (IMM32.@)
541  */
542 BOOL WINAPI ImmAssociateContextEx(HWND hWnd, HIMC hIMC, DWORD dwFlags)
543 {
544     HWND hwndFocus;
545     PWND pFocusWnd;
546     HIMC hOldIMC = NULL;
547     DWORD dwValue;
548 
549     TRACE("(%p, %p, 0x%lX)\n", hWnd, hIMC, dwFlags);
550 
551     if (!IS_IMM_MODE())
552         return FALSE;
553 
554     if (hIMC && !(dwFlags & IACE_DEFAULT) && Imm32IsCrossThreadAccess(hIMC))
555         return FALSE;
556 
557     hwndFocus = (HWND)NtUserQueryWindow(hWnd, QUERY_WINDOW_FOCUS);
558     pFocusWnd = ValidateHwnd(hwndFocus);
559     if (pFocusWnd)
560         hOldIMC = pFocusWnd->hImc;
561 
562     dwValue = NtUserAssociateInputContext(hWnd, hIMC, dwFlags);
563     switch (dwValue)
564     {
565         case 0:
566             return TRUE;
567 
568         case 1:
569             pFocusWnd = ValidateHwnd(hwndFocus);
570             if (pFocusWnd)
571             {
572                 hIMC = pFocusWnd->hImc;
573                 if (hIMC != hOldIMC)
574                 {
575                     ImmSetActiveContext(hwndFocus, hOldIMC, FALSE);
576                     ImmSetActiveContext(hwndFocus, hIMC, TRUE);
577                 }
578             }
579             return TRUE;
580 
581         default:
582             return FALSE;
583     }
584 }
585 
586 /***********************************************************************
587  *		ImmCreateContext (IMM32.@)
588  */
589 HIMC WINAPI ImmCreateContext(void)
590 {
591     PCLIENTIMC pClientImc;
592     HIMC hIMC;
593 
594     TRACE("()\n");
595 
596     if (!IS_IMM_MODE())
597         return NULL;
598 
599     pClientImc = ImmLocalAlloc(HEAP_ZERO_MEMORY, sizeof(CLIENTIMC));
600     if (pClientImc == NULL)
601         return NULL;
602 
603     hIMC = NtUserCreateInputContext((ULONG_PTR)pClientImc);
604     if (hIMC == NULL)
605     {
606         ImmLocalFree(pClientImc);
607         return NULL;
608     }
609 
610     RtlInitializeCriticalSection(&pClientImc->cs);
611 
612     pClientImc->dwCompatFlags = (DWORD)NtUserGetThreadState(THREADSTATE_IMECOMPATFLAGS);
613 
614     return hIMC;
615 }
616 
617 // Win: DestroyImeModeSaver
618 static VOID APIENTRY Imm32DestroyImeModeSaver(LPINPUTCONTEXTDX pIC)
619 {
620     PIME_STATE pState, pNext;
621     PIME_SUBSTATE pSubState, pSubNext;
622 
623     for (pState = pIC->pState; pState; pState = pNext)
624     {
625         pNext = pState->pNext;
626 
627         for (pSubState = pState->pSubState; pSubState; pSubState = pSubNext)
628         {
629             pSubNext = pSubState->pNext;
630             ImmLocalFree(pSubState);
631         }
632 
633         ImmLocalFree(pState);
634     }
635 
636     pIC->pState = NULL;
637 }
638 
639 // Win: DestroyInputContext
640 BOOL APIENTRY Imm32DestroyInputContext(HIMC hIMC, HKL hKL, BOOL bKeep)
641 {
642     PIMEDPI pImeDpi;
643     LPINPUTCONTEXTDX pIC;
644     PCLIENTIMC pClientImc;
645     PIMC pIMC;
646 
647     if (!hIMC || !IS_IMM_MODE())
648         return FALSE;
649 
650     pIMC = ValidateHandle(hIMC, TYPE_INPUTCONTEXT);
651     if (!pIMC || pIMC->head.pti != Imm32CurrentPti())
652     {
653         ERR("invalid pIMC: %p\n", pIMC);
654         return FALSE;
655     }
656 
657     pClientImc = (PCLIENTIMC)pIMC->dwClientImcData;
658     if (!pClientImc)
659         goto Finish;
660 
661     if ((pClientImc->dwFlags & CLIENTIMC_UNKNOWN2) && !bKeep)
662     {
663         ERR("CLIENTIMC_UNKNOWN2\n");
664         return FALSE;
665     }
666 
667     if (pClientImc->dwFlags & CLIENTIMC_DESTROY)
668         return TRUE;
669 
670     InterlockedIncrement(&pClientImc->cLockObj);
671 
672     if (!pClientImc->hInputContext)
673         goto Quit;
674 
675     pIC = (LPINPUTCONTEXTDX)ImmLockIMC(hIMC);
676     if (!pIC)
677     {
678         ImmUnlockClientImc(pClientImc);
679         ERR("!pIC\n");
680         return FALSE;
681     }
682 
683     CtfImmTIMDestroyInputContext(hIMC);
684 
685     if (pClientImc->hKL == hKL)
686     {
687         pImeDpi = ImmLockImeDpi(hKL);
688         if (pImeDpi)
689         {
690             if (IS_IME_HKL(hKL))
691                 pImeDpi->ImeSelect(hIMC, FALSE);
692             else if (Imm32IsCiceroMode() && !Imm32Is16BitMode())
693                 pImeDpi->CtfImeSelectEx(hIMC, FALSE, hKL);
694 
695             ImmUnlockImeDpi(pImeDpi);
696         }
697 
698         pClientImc->hKL = NULL;
699     }
700 
701     ImmDestroyIMCC(pIC->hPrivate);
702     ImmDestroyIMCC(pIC->hMsgBuf);
703     ImmDestroyIMCC(pIC->hGuideLine);
704     ImmDestroyIMCC(pIC->hCandInfo);
705     ImmDestroyIMCC(pIC->hCompStr);
706     Imm32DestroyImeModeSaver(pIC);
707     ImmUnlockIMC(hIMC);
708 
709 Quit:
710     pClientImc->dwFlags |= CLIENTIMC_DESTROY;
711     ImmUnlockClientImc(pClientImc);
712 
713 Finish:
714     if (bKeep)
715         return TRUE;
716     return NtUserDestroyInputContext(hIMC);
717 }
718 
719 // NOTE: Windows does recursive call ImmLockIMC here but we don't do so.
720 // Win: BOOL CreateInputContext(HIMC hIMC, HKL hKL, BOOL fSelect)
721 BOOL APIENTRY
722 Imm32CreateInputContext(HIMC hIMC, LPINPUTCONTEXT pIC, PCLIENTIMC pClientImc, HKL hKL, BOOL fSelect)
723 {
724     DWORD dwIndex, cbPrivate;
725     PIMEDPI pImeDpi = NULL;
726     LPCOMPOSITIONSTRING pCS;
727     LPCANDIDATEINFO pCI;
728     LPGUIDELINE pGL;
729 
730     /* Create IC components */
731     pIC->hCompStr = ImmCreateIMCC(sizeof(COMPOSITIONSTRING));
732     pIC->hCandInfo = ImmCreateIMCC(sizeof(CANDIDATEINFO));
733     pIC->hGuideLine = ImmCreateIMCC(sizeof(GUIDELINE));
734     pIC->hMsgBuf = ImmCreateIMCC(sizeof(UINT));
735     if (!pIC->hCompStr || !pIC->hCandInfo || !pIC->hGuideLine || !pIC->hMsgBuf)
736         goto Fail;
737 
738     /* Initialize IC components */
739     pCS = ImmLockIMCC(pIC->hCompStr);
740     if (!pCS)
741         goto Fail;
742     pCS->dwSize = sizeof(COMPOSITIONSTRING);
743     ImmUnlockIMCC(pIC->hCompStr);
744 
745     pCI = ImmLockIMCC(pIC->hCandInfo);
746     if (!pCI)
747         goto Fail;
748     pCI->dwSize = sizeof(CANDIDATEINFO);
749     ImmUnlockIMCC(pIC->hCandInfo);
750 
751     pGL = ImmLockIMCC(pIC->hGuideLine);
752     if (!pGL)
753         goto Fail;
754     pGL->dwSize = sizeof(GUIDELINE);
755     ImmUnlockIMCC(pIC->hGuideLine);
756 
757     pIC->dwNumMsgBuf = 0;
758     pIC->fOpen = FALSE;
759     pIC->fdwConversion = pIC->fdwSentence = 0;
760 
761     for (dwIndex = 0; dwIndex < MAX_CANDIDATEFORM; ++dwIndex)
762         pIC->cfCandForm[dwIndex].dwIndex = IMM_INVALID_CANDFORM;
763 
764     /* Get private data size */
765     pImeDpi = ImmLockImeDpi(hKL);
766     if (!pImeDpi)
767     {
768         cbPrivate = sizeof(DWORD);
769     }
770     else
771     {
772         /* Update CLIENTIMC */
773         pClientImc->uCodePage = pImeDpi->uCodePage;
774         if (ImeDpi_IsUnicode(pImeDpi))
775             pClientImc->dwFlags |= CLIENTIMC_WIDE;
776 
777         cbPrivate = pImeDpi->ImeInfo.dwPrivateDataSize;
778     }
779 
780     /* Create private data */
781     pIC->hPrivate = ImmCreateIMCC(cbPrivate);
782     if (!pIC->hPrivate)
783         goto Fail;
784 
785     if (pImeDpi)
786     {
787         /* Select the IME */
788         if (fSelect)
789         {
790             if (IS_IME_HKL(hKL))
791                 pImeDpi->ImeSelect(hIMC, TRUE);
792             else if (Imm32IsCiceroMode() && !Imm32Is16BitMode() && pImeDpi->CtfImeSelectEx)
793                 pImeDpi->CtfImeSelectEx(hIMC, TRUE, hKL);
794         }
795 
796         /* Set HKL */
797         pClientImc->hKL = hKL;
798 
799         ImmUnlockImeDpi(pImeDpi);
800     }
801 
802     return TRUE;
803 
804 Fail:
805     if (pImeDpi)
806         ImmUnlockImeDpi(pImeDpi);
807 
808     pIC->hMsgBuf = ImmDestroyIMCC(pIC->hMsgBuf);
809     pIC->hGuideLine = ImmDestroyIMCC(pIC->hGuideLine);
810     pIC->hCandInfo = ImmDestroyIMCC(pIC->hCandInfo);
811     pIC->hCompStr = ImmDestroyIMCC(pIC->hCompStr);
812     return FALSE;
813 }
814 
815 // Win: InternalImmLockIMC
816 LPINPUTCONTEXT APIENTRY Imm32InternalLockIMC(HIMC hIMC, BOOL fSelect)
817 {
818     HANDLE hIC;
819     LPINPUTCONTEXT pIC = NULL;
820     PCLIENTIMC pClientImc;
821     WORD LangID;
822     DWORD dwThreadId;
823     HKL hOldKL, hNewKL;
824     PIMEDPI pImeDpi = NULL;
825 
826     pClientImc = ImmLockClientImc(hIMC);
827     if (!pClientImc)
828         return NULL;
829 
830     RtlEnterCriticalSection(&pClientImc->cs);
831 
832     if (pClientImc->hInputContext)
833     {
834         pIC = LocalLock(pClientImc->hInputContext);
835         if (pIC)
836             goto Success;
837         else
838             goto Failure;
839     }
840 
841     dwThreadId = (DWORD)NtUserQueryInputContext(hIMC, QIC_INPUTTHREADID);
842     if (dwThreadId == GetCurrentThreadId() && Imm32IsCiceroMode() && !Imm32Is16BitMode())
843     {
844         hOldKL = GetKeyboardLayout(0);
845         LangID = LOWORD(hOldKL);
846         hNewKL = (HKL)(DWORD_PTR)MAKELONG(LangID, LangID);
847 
848         pImeDpi = Imm32FindOrLoadImeDpi(hNewKL);
849         if (pImeDpi)
850         {
851             CtfImmTIMActivate(hNewKL);
852         }
853     }
854 
855     if (!NtUserQueryInputContext(hIMC, QIC_DEFAULTWINDOWIME))
856         goto Failure;
857 
858     hIC = LocalAlloc(LHND, sizeof(INPUTCONTEXTDX));
859     pIC = LocalLock(hIC);
860     if (!pIC)
861     {
862         LocalFree(hIC);
863         goto Failure;
864     }
865     pClientImc->hInputContext = hIC;
866 
867     hNewKL = GetKeyboardLayout(dwThreadId);
868     if (!Imm32CreateInputContext(hIMC, pIC, pClientImc, hNewKL, fSelect))
869     {
870         pClientImc->hInputContext = LocalFree(pClientImc->hInputContext);
871         goto Failure;
872     }
873 
874 Success:
875     CtfImmTIMCreateInputContext(hIMC);
876     RtlLeaveCriticalSection(&pClientImc->cs);
877     InterlockedIncrement(&pClientImc->cLockObj);
878     ImmUnlockClientImc(pClientImc);
879     return pIC;
880 
881 Failure:
882     RtlLeaveCriticalSection(&pClientImc->cs);
883     ImmUnlockClientImc(pClientImc);
884     return NULL;
885 }
886 
887 /***********************************************************************
888  *		ImmDestroyContext (IMM32.@)
889  */
890 BOOL WINAPI ImmDestroyContext(HIMC hIMC)
891 {
892     HKL hKL;
893 
894     TRACE("(%p)\n", hIMC);
895 
896     if (!IS_IMM_MODE())
897         return FALSE;
898 
899     if (Imm32IsCrossThreadAccess(hIMC))
900         return FALSE;
901 
902     hKL = GetKeyboardLayout(0);
903     return Imm32DestroyInputContext(hIMC, hKL, FALSE);
904 }
905 
906 /***********************************************************************
907  *		ImmLockClientImc (IMM32.@)
908  */
909 PCLIENTIMC WINAPI ImmLockClientImc(HIMC hImc)
910 {
911     PIMC pIMC;
912     PCLIENTIMC pClientImc;
913 
914     TRACE("(%p)\n", hImc);
915 
916     if (!hImc)
917         return NULL;
918 
919     pIMC = ValidateHandle(hImc, TYPE_INPUTCONTEXT);
920     if (!pIMC || !Imm32CheckImcProcess(pIMC))
921         return NULL;
922 
923     pClientImc = (PCLIENTIMC)pIMC->dwClientImcData;
924     if (pClientImc)
925     {
926         if (pClientImc->dwFlags & CLIENTIMC_DESTROY)
927             return NULL;
928         goto Finish;
929     }
930 
931     pClientImc = ImmLocalAlloc(HEAP_ZERO_MEMORY, sizeof(CLIENTIMC));
932     if (!pClientImc)
933         return NULL;
934 
935     RtlInitializeCriticalSection(&pClientImc->cs);
936     pClientImc->dwCompatFlags = (DWORD)NtUserGetThreadState(THREADSTATE_IMECOMPATFLAGS);
937 
938     if (!NtUserUpdateInputContext(hImc, UIC_CLIENTIMCDATA, (DWORD_PTR)pClientImc))
939     {
940         ImmLocalFree(pClientImc);
941         return NULL;
942     }
943 
944     pClientImc->dwFlags |= CLIENTIMC_UNKNOWN2;
945 
946 Finish:
947     InterlockedIncrement(&pClientImc->cLockObj);
948     return pClientImc;
949 }
950 
951 /***********************************************************************
952  *		ImmUnlockClientImc (IMM32.@)
953  */
954 VOID WINAPI ImmUnlockClientImc(PCLIENTIMC pClientImc)
955 {
956     LONG cLocks;
957     HANDLE hInputContext;
958 
959     TRACE("(%p)\n", pClientImc);
960 
961     cLocks = InterlockedDecrement(&pClientImc->cLockObj);
962     if (cLocks != 0 || !(pClientImc->dwFlags & CLIENTIMC_DESTROY))
963         return;
964 
965     hInputContext = pClientImc->hInputContext;
966     if (hInputContext)
967         LocalFree(hInputContext);
968 
969     RtlDeleteCriticalSection(&pClientImc->cs);
970     ImmLocalFree(pClientImc);
971 }
972 
973 // Win: ImmGetSaveContext
974 static HIMC APIENTRY ImmGetSaveContext(HWND hWnd, DWORD dwContextFlags)
975 {
976     HIMC hIMC;
977     PCLIENTIMC pClientImc;
978     PWND pWnd;
979 
980     if (!IS_IMM_MODE())
981         return NULL;
982 
983     if (!hWnd)
984     {
985         hIMC = (HIMC)NtUserGetThreadState(THREADSTATE_DEFAULTINPUTCONTEXT);
986         goto Quit;
987     }
988 
989     pWnd = ValidateHwnd(hWnd);
990     if (!pWnd || Imm32IsCrossProcessAccess(hWnd))
991         return NULL;
992 
993     hIMC = pWnd->hImc;
994     if (!hIMC && (dwContextFlags & 1))
995         hIMC = (HIMC)NtUserQueryWindow(hWnd, QUERY_WINDOW_DEFAULT_ICONTEXT);
996 
997 Quit:
998     pClientImc = ImmLockClientImc(hIMC);
999     if (pClientImc == NULL)
1000         return NULL;
1001     if ((dwContextFlags & 2) && (pClientImc->dwFlags & CLIENTIMC_DISABLEIME))
1002         hIMC = NULL;
1003     ImmUnlockClientImc(pClientImc);
1004     return hIMC;
1005 }
1006 
1007 /***********************************************************************
1008  *		ImmGetContext (IMM32.@)
1009  */
1010 HIMC WINAPI ImmGetContext(HWND hWnd)
1011 {
1012     TRACE("(%p)\n", hWnd);
1013     if (hWnd == NULL)
1014         return NULL;
1015     return ImmGetSaveContext(hWnd, 2);
1016 }
1017 
1018 /***********************************************************************
1019  *		ImmLockIMC(IMM32.@)
1020  *
1021  * NOTE: This is not ImmLockIMCC. Don't confuse.
1022  */
1023 LPINPUTCONTEXT WINAPI ImmLockIMC(HIMC hIMC)
1024 {
1025     TRACE("(%p)\n", hIMC);
1026     return Imm32InternalLockIMC(hIMC, TRUE);
1027 }
1028 
1029 /***********************************************************************
1030 *		ImmUnlockIMC(IMM32.@)
1031 */
1032 BOOL WINAPI ImmUnlockIMC(HIMC hIMC)
1033 {
1034     PCLIENTIMC pClientImc;
1035 
1036     pClientImc = ImmLockClientImc(hIMC);
1037     if (pClientImc == NULL)
1038         return FALSE;
1039 
1040     if (pClientImc->hInputContext)
1041         LocalUnlock(pClientImc->hInputContext);
1042 
1043     InterlockedDecrement(&pClientImc->cLockObj);
1044     ImmUnlockClientImc(pClientImc);
1045     return TRUE;
1046 }
1047 
1048 /***********************************************************************
1049  *		ImmReleaseContext (IMM32.@)
1050  */
1051 BOOL WINAPI ImmReleaseContext(HWND hWnd, HIMC hIMC)
1052 {
1053     TRACE("(%p, %p)\n", hWnd, hIMC);
1054     UNREFERENCED_PARAMETER(hWnd);
1055     UNREFERENCED_PARAMETER(hIMC);
1056     return TRUE; // Do nothing. This is correct.
1057 }
1058 
1059 /***********************************************************************
1060  *              ImmCreateSoftKeyboard(IMM32.@)
1061  */
1062 HWND WINAPI ImmCreateSoftKeyboard(UINT uType, UINT hOwner, int x, int y)
1063 {
1064     FIXME("(%d, %d, %d, %d): stub\n", uType, hOwner, x, y);
1065     SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1066     return 0;
1067 }
1068 
1069 /***********************************************************************
1070  *              ImmDestroySoftKeyboard(IMM32.@)
1071  */
1072 BOOL WINAPI ImmDestroySoftKeyboard(HWND hSoftWnd)
1073 {
1074     TRACE("(%p)\n", hSoftWnd);
1075     return DestroyWindow(hSoftWnd);
1076 }
1077 
1078 /***********************************************************************
1079  *              ImmShowSoftKeyboard(IMM32.@)
1080  */
1081 BOOL WINAPI ImmShowSoftKeyboard(HWND hSoftWnd, int nCmdShow)
1082 {
1083     TRACE("(%p, %d)\n", hSoftWnd, nCmdShow);
1084     if (hSoftWnd)
1085         return ShowWindow(hSoftWnd, nCmdShow);
1086     return FALSE;
1087 }
1088 
1089 /***********************************************************************
1090 *		ImmDisableTextFrameService(IMM32.@)
1091 */
1092 BOOL WINAPI ImmDisableTextFrameService(DWORD dwThreadId)
1093 {
1094     FIXME("Stub\n");
1095     return FALSE;
1096 }
1097 
1098 /***********************************************************************
1099  *              ImmEnumInputContext(IMM32.@)
1100  */
1101 BOOL WINAPI ImmEnumInputContext(DWORD dwThreadId, IMCENUMPROC lpfn, LPARAM lParam)
1102 {
1103     HIMC *phList;
1104     DWORD dwIndex, dwCount;
1105     BOOL ret = TRUE;
1106     HIMC hIMC;
1107 
1108     TRACE("(%lu, %p, %p)\n", dwThreadId, lpfn, lParam);
1109 
1110     dwCount = Imm32BuildHimcList(dwThreadId, &phList);
1111     if (!dwCount)
1112         return FALSE;
1113 
1114     for (dwIndex = 0; dwIndex < dwCount; ++dwIndex)
1115     {
1116         hIMC = phList[dwIndex];
1117         ret = (*lpfn)(hIMC, lParam);
1118         if (!ret)
1119             break;
1120     }
1121 
1122     ImmLocalFree(phList);
1123     return ret;
1124 }
1125 
1126 /***********************************************************************
1127  *              ImmSetActiveContext(IMM32.@)
1128  */
1129 BOOL WINAPI ImmSetActiveContext(HWND hWnd, HIMC hIMC, BOOL fActive)
1130 {
1131     PCLIENTIMC pClientImc;
1132     LPINPUTCONTEXTDX pIC;
1133     PIMEDPI pImeDpi;
1134     HKL hKL;
1135     BOOL fOpen = FALSE;
1136     DWORD dwConversion = 0, iShow = ISC_SHOWUIALL;
1137     HWND hwndDefIME;
1138 
1139     TRACE("(%p, %p, %d)\n", hWnd, hIMC, fActive);
1140 
1141     if (!IS_IMM_MODE())
1142         return FALSE;
1143 
1144     pClientImc = ImmLockClientImc(hIMC);
1145 
1146     if (!fActive)
1147     {
1148         if (pClientImc)
1149             pClientImc->dwFlags &= ~CLIENTIMC_UNKNOWN4;
1150     }
1151     else if (hIMC)
1152     {
1153         if (!pClientImc)
1154             return FALSE;
1155 
1156         pIC = (LPINPUTCONTEXTDX)ImmLockIMC(hIMC);
1157         if (!pIC)
1158         {
1159             ImmUnlockClientImc(pClientImc);
1160             return FALSE;
1161         }
1162 
1163         pIC->hWnd = hWnd;
1164         pClientImc->dwFlags |= CLIENTIMC_UNKNOWN5;
1165 
1166         if (pIC->dwUIFlags & 2)
1167             iShow = (ISC_SHOWUIGUIDELINE | ISC_SHOWUIALLCANDIDATEWINDOW);
1168 
1169         fOpen = pIC->fOpen;
1170         dwConversion = pIC->fdwConversion;
1171 
1172         ImmUnlockIMC(hIMC);
1173     }
1174     else
1175     {
1176         hIMC = ImmGetSaveContext(hWnd, 1);
1177         pIC = (LPINPUTCONTEXTDX)ImmLockIMC(hIMC);
1178         if (pIC)
1179         {
1180             pIC->hWnd = hWnd;
1181             ImmUnlockIMC(hIMC);
1182         }
1183         hIMC = NULL;
1184     }
1185 
1186     hKL = GetKeyboardLayout(0);
1187 
1188     if (Imm32IsCiceroMode() && !Imm32Is16BitMode())
1189     {
1190         Imm32CiceroSetActiveContext(hIMC, fActive, hWnd, hKL);
1191         hKL = GetKeyboardLayout(0);
1192     }
1193 
1194     pImeDpi = ImmLockImeDpi(hKL);
1195     if (pImeDpi)
1196     {
1197         if (IS_IME_HKL(hKL))
1198             pImeDpi->ImeSetActiveContext(hIMC, fActive);
1199         ImmUnlockImeDpi(pImeDpi);
1200     }
1201 
1202     if (IsWindow(hWnd))
1203     {
1204         SendMessageW(hWnd, WM_IME_SETCONTEXT, fActive, iShow);
1205         if (fActive)
1206             NtUserNotifyIMEStatus(hWnd, fOpen, dwConversion);
1207     }
1208     else if (!fActive)
1209     {
1210         hwndDefIME = ImmGetDefaultIMEWnd(NULL);
1211         if (hwndDefIME)
1212             SendMessageW(hwndDefIME, WM_IME_SETCONTEXT, 0, iShow);
1213     }
1214 
1215     if (pClientImc)
1216         ImmUnlockClientImc(pClientImc);
1217 
1218     return TRUE;
1219 }
1220 
1221 /***********************************************************************
1222  *              ImmWINNLSGetEnableStatus (IMM32.@)
1223  */
1224 
1225 BOOL WINAPI ImmWINNLSGetEnableStatus(HWND hWnd)
1226 {
1227     if (!Imm32IsSystemJapaneseOrKorean())
1228     {
1229         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1230         return FALSE;
1231     }
1232 
1233     return !!ImmGetSaveContext(hWnd, 2);
1234 }
1235 
1236 /***********************************************************************
1237  *              ImmSetActiveContextConsoleIME(IMM32.@)
1238  */
1239 BOOL WINAPI ImmSetActiveContextConsoleIME(HWND hwnd, BOOL fFlag)
1240 {
1241     HIMC hIMC;
1242     TRACE("(%p, %d)\n", hwnd, fFlag);
1243 
1244     hIMC = ImmGetContext(hwnd);
1245     if (hIMC)
1246         return ImmSetActiveContext(hwnd, hIMC, fFlag);
1247     return FALSE;
1248 }
1249 
1250 BOOL WINAPI User32InitializeImmEntryTable(DWORD);
1251 
1252 // Win: ImmDllInitialize
1253 BOOL WINAPI DllMain(HINSTANCE hinstDLL, DWORD fdwReason, LPVOID lpReserved)
1254 {
1255     HKL hKL;
1256     HIMC hIMC;
1257 
1258     TRACE("(%p, 0x%X, %p)\n", hinstDLL, fdwReason, lpReserved);
1259 
1260     switch (fdwReason)
1261     {
1262         case DLL_PROCESS_ATTACH:
1263             if (!ImmInitializeGlobals(hinstDLL))
1264             {
1265                 ERR("ImmInitializeGlobals failed\n");
1266                 return FALSE;
1267             }
1268             if (!User32InitializeImmEntryTable(IMM_INIT_MAGIC))
1269             {
1270                 ERR("User32InitializeImmEntryTable failed\n");
1271                 return FALSE;
1272             }
1273             break;
1274 
1275         case DLL_THREAD_ATTACH:
1276             break;
1277 
1278         case DLL_THREAD_DETACH:
1279             if (!IS_IMM_MODE() || NtCurrentTeb()->Win32ThreadInfo == NULL)
1280                 return TRUE;
1281 
1282             hKL = GetKeyboardLayout(0);
1283             hIMC = (HIMC)NtUserGetThreadState(THREADSTATE_DEFAULTINPUTCONTEXT);
1284             Imm32DestroyInputContext(hIMC, hKL, TRUE);
1285             break;
1286 
1287         case DLL_PROCESS_DETACH:
1288             RtlDeleteCriticalSection(&gcsImeDpi);
1289             TRACE("imm32.dll is unloaded\n");
1290             break;
1291     }
1292 
1293     return TRUE;
1294 }
1295