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)
#define	IFN_GetPenMenuData   12

Typedefs
typedef VOID(CALLBACK *	FN_GetPenMenuData) (PUINT pnID, PDWORD_PTR pdwMenuData)

Functions
	WINE_DEFAULT_DEBUG_CHANNEL (user32)
HWND FASTCALL	IntGetTopLevelWindow (HWND hWnd)
HRESULT	User32GetSystemFilePath (_Out_writes_(cchBuffer) PWSTR lpBuffer, _In_ SIZE_T cchBuffer, _In_ PCWSTR pszFileName)
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 BOOL CALLBACK	ImeWnd_SwitchSoftKbdProc (_In_ HIMC hIMC, _In_ LPARAM lParam)
static BOOL CALLBACK	User32GetPenMenuData (_Out_ PUINT pnID, _Out_ PDWORD_PTR pdwMenuData)
static VOID	User32ImeMenuItemSelected (HWND hwndTarget)
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	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
static FN_GetPenMenuData	s_pGetPenMenuData = NULL
const struct builtin_class_descr	IME_builtin_class

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 41 of file imm.c.

DEFINE_IMM_ENTRY [2/3]

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

Definition at line 41 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 41 of file imm.c.

IFN_GetPenMenuData

#define IFN_GetPenMenuData   12

Definition at line 628 of file imm.c.

IMM_INIT_MAGIC

#define IMM_INIT_MAGIC   0x19650412

Definition at line 15 of file imm.c.

MAX_CANDIDATEFORM

#define MAX_CANDIDATEFORM   4

Definition at line 16 of file imm.c.

Typedef Documentation

FN_GetPenMenuData

typedef VOID(CALLBACK * FN_GetPenMenuData) (PUINT pnID, PDWORD_PTR pdwMenuData)

Definition at line 626 of file imm.c.

Function Documentation

CtfLoadThreadLayout()

VOID FASTCALL CtfLoadThreadLayout

(

PIMEUI

pimeui

)

Definition at line 564 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 334 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 415 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 239 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 380 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 834 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 679 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)((HKL)lParam);
            break;
 
        case IMS_SOFTKBDONOFF:
            IMM_FN(ImmEnumInputContext)(0, ImeWnd_SwitchSoftKbdProc, lParam);
            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 IMS_IMEMENUITEMSELECTED:
            User32ImeMenuItemSelected((HWND)lParam);
            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().

ImeWnd_SwitchSoftKbdProc()

static BOOL CALLBACK ImeWnd_SwitchSoftKbdProc ( _In_ HIMC  hIMC, _In_ LPARAM  lParam  )

static

Definition at line 608 of file imm.c.

{
    DWORD dwConversion, dwSentence, dwNewConversion;
 
    IMM_FN(ImmGetConversionStatus)(hIMC, &dwConversion, &dwSentence);
 
    if (lParam)
        dwNewConversion = dwConversion | IME_CMODE_SOFTKBD;
    else
        dwNewConversion = dwConversion & ~IME_CMODE_SOFTKBD;
 
    if (dwNewConversion != dwConversion)
        IMM_FN(ImmSetConversionStatus)(hIMC, dwNewConversion, dwSentence);
 
    return TRUE;
}

Referenced by ImeWnd_OnImeSystem().

ImeWndProc_common()

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

Definition at line 989 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;
    }
 
    if (msg == WM_NCCREATE)
    {
        pimeui = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(IMEUI));
        if (!pimeui)
        {
            ERR("HeapAlloc failed\n");
            NtUserSetWindowFNID(hwnd, FNID_DESTROY);
            return FALSE;
        }
        pimeui->spwnd = pWnd;
        SetWindowLongPtrW(hwnd, GWLP_IMEWND_PIMEUI, (LONG_PTR)pimeui);
    }
    else
    {
        pimeui = (PIMEUI)GetWindowLongPtrW(hwnd, GWLP_IMEWND_PIMEUI);
        if (!pimeui)
        {
            ERR("Invalid IMEWND\n");
            NtUserSetWindowFNID(hwnd, FNID_DESTROY);
            return 0;
        }
    }
 
    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 1150 of file imm.c.

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

ImeWndProcW()

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

Definition at line 1155 of file imm.c.

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

IMPGetIMEA()

BOOL WINAPI IMPGetIMEA	(	HWND	hwnd,
		LPIMEPROA	ime
	)

Definition at line 1249 of file imm.c.

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

IMPGetIMEW()

BOOL WINAPI IMPGetIMEW	(	HWND	hwnd,
		LPIMEPROW	ime
	)

Definition at line 1219 of file imm.c.

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

IMPQueryIMEA()

BOOL WINAPI IMPQueryIMEA

(

LPIMEPROA

ime

)

Definition at line 1239 of file imm.c.

{
    return IMM_FN(ImmIMPQueryIMEA)(ime);
}

IMPQueryIMEW()

BOOL WINAPI IMPQueryIMEW

(

LPIMEPROW

ime

)

Definition at line 1209 of file imm.c.

{
    return IMM_FN(ImmIMPQueryIMEW)(ime);
}

IMPSetIMEA()

BOOL WINAPI IMPSetIMEA	(	HWND	hwnd,
		LPIMEPROA	ime
	)

Definition at line 1229 of file imm.c.

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

IMPSetIMEW()

BOOL WINAPI IMPSetIMEW	(	HWND	hwnd,
		LPIMEPROW	ime
	)

Definition at line 1199 of file imm.c.

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

InitializeImmEntryTable()

BOOL WINAPI InitializeImmEntryTable

(

VOID

)

Definition at line 120 of file imm.c.

{
    gbImmInitializing = TRUE;
    return IntInitializeImmEntryTable();
}

Referenced by DllMain().

IntGetTopLevelWindow()

HWND FASTCALL IntGetTopLevelWindow

(

HWND

hWnd

)

Definition at line 25 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 72 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;
 
    User32GetSystemFilePath(ImmFile, _countof(ImmFile), L"imm32.dll");
    TRACE("File %s\n", debugstr_w(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().

SendIMEMessageExA()

LRESULT WINAPI SendIMEMessageExA	(	HWND	hwnd,
		LPARAM	lParam
	)

Definition at line 1269 of file imm.c.

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

SendIMEMessageExW()

LRESULT WINAPI SendIMEMessageExW	(	HWND	hwnd,
		LPARAM	lParam
	)

Definition at line 1259 of file imm.c.

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

UpdatePerUserImmEnabling()

BOOL WINAPI UpdatePerUserImmEnabling

(

VOID

)

Definition at line 1160 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 154 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 289 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 365 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 574 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 160 of file imm.c.

{
    return (BOOL)NtUserCallNoParam(NOPARAM_ROUTINE_GETIMESHOWSTATUS);
}

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

User32GetPenMenuData()

static BOOL CALLBACK User32GetPenMenuData ( _Out_ PUINT  pnID, _Out_ PDWORD_PTR  pdwMenuData  )

static

Definition at line 631 of file imm.c.

{
    if (!s_pGetPenMenuData)
    {
        WCHAR szPath[MAX_PATH];
        HMODULE hIndicDll = GetModuleHandleW(L"indicdll.dll");
        if (!hIndicDll)
        {
            User32GetSystemFilePath(szPath, _countof(szPath), L"indicdll.dll");
            hIndicDll = LoadLibraryW(szPath);
        }
        if (!hIndicDll)
        {
            ERR("indicdll.dll not loaded: %s\n", debugstr_w(szPath));
            return FALSE;
        }
 
        s_pGetPenMenuData =
            (FN_GetPenMenuData)GetProcAddress(hIndicDll, MAKEINTRESOURCEA(IFN_GetPenMenuData));
    }
 
    if (!s_pGetPenMenuData)
        return FALSE;
 
    s_pGetPenMenuData(pnID, pdwMenuData);
    return TRUE;
}

Referenced by User32ImeMenuItemSelected().

User32GetSystemFilePath()

HRESULT User32GetSystemFilePath	(	_Out_writes_(cchBuffer) PWSTR	lpBuffer,
		_In_ SIZE_T	cchBuffer,
		_In_ PCWSTR	pszFileName
	)

Definition at line 54 of file imm.c.

{
    UINT length = GetSystemDirectoryW(lpBuffer, cchBuffer);
    if (length && length < cchBuffer)
    {
        StringCchCatW(lpBuffer, cchBuffer, L"\\");
        return StringCchCatW(lpBuffer, cchBuffer, pszFileName);
    }
    DWORD dwError = GetLastError();
    ERR("GetSystemDirectoryW failed (error %lu)\n", dwError);
    StringCchCopyW(lpBuffer, cchBuffer, pszFileName);
    return HRESULT_FROM_WIN32(dwError);
}

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

User32ImeMenuItemSelected()

static VOID User32ImeMenuItemSelected ( HWND  hwndTarget )

static

Definition at line 661 of file imm.c.

{
    if (!IsWindow(hwndTarget))
        return;
 
    HIMC hIMC = IMM_FN(ImmGetContext)(hwndTarget);
    if (!hIMC)
        return;
 
    UINT nID = 0;
    DWORD_PTR dwMenuData = 0;
    if (User32GetPenMenuData(&nID, &dwMenuData))
        IMM_FN(ImmNotifyIME)(hIMC, NI_IMEMENUSELECTED, nID, dwMenuData);
 
    IMM_FN(ImmReleaseContext)(hwndTarget, hIMC);
}

Referenced by ImeWnd_OnImeSystem().

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];
        User32GetSystemFilePath(ImmFile, _countof(ImmFile), L"imm32.dll");
        ghImm32 = LoadLibraryW(ImmFile);
        if (ghImm32 == NULL)
        {
            ERR("Did not load imm32.dll!\n");
            return FALSE;
        }
    }
 
    return IMM_FN(ImmRegisterClient)(&gSharedInfo, ghImm32);
}

User32NotifyOpenStatus()

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

static

Definition at line 195 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 167 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 549 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 209 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 218 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 1279 of file imm.c.

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

WINNLSGetEnableStatus()

BOOL WINAPI WINNLSGetEnableStatus

(

HWND

hwnd

)

Definition at line 1289 of file imm.c.

{
    return IMM_FN(ImmWINNLSGetEnableStatus)(hwnd);
}

WINNLSGetIMEHotkey()

UINT WINAPI WINNLSGetIMEHotkey

(

HWND

hwnd

)

Definition at line 1299 of file imm.c.

{
    return FALSE;
}

Variable Documentation

gbImmInitializing

BOOL gbImmInitializing = FALSE

Definition at line 21 of file imm.c.

Referenced by InitializeImmEntryTable(), and User32InitializeImmEntryTable().

gfConIme

INT gfConIme = -1

Definition at line 23 of file imm.c.

Referenced by ImeWnd_OnImeNotify(), and ImeWnd_OnImeSetContext().

ghImm32

HINSTANCE ghImm32 = NULL

Definition at line 19 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 45 of file imm.c.

IME_builtin_class

const struct builtin_class_descr IME_builtin_class

Initial value:

=
{
    L"IME",                       
    CS_GLOBALCLASS,               
    ImeWndProcA,                  
    ImeWndProcW,                  
    sizeof(IMEWND) - sizeof(WND), 
    IDC_ARROW,                    
    NULL                          
}

Definition at line 1183 of file imm.c.

s_pGetPenMenuData

FN_GetPenMenuData s_pGetPenMenuData = NULL

static

Definition at line 627 of file imm.c.

Referenced by User32GetPenMenuData().