#include "precomp.h"

Include dependency graph for imm.c:

Classes
struct	SELECT_LAYOUT

Macros
#define	MAX_IMCC_SIZE 0x1000

Typedefs
typedef struct SELECT_LAYOUT	SELECT_LAYOUT

typedef struct SELECT_LAYOUT *	LPSELECT_LAYOUT

Functions
	WINE_DEFAULT_DEBUG_CHANNEL (imm)

static BOOL APIENTRY	Imm32InitInstance (HMODULE hMod)

BOOL WINAPI	ImmRegisterClient (PSHAREDINFO ptr, HINSTANCE hMod)

BOOL WINAPI	ImmLoadLayout (HKL hKL, PIMEINFOEX pImeInfoEx)

BOOL WINAPI	ImmFreeLayout (DWORD dwUnknown)

VOID APIENTRY	Imm32SelectLayout (HKL hNewKL, HKL hOldKL, HIMC hIMC)

static BOOL CALLBACK	Imm32SelectLayoutProc (HIMC hIMC, LPARAM lParam)

static BOOL CALLBACK	Imm32NotifyCompStrProc (HIMC hIMC, LPARAM lParam)

BOOL WINAPI	ImmActivateLayout (HKL hKL)

static VOID APIENTRY	Imm32CiceroSetActiveContext (HIMC hIMC, BOOL fActive, HWND hWnd, HKL hKL)

HIMC WINAPI	ImmAssociateContext (HWND hWnd, HIMC hIMC)

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

HIMC WINAPI	ImmCreateContext (void)

static VOID APIENTRY	Imm32FreeImeStates (LPINPUTCONTEXTDX pIC)

BOOL APIENTRY	Imm32CleanupContext (HIMC hIMC, HKL hKL, BOOL bKeep)

BOOL APIENTRY	Imm32InitContext (HIMC hIMC, LPINPUTCONTEXT pIC, PCLIENTIMC pClientImc, HKL hKL, BOOL fSelect)

LPINPUTCONTEXT APIENTRY	Imm32LockIMCEx (HIMC hIMC, BOOL fSelect)

BOOL WINAPI	ImmDestroyContext (HIMC hIMC)

PCLIENTIMC WINAPI	ImmLockClientImc (HIMC hImc)

VOID WINAPI	ImmUnlockClientImc (PCLIENTIMC pClientImc)

static HIMC APIENTRY	Imm32GetContextEx (HWND hWnd, DWORD dwContextFlags)

HIMC WINAPI	ImmGetContext (HWND hWnd)

BOOL WINAPI	CtfImmIsCiceroEnabled (VOID)

LPINPUTCONTEXT WINAPI	ImmLockIMC (HIMC hIMC)

BOOL WINAPI	ImmUnlockIMC (HIMC hIMC)

BOOL WINAPI	ImmReleaseContext (HWND hWnd, HIMC hIMC)

HWND WINAPI	ImmCreateSoftKeyboard (UINT uType, UINT hOwner, int x, int y)

BOOL WINAPI	ImmDestroySoftKeyboard (HWND hSoftWnd)

BOOL WINAPI	ImmShowSoftKeyboard (HWND hSoftWnd, int nCmdShow)

BOOL WINAPI	ImmDisableTextFrameService (DWORD dwThreadId)

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

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

BOOL WINAPI	ImmSetActiveContextConsoleIME (HWND hwnd, BOOL fFlag)

BOOL WINAPI	User32InitializeImmEntryTable (DWORD)

BOOL WINAPI	DllMain (HINSTANCE hinstDLL, DWORD fdwReason, LPVOID lpReserved)

Variables
HMODULE	g_hImm32Inst = NULL

PSERVERINFO	g_psi = NULL

SHAREDINFO	g_SharedInfo = { NULL }

BYTE	g_bClientRegd = FALSE

Macro Definition Documentation

◆ MAX_IMCC_SIZE

#define MAX_IMCC_SIZE 0x1000

Typedef Documentation

◆ LPSELECT_LAYOUT

typedef struct SELECT_LAYOUT * LPSELECT_LAYOUT

◆ SELECT_LAYOUT

typedef struct SELECT_LAYOUT SELECT_LAYOUT

Function Documentation

◆ CtfImmIsCiceroEnabled()

BOOL WINAPI CtfImmIsCiceroEnabled ( VOID )

Definition at line 1019 of file imm.c.

 {
     return Imm32IsCiceroMode();
 }

◆ DllMain()

BOOL WINAPI DllMain	(	HINSTANCE	hinstDLL,
		DWORD	fdwReason,
		LPVOID	lpReserved
	)

Definition at line 1243 of file imm.c.

 {
     HKL hKL;
     HIMC hIMC;
     PTEB pTeb;
 
     TRACE("(%p, 0x%X, %p)\n", hinstDLL, fdwReason, lpReserved);
 
     switch (fdwReason)
     {
         case DLL_PROCESS_ATTACH:
             if (!Imm32InitInstance(hinstDLL))
             {
                 ERR("Imm32InitInstance failed\n");
                 return FALSE;
             }
             if (!User32InitializeImmEntryTable(IMM_INIT_MAGIC))
             {
                 ERR("User32InitializeImmEntryTable failed\n");
                 return FALSE;
             }
             break;
 
         case DLL_THREAD_ATTACH:
             break;
 
         case DLL_THREAD_DETACH:
             if (!Imm32IsImmMode())
                 return TRUE;
 
             pTeb = NtCurrentTeb();
             if (pTeb->Win32ThreadInfo == NULL)
                 return TRUE;
 
             hKL = GetKeyboardLayout(0);
             // FIXME: NtUserGetThreadState and enum ThreadStateRoutines are broken.
             hIMC = (HIMC)NtUserGetThreadState(4);
             Imm32CleanupContext(hIMC, hKL, TRUE);
             break;
 
         case DLL_PROCESS_DETACH:
             RtlDeleteCriticalSection(&g_csImeDpi);
             TRACE("imm32.dll is unloaded\n");
             break;
     }
 
     return TRUE;
 }

◆ Imm32CiceroSetActiveContext()

static VOID APIENTRY Imm32CiceroSetActiveContext	(	HIMC	hIMC,
		BOOL	fActive,
		HWND	hWnd,
		HKL	hKL
	)

static

Definition at line 489 of file imm.c.

 {
     FIXME("We have to do something\n");
 }

Referenced by ImmSetActiveContext().

◆ Imm32CleanupContext()

BOOL APIENTRY Imm32CleanupContext	(	HIMC	hIMC,
		HKL	hKL,
		BOOL	bKeep
	)

Definition at line 634 of file imm.c.

 {
     PIMEDPI pImeDpi;
     LPINPUTCONTEXTDX pIC;
     PCLIENTIMC pClientImc;
     PIMC pIMC;
 
     if (!Imm32IsImmMode() || hIMC == NULL)
         return FALSE;
 
     pIMC = ValidateHandleNoErr(hIMC, TYPE_INPUTCONTEXT);
     if (!pIMC || pIMC->head.pti != NtCurrentTeb()->Win32ThreadInfo)
         return FALSE;
 
     pClientImc = (PCLIENTIMC)pIMC->dwClientImcData;
     if (!pClientImc)
         return FALSE;
 
     if (pClientImc->hInputContext == NULL)
     {
         pClientImc->dwFlags |= CLIENTIMC_UNKNOWN1;
         ImmUnlockClientImc(pClientImc);
         if (!bKeep)
             return NtUserDestroyInputContext(hIMC);
         return TRUE;
     }
 
     pIC = (LPINPUTCONTEXTDX)ImmLockIMC(hIMC);
     if (pIC == NULL)
     {
         ImmUnlockClientImc(pClientImc);
         return FALSE;
     }
 
     FIXME("We have do something to do here\n");
 
     if (pClientImc->hKL == hKL)
     {
         pImeDpi = ImmLockImeDpi(hKL);
         if (pImeDpi != NULL)
         {
             if (IS_IME_HKL(hKL))
             {
                 pImeDpi->ImeSelect(hIMC, FALSE);
             }
             else if (Imm32IsCiceroMode() && pImeDpi->CtfImeSelectEx)
             {
                 pImeDpi->CtfImeSelectEx(hIMC, FALSE, hKL);
             }
             ImmUnlockImeDpi(pImeDpi);
         }
         pClientImc->hKL = NULL;
     }
 
     pIC->hPrivate = ImmDestroyIMCC(pIC->hPrivate);
     pIC->hMsgBuf = ImmDestroyIMCC(pIC->hMsgBuf);
     pIC->hGuideLine = ImmDestroyIMCC(pIC->hGuideLine);
     pIC->hCandInfo = ImmDestroyIMCC(pIC->hCandInfo);
     pIC->hCompStr = ImmDestroyIMCC(pIC->hCompStr);
 
     Imm32FreeImeStates(pIC);
 
     ImmUnlockIMC(hIMC);
 
     pClientImc->dwFlags |= CLIENTIMC_UNKNOWN1;
     ImmUnlockClientImc(pClientImc);
 
     if (!bKeep)
         return NtUserDestroyInputContext(hIMC);
 
     return TRUE;
 }

Referenced by DllMain(), and ImmDestroyContext().

◆ Imm32FreeImeStates()

static VOID APIENTRY Imm32FreeImeStates ( LPINPUTCONTEXTDX pIC )

static

Definition at line 615 of file imm.c.

 {
     PIME_STATE pState, pStateNext;
     PIME_SUBSTATE pSubState, pSubStateNext;
 
     pState = pIC->pState;
     pIC->pState = NULL;
     for (; pState; pState = pStateNext)
     {
         pStateNext = pState->pNext;
         for (pSubState = pState->pSubState; pSubState; pSubState = pSubStateNext)
         {
             pSubStateNext = pSubState->pNext;
             Imm32HeapFree(pSubState);
         }
         Imm32HeapFree(pState);
     }
 }

Referenced by Imm32CleanupContext().

◆ Imm32GetContextEx()

static HIMC APIENTRY Imm32GetContextEx	(	HWND	hWnd,
		DWORD	dwContextFlags
	)

static

Definition at line 971 of file imm.c.

 {
     HIMC hIMC;
     PCLIENTIMC pClientImc;
     PWND pWnd;
 
     if (!Imm32IsImmMode())
         return NULL;
 
     if (!hWnd)
     {
         // FIXME: NtUserGetThreadState and enum ThreadStateRoutines are broken.
         hIMC = (HIMC)NtUserGetThreadState(4);
         goto Quit;
     }
 
     pWnd = ValidateHwndNoErr(hWnd);
     if (!pWnd || Imm32IsCrossProcessAccess(hWnd))
         return NULL;
 
     hIMC = pWnd->hImc;
     if (!hIMC && (dwContextFlags & 1))
         hIMC = (HIMC)NtUserQueryWindow(hWnd, QUERY_WINDOW_DEFAULT_ICONTEXT);
 
 Quit:
     pClientImc = ImmLockClientImc(hIMC);
     if (pClientImc == NULL)
         return NULL;
     if ((dwContextFlags & 2) && (pClientImc->dwFlags & CLIENTIMC_UNKNOWN3))
         hIMC = NULL;
     ImmUnlockClientImc(pClientImc);
     return hIMC;
 }

Referenced by ImmGetContext(), and ImmSetActiveContext().

◆ Imm32InitContext()

BOOL APIENTRY Imm32InitContext	(	HIMC	hIMC,
		LPINPUTCONTEXT	pIC,
		PCLIENTIMC	pClientImc,
		HKL	hKL,
		BOOL	fSelect
	)

Definition at line 708 of file imm.c.

 {
     DWORD dwIndex, cbPrivate;
     PIMEDPI pImeDpi = NULL;
     LPCOMPOSITIONSTRING pCS;
     LPCANDIDATEINFO pCI;
     LPGUIDELINE pGL;
     /* NOTE: Windows does recursive call ImmLockIMC here but we don't do so. */
 
     /* Create IC components */
     pIC->hCompStr = ImmCreateIMCC(sizeof(COMPOSITIONSTRING));
     pIC->hCandInfo = ImmCreateIMCC(sizeof(CANDIDATEINFO));
     pIC->hGuideLine = ImmCreateIMCC(sizeof(GUIDELINE));
     pIC->hMsgBuf = ImmCreateIMCC(sizeof(UINT));
     if (!pIC->hCompStr || !pIC->hCandInfo || !pIC->hGuideLine || !pIC->hMsgBuf)
         goto Fail;
 
     /* Initialize IC components */
     pCS = ImmLockIMCC(pIC->hCompStr);
     if (!pCS)
         goto Fail;
     pCS->dwSize = sizeof(COMPOSITIONSTRING);
     ImmUnlockIMCC(pIC->hCompStr);
 
     pCI = ImmLockIMCC(pIC->hCandInfo);
     if (!pCI)
         goto Fail;
     pCI->dwSize = sizeof(CANDIDATEINFO);
     ImmUnlockIMCC(pIC->hCandInfo);
 
     pGL = ImmLockIMCC(pIC->hGuideLine);
     if (!pGL)
         goto Fail;
     pGL->dwSize = sizeof(GUIDELINE);
     ImmUnlockIMCC(pIC->hGuideLine);
 
     pIC->dwNumMsgBuf = 0;
     pIC->fOpen = FALSE;
     pIC->fdwConversion = pIC->fdwSentence = 0;
 
     for (dwIndex = 0; dwIndex < MAX_CANDIDATEFORM; ++dwIndex)
         pIC->cfCandForm[dwIndex].dwIndex = IMM_INVALID_CANDFORM;
 
     /* Get private data size */
     pImeDpi = ImmLockImeDpi(hKL);
     if (!pImeDpi)
     {
         cbPrivate = sizeof(DWORD);
     }
     else
     {
         /* Update CLIENTIMC */
         pClientImc->uCodePage = pImeDpi->uCodePage;
         if (ImeDpi_IsUnicode(pImeDpi))
             pClientImc->dwFlags |= CLIENTIMC_WIDE;
 
         cbPrivate = pImeDpi->ImeInfo.dwPrivateDataSize;
     }
 
     /* Create private data */
     pIC->hPrivate = ImmCreateIMCC(cbPrivate);
     if (!pIC->hPrivate)
         goto Fail;
 
     if (pImeDpi)
     {
         /* Select the IME */
         if (fSelect)
         {
             if (IS_IME_HKL(hKL))
                 pImeDpi->ImeSelect(hIMC, TRUE);
             else if (Imm32IsCiceroMode() && !Imm32Is16BitMode() && pImeDpi->CtfImeSelectEx)
                 pImeDpi->CtfImeSelectEx(hIMC, TRUE, hKL);
         }
 
         /* Set HKL */
         pClientImc->hKL = hKL;
 
         ImmUnlockImeDpi(pImeDpi);
     }
 
     return TRUE;
 
 Fail:
     if (pImeDpi)
         ImmUnlockImeDpi(pImeDpi);
 
     pIC->hMsgBuf = ImmDestroyIMCC(pIC->hMsgBuf);
     pIC->hGuideLine = ImmDestroyIMCC(pIC->hGuideLine);
     pIC->hCandInfo = ImmDestroyIMCC(pIC->hCandInfo);
     pIC->hCompStr = ImmDestroyIMCC(pIC->hCompStr);
     return FALSE;
 }

Referenced by Imm32LockIMCEx().

◆ Imm32InitInstance()

static BOOL APIENTRY Imm32InitInstance ( HMODULE hMod )

static

Definition at line 22 of file imm.c.

 {
     NTSTATUS status;
 
     if (hMod)
         g_hImm32Inst = hMod;
 
     if (g_bClientRegd)
         return TRUE;
 
     status = RtlInitializeCriticalSection(&g_csImeDpi);
     if (NT_ERROR(status))
         return FALSE;
 
     g_bClientRegd = TRUE;
     return TRUE;
 }

Referenced by DllMain(), and ImmRegisterClient().

◆ Imm32LockIMCEx()

LPINPUTCONTEXT APIENTRY Imm32LockIMCEx	(	HIMC	hIMC,
		BOOL	fSelect
	)

Definition at line 802 of file imm.c.

 {
     HANDLE hIC;
     LPINPUTCONTEXT pIC = NULL;
     PCLIENTIMC pClientImc;
     WORD Word;
     DWORD dwThreadId;
     HKL hKL, hNewKL;
     PIMEDPI pImeDpi = NULL;
     BOOL bInited;
 
     pClientImc = ImmLockClientImc(hIMC);
     if (!pClientImc)
         return NULL;
 
     RtlEnterCriticalSection(&pClientImc->cs);
 
     if (!pClientImc->hInputContext)
     {
         dwThreadId = (DWORD)NtUserQueryInputContext(hIMC, 1);
 
         if (dwThreadId == GetCurrentThreadId() && Imm32IsCiceroMode() && !Imm32Is16BitMode())
         {
             hKL = GetKeyboardLayout(0);
             Word = LOWORD(hKL);
             hNewKL = (HKL)(DWORD_PTR)MAKELONG(Word, Word);
 
             pImeDpi = ImmLockOrLoadImeDpi(hNewKL);
             if (pImeDpi)
             {
                 FIXME("We have to do something here\n");
             }
         }
 
         if (!NtUserQueryInputContext(hIMC, 2))
         {
             RtlLeaveCriticalSection(&pClientImc->cs);
             goto Quit;
         }
 
         hIC = LocalAlloc(LHND, sizeof(INPUTCONTEXTDX));
         if (!hIC)
         {
             RtlLeaveCriticalSection(&pClientImc->cs);
             goto Quit;
         }
         pClientImc->hInputContext = hIC;
 
         pIC = LocalLock(pClientImc->hInputContext);
         if (!pIC)
         {
             pClientImc->hInputContext = LocalFree(pClientImc->hInputContext);
             RtlLeaveCriticalSection(&pClientImc->cs);
             goto Quit;
         }
 
         hKL = GetKeyboardLayout(dwThreadId);
         // bInited = Imm32InitContext(hIMC, hKL, fSelect);
         bInited = Imm32InitContext(hIMC, pIC, pClientImc, hKL, fSelect);
         LocalUnlock(pClientImc->hInputContext);
 
         if (!bInited)
         {
             pIC = NULL;
             pClientImc->hInputContext = LocalFree(pClientImc->hInputContext);
             RtlLeaveCriticalSection(&pClientImc->cs);
             goto Quit;
         }
     }
 
     FIXME("We have to do something here\n");
 
     RtlLeaveCriticalSection(&pClientImc->cs);
     pIC = LocalLock(pClientImc->hInputContext);
     InterlockedIncrement(&pClientImc->cLockObj);
 
 Quit:
     ImmUnlockClientImc(pClientImc);
     return pIC;
 }

Referenced by Imm32SelectLayout(), and ImmLockIMC().

◆ Imm32NotifyCompStrProc()

static BOOL CALLBACK Imm32NotifyCompStrProc	(	HIMC	hIMC,
		LPARAM	lParam
	)

static

Definition at line 434 of file imm.c.

 {
     ImmNotifyIME(hIMC, NI_COMPOSITIONSTR, (DWORD)lParam, 0);
     return TRUE;
 }

Referenced by ImmActivateLayout().

◆ Imm32SelectLayout()

VOID APIENTRY Imm32SelectLayout	(	HKL	hNewKL,
		HKL	hOldKL,
		HIMC	hIMC
	)

Definition at line 181 of file imm.c.

 {
     PCLIENTIMC pClientImc;
     LPINPUTCONTEXTDX pIC;
     LPGUIDELINE pGL;
     LPCANDIDATEINFO pCI;
     LPCOMPOSITIONSTRING pCS;
     LOGFONTA LogFontA;
     LOGFONTW LogFontW;
     BOOL fOpen, bIsNewHKLIme = TRUE, bIsOldHKLIme = TRUE, bClientWide, bNewDpiWide;
     DWORD cbNewPrivate = 0, cbOldPrivate = 0, dwConversion, dwSentence, dwSize, dwNewSize;
     PIMEDPI pNewImeDpi = NULL, pOldImeDpi = NULL;
     HANDLE hPrivate;
     PIME_STATE pNewState = NULL, pOldState = NULL;
 
     pClientImc = ImmLockClientImc(hIMC);
     if (!pClientImc)
         return;
 
     pNewImeDpi = ImmLockImeDpi(hNewKL);
 
     if (hNewKL != hOldKL)
         pOldImeDpi = ImmLockImeDpi(hOldKL);
 
     if (pNewImeDpi)
     {
         cbNewPrivate = pNewImeDpi->ImeInfo.dwPrivateDataSize;
         pClientImc->uCodePage = pNewImeDpi->uCodePage;
     }
     else
     {
         pClientImc->uCodePage = CP_ACP;
     }
 
     if (cbNewPrivate < sizeof(DWORD))
         cbNewPrivate = sizeof(DWORD);
 
     if (pOldImeDpi)
         cbOldPrivate = pOldImeDpi->ImeInfo.dwPrivateDataSize;
 
     if (cbOldPrivate < sizeof(DWORD))
         cbOldPrivate = sizeof(DWORD);
 
     if (pClientImc->hKL == hOldKL)
     {
         if (pOldImeDpi)
         {
             if (IS_IME_HKL(hOldKL))
                 pOldImeDpi->ImeSelect(hIMC, FALSE);
             else if (Imm32IsCiceroMode() && !Imm32Is16BitMode() && pOldImeDpi->CtfImeSelectEx)
                 pOldImeDpi->CtfImeSelectEx(hIMC, FALSE, hOldKL);
         }
         pClientImc->hKL = NULL;
     }
 
     if (CtfImmIsTextFrameServiceDisabled())
     {
         if (Imm32IsImmMode() && !Imm32IsCiceroMode())
         {
             bIsNewHKLIme = IS_IME_HKL(hNewKL);
             bIsOldHKLIme = IS_IME_HKL(hOldKL);
         }
     }
 
     pIC = (LPINPUTCONTEXTDX)Imm32LockIMCEx(hIMC, FALSE);
     if (!pIC)
     {
         if (pNewImeDpi)
         {
             if (IS_IME_HKL(hNewKL))
                 pNewImeDpi->ImeSelect(hIMC, TRUE);
             else if (Imm32IsCiceroMode() && !Imm32Is16BitMode() && pNewImeDpi->CtfImeSelectEx)
                 pNewImeDpi->CtfImeSelectEx(hIMC, TRUE, hNewKL);
 
             pClientImc->hKL = hNewKL;
         }
     }
     else
     {
         dwConversion = pIC->fdwConversion;
         dwSentence = pIC->fdwSentence;
         fOpen = pIC->fOpen;
 
         if (pNewImeDpi)
         {
             bClientWide = (pClientImc->dwFlags & CLIENTIMC_WIDE);
             bNewDpiWide = ImeDpi_IsUnicode(pNewImeDpi);
             if (bClientWide && !bNewDpiWide)
             {
                 if (pIC->fdwInit & INIT_LOGFONT)
                 {
                     LogFontWideToAnsi(&pIC->lfFont.W, &LogFontA);
                     pIC->lfFont.A = LogFontA;
                 }
                 pClientImc->dwFlags &= ~CLIENTIMC_WIDE;
             }
             else if (!bClientWide && bNewDpiWide)
             {
                 if (pIC->fdwInit & INIT_LOGFONT)
                 {
                     LogFontAnsiToWide(&pIC->lfFont.A, &LogFontW);
                     pIC->lfFont.W = LogFontW;
                 }
                 pClientImc->dwFlags |= CLIENTIMC_WIDE;
             }
         }
 
         if (cbOldPrivate != cbNewPrivate)
         {
             hPrivate = ImmReSizeIMCC(pIC->hPrivate, cbNewPrivate);
             if (!hPrivate)
             {
                 ImmDestroyIMCC(pIC->hPrivate);
                 hPrivate = ImmCreateIMCC(cbNewPrivate);
             }
             pIC->hPrivate = hPrivate;
         }
 
 #define MAX_IMCC_SIZE 0x1000
         dwSize = ImmGetIMCCSize(pIC->hMsgBuf);
         if (ImmGetIMCCLockCount(pIC->hMsgBuf) || dwSize > MAX_IMCC_SIZE)
         {
             ImmDestroyIMCC(pIC->hMsgBuf);
             pIC->hMsgBuf = ImmCreateIMCC(sizeof(UINT));
             pIC->dwNumMsgBuf = 0;
         }
 
         dwSize = ImmGetIMCCSize(pIC->hGuideLine);
         dwNewSize = sizeof(GUIDELINE);
         if (ImmGetIMCCLockCount(pIC->hGuideLine) ||
             dwSize < dwNewSize || dwSize > MAX_IMCC_SIZE)
         {
             ImmDestroyIMCC(pIC->hGuideLine);
             pIC->hGuideLine = ImmCreateIMCC(dwNewSize);
             pGL = ImmLockIMCC(pIC->hGuideLine);
             if (pGL)
             {
                 pGL->dwSize = dwNewSize;
                 ImmUnlockIMCC(pIC->hGuideLine);
             }
         }
 
         dwSize = ImmGetIMCCSize(pIC->hCandInfo);
         dwNewSize = sizeof(CANDIDATEINFO);
         if (ImmGetIMCCLockCount(pIC->hCandInfo) ||
             dwSize < dwNewSize || dwSize > MAX_IMCC_SIZE)
         {
             ImmDestroyIMCC(pIC->hCandInfo);
             pIC->hCandInfo = ImmCreateIMCC(dwNewSize);
             pCI = ImmLockIMCC(pIC->hCandInfo);
             if (pCI)
             {
                 pCI->dwSize = dwNewSize;
                 ImmUnlockIMCC(pIC->hCandInfo);
             }
         }
 
         dwSize = ImmGetIMCCSize(pIC->hCompStr);
         dwNewSize = sizeof(COMPOSITIONSTRING);
         if (ImmGetIMCCLockCount(pIC->hCompStr) ||
             dwSize < dwNewSize || dwSize > MAX_IMCC_SIZE)
         {
             ImmDestroyIMCC(pIC->hCompStr);
             pIC->hCompStr = ImmCreateIMCC(dwNewSize);
             pCS = ImmLockIMCC(pIC->hCompStr);
             if (pCS)
             {
                 pCS->dwSize = dwNewSize;
                 ImmUnlockIMCC(pIC->hCompStr);
             }
         }
 #undef MAX_IMCC_SIZE
 
         if (pOldImeDpi && bIsOldHKLIme)
         {
             pOldState = Imm32FetchImeState(pIC, hOldKL);
             if (pOldState)
                 Imm32SaveImeStateSentence(pIC, pOldState, hOldKL);
         }
 
         if (pNewImeDpi && bIsNewHKLIme)
             pNewState = Imm32FetchImeState(pIC, hNewKL);
 
         if (pOldState != pNewState)
         {
             if (pOldState)
             {
                 pOldState->fOpen = !!pIC->fOpen;
                 pOldState->dwConversion = (pIC->fdwConversion & ~IME_CMODE_EUDC);
                 pOldState->dwSentence = pIC->fdwSentence;
                 pOldState->dwInit = pIC->fdwInit;
             }
 
             if (pNewState)
             {
                 if (pIC->dwChange & INPUTCONTEXTDX_CHANGE_FORCE_OPEN)
                 {
                     pIC->dwChange &= ~INPUTCONTEXTDX_CHANGE_FORCE_OPEN;
                     pIC->fOpen = TRUE;
                 }
                 else
                 {
                     pIC->fOpen = pNewState->fOpen;
                 }
 
                 pIC->fdwConversion = (pNewState->dwConversion & ~IME_CMODE_EUDC);
                 pIC->fdwSentence = pNewState->dwSentence;
                 pIC->fdwInit = pNewState->dwInit;
             }
         }
 
         if (pNewState)
             Imm32LoadImeStateSentence(pIC, pNewState, hNewKL);
 
         if (pNewImeDpi)
         {
             if (IS_IME_HKL(hNewKL))
                 pNewImeDpi->ImeSelect(hIMC, TRUE);
             else if (Imm32IsCiceroMode() && !Imm32Is16BitMode() && pNewImeDpi->CtfImeSelectEx)
                 pNewImeDpi->CtfImeSelectEx(hIMC, TRUE, hNewKL);
 
             pClientImc->hKL = hNewKL;
         }
 
         pIC->dwChange = 0;
         if (pIC->fOpen != fOpen)
             pIC->dwChange |= INPUTCONTEXTDX_CHANGE_OPEN;
         if (pIC->fdwConversion != dwConversion)
             pIC->dwChange |= INPUTCONTEXTDX_CHANGE_CONVERSION;
         if (pIC->fdwSentence != dwSentence)
             pIC->dwChange |= INPUTCONTEXTDX_CHANGE_SENTENCE;
 
         ImmUnlockIMC(hIMC);
     }
 
     ImmUnlockImeDpi(pOldImeDpi);
     ImmUnlockImeDpi(pNewImeDpi);
     ImmUnlockClientImc(pClientImc);
 }

Referenced by Imm32SelectLayoutProc().

◆ Imm32SelectLayoutProc()

static BOOL CALLBACK Imm32SelectLayoutProc	(	HIMC	hIMC,
		LPARAM	lParam
	)

static

Definition at line 427 of file imm.c.

 {
     LPSELECT_LAYOUT pSelect = (LPSELECT_LAYOUT)lParam;
     Imm32SelectLayout(pSelect->hNewKL, pSelect->hOldKL, hIMC);
     return TRUE;
 }

Referenced by ImmActivateLayout().

◆ ImmActivateLayout()

BOOL WINAPI ImmActivateLayout ( HKL hKL )

Definition at line 443 of file imm.c.

 {
     PIMEDPI pImeDpi;
     HKL hOldKL;
     LPARAM lParam;
     HWND hwndDefIME = NULL;
     SELECT_LAYOUT SelectLayout;
 
     hOldKL = GetKeyboardLayout(0);
 
     if (hOldKL == hKL && !(GetWin32ClientInfo()->CI_flags & CI_IMMACTIVATE))
         return TRUE;
 
     ImmLoadIME(hKL);
 
     if (hOldKL != hKL)
     {
         pImeDpi = ImmLockImeDpi(hOldKL);
         if (pImeDpi)
         {
             if (pImeDpi->ImeInfo.fdwProperty & IME_PROP_COMPLETE_ON_UNSELECT)
                 lParam = CPS_COMPLETE;
             else
                 lParam = CPS_CANCEL;
             ImmUnlockImeDpi(pImeDpi);
 
             ImmEnumInputContext(0, Imm32NotifyCompStrProc, lParam);
         }
 
         hwndDefIME = ImmGetDefaultIMEWnd(NULL);
         if (IsWindow(hwndDefIME))
             SendMessageW(hwndDefIME, WM_IME_SELECT, FALSE, (LPARAM)hOldKL);
 
         NtUserSetThreadLayoutHandles(hKL, hOldKL);
     }
 
     SelectLayout.hNewKL = hKL;
     SelectLayout.hOldKL = hOldKL;
     ImmEnumInputContext(0, Imm32SelectLayoutProc, (LPARAM)&SelectLayout);
 
     if (IsWindow(hwndDefIME))
         SendMessageW(hwndDefIME, WM_IME_SELECT, TRUE, (LPARAM)hKL);
 
     return TRUE;
 }

◆ ImmAssociateContext()

HIMC WINAPI ImmAssociateContext	(	HWND	hWnd,
		HIMC	hIMC
	)

Definition at line 497 of file imm.c.

 {
     PWND pWnd;
     HWND hwndFocus;
     DWORD dwValue;
     HIMC hOldIMC;
 
     TRACE("(%p, %p)\n", hWnd, hIMC);
 
     if (!Imm32IsImmMode())
         return NULL;
 
     pWnd = ValidateHwndNoErr(hWnd);
     if (!pWnd)
         return NULL;
 
     if (hIMC && Imm32IsCrossThreadAccess(hIMC))
         return NULL;
 
     hOldIMC = pWnd->hImc;
     if (hOldIMC == hIMC)
         return hIMC;
 
     dwValue = NtUserAssociateInputContext(hWnd, hIMC, 0);
     if (dwValue == 0)
         return hOldIMC;
     if (dwValue != 1)
         return NULL;
 
     hwndFocus = (HWND)NtUserQueryWindow(hWnd, QUERY_WINDOW_FOCUS);
     if (hwndFocus == hWnd)
     {
         ImmSetActiveContext(hWnd, hOldIMC, FALSE);
         ImmSetActiveContext(hWnd, hIMC, TRUE);
     }
 
     return hOldIMC;
 }

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

◆ ImmAssociateContextEx()

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

Definition at line 539 of file imm.c.

 {
     HWND hwndFocus;
     PWND pFocusWnd;
     HIMC hOldIMC = NULL;
     DWORD dwValue;
 
     TRACE("(%p, %p, 0x%lX)\n", hWnd, hIMC, dwFlags);
 
     if (!Imm32IsImmMode())
         return FALSE;
 
     if (hIMC && !(dwFlags & IACE_DEFAULT) && Imm32IsCrossThreadAccess(hIMC))
         return FALSE;
 
     hwndFocus = (HWND)NtUserQueryWindow(hWnd, QUERY_WINDOW_FOCUS);
     pFocusWnd = ValidateHwndNoErr(hwndFocus);
     if (pFocusWnd)
         hOldIMC = pFocusWnd->hImc;
 
     dwValue = NtUserAssociateInputContext(hWnd, hIMC, dwFlags);
     switch (dwValue)
     {
         case 0:
             return TRUE;
 
         case 1:
             pFocusWnd = ValidateHwndNoErr(hwndFocus);
             if (pFocusWnd)
             {
                 hIMC = pFocusWnd->hImc;
                 if (hIMC != hOldIMC)
                 {
                     ImmSetActiveContext(hwndFocus, hOldIMC, FALSE);
                     ImmSetActiveContext(hwndFocus, hIMC, TRUE);
                 }
             }
             return TRUE;
 
         default:
             return FALSE;
     }
 }

Referenced by ActiveIMMApp_AssociateContextEx().

◆ ImmCreateContext()

HIMC WINAPI ImmCreateContext ( void )

Definition at line 586 of file imm.c.

 {
     PCLIENTIMC pClientImc;
     HIMC hIMC;
 
     TRACE("()\n");
 
     if (!Imm32IsImmMode())
         return NULL;
 
     pClientImc = Imm32HeapAlloc(HEAP_ZERO_MEMORY, sizeof(CLIENTIMC));
     if (pClientImc == NULL)
         return NULL;
 
     hIMC = NtUserCreateInputContext(pClientImc);
     if (hIMC == NULL)
     {
         Imm32HeapFree(pClientImc);
         return NULL;
     }
 
     RtlInitializeCriticalSection(&pClientImc->cs);
 
     // FIXME: NtUserGetThreadState and enum ThreadStateRoutines are broken.
     pClientImc->unknown = NtUserGetThreadState(13);
 
     return hIMC;
 }

Referenced by ActiveIMMApp_CreateContext(), ImmGetContextThreadFunc(), START_TEST(), test_ImmAssociateContextEx(), test_ImmDefaultHwnd(), test_ImmDestroyContext(), test_ImmGetIMCLockCount(), test_ImmNotifyIME(), and test_InvalidIMC().

◆ ImmCreateSoftKeyboard()

HWND WINAPI ImmCreateSoftKeyboard	(	UINT	uType,
		UINT	hOwner,
		int	x,
		int	y
	)

Definition at line 1068 of file imm.c.

 {
     FIXME("(%d, %d, %d, %d): stub\n", uType, hOwner, x, y);
     SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
     return 0;
 }

◆ ImmDestroyContext()

BOOL WINAPI ImmDestroyContext ( HIMC hIMC )

Definition at line 886 of file imm.c.

 {
     HKL hKL;
 
     TRACE("(%p)\n", hIMC);
 
     if (!Imm32IsImmMode())
         return FALSE;
 
     if (Imm32IsCrossThreadAccess(hIMC))
         return FALSE;
 
     hKL = GetKeyboardLayout(0);
     return Imm32CleanupContext(hIMC, hKL, FALSE);
 }

Referenced by ActiveIMMApp_DestroyContext(), START_TEST(), test_ImmDefaultHwnd(), test_ImmDestroyContext(), test_ImmGetIMCLockCount(), test_ImmNotifyIME(), test_ImmThreads(), and test_InvalidIMC().

◆ ImmDestroySoftKeyboard()

BOOL WINAPI ImmDestroySoftKeyboard ( HWND hSoftWnd )

Definition at line 1078 of file imm.c.

 {
     TRACE("(%p)\n", hSoftWnd);
     return DestroyWindow(hSoftWnd);
 }

◆ ImmDisableTextFrameService()

BOOL WINAPI ImmDisableTextFrameService ( DWORD dwThreadId )

Definition at line 1098 of file imm.c.

 {
     FIXME("Stub\n");
     return FALSE;
 }

◆ ImmEnumInputContext()

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

Definition at line 1107 of file imm.c.

 {
     HIMC *phList;
     DWORD dwIndex, dwCount;
     BOOL ret = TRUE;
     HIMC hIMC;
 
     TRACE("(%lu, %p, %p)\n", dwThreadId, lpfn, lParam);
 
     dwCount = Imm32AllocAndBuildHimcList(dwThreadId, &phList);
     if (!dwCount)
         return FALSE;
 
     for (dwIndex = 0; dwIndex < dwCount; ++dwIndex)
     {
         hIMC = phList[dwIndex];
         ret = (*lpfn)(hIMC, lParam);
         if (!ret)
             break;
     }
 
     Imm32HeapFree(phList);
     return ret;
 }

Referenced by Imm32SendChange(), and ImmActivateLayout().

◆ ImmFreeLayout()

BOOL WINAPI ImmFreeLayout ( DWORD dwUnknown )

Definition at line 117 of file imm.c.

 {
     WCHAR szKBD[9];
     UINT iKL, cKLs;
     HKL hOldKL, hNewKL, *pList;
     PIMEDPI pImeDpi;
     LANGID LangID;
 
     TRACE("(0x%lX)\n", dwUnknown);
 
     hOldKL = GetKeyboardLayout(0);
 
     if (dwUnknown == 1)
     {
         if (!IS_IME_HKL(hOldKL))
             return TRUE;
 
         LangID = LANGIDFROMLCID(GetSystemDefaultLCID());
 
         cKLs = GetKeyboardLayoutList(0, NULL);
         if (cKLs)
         {
             pList = Imm32HeapAlloc(0, cKLs * sizeof(HKL));
             if (pList == NULL)
                 return FALSE;
 
             cKLs = GetKeyboardLayoutList(cKLs, pList);
             for (iKL = 0; iKL < cKLs; ++iKL)
             {
                 if (!IS_IME_HKL(pList[iKL]))
                 {
                     LangID = LOWORD(pList[iKL]);
                     break;
                 }
             }
 
             Imm32HeapFree(pList);
         }
 
         StringCchPrintfW(szKBD, _countof(szKBD), L"%08X", LangID);
         if (!LoadKeyboardLayoutW(szKBD, KLF_ACTIVATE))
             LoadKeyboardLayoutW(L"00000409", KLF_ACTIVATE | 0x200);
     }
     else if (dwUnknown == 2)
     {
         RtlEnterCriticalSection(&g_csImeDpi);
 Retry:
         for (pImeDpi = g_pImeDpiList; pImeDpi; pImeDpi = pImeDpi->pNext)
         {
             if (Imm32ReleaseIME(pImeDpi->hKL))
                 goto Retry;
         }
         RtlLeaveCriticalSection(&g_csImeDpi);
     }
     else
     {
         hNewKL = (HKL)(DWORD_PTR)dwUnknown;
         if (IS_IME_HKL(hNewKL) && hNewKL != hOldKL)
             Imm32ReleaseIME(hNewKL);
     }
 
     return TRUE;
 }

◆ ImmGetContext()

HIMC WINAPI ImmGetContext ( HWND hWnd )

Definition at line 1008 of file imm.c.

 {
     TRACE("(%p)\n", hWnd);
     if (hWnd == NULL)
         return NULL;
     return Imm32GetContextEx(hWnd, 2);
 }

Referenced by ActiveIMMApp_GetContext(), DoTest_BUTTON(), DoTest_EDIT(), EDIT_ImeComposition(), ImmGetContextThreadFunc(), ImmGetVirtualKey(), ImmProcessKey(), ImmSetActiveContextConsoleIME(), ImmSimulateHotKey(), ImmTranslateMessage(), init(), ITextHostImpl_TxImmGetContext(), RealDefWindowProcA(), RealDefWindowProcW(), START_TEST(), test_ime_processkey(), test_ime_wnd_proc(), test_ImmAssociateContextEx(), test_ImmDefaultHwnd(), test_ImmGetCompositionString(), test_ImmGetContext(), test_ImmIME(), test_ImmMessages(), test_ImmNotifyIME(), test_ImmSetCompositionString(), test_ImmThreads(), and test_InvalidIMC().

◆ ImmLoadLayout()

BOOL WINAPI ImmLoadLayout	(	HKL	hKL,
		PIMEINFOEX	pImeInfoEx
	)

Definition at line 54 of file imm.c.

 {
     DWORD cbData;
     HKEY hLayoutKey = NULL, hLayoutsKey = NULL;
     LONG error;
     WCHAR szLayout[MAX_PATH];
 
     TRACE("(%p, %p)\n", hKL, pImeInfoEx);
 
     if (IS_IME_HKL(hKL) || !Imm32IsCiceroMode() || Imm32Is16BitMode())
     {
         Imm32UIntToStr((DWORD)(DWORD_PTR)hKL, 16, szLayout, _countof(szLayout));
 
         error = RegOpenKeyW(HKEY_LOCAL_MACHINE, REGKEY_KEYBOARD_LAYOUTS, &hLayoutsKey);
         if (error)
         {
             ERR("RegOpenKeyW: 0x%08lX\n", error);
             return FALSE;
         }
 
         error = RegOpenKeyW(hLayoutsKey, szLayout, &hLayoutKey);
         if (error)
         {
             ERR("RegOpenKeyW: 0x%08lX\n", error);
             RegCloseKey(hLayoutsKey);
             return FALSE;
         }
     }
     else
     {
         error = RegOpenKeyW(HKEY_LOCAL_MACHINE, REGKEY_IMM, &hLayoutKey);
         if (error)
         {
             ERR("RegOpenKeyW: 0x%08lX\n", error);
             return FALSE;
         }
     }
 
     cbData = sizeof(pImeInfoEx->wszImeFile);
     error = RegQueryValueExW(hLayoutKey, L"Ime File", 0, 0,
                              (LPBYTE)pImeInfoEx->wszImeFile, &cbData);
     pImeInfoEx->wszImeFile[_countof(pImeInfoEx->wszImeFile) - 1] = 0;
 
     RegCloseKey(hLayoutKey);
     if (hLayoutsKey)
         RegCloseKey(hLayoutsKey);
 
     pImeInfoEx->fLoadFlag = 0;
 
     if (error)
     {
         ERR("RegQueryValueExW: 0x%08lX\n", error);
         pImeInfoEx->hkl = NULL;
         return FALSE;
     }
 
     pImeInfoEx->hkl = hKL;
     return Imm32LoadImeVerInfo(pImeInfoEx);
 }

◆ ImmLockClientImc()

PCLIENTIMC WINAPI ImmLockClientImc ( HIMC hImc )

Definition at line 905 of file imm.c.

 {
     PIMC pIMC;
     PCLIENTIMC pClientImc;
 
     TRACE("(%p)\n", hImc);
 
     if (hImc == NULL)
         return NULL;
 
     pIMC = ValidateHandleNoErr(hImc, TYPE_INPUTCONTEXT);
     if (pIMC == NULL || !Imm32CheckImcProcess(pIMC))
         return NULL;
 
     pClientImc = (PCLIENTIMC)pIMC->dwClientImcData;
     if (!pClientImc)
     {
         pClientImc = Imm32HeapAlloc(HEAP_ZERO_MEMORY, sizeof(CLIENTIMC));
         if (!pClientImc)
             return NULL;
 
         RtlInitializeCriticalSection(&pClientImc->cs);
 
         // FIXME: NtUserGetThreadState and enum ThreadStateRoutines are broken.
         pClientImc->unknown = NtUserGetThreadState(13);
 
         if (!NtUserUpdateInputContext(hImc, 0, pClientImc))
         {
             Imm32HeapFree(pClientImc);
             return NULL;
         }
 
         pClientImc->dwFlags |= CLIENTIMC_UNKNOWN2;
     }
     else
     {
         if (pClientImc->dwFlags & CLIENTIMC_UNKNOWN1)
             return NULL;
     }
 
     InterlockedIncrement(&pClientImc->cLockObj);
     return pClientImc;
 }

Referenced by Imm32GetContextEx(), Imm32IsImcAnsi(), Imm32LockIMCEx(), Imm32PostMessages(), Imm32ProcessRequest(), Imm32SelectLayout(), ImmGenerateMessage(), ImmGetCandidateListAW(), ImmGetCandidateListCountAW(), ImmGetCompositionFontA(), ImmGetCompositionFontW(), ImmGetCompositionStringA(), ImmGetCompositionStringW(), ImmGetGuideLineAW(), ImmGetIMCLockCount(), ImmSetActiveContext(), ImmSetCompositionFontA(), ImmSetCompositionFontW(), and ImmUnlockIMC().

◆ ImmLockIMC()

LPINPUTCONTEXT WINAPI ImmLockIMC ( HIMC hIMC )

Definition at line 1029 of file imm.c.

 {
     TRACE("(%p)\n", hIMC);
     return Imm32LockIMCEx(hIMC, TRUE);
 }

Referenced by Imm32CleanupContext(), Imm32CShapeToggle(), Imm32CSymbolToggle(), Imm32GetImeMenuItemsAW(), Imm32ImeNonImeToggle(), Imm32KEnglish(), Imm32KHanjaConvert(), Imm32KShapeToggle(), Imm32OpenICAndCS(), Imm32RequestMessageAW(), Imm32SendChangeProc(), ImmGenerateMessage(), ImmGetCandidateListAW(), ImmGetCandidateListCountAW(), ImmGetCandidateWindow(), ImmGetCompositionFontA(), ImmGetCompositionFontW(), ImmGetCompositionStringA(), ImmGetCompositionStringW(), ImmGetCompositionWindow(), ImmGetConversionStatus(), ImmGetGuideLineAW(), ImmGetOpenStatus(), ImmGetStatusWindowPos(), ImmGetVirtualKey(), ImmProcessKey(), ImmSetActiveContext(), ImmSetCandidateWindow(), ImmSetCompositionFontA(), ImmSetCompositionFontW(), ImmSetCompositionWindow(), ImmSetConversionStatus(), ImmSetOpenStatus(), ImmSetStatusWindowPos(), ImmTranslateMessage(), START_TEST(), test_ImmDestroyContext(), test_ImmGetIMCLockCount(), test_ImmMessages(), and test_InvalidIMC().

◆ ImmRegisterClient()

BOOL WINAPI ImmRegisterClient	(	PSHAREDINFO	ptr,
		HINSTANCE	hMod
	)

Definition at line 44 of file imm.c.

 {
     g_SharedInfo = *ptr;
     g_psi = g_SharedInfo.psi;
     return Imm32InitInstance(hMod);
 }

Referenced by DllMain(), and User32InitializeImmEntryTable().

◆ ImmReleaseContext()

BOOL WINAPI ImmReleaseContext	(	HWND	hWnd,
		HIMC	hIMC
	)

Definition at line 1057 of file imm.c.

 {
     TRACE("(%p, %p)\n", hWnd, hIMC);
     UNREFERENCED_PARAMETER(hWnd);
     UNREFERENCED_PARAMETER(hIMC);
     return TRUE; // Do nothing. This is correct.
 }

Referenced by ActiveIMMApp_ReleaseContext(), DoTest_EDIT(), EDIT_ImeComposition(), ImmGetContextThreadFunc(), ImmProcessKey(), ImmSimulateHotKey(), ImmTranslateMessage(), init(), ITextHostImpl_TxImmReleaseContext(), RealDefWindowProcA(), RealDefWindowProcW(), START_TEST(), test_ime_processkey(), test_ime_wnd_proc(), test_ImmAssociateContextEx(), test_ImmDefaultHwnd(), test_ImmGetCompositionString(), test_ImmGetContext(), test_ImmIME(), test_ImmMessages(), test_ImmNotifyIME(), test_ImmSetCompositionString(), and test_ImmThreads().

◆ ImmSetActiveContext()

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

Definition at line 1135 of file imm.c.

 {
     PCLIENTIMC pClientImc;
     LPINPUTCONTEXTDX pIC;
     PIMEDPI pImeDpi;
     HKL hKL;
     BOOL fOpen = FALSE;
     DWORD dwConversion = 0, iShow = ISC_SHOWUIALL;
     HWND hwndDefIME;
 
     TRACE("(%p, %p, %d)\n", hWnd, hIMC, fActive);
 
     if (!Imm32IsImmMode())
         return FALSE;
 
     pClientImc = ImmLockClientImc(hIMC);
 
     if (!fActive)
     {
         if (pClientImc)
             pClientImc->dwFlags &= ~CLIENTIMC_UNKNOWN4;
     }
     else if (hIMC)
     {
         if (!pClientImc)
             return FALSE;
 
         pIC = (LPINPUTCONTEXTDX)ImmLockIMC(hIMC);
         if (!pIC)
         {
             ImmUnlockClientImc(pClientImc);
             return FALSE;
         }
 
         pIC->hWnd = hWnd;
         pClientImc->dwFlags |= CLIENTIMC_UNKNOWN5;
 
         if (pIC->dwUIFlags & 2)
             iShow = (ISC_SHOWUIGUIDELINE | ISC_SHOWUIALLCANDIDATEWINDOW);
 
         fOpen = pIC->fOpen;
         dwConversion = pIC->fdwConversion;
 
         ImmUnlockIMC(hIMC);
     }
     else
     {
         hIMC = Imm32GetContextEx(hWnd, TRUE);
         pIC = (LPINPUTCONTEXTDX)ImmLockIMC(hIMC);
         if (pIC)
         {
             pIC->hWnd = hWnd;
             ImmUnlockIMC(hIMC);
         }
         hIMC = NULL;
     }
 
     hKL = GetKeyboardLayout(0);
 
     if (Imm32IsCiceroMode() && !Imm32Is16BitMode())
     {
         Imm32CiceroSetActiveContext(hIMC, fActive, hWnd, hKL);
         hKL = GetKeyboardLayout(0);
     }
 
     pImeDpi = ImmLockImeDpi(hKL);
     if (pImeDpi)
     {
         if (IS_IME_HKL(hKL))
             pImeDpi->ImeSetActiveContext(hIMC, fActive);
         ImmUnlockImeDpi(pImeDpi);
     }
 
     if (IsWindow(hWnd))
     {
         SendMessageW(hWnd, WM_IME_SETCONTEXT, fActive, iShow);
         if (fActive)
             NtUserNotifyIMEStatus(hWnd, fOpen, dwConversion);
     }
     else if (!fActive)
     {
         hwndDefIME = ImmGetDefaultIMEWnd(NULL);
         if (hwndDefIME)
             SendMessageW(hwndDefIME, WM_IME_SETCONTEXT, 0, iShow);
     }
 
     if (pClientImc)
         ImmUnlockClientImc(pClientImc);
 
     return TRUE;
 }

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

◆ ImmSetActiveContextConsoleIME()

BOOL WINAPI ImmSetActiveContextConsoleIME	(	HWND	hwnd,
		BOOL	fFlag
	)

Definition at line 1230 of file imm.c.

 {
     HIMC hIMC;
     TRACE("(%p, %d)\n", hwnd, fFlag);
 
     hIMC = ImmGetContext(hwnd);
     if (hIMC)
         return ImmSetActiveContext(hwnd, hIMC, fFlag);
     return FALSE;
 }

◆ ImmShowSoftKeyboard()

BOOL WINAPI ImmShowSoftKeyboard	(	HWND	hSoftWnd,
		int	nCmdShow
	)

Definition at line 1087 of file imm.c.

 {
     TRACE("(%p, %d)\n", hSoftWnd, nCmdShow);
     if (hSoftWnd)
         return ShowWindow(hSoftWnd, nCmdShow);
     return FALSE;
 }

◆ ImmUnlockClientImc()

VOID WINAPI ImmUnlockClientImc ( PCLIENTIMC pClientImc )

Definition at line 952 of file imm.c.

 {
     LONG cLocks;
     HANDLE hInputContext;
 
     TRACE("(%p)\n", pClientImc);
 
     cLocks = InterlockedDecrement(&pClientImc->cLockObj);
     if (cLocks != 0 || !(pClientImc->dwFlags & CLIENTIMC_UNKNOWN1))
         return;
 
     hInputContext = pClientImc->hInputContext;
     if (hInputContext)
         LocalFree(hInputContext);
 
     RtlDeleteCriticalSection(&pClientImc->cs);
     Imm32HeapFree(pClientImc);
 }

Referenced by Imm32CleanupContext(), Imm32GetContextEx(), Imm32IsImcAnsi(), Imm32LockIMCEx(), Imm32PostMessages(), Imm32ProcessRequest(), Imm32SelectLayout(), ImmGenerateMessage(), ImmGetCandidateListAW(), ImmGetCandidateListCountAW(), ImmGetCompositionFontA(), ImmGetCompositionFontW(), ImmGetCompositionStringA(), ImmGetCompositionStringW(), ImmGetGuideLineAW(), ImmGetIMCLockCount(), ImmSetActiveContext(), ImmSetCompositionFontA(), ImmSetCompositionFontW(), ImmUnlockIMC(), and START_TEST().

◆ ImmUnlockIMC()

BOOL WINAPI ImmUnlockIMC ( HIMC hIMC )

Definition at line 1038 of file imm.c.

 {
     PCLIENTIMC pClientImc;
 
     pClientImc = ImmLockClientImc(hIMC);
     if (pClientImc == NULL)
         return FALSE;
 
     if (pClientImc->hInputContext)
         LocalUnlock(pClientImc->hInputContext);
 
     InterlockedDecrement(&pClientImc->cLockObj);
     ImmUnlockClientImc(pClientImc);
     return TRUE;
 }

Referenced by Imm32CleanupContext(), Imm32CShapeToggle(), Imm32CSymbolToggle(), Imm32GetImeMenuItemsAW(), Imm32ImeNonImeToggle(), Imm32KEnglish(), Imm32KHanjaConvert(), Imm32KShapeToggle(), Imm32OpenICAndCS(), Imm32RequestMessageAW(), Imm32SelectLayout(), Imm32SendChangeProc(), Imm32SetCompositionStringAW(), ImmGenerateMessage(), ImmGetCandidateListAW(), ImmGetCandidateListCountAW(), ImmGetCandidateWindow(), ImmGetCompositionFontA(), ImmGetCompositionFontW(), ImmGetCompositionStringA(), ImmGetCompositionStringW(), ImmGetCompositionWindow(), ImmGetConversionStatus(), ImmGetGuideLineAW(), ImmGetOpenStatus(), ImmGetStatusWindowPos(), ImmGetVirtualKey(), ImmProcessKey(), ImmSetActiveContext(), ImmSetCandidateWindow(), ImmSetCompositionFontA(), ImmSetCompositionFontW(), ImmSetCompositionWindow(), ImmSetConversionStatus(), ImmSetOpenStatus(), ImmSetStatusWindowPos(), ImmTranslateMessage(), START_TEST(), test_ImmDestroyContext(), test_ImmGetIMCLockCount(), test_ImmMessages(), and test_InvalidIMC().

◆ User32InitializeImmEntryTable()

BOOL WINAPI User32InitializeImmEntryTable ( DWORD )

Definition at line 108 of file imm.c.

 {
     TRACE("Imm (%x)\n", magic);
 
     if (magic != IMM_INIT_MAGIC)
         return FALSE;
 
     /* Check whether the IMM table has already been initialized */
     if (IMM_FN(ImmWINNLSEnableIME) != IMMSTUB_ImmWINNLSEnableIME)
         return TRUE;
 
     IntInitializeImmEntryTable();
 
     if (ghImm32 == NULL && !bImmInitializing)
     {
         WCHAR ImmFile[MAX_PATH];
         GetImmFileName(ImmFile, _countof(ImmFile));
         ghImm32 = LoadLibraryW(ImmFile);
         if (ghImm32 == NULL)
         {
             ERR("Did not load imm32.dll!\n");
             return FALSE;
         }
     }
 
     return IMM_FN(ImmRegisterClient)(&gSharedInfo, ghImm32);
 }

Referenced by DllMain().

◆ WINE_DEFAULT_DEBUG_CHANNEL()

WINE_DEFAULT_DEBUG_CHANNEL ( imm )

Variable Documentation

◆ g_bClientRegd

BYTE g_bClientRegd = FALSE

Definition at line 20 of file imm.c.

Referenced by Imm32InitInstance().

◆ g_hImm32Inst

HMODULE g_hImm32Inst = NULL

Definition at line 17 of file imm.c.

Referenced by Imm32InitInstance().

◆ g_psi

PSERVERINFO g_psi = NULL

Definition at line 18 of file imm.c.

Referenced by Imm32UnknownProcess1(), and ImmRegisterClient().

◆ g_SharedInfo

SHAREDINFO g_SharedInfo = { NULL }

Definition at line 19 of file imm.c.

Referenced by ImmRegisterClient(), and ValidateHandleNoErr().

Classes

Macros

Typedefs

Functions

Variables

Macro Definition Documentation

◆ MAX_IMCC_SIZE

Typedef Documentation

◆ LPSELECT_LAYOUT

◆ SELECT_LAYOUT

Function Documentation

◆ CtfImmIsCiceroEnabled()

◆ DllMain()

◆ Imm32CiceroSetActiveContext()

◆ Imm32CleanupContext()

◆ Imm32FreeImeStates()

◆ Imm32GetContextEx()

◆ Imm32InitContext()

◆ Imm32InitInstance()

◆ Imm32LockIMCEx()

◆ Imm32NotifyCompStrProc()

◆ Imm32SelectLayout()

◆ Imm32SelectLayoutProc()

◆ ImmActivateLayout()

◆ ImmAssociateContext()

◆ ImmAssociateContextEx()

◆ ImmCreateContext()

◆ ImmCreateSoftKeyboard()

◆ ImmDestroyContext()

◆ ImmDestroySoftKeyboard()

◆ ImmDisableTextFrameService()

◆ ImmEnumInputContext()

◆ ImmFreeLayout()

◆ ImmGetContext()

◆ ImmLoadLayout()

◆ ImmLockClientImc()

◆ ImmLockIMC()

◆ ImmRegisterClient()

◆ ImmReleaseContext()

◆ ImmSetActiveContext()

◆ ImmSetActiveContextConsoleIME()

◆ ImmShowSoftKeyboard()

◆ ImmUnlockClientImc()

◆ ImmUnlockIMC()

◆ User32InitializeImmEntryTable()

◆ WINE_DEFAULT_DEBUG_CHANNEL()

Variable Documentation

◆ g_bClientRegd

◆ g_hImm32Inst

◆ g_psi

◆ g_SharedInfo