imm.c File Reference

#include <user32.h>
#include <strsafe.h>
#include <immdev.h>
#include "immtable.h"

Include dependency graph for imm.c:

Go to the source code of this file.

Macros
#define	IMM_INIT_MAGIC   0x19650412
#define	MAX_CANDIDATEFORM   4
#define	DEFINE_IMM_ENTRY(type, name, params, retval, retkind)    static type WINAPI IMMSTUB_##name params { IMM_RETURN_##retkind((type)retval); }
#define	DEFINE_IMM_ENTRY(type, name, params, retval, retkind)    IMMSTUB_##name,
#define	DEFINE_IMM_ENTRY(type, name, params, retval, retkind)

Functions
	WINE_DEFAULT_DEBUG_CHANNEL (user32)
HWND FASTCALL	IntGetTopLevelWindow (HWND hWnd)
HRESULT	User32GetImmFileName (_Out_ LPWSTR lpBuffer, _In_ size_t cchBuffer)
static BOOL	IntInitializeImmEntryTable (VOID)
BOOL WINAPI	InitializeImmEntryTable (VOID)
BOOL WINAPI	User32InitializeImmEntryTable (DWORD magic)
static BOOL	User32CanSetImeWindowToImc (HIMC hIMC, HWND hImeWnd)
static BOOL	User32GetImeShowStatus (VOID)
static LRESULT	User32SendImeUIMessage (PIMEUI pimeui, UINT uMsg, WPARAM wParam, LPARAM lParam, BOOL unicode)
static VOID	User32NotifyOpenStatus (PIMEUI pimeui, HWND hwndIMC, BOOL bOpen)
static VOID	User32SetImeWindowOfImc (HIMC hIMC, HWND hImeWnd)
static VOID	User32UpdateImcOfImeUI (PIMEUI pimeui, HIMC hNewIMC)
static LRESULT	ImeWnd_OnImeNotify (PIMEUI pimeui, WPARAM wParam, LPARAM lParam)
static HWND	User32CreateImeUIWindow (PIMEUI pimeui, HKL hKL)
static INT	ImeWnd_OnCreate (PIMEUI pimeui, LPCREATESTRUCT lpCS)
static VOID	User32DestroyImeUIWindow (PIMEUI pimeui)
static VOID	ImeWnd_OnImeSelect (PIMEUI pimeui, WPARAM wParam, LPARAM lParam)
static LRESULT	ImeWnd_OnImeControl (PIMEUI pimeui, WPARAM wParam, LPARAM lParam, BOOL unicode)
static VOID FASTCALL	User32SetImeActivenessOfWindow (HWND hWnd, BOOL bActive)
VOID FASTCALL	CtfLoadThreadLayout (PIMEUI pimeui)
static LRESULT FASTCALL	User32DoImeHelp (PIMEUI pimeui, WPARAM wParam, LPARAM lParam)
static LRESULT	ImeWnd_OnImeSystem (PIMEUI pimeui, WPARAM wParam, LPARAM lParam)
LRESULT	ImeWnd_OnImeSetContext (PIMEUI pimeui, WPARAM wParam, LPARAM lParam)
LRESULT WINAPI	ImeWndProc_common (HWND hwnd, UINT msg, WPARAM wParam, LPARAM lParam, BOOL unicode)
LRESULT WINAPI	ImeWndProcA (HWND hwnd, UINT msg, WPARAM wParam, LPARAM lParam)
LRESULT WINAPI	ImeWndProcW (HWND hwnd, UINT msg, WPARAM wParam, LPARAM lParam)
BOOL WINAPI	UpdatePerUserImmEnabling (VOID)
BOOL WINAPI	RegisterIMEClass (VOID)
BOOL WINAPI	IMPSetIMEW (HWND hwnd, LPIMEPROW ime)
BOOL WINAPI	IMPQueryIMEW (LPIMEPROW ime)
BOOL WINAPI	IMPGetIMEW (HWND hwnd, LPIMEPROW ime)
BOOL WINAPI	IMPSetIMEA (HWND hwnd, LPIMEPROA ime)
BOOL WINAPI	IMPQueryIMEA (LPIMEPROA ime)
BOOL WINAPI	IMPGetIMEA (HWND hwnd, LPIMEPROA ime)
LRESULT WINAPI	SendIMEMessageExW (HWND hwnd, LPARAM lParam)
LRESULT WINAPI	SendIMEMessageExA (HWND hwnd, LPARAM lParam)
BOOL WINAPI	WINNLSEnableIME (HWND hwnd, BOOL enable)
BOOL WINAPI	WINNLSGetEnableStatus (HWND hwnd)
UINT WINAPI	WINNLSGetIMEHotkey (HWND hwnd)

Variables
HINSTANCE	ghImm32 = NULL
BOOL	gbImmInitializing = FALSE
INT	gfConIme = -1
Imm32ApiTable	gImmApiEntries

Macro Definition Documentation

DEFINE_IMM_ENTRY [1/3]

#define DEFINE_IMM_ENTRY	(		type,
			name,
			params,
			retval,
			retkind
	)		static type WINAPI IMMSTUB_##name params { IMM_RETURN_##retkind((type)retval); }

Definition at line 42 of file imm.c.

DEFINE_IMM_ENTRY [2/3]

#define DEFINE_IMM_ENTRY	(		type,
			name,
			params,
			retval,
			retkind
	)		IMMSTUB_##name,

Definition at line 42 of file imm.c.

DEFINE_IMM_ENTRY [3/3]

#define DEFINE_IMM_ENTRY	(		type,
			name,
			params,
			retval,
			retkind
	)

Value:

    do { \
        FN_##name proc = (FN_##name)GetProcAddress(imm32, #name); \
        if (!proc) { \
            ERR("Could not load %s\n", #name); \
            return FALSE; \
        } \
        IMM_FN(name) = proc; \
    } while (0);

Definition at line 42 of file imm.c.

IMM_INIT_MAGIC

#define IMM_INIT_MAGIC   0x19650412

Definition at line 16 of file imm.c.

MAX_CANDIDATEFORM

#define MAX_CANDIDATEFORM   4

Definition at line 17 of file imm.c.

Function Documentation

CtfLoadThreadLayout()

VOID FASTCALL CtfLoadThreadLayout

(

PIMEUI

pimeui

)

Definition at line 578 of file imm.c.

{
    IMM_FN(CtfImmTIMActivate)(pimeui->hKL);
    pimeui->hKL = GetWin32ClientInfo()->hKL;
    IMM_FN(ImmLoadIME)(pimeui->hKL);
    pimeui->hwndUI = NULL;
}

Referenced by ImeWnd_OnImeSystem().

ImeWnd_OnCreate()

static INT ImeWnd_OnCreate ( PIMEUI  pimeui, LPCREATESTRUCT  lpCS  )

static

Definition at line 343 of file imm.c.

{
    PWND pParentWnd, pWnd = pimeui->spwnd;
    HIMC hIMC = NULL;
 
    if (!pWnd || (pWnd->style & (WS_DISABLED | WS_POPUP)) != (WS_DISABLED | WS_POPUP))
        return -1;
 
    pParentWnd = ValidateHwnd(lpCS->hwndParent);
    if (pParentWnd)
    {
        hIMC = pParentWnd->hImc;
        if (hIMC && !User32CanSetImeWindowToImc(hIMC, UserHMGetHandle(pWnd)))
            hIMC = NULL;
    }
 
    User32UpdateImcOfImeUI(pimeui, hIMC);
 
    pimeui->fShowStatus = FALSE;
    pimeui->nCntInIMEProc = 0;
    pimeui->fActivate = FALSE;
    pimeui->fDestroy = FALSE;
    pimeui->hwndIMC = NULL;
    pimeui->hKL = GetWin32ClientInfo()->hKL;
    pimeui->fCtrlShowStatus = TRUE;
    pimeui->dwLastStatus = 0;
 
    return 0;
}

Referenced by ImeWndProc_common().

ImeWnd_OnImeControl()

static LRESULT ImeWnd_OnImeControl ( PIMEUI  pimeui, WPARAM  wParam, LPARAM  lParam, BOOL  unicode  )

static

Definition at line 427 of file imm.c.

{
    HIMC hIMC = pimeui->hIMC;
    DWORD dwConversion, dwSentence;
    POINT pt;
 
    if (IS_CICERO_MODE())
    {
        if (wParam == IMC_OPENSTATUSWINDOW)
        {
            IMM_FN(CtfImmRestoreToolbarWnd)(pimeui->dwLastStatus);
            pimeui->dwLastStatus = 0;
        }
        else if (wParam == IMC_CLOSESTATUSWINDOW)
        {
            pimeui->dwLastStatus = IMM_FN(CtfImmHideToolbarWnd)();
        }
    }
 
    if (!hIMC)
        return 0;
 
    switch (wParam)
    {
        case IMC_GETCONVERSIONMODE:
            if (!IMM_FN(ImmGetConversionStatus)(hIMC, &dwConversion, &dwSentence))
                return 1;
            return dwConversion;
 
        case IMC_GETSENTENCEMODE:
            if (!IMM_FN(ImmGetConversionStatus)(hIMC, &dwConversion, &dwSentence))
                return 1;
            return dwSentence;
 
        case IMC_GETOPENSTATUS:
            return IMM_FN(ImmGetOpenStatus)(hIMC);
 
        case IMC_SETCONVERSIONMODE:
            if (!IMM_FN(ImmGetConversionStatus)(hIMC, &dwConversion, &dwSentence) ||
                !IMM_FN(ImmSetConversionStatus)(hIMC, (DWORD)lParam, dwSentence))
            {
                return 1;
            }
            break;
 
        case IMC_SETSENTENCEMODE:
            if (!IMM_FN(ImmGetConversionStatus)(hIMC, &dwConversion, &dwSentence) ||
                !IMM_FN(ImmSetConversionStatus)(hIMC, dwConversion, (DWORD)lParam))
            {
                return 1;
            }
            break;
 
        case IMC_SETOPENSTATUS:
            if (!IMM_FN(ImmSetOpenStatus)(hIMC, (BOOL)lParam))
                return 1;
            break;
 
        case IMC_GETCANDIDATEPOS:
        case IMC_GETCOMPOSITIONWINDOW:
        case IMC_GETSOFTKBDPOS:
        case IMC_SETSOFTKBDPOS:
        case IMC_GETSTATUSWINDOWPOS:
            return User32SendImeUIMessage(pimeui, WM_IME_CONTROL, wParam, lParam, unicode);
 
        case IMC_SETCANDIDATEPOS:
            if (!IMM_FN(ImmSetCandidateWindow)(hIMC, (LPCANDIDATEFORM)lParam))
                return 1;
            break;
 
        case IMC_GETCOMPOSITIONFONT:
            if (unicode)
            {
                if (!IMM_FN(ImmGetCompositionFontW)(hIMC, (LPLOGFONTW)lParam))
                    return 1;
            }
            else
            {
                if (!IMM_FN(ImmGetCompositionFontA)(hIMC, (LPLOGFONTA)lParam))
                    return 1;
            }
            break;
 
        case IMC_SETCOMPOSITIONFONT:
            if (unicode)
            {
                if (!IMM_FN(ImmSetCompositionFontW)(hIMC, (LPLOGFONTW)lParam))
                    return 1;
            }
            else
            {
                if (!IMM_FN(ImmSetCompositionFontA)(hIMC, (LPLOGFONTA)lParam))
                    return 1;
            }
            break;
 
        case IMC_SETCOMPOSITIONWINDOW:
            if (!IMM_FN(ImmSetCompositionWindow)(hIMC, (LPCOMPOSITIONFORM)lParam))
                return 1;
            break;
 
        case IMC_SETSTATUSWINDOWPOS:
            pt.x = GET_X_LPARAM(lParam);
            pt.y = GET_Y_LPARAM(lParam);
            if (!IMM_FN(ImmSetStatusWindowPos)(hIMC, &pt))
                return 1;
            break;
 
        case IMC_CLOSESTATUSWINDOW:
            if (pimeui->fShowStatus && User32GetImeShowStatus())
            {
                pimeui->fShowStatus = FALSE;
                User32SendImeUIMessage(pimeui, WM_IME_NOTIFY, IMN_CLOSESTATUSWINDOW, 0, TRUE);
            }
            pimeui->fCtrlShowStatus = FALSE;
            break;
 
        case IMC_OPENSTATUSWINDOW:
            if (!pimeui->fShowStatus && User32GetImeShowStatus())
            {
                pimeui->fShowStatus = TRUE;
                User32SendImeUIMessage(pimeui, WM_IME_NOTIFY, IMN_OPENSTATUSWINDOW, 0, TRUE);
            }
            pimeui->fCtrlShowStatus = TRUE;
            break;
 
        default:
            break;
    }
 
    return 0;
}

Referenced by ImeWndProc_common().

ImeWnd_OnImeNotify()

static LRESULT ImeWnd_OnImeNotify ( PIMEUI  pimeui, WPARAM  wParam, LPARAM  lParam  )

static

Definition at line 246 of file imm.c.

{
    LRESULT ret = 0;
    HIMC hIMC;
    LPINPUTCONTEXT pIC;
    HWND hwndUI, hwndIMC, hImeWnd, hwndOwner;
 
    ASSERT(pimeui->spwnd != NULL);
 
    switch (wParam)
    {
        case IMN_SETCONVERSIONMODE:
        case IMN_SETOPENSTATUS:
            hIMC = pimeui->hIMC;
            pIC = IMM_FN(ImmLockIMC)(hIMC);
            if (pIC)
            {
                hwndIMC = pimeui->hwndIMC;
                if (IsWindow(hwndIMC))
                {
                    NtUserNotifyIMEStatus(hwndIMC, pIC->fOpen, pIC->fdwConversion);
                }
                else if (gfConIme == TRUE && pimeui->spwnd)
                {
                    hImeWnd = UserHMGetHandle(pimeui->spwnd);
                    hwndOwner = GetWindow(hImeWnd, GW_OWNER);
                    if (hwndOwner)
                    {
                        NtUserNotifyIMEStatus(hwndOwner, pIC->fOpen, pIC->fdwConversion);
                    }
                }
 
                IMM_FN(ImmUnlockIMC)(hIMC);
            }
            /* FALL THROUGH */
        default:
            ret = User32SendImeUIMessage(pimeui, WM_IME_NOTIFY, wParam, lParam, TRUE);
            break;
 
        case IMN_PRIVATE:
            hwndUI = pimeui->hwndUI;
            if (IsWindow(hwndUI))
                ret = SendMessageW(hwndUI, WM_IME_NOTIFY, wParam, lParam);
            break;
    }
 
    return ret;
}

Referenced by ImeWndProc_common().

ImeWnd_OnImeSelect()

static VOID ImeWnd_OnImeSelect ( PIMEUI  pimeui, WPARAM  wParam, LPARAM  lParam  )

static

Definition at line 391 of file imm.c.

{
    HKL hKL;
    HWND hwndUI, hwndIMC = pimeui->hwndIMC;
 
    if (wParam)
    {
        pimeui->hKL = hKL = (HKL)lParam;
 
        if (!pimeui->fActivate)
            return;
 
        pimeui->hwndUI = hwndUI = User32CreateImeUIWindow(pimeui, hKL);
        if (hwndUI)
            User32SendImeUIMessage(pimeui, WM_IME_SELECT, wParam, lParam, TRUE);
 
        if (User32GetImeShowStatus() && pimeui->fCtrlShowStatus)
        {
            if (!pimeui->fShowStatus && pimeui->fActivate && IsWindow(hwndIMC))
                User32NotifyOpenStatus(pimeui, hwndIMC, TRUE);
        }
    }
    else
    {
        if (pimeui->fShowStatus && pimeui->fActivate && IsWindow(hwndIMC))
            User32NotifyOpenStatus(pimeui, hwndIMC, FALSE);
 
        User32SendImeUIMessage(pimeui, WM_IME_SELECT, wParam, lParam, TRUE);
        User32DestroyImeUIWindow(pimeui);
        pimeui->hKL = NULL;
    }
}

Referenced by ImeWndProc_common().

ImeWnd_OnImeSetContext()

LRESULT ImeWnd_OnImeSetContext	(	PIMEUI	pimeui,
		WPARAM	wParam,
		LPARAM	lParam
	)

Definition at line 779 of file imm.c.

{
    LRESULT ret;
    HIMC hIMC;
    LPINPUTCONTEXTDX pIC;
    HWND hwndFocus, hwndOldImc, hwndNewImc, hImeWnd, hwndActive, hwndOwner;
    PWND pwndFocus, pImeWnd, pwndOwner;
    COMPOSITIONFORM CompForm;
 
    pimeui->fActivate = !!wParam;
    hwndOldImc = pimeui->hwndIMC;
    ASSERT(pimeui->spwnd != NULL);
 
    if (wParam)
    {
        if (!pimeui->hwndUI)
            pimeui->hwndUI = User32CreateImeUIWindow(pimeui, pimeui->hKL);
 
        if (gfConIme == -1)
        {
            gfConIme = (INT)NtUserGetThreadState(THREADSTATE_CHECKCONIME);
            if (gfConIme)
                pimeui->fCtrlShowStatus = FALSE;
        }
 
        hImeWnd = UserHMGetHandle(pimeui->spwnd);
 
        if (gfConIme)
        {
            hwndOwner = GetWindow(hImeWnd, GW_OWNER);
            pwndOwner = ValidateHwnd(hwndOwner);
            if (pwndOwner)
            {
                User32UpdateImcOfImeUI(pimeui, pwndOwner->hImc);
 
                if (pimeui->hwndUI)
                    SetWindowLongPtrW(pimeui->hwndUI, IMMGWLP_IMC, (LONG_PTR)pwndOwner->hImc);
            }
 
            return User32SendImeUIMessage(pimeui, WM_IME_SETCONTEXT, wParam, lParam, TRUE);
        }
 
        hwndFocus = (HWND)NtUserQueryWindow(hImeWnd, QUERY_WINDOW_FOCUS);
 
        hIMC = IMM_FN(ImmGetContext)(hwndFocus);
 
        if (hIMC && !User32CanSetImeWindowToImc(hIMC, hImeWnd))
        {
            User32UpdateImcOfImeUI(pimeui, NULL);
            return 0;
        }
 
        User32UpdateImcOfImeUI(pimeui, hIMC);
 
        if (pimeui->hwndUI)
            SetWindowLongPtrW(pimeui->hwndUI, IMMGWLP_IMC, (LONG_PTR)hIMC);
 
        if (hIMC)
        {
            pIC = IMM_FN(ImmLockIMC)(hIMC);
            if (!pIC)
                return 0;
 
            if (hwndFocus != pIC->hWnd)
            {
                IMM_FN(ImmUnlockIMC)(hIMC);
                return 0;
            }
 
            if ((pIC->dwUIFlags & 0x40000) && hwndOldImc != hwndFocus)
            {
                RtlZeroMemory(&CompForm, sizeof(CompForm));
                IMM_FN(ImmSetCompositionWindow)(hIMC, &CompForm);
 
                pIC->dwUIFlags &= ~0x40000;
            }
 
            IMM_FN(ImmUnlockIMC)(hIMC);
 
            hImeWnd = UserHMGetHandle(pimeui->spwnd);
            if (NtUserSetImeOwnerWindow(hImeWnd, hwndFocus))
                pimeui->hwndIMC = hwndFocus;
        }
        else
        {
            pimeui->hwndIMC = hwndFocus;
 
            hImeWnd = UserHMGetHandle(pimeui->spwnd);
            NtUserSetImeOwnerWindow(hImeWnd, NULL);
        }
    }
 
    ret = User32SendImeUIMessage(pimeui, WM_IME_SETCONTEXT, wParam, lParam, TRUE);
 
    if (!pimeui->spwnd)
        return 0;
 
    if (!pimeui->fCtrlShowStatus || !User32GetImeShowStatus())
        return ret;
 
    hImeWnd = UserHMGetHandle(pimeui->spwnd);
    hwndFocus = (HWND)NtUserQueryWindow(hImeWnd, QUERY_WINDOW_FOCUS);
    pwndFocus = ValidateHwnd(hwndFocus);
 
    if (wParam)
    {
        pImeWnd = ValidateHwnd(hImeWnd);
        if (pwndFocus && pImeWnd && pImeWnd->head.pti == pwndFocus->head.pti)
        {
            hwndNewImc = pimeui->hwndIMC;
            if (pimeui->fShowStatus)
            {
                if (hwndOldImc && hwndNewImc && hwndOldImc != hwndNewImc &&
                    IntGetTopLevelWindow(hwndOldImc) != IntGetTopLevelWindow(hwndNewImc))
                {
                    User32NotifyOpenStatus(pimeui, hwndOldImc, FALSE);
                    User32NotifyOpenStatus(pimeui, hwndNewImc, TRUE);
                }
            }
            else
            {
                if (ValidateHwnd(hwndNewImc))
                    User32NotifyOpenStatus(pimeui, hwndNewImc, TRUE);
            }
        }
 
        pImeWnd = pimeui->spwnd;
        hImeWnd = (pImeWnd ? UserHMGetHandle(pImeWnd) : NULL);
        if (hImeWnd)
            NtUserCallHwndLock(hImeWnd, HWNDLOCK_ROUTINE_CHECKIMESHOWSTATUSINTHRD);
    }
    else
    {
        pImeWnd = pimeui->spwnd;
        hImeWnd = UserHMGetHandle(pImeWnd);
        hwndActive = (HWND)NtUserQueryWindow(hImeWnd, QUERY_WINDOW_ACTIVE);
        if (!pwndFocus || !hwndActive || pImeWnd->head.pti != pwndFocus->head.pti)
        {
            if (IsWindow(hwndOldImc))
            {
                User32NotifyOpenStatus(pimeui, hwndOldImc, FALSE);
            }
            else
            {
                pimeui->fShowStatus = FALSE;
                User32SendImeUIMessage(pimeui, WM_IME_NOTIFY, IMN_CLOSESTATUSWINDOW, 0, TRUE);
            }
        }
    }
 
    return ret;
}

Referenced by ImeWndProc_common().

ImeWnd_OnImeSystem()

static LRESULT ImeWnd_OnImeSystem ( PIMEUI  pimeui, WPARAM  wParam, LPARAM  lParam  )

static

Definition at line 623 of file imm.c.

{
    LRESULT ret = 0;
    LPINPUTCONTEXTDX pIC;
    HIMC hIMC = pimeui->hIMC;
    LPCANDIDATEFORM pCandForm;
    LPCOMPOSITIONFORM pCompForm;
    DWORD dwConversion, dwSentence;
    HWND hImeWnd;
    BOOL bCompForm;
    CANDIDATEFORM CandForm;
    COMPOSITIONFORM CompForm;
    UINT iCandForm;
 
    ASSERT(pimeui->spwnd != NULL);
 
    switch (wParam)
    {
        case IMS_NOTIFYIMESHOW:
            if (User32GetImeShowStatus() == !lParam)
            {
                hImeWnd = UserHMGetHandle(pimeui->spwnd);
                NtUserCallHwndParamLock(hImeWnd, lParam, TWOPARAM_ROUTINE_IMESHOWSTATUSCHANGE);
            }
            break;
 
        case IMS_UPDATEIMEUI:
            if (!hIMC)
                break;
 
            bCompForm = TRUE;
            pIC = IMM_FN(ImmLockIMC)(hIMC);
            if (pIC)
            {
                bCompForm = !(pIC->dwUIFlags & 0x2);
                IMM_FN(ImmUnlockIMC)(hIMC);
            }
 
            if (!IsWindow(pimeui->hwndIMC))
                break;
 
            if (bCompForm && IMM_FN(ImmGetCompositionWindow)(hIMC, &CompForm))
            {
                if (CompForm.dwStyle)
                    IMM_FN(ImmSetCompositionWindow)(hIMC, &CompForm);
            }
 
            for (iCandForm = 0; iCandForm < MAX_CANDIDATEFORM; ++iCandForm)
            {
                if (IMM_FN(ImmGetCandidateWindow)(hIMC, iCandForm, &CandForm))
                {
                    if (CandForm.dwStyle)
                        IMM_FN(ImmSetCandidateWindow)(hIMC, &CandForm);
                }
            }
            break;
 
        case IMS_SETCANDFORM:
            pIC = IMM_FN(ImmLockIMC)(hIMC);
            if (!pIC)
                break;
 
            pCandForm = &pIC->cfCandForm[lParam];
            IMM_FN(ImmSetCandidateWindow)(hIMC, pCandForm);
            IMM_FN(ImmUnlockIMC)(hIMC);
            break;
 
        case IMS_SETCOMPFONT:
            pIC = IMM_FN(ImmLockIMC)(hIMC);
            if (!pIC)
                break;
 
            IMM_FN(ImmSetCompositionFontW)(hIMC, &pIC->lfFont.W);
            IMM_FN(ImmUnlockIMC)(hIMC);
            break;
 
        case IMS_SETCOMPFORM:
            pIC = IMM_FN(ImmLockIMC)(hIMC);
            if (!pIC)
                break;
 
            pCompForm = &pIC->cfCompForm;
            pIC->dwUIFlags |= 0x8;
            IMM_FN(ImmSetCompositionWindow)(hIMC, pCompForm);
            IMM_FN(ImmUnlockIMC)(hIMC);
            break;
 
        case IMS_CONFIGURE:
            IMM_FN(ImmConfigureIMEW)((HKL)lParam, pimeui->hwndIMC, IME_CONFIG_GENERAL, NULL);
            break;
 
        case IMS_SETOPENSTATUS:
            if (hIMC)
                IMM_FN(ImmSetOpenStatus)(hIMC, (BOOL)lParam);
            break;
 
        case IMS_FREELAYOUT:
            ret = IMM_FN(ImmFreeLayout)((DWORD)lParam);
            break;
 
        case 0x13:
            FIXME("\n");
            break;
 
        case IMS_GETCONVSTATUS:
            IMM_FN(ImmGetConversionStatus)(hIMC, &dwConversion, &dwSentence);
            ret = dwConversion;
            break;
 
        case IMS_IMEHELP:
            return User32DoImeHelp(pimeui, wParam, lParam);
 
        case IMS_IMEACTIVATE:
            User32SetImeActivenessOfWindow((HWND)lParam, TRUE);
            break;
 
        case IMS_IMEDEACTIVATE:
            User32SetImeActivenessOfWindow((HWND)lParam, FALSE);
            break;
 
        case IMS_ACTIVATELAYOUT:
            ret = IMM_FN(ImmActivateLayout)((HKL)lParam);
            break;
 
        case IMS_GETIMEMENU:
            ret = IMM_FN(ImmPutImeMenuItemsIntoMappedFile)((HIMC)lParam);
            break;
 
        case 0x1D:
            FIXME("\n");
            break;
 
        case IMS_GETCONTEXT:
            ret = (ULONG_PTR)IMM_FN(ImmGetContext)((HWND)lParam);
            break;
 
        case IMS_SENDNOTIFICATION:
        case IMS_COMPLETECOMPSTR:
        case IMS_SETLANGBAND:
        case IMS_UNSETLANGBAND:
            ret = IMM_FN(ImmSystemHandler)(hIMC, wParam, lParam);
            break;
 
        case IMS_LOADTHREADLAYOUT:
            CtfLoadThreadLayout(pimeui);
            break;
 
        default:
            break;
    }
 
    return ret;
}

Referenced by ImeWndProc_common().

ImeWndProc_common()

LRESULT WINAPI ImeWndProc_common	(	HWND	hwnd,
		UINT	msg,
		WPARAM	wParam,
		LPARAM	lParam,
		BOOL	unicode
	)

Definition at line 935 of file imm.c.

{
    PWND pWnd;
    PIMEUI pimeui;
    LRESULT ret;
 
    pWnd = ValidateHwnd(hwnd);
    if (pWnd == NULL)
    {
        ERR("hwnd was %p\n", hwnd);
        return 0;
    }
 
    if (!pWnd->fnid)
    {
        NtUserSetWindowFNID(hwnd, FNID_IME);
    }
    else if (pWnd->fnid != FNID_IME)
    {
        ERR("fnid was 0x%x\n", pWnd->fnid);
        return 0;
    }
 
    pimeui = (PIMEUI)GetWindowLongPtrW(hwnd, 0);
    if (pimeui == NULL)
    {
        pimeui = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(IMEUI));
        if (pimeui == NULL)
        {
            ERR("HeapAlloc failed\n");
            NtUserSetWindowFNID(hwnd, FNID_DESTROY);
            DestroyWindow(hwnd);
            return 0;
        }
 
        SetWindowLongPtrW(hwnd, 0, (LONG_PTR)pimeui);
        pimeui->spwnd = pWnd;
    }
 
    if (IS_CICERO_MODE())
    {
        ret = IMM_FN(CtfImmDispatchDefImeMessage)(hwnd, msg, wParam, lParam);
        if (ret)
            return ret;
    }
 
    if (pimeui->nCntInIMEProc > 0)
    {
        switch (msg)
        {
            case WM_IME_CHAR:
            case WM_IME_COMPOSITIONFULL:
            case WM_IME_CONTROL:
            case WM_IME_REQUEST:
            case WM_IME_SELECT:
            case WM_IME_SETCONTEXT:
            case WM_IME_STARTCOMPOSITION:
            case WM_IME_COMPOSITION:
            case WM_IME_ENDCOMPOSITION:
                return 0;
 
            case WM_IME_NOTIFY:
                if (wParam < IMN_PRIVATE || IS_IME_HKL(pimeui->hKL) || !IS_CICERO_MODE())
                    return 0;
                break;
 
            case WM_IME_SYSTEM:
                switch (wParam)
                {
                    case 0x03:
                    case 0x10:
                    case 0x13:
                        break;
 
                    default:
                        return 0;
                }
                break;
 
            default:
                goto Finish;
        }
    }
 
    if ((pWnd->state2 & WNDS2_INDESTROY) || (pWnd->state & WNDS_DESTROYED))
    {
        switch (msg)
        {
            case WM_DESTROY:
            case WM_NCDESTROY:
            case WM_FINALDESTROY:
                break;
 
            default:
                return 0;
        }
    }
 
    switch (msg)
    {
        case WM_CREATE:
            return ImeWnd_OnCreate(pimeui, (LPCREATESTRUCT)lParam);
 
        case WM_DESTROY:
            User32DestroyImeUIWindow(pimeui);
            return 0;
 
        case WM_NCDESTROY:
        case WM_FINALDESTROY:
            pimeui->spwnd = NULL;
            HeapFree(GetProcessHeap(), 0, pimeui);
            NtUserSetWindowFNID(hwnd, FNID_DESTROY);
            break;
 
        case WM_ERASEBKGND:
            return TRUE;
 
        case WM_PAINT:
            return 0;
 
        case WM_IME_STARTCOMPOSITION:
        case WM_IME_COMPOSITION:
        case WM_IME_ENDCOMPOSITION:
            return User32SendImeUIMessage(pimeui, msg, wParam, lParam, unicode);
 
        case WM_IME_CONTROL:
            return ImeWnd_OnImeControl(pimeui, wParam, lParam, unicode);
 
        case WM_IME_NOTIFY:
            return ImeWnd_OnImeNotify(pimeui, wParam, lParam);
 
        case WM_IME_REQUEST:
            return 0;
 
        case WM_IME_SELECT:
            ImeWnd_OnImeSelect(pimeui, wParam, lParam);
            return (LRESULT)pimeui;
 
        case WM_IME_SETCONTEXT:
            return ImeWnd_OnImeSetContext(pimeui, wParam, lParam);
 
        case WM_IME_SYSTEM:
            return ImeWnd_OnImeSystem(pimeui, wParam, lParam);
 
        default:
            break;
    }
 
Finish:
    if (unicode)
        return DefWindowProcW(hwnd, msg, wParam, lParam);
    return DefWindowProcA(hwnd, msg, wParam, lParam);
}

Referenced by ImeWndProcA(), ImeWndProcW(), RealDefWindowProcA(), RealDefWindowProcW(), and RegisterClientPFN().

ImeWndProcA()

LRESULT WINAPI ImeWndProcA	(	HWND	hwnd,
		UINT	msg,
		WPARAM	wParam,
		LPARAM	lParam
	)

Definition at line 1090 of file imm.c.

{
    return ImeWndProc_common(hwnd, msg, wParam, lParam, FALSE);
}

Referenced by RegisterClientPFN().

ImeWndProcW()

LRESULT WINAPI ImeWndProcW	(	HWND	hwnd,
		UINT	msg,
		WPARAM	wParam,
		LPARAM	lParam
	)

Definition at line 1096 of file imm.c.

{
    return ImeWndProc_common(hwnd, msg, wParam, lParam, TRUE);
}

Referenced by RegisterClientPFN(), and RegisterIMEClass().

IMPGetIMEA()

BOOL WINAPI IMPGetIMEA	(	HWND	hwnd,
		LPIMEPROA	ime
	)

Definition at line 1205 of file imm.c.

{
    return IMM_FN(ImmIMPGetIMEA)(hwnd, ime);
}

IMPGetIMEW()

BOOL WINAPI IMPGetIMEW	(	HWND	hwnd,
		LPIMEPROW	ime
	)

Definition at line 1175 of file imm.c.

{
    return IMM_FN(ImmIMPGetIMEW)(hwnd, ime);
}

IMPQueryIMEA()

BOOL WINAPI IMPQueryIMEA

(

LPIMEPROA

ime

)

Definition at line 1195 of file imm.c.

{
    return IMM_FN(ImmIMPQueryIMEA)(ime);
}

IMPQueryIMEW()

BOOL WINAPI IMPQueryIMEW

(

LPIMEPROW

ime

)

Definition at line 1165 of file imm.c.

{
    return IMM_FN(ImmIMPQueryIMEW)(ime);
}

IMPSetIMEA()

BOOL WINAPI IMPSetIMEA	(	HWND	hwnd,
		LPIMEPROA	ime
	)

Definition at line 1185 of file imm.c.

{
    return IMM_FN(ImmIMPSetIMEA)(hwnd, ime);
}

IMPSetIMEW()

BOOL WINAPI IMPSetIMEW	(	HWND	hwnd,
		LPIMEPROW	ime
	)

Definition at line 1155 of file imm.c.

{
    return IMM_FN(ImmIMPSetIMEW)(hwnd, ime);
}

InitializeImmEntryTable()

BOOL WINAPI InitializeImmEntryTable

(

VOID

)

Definition at line 119 of file imm.c.

{
    gbImmInitializing = TRUE;
    return IntInitializeImmEntryTable();
}

Referenced by DllMain().

IntGetTopLevelWindow()

HWND FASTCALL IntGetTopLevelWindow

(

HWND

hWnd

)

Definition at line 26 of file imm.c.

{
    DWORD style;
 
    for (; hWnd; hWnd = GetParent(hWnd))
    {
        style = (DWORD)GetWindowLongPtrW(hWnd, GWL_STYLE);
        if (!(style & WS_CHILD))
            break;
    }
 
    return hWnd;
}

Referenced by ImeWnd_OnImeSetContext().

IntInitializeImmEntryTable()

static BOOL IntInitializeImmEntryTable ( VOID  )

static

Definition at line 70 of file imm.c.

{
    WCHAR ImmFile[MAX_PATH];
    HMODULE imm32 = ghImm32;
 
    /* Check whether the IMM table has already been initialized */
    if (IMM_FN(ImmWINNLSEnableIME) != IMMSTUB_ImmWINNLSEnableIME)
        return TRUE;
 
    User32GetImmFileName(ImmFile, _countof(ImmFile));
    TRACE("File %S\n", ImmFile);
 
    /* If IMM32 is already loaded, use it without increasing reference count. */
    if (imm32 == NULL)
        imm32 = GetModuleHandleW(ImmFile);
 
    /*
     * Loading imm32.dll will call imm32!DllMain function.
     * imm32!DllMain calls User32InitializeImmEntryTable.
     * Thus, if imm32.dll was loaded, the table has been loaded.
     */
    if (imm32 == NULL)
    {
        imm32 = ghImm32 = LoadLibraryW(ImmFile);
        if (imm32 == NULL)
        {
            ERR("Did not load imm32.dll!\n");
            return FALSE;
        }
        return TRUE;
    }
 
/* load imm procedures */
#undef DEFINE_IMM_ENTRY
#define DEFINE_IMM_ENTRY(type, name, params, retval, retkind) \
    do { \
        FN_##name proc = (FN_##name)GetProcAddress(imm32, #name); \
        if (!proc) { \
            ERR("Could not load %s\n", #name); \
            return FALSE; \
        } \
        IMM_FN(name) = proc; \
    } while (0);
#include "immtable.h"
 
    return TRUE;
}

Referenced by InitializeImmEntryTable(), and User32InitializeImmEntryTable().

RegisterIMEClass()

BOOL WINAPI RegisterIMEClass

(

VOID

)

Definition at line 1127 of file imm.c.

{
    ATOM atom;
    WNDCLASSEXW WndClass = { sizeof(WndClass) };
 
    WndClass.lpszClassName  = L"IME";
    WndClass.style          = CS_GLOBALCLASS;
    WndClass.lpfnWndProc    = ImeWndProcW;
    WndClass.cbWndExtra     = sizeof(LONG_PTR);
    WndClass.hCursor        = LoadCursorW(NULL, IDC_ARROW);
 
    atom = RegisterClassExWOWW(&WndClass, 0, FNID_IME, 0, FALSE);
    if (!atom)
    {
        ERR("Failed to register IME Class!\n");
        return FALSE;
    }
 
    RegisterDefaultClasses |= ICLASS_TO_MASK(ICLS_IME);
    TRACE("RegisterIMEClass atom = %u\n", atom);
    return TRUE;
}

Referenced by RegisterSystemControls().

SendIMEMessageExA()

LRESULT WINAPI SendIMEMessageExA	(	HWND	hwnd,
		LPARAM	lParam
	)

Definition at line 1225 of file imm.c.

{
    return IMM_FN(ImmSendIMEMessageExA)(hwnd, lParam);
}

SendIMEMessageExW()

LRESULT WINAPI SendIMEMessageExW	(	HWND	hwnd,
		LPARAM	lParam
	)

Definition at line 1215 of file imm.c.

{
    return IMM_FN(ImmSendIMEMessageExW)(hwnd, lParam);
}

UpdatePerUserImmEnabling()

BOOL WINAPI UpdatePerUserImmEnabling

(

VOID

)

Definition at line 1102 of file imm.c.

{
    HMODULE imm32;
    BOOL ret;
 
    ret = NtUserCallNoParam(NOPARAM_ROUTINE_UPDATEPERUSERIMMENABLING);
    if (!ret || !(gpsi->dwSRVIFlags & SRVINFO_IMM32))
        return FALSE;
 
    imm32 = GetModuleHandleW(L"imm32.dll");
    if (imm32)
        return TRUE;
 
    imm32 = LoadLibraryW(L"imm32.dll");
    if (imm32 == NULL)
    {
        ERR("Imm32 not installed!\n");
        ret = FALSE;
    }
 
    return ret;
}

Referenced by UpdatePerUserSystemParameters().

User32CanSetImeWindowToImc()

static BOOL User32CanSetImeWindowToImc ( HIMC  hIMC, HWND  hImeWnd  )

static

Definition at line 155 of file imm.c.

{
    PIMC pIMC = ValidateHandle(hIMC, TYPE_INPUTCONTEXT);
    return pIMC && (!pIMC->hImeWnd || pIMC->hImeWnd == hImeWnd || !ValidateHwnd(pIMC->hImeWnd));
}

Referenced by ImeWnd_OnCreate(), and ImeWnd_OnImeSetContext().

User32CreateImeUIWindow()

static HWND User32CreateImeUIWindow ( PIMEUI  pimeui, HKL  hKL  )

static

Definition at line 297 of file imm.c.

{
    IMEINFOEX ImeInfoEx;
    PIMEDPI pImeDpi;
    WNDCLASSW wc;
    HWND hwndUI = NULL;
    CHAR szUIClass[32];
    PWND pwnd = pimeui->spwnd;
 
    ASSERT(pimeui->spwnd != NULL);
 
    if (!pwnd || !IMM_FN(ImmGetImeInfoEx)(&ImeInfoEx, ImeInfoExKeyboardLayout, &hKL))
        return NULL;
 
    pImeDpi = IMM_FN(ImmLockImeDpi)(hKL);
    if (!pImeDpi)
        return NULL;
 
    if (!GetClassInfoW(pImeDpi->hInst, ImeInfoEx.wszUIClass, &wc))
        goto Quit;
 
    if (ImeInfoEx.ImeInfo.fdwProperty & IME_PROP_UNICODE)
    {
        hwndUI = CreateWindowW(ImeInfoEx.wszUIClass, ImeInfoEx.wszUIClass, WS_POPUP | WS_DISABLED,
                               0, 0, 0, 0, UserHMGetHandle(pwnd), 0, wc.hInstance, NULL);
    }
    else
    {
        WideCharToMultiByte(CP_ACP, 0, ImeInfoEx.wszUIClass, -1,
                            szUIClass, _countof(szUIClass), NULL, NULL);
        szUIClass[_countof(szUIClass) - 1] = 0;
 
        hwndUI = CreateWindowA(szUIClass, szUIClass, WS_POPUP | WS_DISABLED,
                               0, 0, 0, 0, UserHMGetHandle(pwnd), 0, wc.hInstance, NULL);
    }
 
    if (hwndUI)
        NtUserSetWindowLongPtr(hwndUI, IMMGWLP_IMC, (LONG_PTR)pimeui->hIMC, FALSE);
 
Quit:
    IMM_FN(ImmUnlockImeDpi)(pImeDpi);
    return hwndUI;
}

Referenced by ImeWnd_OnImeSelect(), and ImeWnd_OnImeSetContext().

User32DestroyImeUIWindow()

static VOID User32DestroyImeUIWindow ( PIMEUI  pimeui )

static

Definition at line 375 of file imm.c.

{
    HWND hwndUI = pimeui->hwndUI;
 
    if (IsWindow(hwndUI))
    {
        pimeui->fDestroy = TRUE;
        NtUserDestroyWindow(hwndUI);
    }
 
    pimeui->fShowStatus = pimeui->fDestroy = FALSE;
    pimeui->hwndUI = NULL;
}

Referenced by ImeWnd_OnImeSelect(), and ImeWndProc_common().

User32DoImeHelp()

static LRESULT FASTCALL User32DoImeHelp ( PIMEUI  pimeui, WPARAM  wParam, LPARAM  lParam  )

static

Definition at line 588 of file imm.c.

{
    WCHAR szHelpFile[MAX_PATH];
    DWORD ret, dwEsc = IME_ESC_GETHELPFILENAME;
    size_t cch;
 
    /* Is there any IME help file? */
    ret = IMM_FN(ImmEscapeW)(pimeui->hKL, pimeui->hIMC, IME_ESC_QUERY_SUPPORT, &dwEsc);
    if (!ret || !lParam)
        return ret;
 
    /* Get the help filename */
    if (IMM_FN(ImmEscapeW)(pimeui->hKL, pimeui->hIMC, IME_ESC_GETHELPFILENAME, szHelpFile))
    {
        /* Check filename extension */
        cch = wcslen(szHelpFile);
        if (cch > 4 && _wcsicmp(&szHelpFile[cch - 4], L".HLP") == 0)
        {
            /* Open the old-style help */
            TRACE("szHelpFile: %s\n", debugstr_w(szHelpFile));
            WinHelpW(NULL, szHelpFile, HELP_FINDER, 0);
        }
        else
        {
            /* Open the new-style help */
            FIXME("(%p, %p, %p): %s\n", pimeui, wParam, lParam, debugstr_w(szHelpFile));
            ret = FALSE;
        }
    }
 
    return ret;
}

Referenced by ImeWnd_OnImeSystem().

User32GetImeShowStatus()

static BOOL User32GetImeShowStatus ( VOID  )

static

Definition at line 162 of file imm.c.

{
    return (BOOL)NtUserCallNoParam(NOPARAM_ROUTINE_GETIMESHOWSTATUS);
}

Referenced by ImeWnd_OnImeControl(), ImeWnd_OnImeSelect(), ImeWnd_OnImeSetContext(), and ImeWnd_OnImeSystem().

User32GetImmFileName()

HRESULT User32GetImmFileName	(	_Out_ LPWSTR	lpBuffer,
		_In_ size_t	cchBuffer
	)

Definition at line 57 of file imm.c.

{
    UINT length = GetSystemDirectoryW(lpBuffer, cchBuffer);
    if (length && length < cchBuffer)
    {
        StringCchCatW(lpBuffer, cchBuffer, L"\\");
        return StringCchCatW(lpBuffer, cchBuffer, L"imm32.dll");
    }
    return StringCchCopyW(lpBuffer, cchBuffer, L"imm32.dll");
}

Referenced by DllMain(), IntInitializeImmEntryTable(), and User32InitializeImmEntryTable().

User32InitializeImmEntryTable()

BOOL WINAPI User32InitializeImmEntryTable

(

DWORD

magic

)

Definition at line 126 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 && !gbImmInitializing)
    {
        WCHAR ImmFile[MAX_PATH];
        User32GetImmFileName(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 ImmDllInitialize().

User32NotifyOpenStatus()

static VOID User32NotifyOpenStatus ( PIMEUI  pimeui, HWND  hwndIMC, BOOL  bOpen  )

static

Definition at line 199 of file imm.c.

{
    WPARAM wParam = (bOpen ? IMN_OPENSTATUSWINDOW : IMN_CLOSESTATUSWINDOW);
 
    ASSERT(pimeui->spwnd != NULL);
 
    pimeui->fShowStatus = bOpen;
 
    if (LOWORD(GetWin32ClientInfo()->dwExpWinVer) >= 0x400)
        SendMessageW(hwndIMC, WM_IME_NOTIFY, wParam, 0);
    else
        User32SendImeUIMessage(pimeui, WM_IME_NOTIFY, wParam, 0, TRUE);
}

Referenced by ImeWnd_OnImeSelect(), and ImeWnd_OnImeSetContext().

User32SendImeUIMessage()

static LRESULT User32SendImeUIMessage ( PIMEUI  pimeui, UINT  uMsg, WPARAM  wParam, LPARAM  lParam, BOOL  unicode  )

static

Definition at line 170 of file imm.c.

{
    LRESULT ret = 0;
    HWND hwndUI = pimeui->hwndUI;
    PWND pwnd, pwndUI;
 
    ASSERT(pimeui->spwnd != NULL);
 
    pwnd = pimeui->spwnd;
    pwndUI = ValidateHwnd(hwndUI);
    if (!pwnd || (pwnd->state & WNDS_DESTROYED) || (pwnd->state2 & WNDS2_INDESTROY) ||
        !pwndUI || (pwndUI->state & WNDS_DESTROYED) || (pwndUI->state2 & WNDS2_INDESTROY))
    {
        return 0;
    }
 
    InterlockedIncrement(&pimeui->nCntInIMEProc);
 
    if (unicode)
        ret = SendMessageW(hwndUI, uMsg, wParam, lParam);
    else
        ret = SendMessageA(hwndUI, uMsg, wParam, lParam);
 
    InterlockedDecrement(&pimeui->nCntInIMEProc);
 
    return ret;
}

Referenced by ImeWnd_OnImeControl(), ImeWnd_OnImeNotify(), ImeWnd_OnImeSelect(), ImeWnd_OnImeSetContext(), ImeWndProc_common(), and User32NotifyOpenStatus().

User32SetImeActivenessOfWindow()

static VOID FASTCALL User32SetImeActivenessOfWindow ( HWND  hWnd, BOOL  bActive  )

static

Definition at line 562 of file imm.c.

{
    HIMC hIMC;
 
    if (!hWnd || !IsWindow(hWnd))
    {
        IMM_FN(ImmSetActiveContext)(NULL, NULL, bActive);
        return;
    }
 
    hIMC = IMM_FN(ImmGetContext)(hWnd);
    IMM_FN(ImmSetActiveContext)(hWnd, hIMC, bActive);
    IMM_FN(ImmReleaseContext)(hWnd, hIMC);
}

Referenced by ImeWnd_OnImeSystem().

User32SetImeWindowOfImc()

static VOID User32SetImeWindowOfImc ( HIMC  hIMC, HWND  hImeWnd  )

static

Definition at line 214 of file imm.c.

{
    PIMC pIMC = ValidateHandle(hIMC, TYPE_INPUTCONTEXT);
    if (!pIMC || pIMC->hImeWnd == hImeWnd)
        return;
 
    NtUserUpdateInputContext(hIMC, UIC_IMEWINDOW, (ULONG_PTR)hImeWnd);
}

Referenced by User32UpdateImcOfImeUI().

User32UpdateImcOfImeUI()

static VOID User32UpdateImcOfImeUI ( PIMEUI  pimeui, HIMC  hNewIMC  )

static

Definition at line 224 of file imm.c.

{
    HWND hImeWnd;
    HIMC hOldIMC = pimeui->hIMC;
 
    ASSERT(pimeui->spwnd != NULL);
    hImeWnd = UserHMGetHandle(pimeui->spwnd);
 
    if (hNewIMC == hOldIMC)
        return;
 
    if (hOldIMC)
        User32SetImeWindowOfImc(hOldIMC, NULL);
 
    pimeui->hIMC = hNewIMC;
 
    if (hNewIMC)
        User32SetImeWindowOfImc(hNewIMC, hImeWnd);
}

Referenced by ImeWnd_OnCreate(), and ImeWnd_OnImeSetContext().

WINE_DEFAULT_DEBUG_CHANNEL()

WINE_DEFAULT_DEBUG_CHANNEL

(

user32

)

WINNLSEnableIME()

BOOL WINAPI WINNLSEnableIME	(	HWND	hwnd,
		BOOL	enable
	)

Definition at line 1235 of file imm.c.

{
    return IMM_FN(ImmWINNLSEnableIME)(hwnd, enable);
}

WINNLSGetEnableStatus()

BOOL WINAPI WINNLSGetEnableStatus

(

HWND

hwnd

)

Definition at line 1245 of file imm.c.

{
    return IMM_FN(ImmWINNLSGetEnableStatus)(hwnd);
}

WINNLSGetIMEHotkey()

UINT WINAPI WINNLSGetIMEHotkey

(

HWND

hwnd

)

Definition at line 1255 of file imm.c.

{
    return FALSE;
}

Variable Documentation

gbImmInitializing

BOOL gbImmInitializing = FALSE

Definition at line 22 of file imm.c.

Referenced by InitializeImmEntryTable(), and User32InitializeImmEntryTable().

gfConIme

INT gfConIme = -1

Definition at line 24 of file imm.c.

Referenced by ImeWnd_OnImeNotify(), and ImeWnd_OnImeSetContext().

ghImm32

HINSTANCE ghImm32 = NULL

Definition at line 20 of file imm.c.

Referenced by DllMain(), IntInitializeImmEntryTable(), and User32InitializeImmEntryTable().

gImmApiEntries

Imm32ApiTable gImmApiEntries

Initial value:

= {
 
 
#define DEFINE_IMM_ENTRY(type, name, params, retval, retkind) 
                   
 
}

Definition at line 47 of file imm.c.