ReactOS 0.4.16-dev-1457-g02ea0aa
imm.c File Reference
#include "precomp.h"
#include <ndk/exfuncs.h>
Include dependency graph for imm.c:

Go to the source code of this file.

Classes

struct  SELECT_LAYOUT
 

Macros

#define MAX_IMCC_SIZE   0x1000
 

Typedefs

typedef struct SELECT_LAYOUT SELECT_LAYOUT
 
typedef struct SELECT_LAYOUTLPSELECT_LAYOUT
 

Functions

 WINE_DEFAULT_DEBUG_CHANNEL (imm)
 
static BOOL ImmInitializeGlobals (HMODULE hMod)
 
BOOL WINAPI ImmRegisterClient (_Inout_ PSHAREDINFO ptr, _In_ HINSTANCE hMod)
 
BOOL WINAPI ImmLoadLayout (_In_ HKL hKL, _Inout_ PIMEINFOEX pImeInfoEx)
 
BOOL WINAPI ImmFreeLayout (_In_ HKL hKL)
 
static VOID Imm32SelectInputContext (HKL hNewKL, HKL hOldKL, HIMC hIMC)
 
static BOOL CALLBACK Imm32SelectContextProc (HIMC hIMC, LPARAM lParam)
 
static BOOL CALLBACK Imm32NotifyIMEProc (HIMC hIMC, LPARAM lParam)
 
BOOL WINAPI ImmActivateLayout (_In_ HKL hKL)
 
HIMC WINAPI ImmAssociateContext (_In_ HWND hWnd, _In_opt_ HIMC hIMC)
 
BOOL WINAPI ImmAssociateContextEx (_In_ HWND hWnd, _In_opt_ HIMC hIMC, _In_ DWORD dwFlags)
 
HIMC WINAPI ImmCreateContext (VOID)
 
static VOID Imm32DestroyImeModeSaver (LPINPUTCONTEXTDX pIC)
 
static BOOL Imm32DestroyInputContext (HIMC hIMC, HKL hKL, BOOL bKeep)
 
static BOOL Imm32CreateInputContext (HIMC hIMC, LPINPUTCONTEXT pIC, PCLIENTIMC pClientImc, HKL hKL, BOOL fSelect)
 
LPINPUTCONTEXT Imm32InternalLockIMC (HIMC hIMC, BOOL fSelect)
 
BOOL WINAPI ImmDestroyContext (_In_ HIMC hIMC)
 
PCLIENTIMC WINAPI ImmLockClientImc (_In_ HIMC hImc)
 
VOID WINAPI ImmUnlockClientImc (_Inout_ PCLIENTIMC pClientImc)
 
static HIMC ImmGetSaveContext (_In_opt_ HWND hWnd, _In_ DWORD dwContextFlags)
 
HIMC WINAPI ImmGetContext (_In_ HWND hWnd)
 
LPINPUTCONTEXT WINAPI ImmLockIMC (_In_ HIMC hIMC)
 
BOOL WINAPI ImmUnlockIMC (_In_ HIMC hIMC)
 
BOOL WINAPI ImmReleaseContext (_In_ HWND hWnd, _In_ HIMC hIMC)
 
BOOL WINAPI ImmEnumInputContext (_In_ DWORD dwThreadId, _In_ IMCENUMPROC lpfn, _In_ LPARAM lParam)
 
BOOL WINAPI ImmSetActiveContext (_In_ HWND hWnd, _In_opt_ HIMC hIMC, _In_ BOOL fActive)
 
BOOL WINAPI ImmWINNLSGetEnableStatus (_In_opt_ HWND hWnd)
 
BOOL WINAPI ImmSetActiveContextConsoleIME (_In_ HWND hwnd, _In_ BOOL fFlag)
 
UINT WINAPI GetKeyboardLayoutCP (_In_ LANGID wLangId)
 
VOID Imm32UnitTest (VOID)
 
BOOL WINAPI ImmDllInitialize (_In_ HINSTANCE hDll, _In_ ULONG dwReason, _In_opt_ PVOID pReserved)
 

Variables

HMODULE ghImm32Inst = NULL
 
PSERVERINFO gpsi = NULL
 
SHAREDINFO gSharedInfo = { NULL }
 
BYTE gfImmInitialized = FALSE
 
ULONG_PTR gHighestUserAddress = 0
 

Macro Definition Documentation

◆ MAX_IMCC_SIZE

#define MAX_IMCC_SIZE   0x1000

Typedef Documentation

◆ LPSELECT_LAYOUT

◆ SELECT_LAYOUT

Function Documentation

◆ GetKeyboardLayoutCP()

UINT WINAPI GetKeyboardLayoutCP ( _In_ LANGID  wLangId)

Definition at line 1287 of file imm.c.

1288{
1289 WCHAR szText[8];
1290 static LANGID s_wKeyboardLangIdCache = 0;
1291 static UINT s_uKeyboardLayoutCPCache = 0;
1292
1293 TRACE("(%u)\n", wLangId);
1294
1295 if (wLangId == s_wKeyboardLangIdCache)
1296 return s_uKeyboardLayoutCPCache;
1297
1298 if (!GetLocaleInfoW(wLangId, LOCALE_IDEFAULTANSICODEPAGE, szText, _countof(szText)))
1299 return 0;
1300
1301 s_wKeyboardLangIdCache = wLangId;
1302 szText[_countof(szText) - 1] = UNICODE_NULL; /* Avoid buffer overrun */
1303 s_uKeyboardLayoutCPCache = wcstol(szText, NULL, 10);
1304 return s_uKeyboardLayoutCPCache;
1305}
#define NULL
Definition: types.h:112
INT WINAPI GetLocaleInfoW(LCID lcid, LCTYPE lctype, LPWSTR buffer, INT len)
Definition: locale.c:1675
USHORT LANGID
Definition: mui.h:9
unsigned int UINT
Definition: ndis.h:50
#define UNICODE_NULL
_Check_return_ long __cdecl wcstol(_In_z_ const wchar_t *_Str, _Out_opt_ _Deref_post_z_ wchar_t **_EndPtr, _In_ int _Radix)
#define _countof(array)
Definition: sndvol32.h:70
#define TRACE(s)
Definition: solgame.cpp:4
#define LOCALE_IDEFAULTANSICODEPAGE
Definition: winnls.h:45
__wchar_t WCHAR
Definition: xmlstorage.h:180

◆ Imm32CreateInputContext()

static BOOL Imm32CreateInputContext ( HIMC  hIMC,
LPINPUTCONTEXT  pIC,
PCLIENTIMC  pClientImc,
HKL  hKL,
BOOL  fSelect 
)
static

Definition at line 752 of file imm.c.

753{
754 DWORD dwIndex, cbPrivate;
755 PIMEDPI pImeDpi = NULL;
757 LPCANDIDATEINFO pCI;
758 LPGUIDELINE pGL;
759
760 /* Create IC components */
762 pIC->hCandInfo = ImmCreateIMCC(sizeof(CANDIDATEINFO));
763 pIC->hGuideLine = ImmCreateIMCC(sizeof(GUIDELINE));
764 pIC->hMsgBuf = ImmCreateIMCC(sizeof(UINT));
765 if (IS_NULL_UNEXPECTEDLY(pIC->hCompStr) ||
769 {
770 goto Fail;
771 }
772
773 /* Initialize IC components */
774 pCS = ImmLockIMCC(pIC->hCompStr);
775 if (IS_NULL_UNEXPECTEDLY(pCS))
776 goto Fail;
777 pCS->dwSize = sizeof(COMPOSITIONSTRING);
779
780 pCI = ImmLockIMCC(pIC->hCandInfo);
781 if (IS_NULL_UNEXPECTEDLY(pCI))
782 goto Fail;
783 pCI->dwSize = sizeof(CANDIDATEINFO);
785
786 pGL = ImmLockIMCC(pIC->hGuideLine);
787 if (IS_NULL_UNEXPECTEDLY(pGL))
788 goto Fail;
789 pGL->dwSize = sizeof(GUIDELINE);
791
792 pIC->dwNumMsgBuf = 0;
793 pIC->fOpen = FALSE;
794 pIC->fdwConversion = pIC->fdwSentence = 0;
795
796 for (dwIndex = 0; dwIndex < MAX_CANDIDATEFORM; ++dwIndex)
798
799 /* Get private data size */
800 pImeDpi = ImmLockImeDpi(hKL);
801 if (!pImeDpi)
802 {
803 cbPrivate = sizeof(DWORD);
804 }
805 else
806 {
807 /* Update CLIENTIMC */
808 pClientImc->uCodePage = pImeDpi->uCodePage;
809 if (ImeDpi_IsUnicode(pImeDpi))
810 pClientImc->dwFlags |= CLIENTIMC_WIDE;
811
812 cbPrivate = pImeDpi->ImeInfo.dwPrivateDataSize;
813 }
814
815 /* Create private data */
816 pIC->hPrivate = ImmCreateIMCC(cbPrivate);
818 goto Fail;
819
821
822 if (pImeDpi)
823 {
824 /* Select the IME */
825 if (fSelect)
826 {
827 if (IS_IME_HKL(hKL))
828 pImeDpi->ImeSelect(hIMC, TRUE);
829 else if (IS_CICERO_MODE() && !IS_16BIT_MODE())
830 pImeDpi->CtfImeSelectEx(hIMC, TRUE, hKL);
831 }
832
833 /* Set HKL */
834 pClientImc->hKL = hKL;
835
836 ImmUnlockImeDpi(pImeDpi);
837 }
838
839 return TRUE;
840
841Fail:
842 if (pImeDpi)
843 ImmUnlockImeDpi(pImeDpi);
844
845 pIC->hMsgBuf = ImmDestroyIMCC(pIC->hMsgBuf);
848 pIC->hCompStr = ImmDestroyIMCC(pIC->hCompStr);
849 return FALSE;
850}
HRESULT CtfImmTIMCreateInputContext(_In_ HIMC hIMC)
Definition: ctf.c:939
#define TRUE
Definition: types.h:120
#define FALSE
Definition: types.h:117
int Fail
Definition: ehthrow.cxx:24
unsigned long DWORD
Definition: ntddk_ex.h:95
#define IS_IME_HKL(hKL)
Definition: imm32_undoc.h:21
PIMEDPI WINAPI ImmLockImeDpi(_In_ HKL hKL)
Definition: ime.c:531
VOID WINAPI ImmUnlockImeDpi(_Inout_opt_ PIMEDPI pImeDpi)
Definition: ime.c:561
#define CLIENTIMC_WIDE
Definition: imm32_undoc.h:169
struct tagGUIDELINE GUIDELINE
BOOL WINAPI ImmUnlockIMCC(_In_ HIMCC imcc)
Definition: utils.c:615
HIMCC WINAPI ImmDestroyIMCC(_In_ HIMCC block)
Definition: utils.c:593
struct tagCANDIDATEINFO CANDIDATEINFO
HIMCC WINAPI ImmCreateIMCC(_In_ DWORD size)
Definition: utils.c:582
struct tagCOMPOSITIONSTRING COMPOSITIONSTRING
LPVOID WINAPI ImmLockIMCC(_In_ HIMCC imcc)
Definition: utils.c:604
#define IS_16BIT_MODE()
Definition: ntuser.h:1214
#define IS_CICERO_MODE()
Definition: ntuser.h:1213
#define DWORD
Definition: nt_native.h:44
DWORD dwIndex
Definition: dimm.idl:79
IMEINFO ImeInfo
Definition: imm32_undoc.h:94
UINT uCodePage
Definition: imm32_undoc.h:95
DWORD dwPrivateDataSize
Definition: immdev.h:21
HIMCC hPrivate
Definition: immdev.h:122
CANDIDATEFORM cfCandForm[4]
Definition: immdev.h:118
HIMCC hMsgBuf
Definition: immdev.h:124
HIMCC hCompStr
Definition: immdev.h:119
DWORD fdwConversion
Definition: immdev.h:111
HIMCC hCandInfo
Definition: immdev.h:120
HIMCC hGuideLine
Definition: immdev.h:121
DWORD fdwSentence
Definition: immdev.h:112
DWORD dwNumMsgBuf
Definition: immdev.h:123
DWORD dwSize
Definition: immdev.h:31
DWORD dwSize
Definition: immdev.h:76
#define IMM_INVALID_CANDFORM
Definition: precomp.h:76
#define IS_NULL_UNEXPECTEDLY(p)
Definition: precomp.h:66
#define MAX_CANDIDATEFORM
Definition: precomp.h:78
#define ImeDpi_IsUnicode(pImeDpi)
Definition: precomp.h:120

Referenced by Imm32InternalLockIMC().

◆ Imm32DestroyImeModeSaver()

static VOID Imm32DestroyImeModeSaver ( LPINPUTCONTEXTDX  pIC)
static

Definition at line 638 of file imm.c.

639{
640 PIME_STATE pState, pNext;
641 PIME_SUBSTATE pSubState, pSubNext;
642
643 for (pState = pIC->pState; pState; pState = pNext)
644 {
645 pNext = pState->pNext;
646
647 for (pSubState = pState->pSubState; pSubState; pSubState = pSubNext)
648 {
649 pSubNext = pSubState->pNext;
650 ImmLocalFree(pSubState);
651 }
652
653 ImmLocalFree(pState);
654 }
655
656 pIC->pState = NULL;
657}
PIME_SUBSTATE pSubState
Definition: imm32_undoc.h:219
struct IME_STATE * pNext
Definition: imm32_undoc.h:213
struct IME_SUBSTATE * pNext
Definition: imm32_undoc.h:202
struct IME_STATE * pState
Definition: imm32_undoc.h:195
#define ImmLocalFree(lpData)
Definition: precomp.h:105

Referenced by Imm32DestroyInputContext().

◆ Imm32DestroyInputContext()

static BOOL Imm32DestroyInputContext ( HIMC  hIMC,
HKL  hKL,
BOOL  bKeep 
)
static

Definition at line 660 of file imm.c.

661{
662 PIMEDPI pImeDpi;
664 PCLIENTIMC pClientImc;
665 PIMC pIMC;
666
667 if (hIMC == NULL)
668 return FALSE;
669
670 if (!IS_IMM_MODE())
671 {
672 TRACE("\n");
673 return FALSE;
674 }
675
676 pIMC = ValidateHandle(hIMC, TYPE_INPUTCONTEXT);
677 if (IS_NULL_UNEXPECTEDLY(pIMC))
678 return FALSE;
679
680 if (pIMC->head.pti != Imm32CurrentPti())
681 {
682 ERR("Thread mismatch\n");
683 return FALSE;
684 }
685
686 pClientImc = (PCLIENTIMC)pIMC->dwClientImcData;
687 if (pClientImc == NULL)
688 {
689 TRACE("pClientImc == NULL\n");
690 goto Finish;
691 }
692
693 if ((pClientImc->dwFlags & CLIENTIMC_UNKNOWN2) && !bKeep)
694 {
695 ERR("Can't destroy for CLIENTIMC_UNKNOWN2\n");
696 return FALSE;
697 }
698
699 if (pClientImc->dwFlags & CLIENTIMC_DESTROY)
700 return TRUE;
701
702 InterlockedIncrement(&pClientImc->cLockObj);
703
704 if (IS_NULL_UNEXPECTEDLY(pClientImc->hInputContext))
705 goto Quit;
706
707 pIC = (LPINPUTCONTEXTDX)ImmLockIMC(hIMC);
708 if (IS_NULL_UNEXPECTEDLY(pIC))
709 {
710 ImmUnlockClientImc(pClientImc);
711 return FALSE;
712 }
713
715
716 if (pClientImc->hKL == hKL)
717 {
718 pImeDpi = ImmLockImeDpi(hKL);
719 if (pImeDpi)
720 {
721 if (IS_IME_HKL(hKL))
722 pImeDpi->ImeSelect(hIMC, FALSE);
723 else if (IS_CICERO_MODE() && !IS_16BIT_MODE())
724 pImeDpi->CtfImeSelectEx(hIMC, FALSE, hKL);
725
726 ImmUnlockImeDpi(pImeDpi);
727 }
728
729 pClientImc->hKL = NULL;
730 }
731
732 ImmDestroyIMCC(pIC->hPrivate);
733 ImmDestroyIMCC(pIC->hMsgBuf);
734 ImmDestroyIMCC(pIC->hGuideLine);
735 ImmDestroyIMCC(pIC->hCandInfo);
736 ImmDestroyIMCC(pIC->hCompStr);
738 ImmUnlockIMC(hIMC);
739
740Quit:
741 pClientImc->dwFlags |= CLIENTIMC_DESTROY;
742 ImmUnlockClientImc(pClientImc);
743
744Finish:
745 if (bKeep)
746 return TRUE;
747 return NtUserDestroyInputContext(hIMC);
748}
#define InterlockedIncrement
Definition: armddk.h:53
#define ERR(fmt,...)
Definition: precomp.h:57
HRESULT CtfImmTIMDestroyInputContext(_In_ HIMC hIMC)
Definition: ctf.c:929
PTHEME_CLASS ValidateHandle(HTHEME hTheme)
Definition: system.c:772
LPINPUTCONTEXT WINAPI ImmLockIMC(_In_ HIMC hIMC)
Definition: imm.c:1079
static VOID Imm32DestroyImeModeSaver(LPINPUTCONTEXTDX pIC)
Definition: imm.c:638
BOOL WINAPI ImmUnlockIMC(_In_ HIMC hIMC)
Definition: imm.c:1089
VOID WINAPI ImmUnlockClientImc(_Inout_ PCLIENTIMC pClientImc)
Definition: imm.c:1001
struct tagCLIENTIMC * PCLIENTIMC
#define CLIENTIMC_DESTROY
Definition: imm32_undoc.h:172
struct INPUTCONTEXTDX * LPINPUTCONTEXTDX
#define CLIENTIMC_UNKNOWN2
Definition: imm32_undoc.h:174
BOOL NTAPI NtUserDestroyInputContext(_In_ HIMC hIMC)
Definition: ime.c:1612
#define IS_IMM_MODE()
Definition: ntuser.h:1212
@ TYPE_INPUTCONTEXT
Definition: ntuser.h:57
if(dx< 0)
Definition: linetemp.h:194
HANDLE hInputContext
Definition: imm32_undoc.h:147
Definition: ntuser.h:199
THRDESKHEAD head
Definition: ntuser.h:200
ULONG_PTR dwClientImcData
Definition: ntuser.h:202
PTHREADINFO FASTCALL Imm32CurrentPti(VOID)
Definition: utils.c:18

Referenced by ImmDestroyContext(), and ImmDllInitialize().

◆ Imm32InternalLockIMC()

LPINPUTCONTEXT Imm32InternalLockIMC ( HIMC  hIMC,
BOOL  fSelect 
)

Definition at line 852 of file imm.c.

853{
854 HANDLE hIC;
855 LPINPUTCONTEXT pIC = NULL;
856 PCLIENTIMC pClientImc;
857 WORD LangID;
859 HKL hOldKL, hNewKL;
860 PIMEDPI pImeDpi = NULL;
861
862 pClientImc = ImmLockClientImc(hIMC);
863 if (!pClientImc)
864 return NULL;
865
866 RtlEnterCriticalSection(&pClientImc->cs);
867
868 if (pClientImc->hInputContext)
869 {
870 pIC = LocalLock(pClientImc->hInputContext);
871 if (IS_NULL_UNEXPECTEDLY(pIC))
872 goto Failure;
873
875 goto Success;
876 }
877
880 {
881 hOldKL = GetKeyboardLayout(0);
882 LangID = LOWORD(hOldKL);
884
885 pImeDpi = Imm32FindOrLoadImeDpi(hNewKL);
886 if (pImeDpi)
887 {
888 CtfImmTIMActivate(hNewKL);
889 }
890 }
891
893 {
894 ERR("No default IME window\n");
895 goto Failure;
896 }
897
898 hIC = LocalAlloc(LHND, sizeof(INPUTCONTEXTDX));
899 pIC = LocalLock(hIC);
900 if (IS_NULL_UNEXPECTEDLY(pIC))
901 {
902 LocalFree(hIC);
903 goto Failure;
904 }
905 pClientImc->hInputContext = hIC;
906
908 if (!Imm32CreateInputContext(hIMC, pIC, pClientImc, hNewKL, fSelect))
909 {
910 LocalUnlock(hIC);
911 pClientImc->hInputContext = LocalFree(hIC);
912 goto Failure;
913 }
914
915Success:
916 RtlLeaveCriticalSection(&pClientImc->cs);
917 InterlockedIncrement(&pClientImc->cLockObj);
918 ImmUnlockClientImc(pClientImc);
919 return pIC;
920
921Failure:
922 RtlLeaveCriticalSection(&pClientImc->cs);
923 ImmUnlockClientImc(pClientImc);
924 return NULL;
925}
#define UlongToHandle(ul)
Definition: basetsd.h:97
@ Success
Definition: eventcreate.c:712
DWORD dwThreadId
Definition: fdebug.c:31
unsigned short WORD
Definition: ntddk_ex.h:93
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
PIMEDPI Imm32FindOrLoadImeDpi(HKL hKL)
Definition: ime.c:350
static BOOL Imm32CreateInputContext(HIMC hIMC, LPINPUTCONTEXT pIC, PCLIENTIMC pClientImc, HKL hKL, BOOL fSelect)
Definition: imm.c:752
PCLIENTIMC WINAPI ImmLockClientImc(_In_ HIMC hImc)
Definition: imm.c:954
HRESULT WINAPI CtfImmTIMActivate(_In_ HKL hKL)
Definition: ctf.c:1123
DWORD_PTR NTAPI NtUserQueryInputContext(HIMC hIMC, DWORD dwType)
Definition: ime.c:1878
UINT_PTR HKL
Definition: msctf.idl:125
NTSYSAPI NTSTATUS NTAPI RtlEnterCriticalSection(_In_ PRTL_CRITICAL_SECTION CriticalSection)
NTSYSAPI NTSTATUS NTAPI RtlLeaveCriticalSection(_In_ PRTL_CRITICAL_SECTION CriticalSection)
#define LOWORD(l)
Definition: pedump.c:82
RTL_CRITICAL_SECTION cs
Definition: imm32_undoc.h:151
#define MAKELONG(a, b)
Definition: typedefs.h:249
@ QIC_DEFAULTWINDOWIME
Definition: undocuser.h:405
@ QIC_INPUTTHREADID
Definition: undocuser.h:404
_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
DWORD WINAPI GetCurrentThreadId(void)
Definition: thread.c:459
#define LHND
Definition: winbase.h:415
HKL WINAPI GetKeyboardLayout(_In_ DWORD)

Referenced by Imm32SelectInputContext(), and ImmLockIMC().

◆ Imm32NotifyIMEProc()

static BOOL CALLBACK Imm32NotifyIMEProc ( HIMC  hIMC,
LPARAM  lParam 
)
static

Definition at line 440 of file imm.c.

441{
443 return TRUE;
444}
LPARAM lParam
Definition: combotst.c:139
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

Referenced by ImmActivateLayout().

◆ Imm32SelectContextProc()

static BOOL CALLBACK Imm32SelectContextProc ( HIMC  hIMC,
LPARAM  lParam 
)
static

Definition at line 433 of file imm.c.

434{
436 Imm32SelectInputContext(pSelect->hNewKL, pSelect->hOldKL, hIMC);
437 return TRUE;
438}
LPFN_SELECT pSelect
Definition: handle.c:32
static VOID Imm32SelectInputContext(HKL hNewKL, HKL hOldKL, HIMC hIMC)
Definition: imm.c:191
struct SELECT_LAYOUT * LPSELECT_LAYOUT

Referenced by ImmActivateLayout().

◆ Imm32SelectInputContext()

static VOID Imm32SelectInputContext ( HKL  hNewKL,
HKL  hOldKL,
HIMC  hIMC 
)
static

Definition at line 191 of file imm.c.

192{
193 PCLIENTIMC pClientImc;
195 LPGUIDELINE pGL;
196 LPCANDIDATEINFO pCI;
198 LOGFONTA LogFontA;
199 LOGFONTW LogFontW;
200 BOOL fOldOpen, bIsNewHKLIme = TRUE, bIsOldHKLIme = TRUE, bClientWide, bNewDpiWide;
201 DWORD cbNewPrivate = 0, cbOldPrivate = 0, dwOldConversion, dwOldSentence, dwSize, dwNewSize;
202 PIMEDPI pNewImeDpi = NULL, pOldImeDpi = NULL;
203 HANDLE hPrivate;
204 PIME_STATE pNewState = NULL, pOldState = NULL;
205
206 pClientImc = ImmLockClientImc(hIMC);
207 if (IS_NULL_UNEXPECTEDLY(pClientImc))
208 return;
209
210 pNewImeDpi = ImmLockImeDpi(hNewKL);
211
212 if (hNewKL != hOldKL)
213 pOldImeDpi = ImmLockImeDpi(hOldKL);
214
215 if (pNewImeDpi)
216 {
217 cbNewPrivate = pNewImeDpi->ImeInfo.dwPrivateDataSize;
218 pClientImc->uCodePage = pNewImeDpi->uCodePage;
219 }
220 else
221 {
222 pClientImc->uCodePage = CP_ACP;
223 }
224
225 if (pOldImeDpi)
226 cbOldPrivate = pOldImeDpi->ImeInfo.dwPrivateDataSize;
227
228 cbNewPrivate = max(cbNewPrivate, sizeof(DWORD));
229 cbOldPrivate = max(cbOldPrivate, sizeof(DWORD));
230
231 if (pClientImc->hKL == hOldKL)
232 {
233 if (pOldImeDpi)
234 {
235 if (IS_IME_HKL(hOldKL))
236 pOldImeDpi->ImeSelect(hIMC, FALSE);
237 else if (IS_CICERO_MODE() && !IS_16BIT_MODE())
238 pOldImeDpi->CtfImeSelectEx(hIMC, FALSE, hOldKL);
239 }
240 pClientImc->hKL = NULL;
241 }
242
244 {
245 bIsNewHKLIme = IS_IME_HKL(hNewKL);
246 bIsOldHKLIme = IS_IME_HKL(hOldKL);
247 }
248
250 if (!pIC)
251 {
252 if (pNewImeDpi)
253 {
254 if (IS_IME_HKL(hNewKL))
255 pNewImeDpi->ImeSelect(hIMC, TRUE);
256 else if (IS_CICERO_MODE() && !IS_16BIT_MODE())
257 pNewImeDpi->CtfImeSelectEx(hIMC, TRUE, hNewKL);
258
259 pClientImc->hKL = hNewKL;
260 }
261 }
262 else
263 {
264 dwOldConversion = pIC->fdwConversion;
265 dwOldSentence = pIC->fdwSentence;
266 fOldOpen = pIC->fOpen;
267
268 if (pNewImeDpi)
269 {
270 bClientWide = (pClientImc->dwFlags & CLIENTIMC_WIDE);
271 bNewDpiWide = ImeDpi_IsUnicode(pNewImeDpi);
272 if (bClientWide && !bNewDpiWide)
273 {
274 if (pIC->fdwInit & INIT_LOGFONT)
275 {
276 LogFontWideToAnsi(&pIC->lfFont.W, &LogFontA);
277 pIC->lfFont.A = LogFontA;
278 }
279 pClientImc->dwFlags &= ~CLIENTIMC_WIDE;
280 }
281 else if (!bClientWide && bNewDpiWide)
282 {
283 if (pIC->fdwInit & INIT_LOGFONT)
284 {
285 LogFontAnsiToWide(&pIC->lfFont.A, &LogFontW);
286 pIC->lfFont.W = LogFontW;
287 }
288 pClientImc->dwFlags |= CLIENTIMC_WIDE;
289 }
290 }
291
292 if (cbOldPrivate != cbNewPrivate)
293 {
294 hPrivate = ImmReSizeIMCC(pIC->hPrivate, cbNewPrivate);
295 if (!hPrivate)
296 {
297 ImmDestroyIMCC(pIC->hPrivate);
298 hPrivate = ImmCreateIMCC(cbNewPrivate);
299 }
300 pIC->hPrivate = hPrivate;
301 }
302
303#define MAX_IMCC_SIZE 0x1000
304 dwSize = ImmGetIMCCSize(pIC->hMsgBuf);
305 if (ImmGetIMCCLockCount(pIC->hMsgBuf) || dwSize > MAX_IMCC_SIZE)
306 {
307 ImmDestroyIMCC(pIC->hMsgBuf);
308 pIC->hMsgBuf = ImmCreateIMCC(sizeof(UINT));
309 pIC->dwNumMsgBuf = 0;
310 }
311
312 dwSize = ImmGetIMCCSize(pIC->hGuideLine);
313 dwNewSize = sizeof(GUIDELINE);
314 if (ImmGetIMCCLockCount(pIC->hGuideLine) ||
315 dwSize < dwNewSize || dwSize > MAX_IMCC_SIZE)
316 {
317 ImmDestroyIMCC(pIC->hGuideLine);
318 pIC->hGuideLine = ImmCreateIMCC(dwNewSize);
319 pGL = ImmLockIMCC(pIC->hGuideLine);
320 if (pGL)
321 {
322 pGL->dwSize = dwNewSize;
323 ImmUnlockIMCC(pIC->hGuideLine);
324 }
325 }
326
327 dwSize = ImmGetIMCCSize(pIC->hCandInfo);
328 dwNewSize = sizeof(CANDIDATEINFO);
329 if (ImmGetIMCCLockCount(pIC->hCandInfo) ||
330 dwSize < dwNewSize || dwSize > MAX_IMCC_SIZE)
331 {
332 ImmDestroyIMCC(pIC->hCandInfo);
333 pIC->hCandInfo = ImmCreateIMCC(dwNewSize);
334 pCI = ImmLockIMCC(pIC->hCandInfo);
335 if (pCI)
336 {
337 pCI->dwSize = dwNewSize;
338 ImmUnlockIMCC(pIC->hCandInfo);
339 }
340 }
341
342 dwSize = ImmGetIMCCSize(pIC->hCompStr);
343 dwNewSize = sizeof(COMPOSITIONSTRING);
344 if (ImmGetIMCCLockCount(pIC->hCompStr) ||
345 dwSize < dwNewSize || dwSize > MAX_IMCC_SIZE)
346 {
347 ImmDestroyIMCC(pIC->hCompStr);
348 pIC->hCompStr = ImmCreateIMCC(dwNewSize);
349 pCS = ImmLockIMCC(pIC->hCompStr);
350 if (pCS)
351 {
352 pCS->dwSize = dwNewSize;
353 ImmUnlockIMCC(pIC->hCompStr);
354 }
355 }
356#undef MAX_IMCC_SIZE
357
358 if (pOldImeDpi && bIsOldHKLIme)
359 {
360 pOldState = Imm32FetchImeState(pIC, hOldKL);
361 if (pOldState)
362 Imm32SaveImeStateSentence(pIC, pOldState, hOldKL);
363 }
364
365 if (pNewImeDpi && bIsNewHKLIme)
366 pNewState = Imm32FetchImeState(pIC, hNewKL);
367
368 if (pOldState != pNewState)
369 {
370 if (pOldState)
371 {
372 pOldState->fOpen = !!pIC->fOpen;
373 pOldState->dwConversion = pIC->fdwConversion;
374 pOldState->dwConversion &= ~IME_CMODE_EUDC;
375 pOldState->dwSentence = pIC->fdwSentence;
376 pOldState->dwInit = pIC->fdwInit;
377 }
378
379 if (pNewState)
380 {
382 {
383 pIC->dwChange &= ~INPUTCONTEXTDX_CHANGE_FORCE_OPEN;
384 pIC->fOpen = TRUE;
385 }
386 else
387 {
388 pIC->fOpen = pNewState->fOpen;
389 }
390
391 pIC->fdwConversion = pNewState->dwConversion;
392 pIC->fdwConversion &= ~IME_CMODE_EUDC;
393 pIC->fdwSentence = pNewState->dwSentence;
394 pIC->fdwInit = pNewState->dwInit;
395 }
396 }
397
398 if (pNewState)
399 Imm32LoadImeStateSentence(pIC, pNewState, hNewKL);
400
401 if (pNewImeDpi)
402 {
403 if (IS_IME_HKL(hNewKL))
404 pNewImeDpi->ImeSelect(hIMC, TRUE);
405 else if (IS_CICERO_MODE() && !IS_16BIT_MODE())
406 pNewImeDpi->CtfImeSelectEx(hIMC, TRUE, hNewKL);
407
408 pClientImc->hKL = hNewKL;
409 }
410
411 pIC->dwChange = 0;
412 if (pIC->fOpen != fOldOpen)
414 if (pIC->fdwConversion != dwOldConversion)
416 if (pIC->fdwSentence != dwOldSentence)
418
419 ImmUnlockIMC(hIMC);
420 }
421
422 ImmUnlockImeDpi(pOldImeDpi);
423 ImmUnlockImeDpi(pNewImeDpi);
424 ImmUnlockClientImc(pClientImc);
425}
#define CP_ACP
Definition: compat.h:109
unsigned int BOOL
Definition: ntddk_ex.h:94
LPINPUTCONTEXT Imm32InternalLockIMC(HIMC hIMC, BOOL fSelect)
Definition: imm.c:852
#define MAX_IMCC_SIZE
BOOL WINAPI CtfImmIsTextFrameServiceDisabled(VOID)
Definition: ctf.c:1079
DWORD WINAPI ImmGetIMCCSize(_In_ HIMCC imcc)
Definition: utils.c:648
#define INPUTCONTEXTDX_CHANGE_OPEN
Definition: immdev.h:160
#define INPUTCONTEXTDX_CHANGE_SENTENCE
Definition: immdev.h:162
HIMCC WINAPI ImmReSizeIMCC(_In_ HIMCC imcc, _In_ DWORD size)
Definition: utils.c:635
#define INIT_LOGFONT
Definition: immdev.h:154
DWORD WINAPI ImmGetIMCCLockCount(_In_ HIMCC imcc)
Definition: utils.c:626
#define INPUTCONTEXTDX_CHANGE_FORCE_OPEN
Definition: immdev.h:163
#define INPUTCONTEXTDX_CHANGE_CONVERSION
Definition: immdev.h:161
PSDBQUERYRESULT_VISTA PVOID DWORD * dwSize
Definition: env.c:56
DWORD dwConversion
Definition: imm32_undoc.h:216
WORD fOpen
Definition: imm32_undoc.h:215
DWORD dwInit
Definition: imm32_undoc.h:218
DWORD dwSentence
Definition: imm32_undoc.h:217
#define max(a, b)
Definition: svc.c:63
BOOL Imm32LoadImeStateSentence(LPINPUTCONTEXTDX pIC, PIME_STATE pState, HKL hKL)
Definition: utils.c:420
VOID LogFontAnsiToWide(const LOGFONTA *plfA, LPLOGFONTW plfW)
Definition: utils.c:164
BOOL Imm32SaveImeStateSentence(LPINPUTCONTEXTDX pIC, PIME_STATE pState, HKL hKL)
Definition: utils.c:431
PIME_STATE Imm32FetchImeState(LPINPUTCONTEXTDX pIC, HKL hKL)
Definition: utils.c:378
VOID LogFontWideToAnsi(const LOGFONTW *plfW, LPLOGFONTA plfA)
Definition: utils.c:176

Referenced by Imm32SelectContextProc().

◆ Imm32UnitTest()

VOID Imm32UnitTest ( VOID  )

Definition at line 1308 of file imm.c.

1309{
1310 if (0)
1311 {
1312 DWORD dwValue;
1313 WCHAR szText[64];
1314
1315 Imm32StrToUInt(L"123", &dwValue, 10);
1316 ASSERT(dwValue == 123);
1317 Imm32StrToUInt(L"100", &dwValue, 16);
1318 ASSERT(dwValue == 0x100);
1319
1320 Imm32UIntToStr(123, 10, szText, _countof(szText));
1321 ASSERT(lstrcmpW(szText, L"123") == 0);
1322 Imm32UIntToStr(0x100, 16, szText, _countof(szText));
1323 ASSERT(lstrcmpW(szText, L"100") == 0);
1324 }
1325}
int WINAPI lstrcmpW(LPCWSTR str1, LPCWSTR str2)
Definition: locale.c:4246
#define L(x)
Definition: resources.c:13
#define ASSERT(a)
Definition: mode.c:44
HRESULT Imm32UIntToStr(_In_ DWORD dwValue, _In_ ULONG nBase, _Out_ PWSTR pszBuff, _In_ USHORT cchBuff)
Definition: utils.c:56
HRESULT Imm32StrToUInt(_In_ PCWSTR pszText, _Out_ PDWORD pdwValue, _In_ ULONG nBase)
Definition: utils.c:40

Referenced by ImmDllInitialize().

◆ ImmActivateLayout()

BOOL WINAPI ImmActivateLayout ( _In_ HKL  hKL)

Definition at line 450 of file imm.c.

451{
452 PIMEDPI pImeDpi;
453 HKL hOldKL;
455 HWND hwndDefIME = NULL;
456 SELECT_LAYOUT SelectLayout;
457
458 hOldKL = GetKeyboardLayout(0);
459
460 if (hOldKL == hKL && !(GetWin32ClientInfo()->CI_flags & CI_IMMACTIVATE))
461 return TRUE;
462
463 ImmLoadIME(hKL);
464
465 if (hOldKL != hKL)
466 {
467 pImeDpi = ImmLockImeDpi(hOldKL);
468 if (pImeDpi)
469 {
472 else
474 ImmUnlockImeDpi(pImeDpi);
475
477 }
478
479 hwndDefIME = ImmGetDefaultIMEWnd(NULL);
480 if (IsWindow(hwndDefIME))
481 SendMessageW(hwndDefIME, WM_IME_SELECT, FALSE, (LPARAM)hOldKL);
482
483 NtUserSetThreadLayoutHandles(hKL, hOldKL);
484 }
485
486 SelectLayout.hNewKL = hKL;
487 SelectLayout.hOldKL = hOldKL;
489
490 if (IsWindow(hwndDefIME))
491 SendMessageW(hwndDefIME, WM_IME_SELECT, TRUE, (LPARAM)hKL);
492
493 return TRUE;
494}
static BOOL CALLBACK Imm32SelectContextProc(HIMC hIMC, LPARAM lParam)
Definition: imm.c:433
BOOL WINAPI ImmEnumInputContext(_In_ DWORD dwThreadId, _In_ IMCENUMPROC lpfn, _In_ LPARAM lParam)
Definition: imm.c:1123
static BOOL CALLBACK Imm32NotifyIMEProc(HIMC hIMC, LPARAM lParam)
Definition: imm.c:440
BOOL WINAPI ImmLoadIME(_In_ HKL hKL)
Definition: ime.c:611
#define CPS_CANCEL
Definition: imm.h:181
#define CPS_COMPLETE
Definition: imm.h:178
HWND WINAPI ImmGetDefaultIMEWnd(_In_opt_ HWND hWnd)
Definition: ime.c:440
#define IME_PROP_COMPLETE_ON_UNSELECT
Definition: imm.h:250
DWORD NTAPI NtUserSetThreadLayoutHandles(_In_ HKL hNewKL, _In_ HKL hOldKL)
Definition: ime.c:535
#define CI_IMMACTIVATE
Definition: ntuser.h:306
#define GetWin32ClientInfo()
Definition: ntuser.h:352
HKL hNewKL
Definition: imm.c:429
HKL hOldKL
Definition: imm.c:430
DWORD fdwProperty
Definition: immdev.h:22
LONG_PTR LPARAM
Definition: windef.h:208
BOOL WINAPI IsWindow(_In_opt_ HWND)
#define WM_IME_SELECT
Definition: winuser.h:1852
LRESULT WINAPI SendMessageW(_In_ HWND, _In_ UINT, _In_ WPARAM, _In_ LPARAM)

Referenced by ImeWnd_OnImeSystem().

◆ ImmAssociateContext()

HIMC WINAPI ImmAssociateContext ( _In_ HWND  hWnd,
_In_opt_ HIMC  hIMC 
)

Definition at line 500 of file imm.c.

503{
504 PWND pWnd;
505 HWND hwndFocus;
506 DWORD dwValue;
507 HIMC hOldIMC;
508
509 TRACE("(%p, %p)\n", hWnd, hIMC);
510
511 if (!IS_IMM_MODE())
512 {
513 TRACE("\n");
514 return NULL;
515 }
516
517 pWnd = ValidateHwnd(hWnd);
518 if (IS_NULL_UNEXPECTEDLY(pWnd))
519 return NULL;
520
521 if (hIMC && IS_CROSS_THREAD_HIMC(hIMC))
522 return NULL;
523
524 hOldIMC = pWnd->hImc;
525 if (hOldIMC == hIMC)
526 return hIMC;
527
528 dwValue = NtUserAssociateInputContext(hWnd, hIMC, 0);
529 switch (dwValue)
530 {
531 case 0:
532 return hOldIMC;
533
534 case 1:
536 if (hwndFocus == hWnd)
537 {
538 ImmSetActiveContext(hWnd, hOldIMC, FALSE);
540 }
541 return hOldIMC;
542
543 default:
544 return NULL;
545 }
546}
HWND hWnd
Definition: settings.c:17
DWORD HIMC
Definition: dimm.idl:75
HANDLE HWND
Definition: compat.h:19
BOOL WINAPI ImmSetActiveContext(_In_ HWND hWnd, _In_opt_ HIMC hIMC, _In_ BOOL fActive)
Definition: imm.c:1155
#define QUERY_WINDOW_FOCUS
Definition: ntuser.h:2846
DWORD NTAPI NtUserAssociateInputContext(_In_ HWND hWnd, _In_opt_ HIMC hIMC, _In_ DWORD dwFlags)
Definition: ime.c:1779
DWORD_PTR NTAPI NtUserQueryWindow(HWND hWnd, DWORD Index)
Definition: window.c:4207
Definition: ntuser.h:694
HIMC hImc
Definition: ntuser.h:740
#define ValidateHwnd(hwnd)
Definition: precomp.h:101
#define IS_CROSS_THREAD_HIMC(hIMC)
Definition: precomp.h:72

Referenced by ActiveIMMApp_AssociateContext(), Test1(), test_ImmThreads(), and test_InvalidIMC().

◆ ImmAssociateContextEx()

BOOL WINAPI ImmAssociateContextEx ( _In_ HWND  hWnd,
_In_opt_ HIMC  hIMC,
_In_ DWORD  dwFlags 
)

Definition at line 552 of file imm.c.

556{
557 HWND hwndFocus;
559 HIMC hOldIMC = NULL;
560 DWORD dwValue;
561
562 TRACE("(%p, %p, 0x%lX)\n", hWnd, hIMC, dwFlags);
563
564 if (!IS_IMM_MODE())
565 {
566 TRACE("\n");
567 return FALSE;
568 }
569
570 if (hIMC && !(dwFlags & IACE_DEFAULT) && IS_CROSS_THREAD_HIMC(hIMC))
571 return FALSE;
572
574 pFocusWnd = ValidateHwnd(hwndFocus);
575 if (pFocusWnd)
576 hOldIMC = pFocusWnd->hImc;
577
578 dwValue = NtUserAssociateInputContext(hWnd, hIMC, dwFlags);
579 switch (dwValue)
580 {
581 case 0:
582 return TRUE;
583
584 case 1:
585 pFocusWnd = ValidateHwnd(hwndFocus);
586 if (pFocusWnd)
587 {
588 hIMC = pFocusWnd->hImc;
589 if (hIMC != hOldIMC)
590 {
591 ImmSetActiveContext(hwndFocus, hOldIMC, FALSE);
592 ImmSetActiveContext(hwndFocus, hIMC, TRUE);
593 }
594 }
595 return TRUE;
596
597 default:
598 return FALSE;
599 }
600}
HWND pFocusWnd
Definition: magnifier.c:66
_In_ PCCERT_CONTEXT _In_ DWORD dwFlags
Definition: wincrypt.h:1176

Referenced by ActiveIMMApp_AssociateContextEx().

◆ ImmCreateContext()

HIMC WINAPI ImmCreateContext ( VOID  )

Definition at line 606 of file imm.c.

607{
608 PCLIENTIMC pClientImc;
609 HIMC hIMC;
610
611 TRACE("()\n");
612
613 if (!IS_IMM_MODE())
614 {
615 TRACE("\n");
616 return NULL;
617 }
618
619 pClientImc = ImmLocalAlloc(HEAP_ZERO_MEMORY, sizeof(CLIENTIMC));
620 if (IS_NULL_UNEXPECTEDLY(pClientImc))
621 return NULL;
622
623 hIMC = NtUserCreateInputContext((ULONG_PTR)pClientImc);
624 if (IS_NULL_UNEXPECTEDLY(hIMC))
625 {
626 ImmLocalFree(pClientImc);
627 return NULL;
628 }
629
630 RtlInitializeCriticalSection(&pClientImc->cs);
631
633
634 return hIMC;
635}
#define HEAP_ZERO_MEMORY
Definition: compat.h:134
@ THREADSTATE_IMECOMPATFLAGS
Definition: ntuser.h:2498
HIMC NTAPI NtUserCreateInputContext(_In_ ULONG_PTR dwClientImcData)
Definition: ime.c:1683
DWORD_PTR NTAPI NtUserGetThreadState(DWORD Routine)
Definition: misc.c:240
NTSYSAPI NTSTATUS NTAPI RtlInitializeCriticalSection(_In_ PRTL_CRITICAL_SECTION CriticalSection)
DWORD dwCompatFlags
Definition: imm32_undoc.h:150
uint32_t ULONG_PTR
Definition: typedefs.h:65
LPVOID ImmLocalAlloc(_In_ DWORD dwFlags, _In_ DWORD dwBytes)
Definition: utils.c:275

Referenced by ActiveIMMApp_CreateContext(), AnotherThreadFunc(), ImmGetContextThreadFunc(), OnInitDialog(), Test1(), test_ImmAssociateContextEx(), test_ImmDefaultHwnd(), test_ImmDestroyContext(), test_ImmGetIMCLockCount(), test_ImmNotifyIME(), and test_InvalidIMC().

◆ ImmDestroyContext()

BOOL WINAPI ImmDestroyContext ( _In_ HIMC  hIMC)

Definition at line 931 of file imm.c.

932{
933 HKL hKL;
934
935 TRACE("(%p)\n", hIMC);
936
937 if (!IS_IMM_MODE())
938 {
939 TRACE("\n");
940 return FALSE;
941 }
942
943 if (IS_CROSS_THREAD_HIMC(hIMC))
944 return FALSE;
945
946 hKL = GetKeyboardLayout(0);
947 return Imm32DestroyInputContext(hIMC, hKL, FALSE);
948}
static BOOL Imm32DestroyInputContext(HIMC hIMC, HKL hKL, BOOL bKeep)
Definition: imm.c:660

Referenced by ActiveIMMApp_DestroyContext(), AnotherThreadFunc(), OnInitDialog(), Test1(), test_ImmDefaultHwnd(), test_ImmDestroyContext(), test_ImmGetIMCLockCount(), test_ImmNotifyIME(), test_ImmThreads(), and test_InvalidIMC().

◆ ImmDllInitialize()

BOOL WINAPI ImmDllInitialize ( _In_ HINSTANCE  hDll,
_In_ ULONG  dwReason,
_In_opt_ PVOID  pReserved 
)

Definition at line 1330 of file imm.c.

1334{
1335 HKL hKL;
1336 HIMC hIMC;
1337
1338 TRACE("(%p, 0x%X, %p)\n", hDll, dwReason, pReserved);
1339
1340 switch (dwReason)
1341 {
1342 case DLL_PROCESS_ATTACH:
1343 if (!ImmInitializeGlobals(hDll))
1344 {
1345 ERR("ImmInitializeGlobals failed\n");
1346 return FALSE;
1347 }
1349 {
1350 ERR("User32InitializeImmEntryTable failed\n");
1351 return FALSE;
1352 }
1353#ifndef NDEBUG
1354 Imm32UnitTest();
1355#endif
1356 break;
1357
1358 case DLL_THREAD_ATTACH:
1359 break;
1360
1361 case DLL_THREAD_DETACH:
1362 if (!IS_IMM_MODE() || NtCurrentTeb()->Win32ThreadInfo == NULL)
1363 return TRUE;
1364
1365 hKL = GetKeyboardLayout(0);
1367 Imm32DestroyInputContext(hIMC, hKL, TRUE);
1368 break;
1369
1370 case DLL_PROCESS_DETACH:
1372 TRACE("imm32.dll is unloaded\n");
1373 break;
1374 }
1375
1376 return TRUE;
1377}
DWORD dwReason
Definition: misc.cpp:135
#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 DLL_THREAD_ATTACH
Definition: compat.h:132
RTL_CRITICAL_SECTION gcsImeDpi
Definition: ime.c:16
VOID Imm32UnitTest(VOID)
Definition: imm.c:1308
static BOOL ImmInitializeGlobals(HMODULE hMod)
Definition: imm.c:23
@ THREADSTATE_DEFAULTINPUTCONTEXT
Definition: ntuser.h:2489
#define NtCurrentTeb
NTSYSAPI NTSTATUS NTAPI RtlDeleteCriticalSection(_In_ PRTL_CRITICAL_SECTION CriticalSection)
BOOL WINAPI User32InitializeImmEntryTable(_In_ DWORD)
#define IMM_INIT_MAGIC
Definition: precomp.h:75

◆ ImmEnumInputContext()

BOOL WINAPI ImmEnumInputContext ( _In_ DWORD  dwThreadId,
_In_ IMCENUMPROC  lpfn,
_In_ LPARAM  lParam 
)

Definition at line 1123 of file imm.c.

1127{
1128 HIMC *phList;
1129 DWORD dwIndex, dwCount;
1130 BOOL ret = TRUE;
1131 HIMC hIMC;
1132
1133 TRACE("(%lu, %p, %p)\n", dwThreadId, lpfn, lParam);
1134
1135 dwCount = Imm32BuildHimcList(dwThreadId, &phList);
1136 if (IS_ZERO_UNEXPECTEDLY(dwCount))
1137 return FALSE;
1138
1139 for (dwIndex = 0; dwIndex < dwCount; ++dwIndex)
1140 {
1141 hIMC = phList[dwIndex];
1142 ret = (*lpfn)(hIMC, lParam);
1143 if (!ret)
1144 break;
1145 }
1146
1147 ImmLocalFree(phList);
1148 return ret;
1149}
return ret
Definition: mutex.c:146
DWORD Imm32BuildHimcList(DWORD dwThreadId, HIMC **pphList)
Definition: utils.c:338
#define IS_ZERO_UNEXPECTEDLY(p)
Definition: precomp.h:67

Referenced by CicBridge::ActivateIMMX(), AnotherThreadFunc(), CtfAImmActivate(), CicBridge::DeactivateIMMX(), ImeWnd_OnImeSystem(), Imm32SendNotification(), ImmActivateLayout(), and OnInitDialog().

◆ ImmFreeLayout()

BOOL WINAPI ImmFreeLayout ( _In_ HKL  hKL)

Definition at line 124 of file imm.c.

125{
126 WCHAR szKBD[KL_NAMELENGTH];
127 UINT iKL, cKLs;
128 HKL hOldKL, *pList;
129 PIMEDPI pImeDpi;
131
132 TRACE("(%p)\n", hKL);
133
134 hOldKL = GetKeyboardLayout(0);
135
136 if (hKL == HKL_SWITCH_TO_NON_IME)
137 {
138 if (!IS_IME_HKL(hOldKL))
139 return TRUE;
140
142
143 cKLs = GetKeyboardLayoutList(0, NULL);
144 if (cKLs)
145 {
146 pList = ImmLocalAlloc(0, cKLs * sizeof(HKL));
148 return FALSE;
149
150 cKLs = GetKeyboardLayoutList(cKLs, pList);
151 for (iKL = 0; iKL < cKLs; ++iKL)
152 {
153 if (!IS_IME_HKL(pList[iKL]))
154 {
155 LangID = LOWORD(pList[iKL]);
156 break;
157 }
158 }
159
161 }
162
163 StringCchPrintfW(szKBD, _countof(szKBD), L"%08X", LangID);
165 {
166 WARN("Default to English US\n");
167 LoadKeyboardLayoutW(L"00000409", KLF_ACTIVATE | 0x200);
168 }
169 }
170 else if (hKL == HKL_RELEASE_IME)
171 {
173Retry:
174 for (pImeDpi = gpImeDpiList; pImeDpi; pImeDpi = pImeDpi->pNext)
175 {
176 if (Imm32ReleaseIME(pImeDpi->hKL))
177 goto Retry;
178 }
180 }
181 else
182 {
183 if (IS_IME_HKL(hKL) && hKL != hOldKL)
184 Imm32ReleaseIME(hKL);
185 }
186
187 return TRUE;
188}
#define WARN(fmt,...)
Definition: precomp.h:61
_In_ PSCSI_REQUEST_BLOCK _Out_ NTSTATUS _Inout_ BOOLEAN * Retry
Definition: classpnp.h:312
LCID WINAPI GetSystemDefaultLCID(void)
Definition: locale.c:1235
FxChildList * pList
PIMEDPI gpImeDpiList
Definition: ime.c:17
BOOL Imm32ReleaseIME(_In_ HKL hKL)
Definition: ime.c:378
#define HKL_SWITCH_TO_NON_IME
Definition: imm32_undoc.h:29
#define HKL_RELEASE_IME
Definition: imm32_undoc.h:30
#define LANGIDFROMLCID(l)
Definition: nls.h:18
STRSAFEAPI StringCchPrintfW(STRSAFE_LPWSTR pszDest, size_t cchDest, STRSAFE_LPCWSTR pszFormat,...)
Definition: strsafe.h:530
HKL hKL
Definition: imm32_undoc.h:93
struct IMEDPI * pNext
Definition: imm32_undoc.h:91
#define KL_NAMELENGTH
Definition: winuser.h:122
#define KLF_ACTIVATE
Definition: winuser.h:111
HKL WINAPI LoadKeyboardLayoutW(_In_ LPCWSTR, _In_ UINT)
UINT WINAPI GetKeyboardLayoutList(_In_ int nBuff, _Out_writes_to_opt_(nBuff, return) HKL FAR *lpList)

Referenced by ImeWnd_OnImeSystem().

◆ ImmGetContext()

◆ ImmGetSaveContext()

static HIMC ImmGetSaveContext ( _In_opt_ HWND  hWnd,
_In_ DWORD  dwContextFlags 
)
static

Definition at line 1021 of file imm.c.

1024{
1025 HIMC hIMC;
1026 PCLIENTIMC pClientImc;
1027 PWND pWnd;
1028
1029 if (!IS_IMM_MODE())
1030 {
1031 TRACE("Not IMM mode.\n");
1032 return NULL;
1033 }
1034
1035 if (!hWnd)
1036 {
1038 goto Quit;
1039 }
1040
1041 pWnd = ValidateHwnd(hWnd);
1043 return NULL;
1044
1045 hIMC = pWnd->hImc;
1046 if (!hIMC && (dwContextFlags & 1))
1048
1049Quit:
1050 pClientImc = ImmLockClientImc(hIMC);
1051 if (IS_NULL_UNEXPECTEDLY(pClientImc))
1052 return NULL;
1053
1054 if ((dwContextFlags & 2) && (pClientImc->dwFlags & CLIENTIMC_DISABLEIME))
1055 hIMC = NULL;
1056
1057 ImmUnlockClientImc(pClientImc);
1058 return hIMC;
1059}
#define CLIENTIMC_DISABLEIME
Definition: imm32_undoc.h:173
#define QUERY_WINDOW_DEFAULT_ICONTEXT
Definition: ntuser.h:2851
#define IS_CROSS_PROCESS_HWND(hWnd)
Definition: precomp.h:73

Referenced by ImmGetContext(), ImmSetActiveContext(), and ImmWINNLSGetEnableStatus().

◆ ImmInitializeGlobals()

static BOOL ImmInitializeGlobals ( HMODULE  hMod)
static

Definition at line 23 of file imm.c.

24{
27
28 if (hMod)
29 ghImm32Inst = hMod;
30
32 return TRUE;
33
35 if (NT_ERROR(status))
36 {
37 ERR("\n");
38 return FALSE;
39 }
40
41 status = NtQuerySystemInformation(SystemBasicInformation, &SysInfo, sizeof(SysInfo), NULL);
42 if (NT_ERROR(status))
43 {
44 ERR("\n");
45 return FALSE;
46 }
48
50 return TRUE;
51}
LONG NTSTATUS
Definition: precomp.h:26
@ SystemBasicInformation
Definition: ntddk_ex.h:11
HMODULE ghImm32Inst
Definition: imm.c:17
BYTE gfImmInitialized
Definition: imm.c:20
ULONG_PTR gHighestUserAddress
Definition: imm.c:21
NTSYSAPI NTSTATUS NTAPI NtQuerySystemInformation(IN SYSTEM_INFORMATION_CLASS SystemInfoClass, OUT PVOID SystemInfoBuffer, IN ULONG SystemInfoBufferSize, OUT PULONG BytesReturned OPTIONAL)
Definition: ps.c:97
#define NT_ERROR(Status)
Definition: umtypes.h:106

Referenced by ImmDllInitialize(), and ImmRegisterClient().

◆ ImmLoadLayout()

BOOL WINAPI ImmLoadLayout ( _In_ HKL  hKL,
_Inout_ PIMEINFOEX  pImeInfoEx 
)

Definition at line 71 of file imm.c.

74{
75 DWORD cbData, dwType;
76 HKEY hKey;
78 WCHAR szLayout[MAX_PATH];
79 LPCWSTR pszSubKey;
80
81 TRACE("(%p, %p)\n", hKL, pImeInfoEx);
82
83 /* Choose a key */
84 if (IS_IME_HKL(hKL) || !IS_CICERO_MODE() || IS_16BIT_MODE()) /* Non-Cicero? */
85 {
86 StringCchPrintfW(szLayout, _countof(szLayout), L"%s\\%08lX",
88 pszSubKey = szLayout;
89 }
90 else /* Cicero */
91 {
92 pszSubKey = L"Software\\Microsoft\\Windows NT\\CurrentVersion\\IMM";
93 }
94
95 /* Open the key */
98 return FALSE;
99
100 /* Load "IME File" value */
101 cbData = sizeof(pImeInfoEx->wszImeFile);
102 error = RegQueryValueExW(hKey, L"IME File", NULL, &dwType,
103 (LPBYTE)pImeInfoEx->wszImeFile, &cbData);
104
105 /* Avoid buffer overrun */
106 pImeInfoEx->wszImeFile[_countof(pImeInfoEx->wszImeFile) - 1] = UNICODE_NULL;
107
109
110 if (error != ERROR_SUCCESS || dwType != REG_SZ)
111 return FALSE; /* Failed */
112
113 pImeInfoEx->hkl = hKL;
114 pImeInfoEx->fLoadFlag = 0;
115 return Imm32LoadImeVerInfo(pImeInfoEx);
116}
#define HandleToUlong(h)
Definition: basetsd.h:79
#define RegCloseKey(hKey)
Definition: registry.h:49
#define ERROR_SUCCESS
Definition: deptool.c:10
static LSTATUS(WINAPI *pRegDeleteTreeW)(HKEY
LONG WINAPI RegOpenKeyExW(HKEY hKey, LPCWSTR lpSubKey, DWORD ulOptions, REGSAM samDesired, PHKEY phkResult)
Definition: reg.c:3333
LONG WINAPI RegQueryValueExW(_In_ HKEY hkeyorg, _In_ LPCWSTR name, _In_ LPDWORD reserved, _In_ LPDWORD type, _In_ LPBYTE data, _In_ LPDWORD count)
Definition: reg.c:4103
#define MAX_PATH
Definition: compat.h:34
FxAutoRegKey hKey
#define REG_SZ
Definition: layer.c:22
#define error(str)
Definition: mkdosfs.c:1605
#define KEY_READ
Definition: nt_native.h:1023
unsigned char * LPBYTE
Definition: typedefs.h:53
BOOL Imm32LoadImeVerInfo(_Inout_ PIMEINFOEX pImeInfoEx)
Definition: install.c:418
#define REGKEY_KEYBOARD_LAYOUTS
Definition: precomp.h:85
#define IS_ERROR_UNEXPECTEDLY(x)
Definition: precomp.h:69
#define HKEY_LOCAL_MACHINE
Definition: winreg.h:12
const WCHAR * LPCWSTR
Definition: xmlstorage.h:185

Referenced by Imm32LoadCtfIme(), and User32CallImmLoadLayoutFromKernel().

◆ ImmLockClientImc()

PCLIENTIMC WINAPI ImmLockClientImc ( _In_ HIMC  hImc)

Definition at line 954 of file imm.c.

955{
956 PIMC pIMC;
957 PCLIENTIMC pClientImc;
958
959 TRACE("(%p)\n", hImc);
960
961 if (IS_NULL_UNEXPECTEDLY(hImc))
962 return NULL;
963
964 pIMC = ValidateHandle(hImc, TYPE_INPUTCONTEXT);
965 if (!pIMC || !Imm32CheckImcProcess(pIMC))
966 return NULL;
967
968 pClientImc = (PCLIENTIMC)pIMC->dwClientImcData;
969 if (pClientImc)
970 {
971 if (pClientImc->dwFlags & CLIENTIMC_DESTROY)
972 return NULL;
973 goto Finish;
974 }
975
976 pClientImc = ImmLocalAlloc(HEAP_ZERO_MEMORY, sizeof(CLIENTIMC));
977 if (IS_NULL_UNEXPECTEDLY(pClientImc))
978 return NULL;
979
980 RtlInitializeCriticalSection(&pClientImc->cs);
982
984 {
985 ERR("\n");
986 ImmLocalFree(pClientImc);
987 return NULL;
988 }
989
990 pClientImc->dwFlags |= CLIENTIMC_UNKNOWN2;
991
992Finish:
993 InterlockedIncrement(&pClientImc->cLockObj);
994 return pClientImc;
995}
BOOL NTAPI NtUserUpdateInputContext(HIMC hIMC, DWORD dwType, DWORD_PTR dwValue)
Definition: ime.c:1846
uint32_t DWORD_PTR
Definition: typedefs.h:65
@ UIC_CLIENTIMCDATA
Definition: undocuser.h:314
BOOL Imm32CheckImcProcess(PIMC pIMC)
Definition: utils.c:252

Referenced by CtfImmGenerateMessage(), CtfImmTIMCreateInputContext(), Imm32InternalLockIMC(), Imm32IsImcAnsi(), Imm32ProcessRequest(), Imm32SelectInputContext(), ImmGenerateMessage(), ImmGetAppCompatFlags(), ImmGetCandidateListAW(), ImmGetCandidateListCountAW(), ImmGetCompositionFontA(), ImmGetCompositionFontW(), ImmGetCompositionStringA(), ImmGetCompositionStringW(), ImmGetGuideLineAW(), ImmGetIMCLockCount(), ImmGetSaveContext(), ImmPostMessages(), ImmSetActiveContext(), ImmSetCompositionFontA(), ImmSetCompositionFontW(), ImmUnlockIMC(), and ImmWINNLSEnableIME().

◆ ImmLockIMC()

◆ ImmRegisterClient()

BOOL WINAPI ImmRegisterClient ( _Inout_ PSHAREDINFO  ptr,
_In_ HINSTANCE  hMod 
)

Definition at line 58 of file imm.c.

61{
64 return ImmInitializeGlobals(hMod);
65}
SHAREDINFO gSharedInfo
Definition: imm.c:19
PSERVERINFO gpsi
Definition: imm.c:18
static PVOID ptr
Definition: dispmode.c:27
PSERVERINFO psi
Definition: ntuser.h:1130

Referenced by DllMain(), and User32InitializeImmEntryTable().

◆ ImmReleaseContext()

◆ ImmSetActiveContext()

BOOL WINAPI ImmSetActiveContext ( _In_ HWND  hWnd,
_In_opt_ HIMC  hIMC,
_In_ BOOL  fActive 
)

Definition at line 1155 of file imm.c.

1159{
1160 PCLIENTIMC pClientImc;
1161 LPINPUTCONTEXTDX pIC;
1162 PIMEDPI pImeDpi;
1163 HIMC hOldIMC;
1164 HKL hKL;
1165 BOOL fOpen = FALSE;
1166 DWORD dwConversion = 0, dwShowFlags = ISC_SHOWUIALL;
1167 HWND hwndDefIME;
1168
1169 TRACE("(%p, %p, %d)\n", hWnd, hIMC, fActive);
1170
1171 if (!IS_IMM_MODE())
1172 {
1173 TRACE("\n");
1174 return FALSE;
1175 }
1176
1177 pClientImc = ImmLockClientImc(hIMC);
1178
1179 if (!fActive)
1180 {
1181 if (pClientImc)
1182 pClientImc->dwFlags &= ~CLIENTIMC_ACTIVE;
1183 }
1184 else if (hIMC)
1185 {
1186 if (IS_NULL_UNEXPECTEDLY(pClientImc))
1187 return FALSE;
1188
1189 pIC = (LPINPUTCONTEXTDX)ImmLockIMC(hIMC);
1190 if (IS_NULL_UNEXPECTEDLY(pIC))
1191 {
1192 ImmUnlockClientImc(pClientImc);
1193 return FALSE;
1194 }
1195
1196 pIC->hWnd = hWnd;
1197 pClientImc->dwFlags |= CLIENTIMC_ACTIVE;
1198
1199 if (pIC->dwUIFlags & 2)
1201
1202 fOpen = pIC->fOpen;
1203 dwConversion = pIC->fdwConversion;
1204
1205 ImmUnlockIMC(hIMC);
1206 }
1207 else
1208 {
1209 hOldIMC = ImmGetSaveContext(hWnd, 1);
1210 pIC = (LPINPUTCONTEXTDX)ImmLockIMC(hOldIMC);
1211 if (pIC)
1212 {
1213 pIC->hWnd = hWnd;
1214 ImmUnlockIMC(hOldIMC);
1215 }
1216 }
1217
1218 hKL = GetKeyboardLayout(0);
1219 if (IS_CICERO_MODE() && !IS_16BIT_MODE())
1220 {
1221 CtfImeSetActiveContextAlways(hIMC, fActive, hWnd, hKL);
1222 hKL = GetKeyboardLayout(0);
1223 }
1224
1225 pImeDpi = ImmLockImeDpi(hKL);
1226 if (pImeDpi)
1227 {
1228 if (IS_IME_HKL(hKL))
1229 pImeDpi->ImeSetActiveContext(hIMC, fActive);
1230 ImmUnlockImeDpi(pImeDpi);
1231 }
1232
1233 if (IsWindow(hWnd))
1234 {
1235 SendMessageW(hWnd, WM_IME_SETCONTEXT, fActive, dwShowFlags);
1236 if (fActive)
1237 NtUserNotifyIMEStatus(hWnd, fOpen, dwConversion);
1238 }
1239 else if (!fActive)
1240 {
1241 hwndDefIME = ImmGetDefaultIMEWnd(NULL);
1242 if (hwndDefIME)
1243 SendMessageW(hwndDefIME, WM_IME_SETCONTEXT, 0, dwShowFlags);
1244 }
1245
1246 if (pClientImc)
1247 ImmUnlockClientImc(pClientImc);
1248
1249 return TRUE;
1250}
#define CLIENTIMC_ACTIVE
Definition: imm32_undoc.h:170
#define ISC_SHOWUIGUIDELINE
Definition: imm.h:173
#define ISC_SHOWUIALLCANDIDATEWINDOW
Definition: imm.h:174
#define ISC_SHOWUIALL
Definition: imm.h:175
DWORD NTAPI NtUserNotifyIMEStatus(_In_ HWND hwnd, _In_ BOOL fOpen, _In_ DWORD dwConversion)
Definition: ime.c:848
EXTERN_C HRESULT WINAPI CtfImeSetActiveContextAlways(_In_ HIMC hIMC, _In_ BOOL fActive, _In_ HWND hWnd, _In_ HKL hKL)
Definition: msctfime.cpp:775
#define WM_IME_SETCONTEXT
Definition: winuser.h:1848

Referenced by ImmAssociateContext(), ImmAssociateContextEx(), ImmSetActiveContextConsoleIME(), ImmWINNLSEnableIME(), and User32SetImeActivenessOfWindow().

◆ ImmSetActiveContextConsoleIME()

BOOL WINAPI ImmSetActiveContextConsoleIME ( _In_ HWND  hwnd,
_In_ BOOL  fFlag 
)

Definition at line 1271 of file imm.c.

1274{
1275 HIMC hIMC;
1276 TRACE("(%p, %d)\n", hwnd, fFlag);
1277
1278 hIMC = ImmGetContext(hwnd);
1279 if (IS_NULL_UNEXPECTEDLY(hIMC))
1280 return FALSE;
1281 return ImmSetActiveContext(hwnd, hIMC, fFlag);
1282}
HIMC WINAPI ImmGetContext(_In_ HWND hWnd)
Definition: imm.c:1065
_In_ LONG _In_ HWND hwnd
Definition: winddi.h:4023

◆ ImmUnlockClientImc()

VOID WINAPI ImmUnlockClientImc ( _Inout_ PCLIENTIMC  pClientImc)

Definition at line 1001 of file imm.c.

1002{
1003 LONG cLocks;
1004 HANDLE hInputContext;
1005
1006 TRACE("(%p)\n", pClientImc);
1007
1008 cLocks = InterlockedDecrement(&pClientImc->cLockObj);
1009 if (cLocks != 0 || !(pClientImc->dwFlags & CLIENTIMC_DESTROY))
1010 return;
1011
1012 hInputContext = pClientImc->hInputContext;
1013 if (hInputContext)
1014 LocalFree(hInputContext);
1015
1016 RtlDeleteCriticalSection(&pClientImc->cs);
1017 ImmLocalFree(pClientImc);
1018}
#define InterlockedDecrement
Definition: armddk.h:52
static LONG cLocks
Definition: compobj.c:119
long LONG
Definition: pedump.c:60

Referenced by CtfImmGenerateMessage(), CtfImmTIMCreateInputContext(), Imm32DestroyInputContext(), Imm32InternalLockIMC(), Imm32IsImcAnsi(), Imm32ProcessRequest(), Imm32SelectInputContext(), ImmGenerateMessage(), ImmGetAppCompatFlags(), ImmGetCandidateListAW(), ImmGetCandidateListCountAW(), ImmGetCompositionFontA(), ImmGetCompositionFontW(), ImmGetCompositionStringA(), ImmGetCompositionStringW(), ImmGetGuideLineAW(), ImmGetIMCLockCount(), ImmGetSaveContext(), ImmPostMessages(), ImmSetActiveContext(), ImmSetCompositionFontA(), ImmSetCompositionFontW(), ImmUnlockIMC(), ImmWINNLSEnableIME(), and START_TEST().

◆ ImmUnlockIMC()

BOOL WINAPI ImmUnlockIMC ( _In_ HIMC  hIMC)

Definition at line 1089 of file imm.c.

1090{
1091 PCLIENTIMC pClientImc;
1092
1093 pClientImc = ImmLockClientImc(hIMC);
1094 if (IS_NULL_UNEXPECTEDLY(pClientImc))
1095 return FALSE;
1096
1097 if (pClientImc->hInputContext)
1098 LocalUnlock(pClientImc->hInputContext);
1099
1100 InterlockedDecrement(&pClientImc->cLockObj);
1101 ImmUnlockClientImc(pClientImc);
1102 return TRUE;
1103}

Referenced by C1_OnButtonUp(), CtfImmGenerateMessage(), EDIT_WindowProc(), editor_handle_message(), ImeWnd_OnImeNotify(), ImeWnd_OnImeSetContext(), ImeWnd_OnImeSystem(), Imm32CImeNonImeToggle(), Imm32CShapeToggle(), Imm32CSymbolToggle(), Imm32DestroyInputContext(), Imm32JCloseOpen(), Imm32KEnglish(), Imm32KHanjaConvert(), Imm32KShapeToggle(), Imm32OpenICAndCS(), Imm32SelectInputContext(), Imm32SendNotificationProc(), ImmGenerateMessage(), ImmGetCandidateListAW(), ImmGetCandidateListCountAW(), ImmGetCandidateWindow(), ImmGetCompositionFontA(), ImmGetCompositionFontW(), ImmGetCompositionStringA(), ImmGetCompositionStringW(), ImmGetCompositionWindow(), ImmGetConversionStatus(), ImmGetGuideLineAW(), ImmGetImeMenuItemsAW(), ImmGetOpenStatus(), ImmGetStatusWindowPos(), ImmGetVirtualKey(), ImmProcessKey(), ImmRequestMessageAW(), ImmSetActiveContext(), ImmSetCandidateWindow(), ImmSetCompositionFontA(), ImmSetCompositionFontW(), ImmSetCompositionStringAW(), ImmSetCompositionWindow(), ImmSetConversionStatus(), ImmSetOpenStatus(), ImmSetStatusWindowPos(), ImmTranslateMessage(), T1_OnButtonUp(), T1_OnImeControl(), Test1(), test_ImmDestroyContext(), test_ImmGetIMCLockCount(), test_ImmMessages(), and test_InvalidIMC().

◆ ImmWINNLSGetEnableStatus()

BOOL WINAPI ImmWINNLSGetEnableStatus ( _In_opt_ HWND  hWnd)

Definition at line 1256 of file imm.c.

1257{
1259 {
1261 return FALSE;
1262 }
1263
1264 return !!ImmGetSaveContext(hWnd, 2);
1265}
#define ERROR_CALL_NOT_IMPLEMENTED
Definition: compat.h:102
#define SetLastError(x)
Definition: compat.h:752
BOOL Imm32IsSystemJapaneseOrKorean(VOID)
Definition: utils.c:72

Referenced by WINNLSGetEnableStatus().

◆ WINE_DEFAULT_DEBUG_CHANNEL()

WINE_DEFAULT_DEBUG_CHANNEL ( imm  )

Variable Documentation

◆ gfImmInitialized

BYTE gfImmInitialized = FALSE

Definition at line 20 of file imm.c.

Referenced by ImmInitializeGlobals().

◆ gHighestUserAddress

ULONG_PTR gHighestUserAddress = 0

Definition at line 21 of file imm.c.

Referenced by ImmInitializeGlobals().

◆ ghImm32Inst

◆ gpsi

PSERVERINFO gpsi = NULL

Definition at line 18 of file imm.c.

Referenced by alloc_user_entry(), CharPrevA(), co_IntCreateDefaultImeWindow(), co_IntInitializeDesktopGraphics(), co_IntSendActivateMessages(), co_IntSendMessageTimeout(), co_IntSetCaretPos(), co_IntSetupOBM(), co_IntSetWndIcons(), co_IntShellHookNotify(), co_MsqInsertMouseMessage(), co_MsqSendMessage(), co_UserCreateWindowEx(), co_UserDestroyWindow(), co_UserShowCaret(), co_WinPosSetWindowPos(), CreateSysColorObjects(), CtfImmSetLangBand(), DefWndControlColor(), DefWndGetIcon(), DefWndHandleSetCursor(), DefWndSetIcon(), DrawFocusRect(), EnumerateCallback(), free_user_entry(), GetLastInputInfo(), GetSysColor(), GetSysColorBrush(), GetSystemMetrics(), ImmCallImeConsoleIME(), ImmRegisterClient(), InitMetrics(), InitUserAtoms(), IntCheckImeShowStatus(), IntCoalesceMouseMove(), IntCreateClass(), IntCreateDesktop(), IntCreateWindow(), IntDeactivateWindow(), IntDefWindowProc(), IntDrawState(), IntFlashWindowEx(), IntGetSysColor(), IntGetSysColorBrush(), IntGetWindowContextHelpId(), IntGrayString(), IntImeWindowPosChanged(), IntIsFontRenderingEnabled(), IntIsGhostWindow(), IntLastInputTick(), IntNotifyWinEvent(), IntRealChildWindowFromPoint(), IntRemoveEvent(), IntSetCaretBlinkTime(), IntSetSrvEventMask(), IntSetSysColors(), IntTranslateKbdMessage(), IsDialogMessageW(), IsWinEventHookInstalled(), LoadSystemCursors(), LoadUserApiHook(), MENU_AdjustMenuItemRect(), MENU_CalcItemSize(), MENU_DrawMenuItem(), MENU_DrawScrollArrows(), MENU_EnsureMenuItemVisible(), MENU_InitPopup(), MouseSafetyOnDrawEnd(), NC_IconForWindow(), NotifyWinEvent(), NtUserCallHwnd(), NtUserCallHwndParam(), NtUserCallNoParam(), NtUserCallOneParam(), NtUserCreateCaret(), NtUserGetCaretBlinkTime(), NtUserGetClassName(), NtUserGetComboBoxInfo(), NtUserGetCursorInfo(), NtUserGetListBoxInfo(), NtUserInitializeClientPfnArrays(), NtUserMessageCall(), NtUserNotifyWinEvent(), NtUserProcessConnect(), NtUserSetImeOwnerWindow(), PostTimerMessages(), ProcessKeyEvent(), RealGetSystemMetrics(), RegisterControlAtoms(), SpiUpdatePerUserSystemParameters(), SystemTimerProc(), UITOOLS_DrawCheckedRect(), UpdatePerUserImmEnabling(), UserAttachThreadInput(), UserChangeDisplaySettings(), UserClipCursor(), UserDrawWindowFrame(), UserGetSystemMetrics(), UserInitialize(), UserPaintCaption(), UserPostMessage(), UserPostThreadMessage(), UserRegisterUserApiHook(), UserSendMouseInput(), UserSendNotifyMessage(), UserSetCursor(), UserSetCursorPos(), UserShowCursor(), UserUnregisterUserApiHook(), and UserUpdateMonitorSize().

◆ gSharedInfo

SHAREDINFO gSharedInfo = { NULL }