ime.c File Reference

#include <win32k.h>
#include <jpnvkeys.h>

Include dependency graph for ime.c:

Go to the source code of this file.

Classes
struct	tagIMEHOTKEY

Macros
#define	INVALID_THREAD_ID   ((ULONG)-1)
#define	INVALID_HOTKEY   ((UINT)-1)
#define	MOD_KEYS   (MOD_CONTROL | MOD_SHIFT | MOD_ALT | MOD_WIN)
#define	MOD_LEFT_RIGHT   (MOD_LEFT | MOD_RIGHT)
#define	LANGID_CHINESE_SIMPLIFIED   MAKELANGID(LANG_CHINESE, SUBLANG_CHINESE_SIMPLIFIED)
#define	LANGID_JAPANESE   MAKELANGID(LANG_JAPANESE, SUBLANG_DEFAULT)
#define	LANGID_KOREAN   MAKELANGID(LANG_KOREAN, SUBLANG_KOREAN)
#define	LANGID_CHINESE_TRADITIONAL   MAKELANGID(LANG_CHINESE, SUBLANG_CHINESE_TRADITIONAL)
#define	LANGID_NEUTRAL   MAKELANGID(LANG_NEUTRAL, SUBLANG_NEUTRAL)
#define	IME_CHOTKEY   0x10
#define	IME_JHOTKEY   0x30
#define	IME_KHOTKEY   0x50
#define	IME_THOTKEY   0x70
#define	IME_XHOTKEY   0x90

Typedefs
typedef struct tagIMEHOTKEY	IMEHOTKEY
typedef struct tagIMEHOTKEY *	PIMEHOTKEY

Functions
	DBG_DEFAULT_CHANNEL (UserMisc)
DWORD FASTCALL	IntGetImeCompatFlags (PTHREADINFO pti)
UINT FASTCALL	IntGetImeHotKeyLanguageScore (HKL hKL, LANGID HotKeyLangId)
HKL FASTCALL	IntGetActiveKeyboardLayout (VOID)
static LANGID FASTCALL	IntGetImeHotKeyLangId (DWORD dwHotKeyId)
static VOID FASTCALL	IntAddImeHotKey (PIMEHOTKEY *ppList, PIMEHOTKEY pHotKey)
static PIMEHOTKEY FASTCALL	IntGetImeHotKeyById (PIMEHOTKEY pList, DWORD dwHotKeyId)
static PIMEHOTKEY APIENTRY	IntGetImeHotKeyByKeyAndLang (PIMEHOTKEY pList, UINT uModKeys, UINT uLeftRight, UINT uVirtualKey, LANGID TargetLangId)
static VOID FASTCALL	IntDeleteImeHotKey (PIMEHOTKEY *ppList, PIMEHOTKEY pHotKey)
PIMEHOTKEY	IntGetImeHotKeyByKey (PIMEHOTKEY pList, UINT uModKeys, UINT uLeftRight, UINT uVirtualKey)
PIMEHOTKEY	IntCheckImeHotKey (PUSER_MESSAGE_QUEUE MessageQueue, UINT uVirtualKey, LPARAM lParam)
VOID FASTCALL	IntFreeImeHotKeys (VOID)
static BOOL APIENTRY	IntSetImeHotKey (DWORD dwHotKeyId, UINT uModifiers, UINT uVirtualKey, HKL hKL, DWORD dwAction)
BOOL NTAPI	NtUserGetImeHotKey (DWORD dwHotKeyId, LPUINT lpuModifiers, LPUINT lpuVirtualKey, LPHKL lphKL)
BOOL NTAPI	NtUserSetImeHotKey (DWORD dwHotKeyId, UINT uModifiers, UINT uVirtualKey, HKL hKL, DWORD dwAction)
DWORD NTAPI	NtUserCheckImeHotKey (UINT uVirtualKey, LPARAM lParam)
PWND FASTCALL	IntGetTopLevelWindow (PWND pwnd)
HIMC FASTCALL	IntAssociateInputContext (PWND pWnd, PIMC pImc)
DWORD NTAPI	NtUserSetThreadLayoutHandles (HKL hNewKL, HKL hOldKL)
DWORD FASTCALL	UserBuildHimcList (PTHREADINFO pti, DWORD dwCount, HIMC *phList)
UINT FASTCALL	IntImmProcessKey (PUSER_MESSAGE_QUEUE MessageQueue, PWND pWnd, UINT uMsg, WPARAM wParam, LPARAM lParam)
NTSTATUS NTAPI	NtUserBuildHimcList (DWORD dwThreadId, DWORD dwCount, HIMC *phList, LPDWORD pdwCount)
static VOID FASTCALL	UserSetImeConversionKeyState (PTHREADINFO pti, DWORD dwConversion)
DWORD NTAPI	NtUserNotifyIMEStatus (HWND hwnd, BOOL fOpen, DWORD dwConversion)
BOOL NTAPI	NtUserDisableThreadIme (DWORD dwThreadID)
DWORD NTAPI	NtUserGetAppImeLevel (HWND hWnd)
BOOL FASTCALL	UserGetImeInfoEx (_Inout_ PWINSTATION_OBJECT pWinSta, _Inout_ PIMEINFOEX pInfoEx, _In_ IMEINFOEXCLASS SearchType)
BOOL NTAPI	NtUserGetImeInfoEx (PIMEINFOEX pImeInfoEx, IMEINFOEXCLASS SearchType)
BOOL NTAPI	NtUserSetAppImeLevel (HWND hWnd, DWORD dwLevel)
BOOL FASTCALL	UserSetImeInfoEx (_Inout_ PWINSTATION_OBJECT pWinSta, _Inout_ PIMEINFOEX pImeInfoEx)
BOOL NTAPI	NtUserSetImeInfoEx (PIMEINFOEX pImeInfoEx)
VOID FASTCALL	IntImeSetFutureOwner (PWND pImeWnd, PWND pwndOwner)
PWND FASTCALL	IntGetLastTopMostWindowNoIME (PWND pImeWnd)
VOID FASTCALL	IntImeSetTopMost (PWND pImeWnd, BOOL bTopMost, PWND pwndInsertBefore)
VOID FASTCALL	IntImeCheckTopmost (PWND pImeWnd)
BOOL NTAPI	NtUserSetImeOwnerWindow (HWND hImeWnd, HWND hwndFocus)
PVOID	AllocInputContextObject (PDESKTOP pDesk, PTHREADINFO pti, SIZE_T Size, PVOID *HandleOwner)
VOID	UserFreeInputContext (PVOID Object)
BOOLEAN	UserDestroyInputContext (PVOID Object)
BOOL	IntDestroyInputContext (PIMC pIMC)
BOOL NTAPI	NtUserDestroyInputContext (HIMC hIMC)
PIMC FASTCALL	UserCreateInputContext (ULONG_PTR dwClientImcData)
HIMC NTAPI	NtUserCreateInputContext (ULONG_PTR dwClientImcData)
DWORD FASTCALL	IntAssociateInputContextEx (PWND pWnd, PIMC pIMC, DWORD dwFlags)
DWORD NTAPI	NtUserAssociateInputContext (HWND hWnd, HIMC hIMC, DWORD dwFlags)
BOOL FASTCALL	UserUpdateInputContext (PIMC pIMC, DWORD dwType, DWORD_PTR dwValue)
BOOL NTAPI	NtUserUpdateInputContext (HIMC hIMC, DWORD dwType, DWORD_PTR dwValue)
DWORD_PTR NTAPI	NtUserQueryInputContext (HIMC hIMC, DWORD dwType)
BOOL	IntFindNonImeRelatedWndOfSameThread (PWND pwndParent, PWND pwndTarget)
BOOL FASTCALL	IntWantImeWindow (PWND pwndTarget)
PWND FASTCALL	co_IntCreateDefaultImeWindow (PWND pwndTarget, HINSTANCE hInst)
BOOL FASTCALL	IntImeCanDestroyDefIMEforChild (PWND pImeWnd, PWND pwndTarget)
BOOL FASTCALL	IntImeCanDestroyDefIME (PWND pImeWnd, PWND pwndTarget)
BOOL FASTCALL	IntCheckImeShowStatus (PWND pwndIme, PTHREADINFO pti)
LRESULT FASTCALL	IntSendMessageToUI (PTHREADINFO ptiIME, PIMEUI pimeui, UINT uMsg, WPARAM wParam, LPARAM lParam)
VOID FASTCALL	IntSendOpenStatusNotify (PTHREADINFO ptiIME, PIMEUI pimeui, PWND pWnd, BOOL bOpen)
VOID FASTCALL	IntNotifyImeShowStatus (PWND pImeWnd)
BOOL FASTCALL	IntBroadcastImeShowStatusChange (PWND pImeWnd, BOOL bShow)
VOID FASTCALL	IntCheckImeShowStatusInThread (PWND pImeWnd)

Variables
HIMC	ghIMC = NULL
BOOL	gfImeOpen = (BOOL)-1
DWORD	gdwImeConversion = (DWORD)-1
BOOL	gfIMEShowStatus = (BOOL)-1
PIMEHOTKEY	gpImeHotKeyList = NULL
LCID	glcidSystem = 0

Macro Definition Documentation

IME_CHOTKEY

#define IME_CHOTKEY   0x10

IME_JHOTKEY

#define IME_JHOTKEY   0x30

IME_KHOTKEY

#define IME_KHOTKEY   0x50

IME_THOTKEY

#define IME_THOTKEY   0x70

IME_XHOTKEY

#define IME_XHOTKEY   0x90

INVALID_HOTKEY

#define INVALID_HOTKEY   ((UINT)-1)

Definition at line 16 of file ime.c.

INVALID_THREAD_ID

#define INVALID_THREAD_ID   ((ULONG)-1)

Definition at line 15 of file ime.c.

LANGID_CHINESE_SIMPLIFIED

#define LANGID_CHINESE_SIMPLIFIED   MAKELANGID(LANG_CHINESE, SUBLANG_CHINESE_SIMPLIFIED)

Definition at line 20 of file ime.c.

LANGID_CHINESE_TRADITIONAL

#define LANGID_CHINESE_TRADITIONAL   MAKELANGID(LANG_CHINESE, SUBLANG_CHINESE_TRADITIONAL)

Definition at line 23 of file ime.c.

LANGID_JAPANESE

#define LANGID_JAPANESE   MAKELANGID(LANG_JAPANESE, SUBLANG_DEFAULT)

Definition at line 21 of file ime.c.

LANGID_KOREAN

#define LANGID_KOREAN   MAKELANGID(LANG_KOREAN, SUBLANG_KOREAN)

Definition at line 22 of file ime.c.

LANGID_NEUTRAL

#define LANGID_NEUTRAL   MAKELANGID(LANG_NEUTRAL, SUBLANG_NEUTRAL)

Definition at line 24 of file ime.c.

MOD_KEYS

#define MOD_KEYS   (MOD_CONTROL | MOD_SHIFT | MOD_ALT | MOD_WIN)

Definition at line 17 of file ime.c.

MOD_LEFT_RIGHT

#define MOD_LEFT_RIGHT   (MOD_LEFT | MOD_RIGHT)

Definition at line 18 of file ime.c.

Typedef Documentation

IMEHOTKEY

typedef struct tagIMEHOTKEY IMEHOTKEY

PIMEHOTKEY

typedef struct tagIMEHOTKEY * PIMEHOTKEY

Function Documentation

AllocInputContextObject()

PVOID AllocInputContextObject	(	PDESKTOP	pDesk,
		PTHREADINFO	pti,
		SIZE_T	Size,
		PVOID *	HandleOwner
	)

Definition at line 1428 of file ime.c.

{
    PTHRDESKHEAD ObjHead;
 
    ASSERT(Size > sizeof(*ObjHead));
    ASSERT(pti != NULL);
 
    if (!pDesk)
        pDesk = pti->rpdesk;
 
    ObjHead = DesktopHeapAlloc(pDesk, Size);
    if (!ObjHead)
        return NULL;
 
    RtlZeroMemory(ObjHead, Size);
 
    ObjHead->pSelf = ObjHead;
    ObjHead->rpdesk = pDesk;
    ObjHead->pti = pti;
    IntReferenceThreadInfo(pti);
    *HandleOwner = pti;
    pti->ppi->UserHandleCount++;
 
    return ObjHead;
}

co_IntCreateDefaultImeWindow()

PWND FASTCALL co_IntCreateDefaultImeWindow	(	PWND	pwndTarget,
		HINSTANCE	hInst
	)

Definition at line 1957 of file ime.c.

{
    LARGE_UNICODE_STRING WindowName;
    UNICODE_STRING ClassName;
    PWND pImeWnd;
    PIMEUI pimeui;
    CREATESTRUCTW Cs;
    USER_REFERENCE_ENTRY Ref;
    PTHREADINFO pti = PsGetCurrentThreadWin32Thread();
    HANDLE pid = PsGetThreadProcessId(pti->pEThread);
 
    if (!(pti->spDefaultImc) && pid == gpidLogon)
        UserCreateInputContext(0);
 
    if (!(pti->spDefaultImc) || IS_WND_IMELIKE(pwndTarget) || !(pti->rpdesk->pheapDesktop))
        return NULL;
 
    if (IS_WND_CHILD(pwndTarget) && !(pwndTarget->style & WS_VISIBLE) &&
        pwndTarget->spwndParent->head.pti->ppi != pti->ppi)
    {
        return NULL;
    }
 
    RtlInitLargeUnicodeString(&WindowName, L"Default IME", 0);
 
    ClassName.Buffer = (PWCH)(ULONG_PTR)gpsi->atomSysClass[ICLS_IME];
    ClassName.Length = 0;
    ClassName.MaximumLength = 0;
 
    UserRefObjectCo(pwndTarget, &Ref);
 
    RtlZeroMemory(&Cs, sizeof(Cs));
    Cs.style = WS_POPUP | WS_DISABLED;
    Cs.hInstance = hInst;
    Cs.hwndParent = UserHMGetHandle(pwndTarget);
    Cs.lpszName = WindowName.Buffer;
    Cs.lpszClass = ClassName.Buffer;
 
    // NOTE: LARGE_UNICODE_STRING is compatible to LARGE_STRING.
    pImeWnd = co_UserCreateWindowEx(&Cs, &ClassName, (PLARGE_STRING)&WindowName, NULL, WINVER);
    if (pImeWnd)
    {
        pimeui = ((PIMEWND)pImeWnd)->pimeui;
        _SEH2_TRY
        {
            ProbeForWrite(pimeui, sizeof(IMEUI), 1);
            pimeui->fDefault = TRUE;
            if (IS_WND_CHILD(pwndTarget) && pwndTarget->spwndParent->head.pti != pti)
                pimeui->fChildThreadDef = TRUE;
        }
        _SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER)
        {
            ERR("%p\n", pimeui);
        }
        _SEH2_END;
    }
 
    UserDerefObjectCo(pwndTarget);
    return pImeWnd;
}

Referenced by co_UserCreateWindowEx().

DBG_DEFAULT_CHANNEL()

DBG_DEFAULT_CHANNEL

(

UserMisc

)

IntAddImeHotKey()

static VOID FASTCALL IntAddImeHotKey ( PIMEHOTKEY *  ppList, PIMEHOTKEY  pHotKey  )

static

Definition at line 125 of file ime.c.

{
    PIMEHOTKEY pNode;
 
    if (!*ppList)
    {
        *ppList = pHotKey;
        return;
    }
 
    for (pNode = *ppList; pNode; pNode = pNode->pNext)
    {
        if (!pNode->pNext)
        {
            pNode->pNext = pHotKey;
            return;
        }
    }
}

Referenced by IntSetImeHotKey().

IntAssociateInputContext()

HIMC FASTCALL IntAssociateInputContext	(	PWND	pWnd,
		PIMC	pImc
	)

Definition at line 499 of file ime.c.

{
    HIMC hOldImc = pWnd->hImc;
    pWnd->hImc = (pImc ? UserHMGetHandle(pImc) : NULL);
    return hOldImc;
}

Referenced by IntAssociateInputContextEx(), and IntDestroyInputContext().

IntAssociateInputContextEx()

DWORD FASTCALL IntAssociateInputContextEx	(	PWND	pWnd,
		PIMC	pIMC,
		DWORD	dwFlags
	)

Definition at line 1636 of file ime.c.

{
    DWORD ret = 0;
    PWINDOWLIST pwl;
    BOOL bIgnoreNullImc = (dwFlags & IACE_IGNORENOCONTEXT);
    PTHREADINFO pti = pWnd->head.pti;
    PWND pwndTarget, pwndFocus = pti->MessageQueue->spwndFocus;
    HWND *phwnd;
    HIMC hIMC;
 
    if (dwFlags & IACE_DEFAULT)
    {
        pIMC = pti->spDefaultImc;
    }
    else
    {
        if (pIMC && pti != pIMC->head.pti)
            return 2;
    }
 
    if (pWnd->head.pti->ppi != GetW32ThreadInfo()->ppi ||
        (pIMC && pIMC->head.rpdesk != pWnd->head.rpdesk))
    {
        return 2;
    }
 
    if ((dwFlags & IACE_CHILDREN) && pWnd->spwndChild)
    {
        pwl = IntBuildHwndList(pWnd->spwndChild, IACE_CHILDREN | IACE_LIST, pti);
        if (pwl)
        {
            for (phwnd = pwl->ahwnd; *phwnd != HWND_TERMINATOR; ++phwnd)
            {
                pwndTarget = ValidateHwndNoErr(*phwnd);
                if (!pwndTarget)
                    continue;
 
                hIMC = (pIMC ? UserHMGetHandle(pIMC) : NULL);
                if (pwndTarget->hImc == hIMC || (bIgnoreNullImc && !pwndTarget->hImc))
                    continue;
 
                IntAssociateInputContext(pwndTarget, pIMC);
                if (pwndTarget == pwndFocus)
                    ret = 1;
            }
 
            IntFreeHwndList(pwl);
        }
    }
 
    if (!bIgnoreNullImc || pWnd->hImc)
    {
        hIMC = (pIMC ? UserHMGetHandle(pIMC) : NULL);
        if (pWnd->hImc != hIMC)
        {
            IntAssociateInputContext(pWnd, pIMC);
            if (pWnd == pwndFocus)
                ret = 1;
        }
    }
 
    return ret;
}

Referenced by NtUserAssociateInputContext().

IntBroadcastImeShowStatusChange()

BOOL FASTCALL IntBroadcastImeShowStatusChange	(	PWND	pImeWnd,
		BOOL	bShow
	)

Definition at line 2386 of file ime.c.

{
    if (gfIMEShowStatus == bShow || !IS_IMM_MODE())
        return TRUE;
 
    gfIMEShowStatus = bShow;
    IntNotifyImeShowStatus(pImeWnd);
    return TRUE;
}

Referenced by NtUserCallHwndParamLock().

IntCheckImeHotKey()

PIMEHOTKEY IntCheckImeHotKey	(	PUSER_MESSAGE_QUEUE	MessageQueue,
		UINT	uVirtualKey,
		LPARAM	lParam
	)

Definition at line 275 of file ime.c.

{
    PIMEHOTKEY pHotKey;
    UINT uModifiers;
    BOOL bKeyUp = (lParam & 0x80000000);
    const BYTE *KeyState = MessageQueue->afKeyState;
    static UINT s_uKeyUpVKey = 0;
 
    if (bKeyUp)
    {
        if (s_uKeyUpVKey != uVirtualKey)
        {
            s_uKeyUpVKey = 0;
            return NULL;
        }
 
        s_uKeyUpVKey = 0;
    }
 
    uModifiers = 0;
    if (IS_KEY_DOWN(KeyState, VK_LSHIFT))   uModifiers |= (MOD_SHIFT | MOD_LEFT);
    if (IS_KEY_DOWN(KeyState, VK_RSHIFT))   uModifiers |= (MOD_SHIFT | MOD_RIGHT);
    if (IS_KEY_DOWN(KeyState, VK_LCONTROL)) uModifiers |= (MOD_CONTROL | MOD_LEFT);
    if (IS_KEY_DOWN(KeyState, VK_RCONTROL)) uModifiers |= (MOD_CONTROL | MOD_RIGHT);
    if (IS_KEY_DOWN(KeyState, VK_LMENU))    uModifiers |= (MOD_ALT | MOD_LEFT);
    if (IS_KEY_DOWN(KeyState, VK_RMENU))    uModifiers |= (MOD_ALT | MOD_RIGHT);
 
    pHotKey = IntGetImeHotKeyByKey(gpImeHotKeyList,
                                   (uModifiers & MOD_KEYS),
                                   (uModifiers & MOD_LEFT_RIGHT),
                                   uVirtualKey);
    if (pHotKey)
    {
        if (bKeyUp)
        {
            if (pHotKey->uModifiers & MOD_ON_KEYUP)
                return pHotKey;
        }
        else
        {
            if (pHotKey->uModifiers & MOD_ON_KEYUP)
                s_uKeyUpVKey = uVirtualKey;
            else
                return pHotKey;
        }
    }
 
    return NULL;
}

Referenced by IntImmProcessKey(), and NtUserCheckImeHotKey().

IntCheckImeShowStatus()

BOOL FASTCALL IntCheckImeShowStatus	(	PWND	pwndIme,
		PTHREADINFO	pti
	)

Definition at line 2129 of file ime.c.

{
    BOOL ret = FALSE, bDifferent;
    PWINDOWLIST pwl;
    HWND *phwnd;
    PWND pwndNode, pwndIMC;
    PTHREADINFO ptiCurrent = GetW32ThreadInfo();
    PIMEUI pimeui;
    IMEUI SafeImeUI;
 
    if (pwndIme->state2 & WNDS2_INDESTROY)
        return FALSE;
 
    // Build a window list
    pwl = IntBuildHwndList(pwndIme->spwndParent->spwndChild, IACE_LIST, NULL);
    if (!pwl)
        return FALSE;
 
    ret = TRUE;
    for (phwnd = pwl->ahwnd; *phwnd != HWND_TERMINATOR; ++phwnd)
    {
        pwndNode = ValidateHwndNoErr(*phwnd);
 
        if (!pwndNode || pwndIme == pwndNode)
            continue;
 
        if (pwndNode->pcls->atomClassName != gpsi->atomSysClass[ICLS_IME] ||
            (pwndNode->state2 & WNDS2_INDESTROY))
        {
            continue;
        }
 
        pimeui = ((PIMEWND)pwndNode)->pimeui;
        if (!pimeui || pimeui == (PIMEUI)-1)
            continue;
 
        if (pti && pti != pwndNode->head.pti)
            continue;
 
        // Attach to the process if necessary
        bDifferent = FALSE;
        if (pwndNode->head.pti->ppi != ptiCurrent->ppi)
        {
            KeAttachProcess(&(pwndNode->head.pti->ppi->peProcess->Pcb));
            bDifferent = TRUE;
        }
 
        // Get pwndIMC and update IMEUI.fShowStatus flag
        _SEH2_TRY
        {
            ProbeForWrite(pimeui, sizeof(IMEUI), 1);
            SafeImeUI = *pimeui;
            if (SafeImeUI.fShowStatus)
            {
                pwndIMC = ValidateHwndNoErr(pimeui->hwndIMC);
                if (pwndIMC)
                    pimeui->fShowStatus = FALSE;
            }
            else
            {
                pwndIMC = NULL;
            }
        }
        _SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER)
        {
            ERR("%p\n", pimeui);
            pwndIMC = NULL;
        }
        _SEH2_END;
 
        // Detach from the process if necessary
        if (bDifferent)
            KeDetachProcess();
 
        // Send the WM_IME_NOTIFY message
        if (pwndIMC && pwndIMC->head.pti && !(pwndIMC->head.pti->TIF_flags & TIF_INCLEANUP))
        {
            HWND hImeWnd;
            USER_REFERENCE_ENTRY Ref;
 
            UserRefObjectCo(pwndIMC, &Ref);
 
            hImeWnd = UserHMGetHandle(pwndIMC);
            co_IntSendMessage(hImeWnd, WM_IME_NOTIFY, IMN_CLOSESTATUSWINDOW, 0);
 
            UserDerefObjectCo(pwndIMC);
        }
    }
 
    // Free the window list
    IntFreeHwndList(pwl);
    return ret;
}

Referenced by IntCheckImeShowStatusInThread(), and IntNotifyImeShowStatus().

IntCheckImeShowStatusInThread()

VOID FASTCALL IntCheckImeShowStatusInThread

(

PWND

pImeWnd

)

Definition at line 2397 of file ime.c.

{
    if (IS_IMM_MODE() && !(pImeWnd->state2 & WNDS2_INDESTROY))
        IntCheckImeShowStatus(pImeWnd, pImeWnd->head.pti);
}

Referenced by NtUserCallHwndLock().

IntDeleteImeHotKey()

static VOID FASTCALL IntDeleteImeHotKey ( PIMEHOTKEY *  ppList, PIMEHOTKEY  pHotKey  )

static

Definition at line 190 of file ime.c.

{
    PIMEHOTKEY pNode;
 
    if (*ppList == pHotKey)
    {
        *ppList = pHotKey->pNext;
        ExFreePoolWithTag(pHotKey, USERTAG_IMEHOTKEY);
        return;
    }
 
    for (pNode = *ppList; pNode; pNode = pNode->pNext)
    {
        if (pNode->pNext == pHotKey)
        {
            pNode->pNext = pHotKey->pNext;
            ExFreePoolWithTag(pHotKey, USERTAG_IMEHOTKEY);
            return;
        }
    }
}

Referenced by IntSetImeHotKey().

IntDestroyInputContext()

BOOL IntDestroyInputContext

(

PIMC

pIMC

)

Definition at line 1496 of file ime.c.

{
    HIMC hIMC = UserHMGetHandle(pIMC);
    PTHREADINFO pti = pIMC->head.pti;
    PWND pwndChild;
    PWINDOWLIST pwl;
    HWND *phwnd;
    PWND pWnd;
 
    if (pti != gptiCurrent)
    {
        EngSetLastError(ERROR_ACCESS_DENIED);
        return FALSE;
    }
 
    if (pIMC == pti->spDefaultImc)
    {
        EngSetLastError(ERROR_INVALID_PARAMETER);
        return FALSE;
    }
 
    pwndChild = pti->rpdesk->pDeskInfo->spwnd->spwndChild;
    pwl = IntBuildHwndList(pwndChild, IACE_LIST | IACE_CHILDREN, pti);
    if (pwl)
    {
        for (phwnd = pwl->ahwnd; *phwnd != HWND_TERMINATOR; ++phwnd)
        {
            pWnd = UserGetObjectNoErr(gHandleTable, *phwnd, TYPE_WINDOW);
            if (pWnd && pWnd->hImc == hIMC)
                IntAssociateInputContext(pWnd, pti->spDefaultImc);
        }
 
        IntFreeHwndList(pwl);
    }
 
    UserDeleteObject(hIMC, TYPE_INPUTCONTEXT);
    return TRUE;
}

Referenced by NtUserDestroyInputContext().

IntFindNonImeRelatedWndOfSameThread()

BOOL IntFindNonImeRelatedWndOfSameThread	(	PWND	pwndParent,
		PWND	pwndTarget
	)

Definition at line 1841 of file ime.c.

{
    PWND pwnd, pwndOwner, pwndNode;
    PTHREADINFO ptiTarget = pwndTarget->head.pti;
 
    // For all the children of pwndParent, ...
    for (pwnd = pwndParent->spwndChild; pwnd; pwnd = pwnd->spwndNext)
    {
        if (pwnd == pwndTarget || pwnd->head.pti != ptiTarget || IS_WND_MENU(pwnd))
            continue;
 
        if (!IS_WND_CHILD(pwnd))
        {
            // Check if any IME-like owner.
            BOOL bFound1 = FALSE;
            for (pwndOwner = pwnd; pwndOwner; pwndOwner = pwndOwner->spwndOwner)
            {
                if (IS_WND_IMELIKE(pwndOwner))
                {
                    bFound1 = TRUE;
                    break;
                }
            }
            if (bFound1)
                continue; // Skip if any IME-like owner.
        }
 
        pwndNode = pwnd;
 
        if (IS_WND_CHILD(pwndNode))
        {
            // Check if any same-thread IME-like ancestor.
            BOOL bFound2 = FALSE;
            for (; IS_WND_CHILD(pwndNode); pwndNode = pwndNode->spwndParent)
            {
                if (pwndNode->head.pti != ptiTarget)
                    break;
 
                if (IS_WND_IMELIKE(pwndNode))
                {
                    bFound2 = TRUE;
                    break;
                }
            }
            if (bFound2)
                continue;
            // Now, pwndNode is non-child or non-same-thread window.
        }
 
        if (!IS_WND_CHILD(pwndNode)) // pwndNode is non-child
        {
            // Check if any same-thread IME-like owner.
            BOOL bFound3 = FALSE;
            for (; pwndNode; pwndNode = pwndNode->spwndOwner)
            {
                if (pwndNode->head.pti != ptiTarget)
                    break;
 
                if (IS_WND_IMELIKE(pwndNode))
                {
                    bFound3 = TRUE;
                    break;
                }
            }
            if (bFound3)
                continue;
        }
 
        return TRUE;
    }
 
    return FALSE;
}

Referenced by IntImeCanDestroyDefIMEforChild().

IntFreeImeHotKeys()

VOID FASTCALL IntFreeImeHotKeys

(

VOID

)

Definition at line 326 of file ime.c.

{
    PIMEHOTKEY pNode, pNext;
    for (pNode = gpImeHotKeyList; pNode; pNode = pNext)
    {
        pNext = pNode->pNext;
        ExFreePoolWithTag(pNode, USERTAG_IMEHOTKEY);
    }
    gpImeHotKeyList = NULL;
}

Referenced by IntSetImeHotKey(), and UserProcessDestroy().

IntGetActiveKeyboardLayout()

HKL FASTCALL IntGetActiveKeyboardLayout

(

VOID

)

Definition at line 84 of file ime.c.

{
    PTHREADINFO pti;
 
    if (gpqForeground && gpqForeground->spwndActive)
    {
        pti = gpqForeground->spwndActive->head.pti;
        if (pti && pti->KeyboardLayout)
            return pti->KeyboardLayout->hkl;
    }
 
    return UserGetKeyboardLayout(0);
}

Referenced by IntGetImeHotKeyByKey().

IntGetImeCompatFlags()

DWORD FASTCALL IntGetImeCompatFlags

(

PTHREADINFO

pti

)

Definition at line 44 of file ime.c.

{
    if (!pti)
        pti = PsGetCurrentThreadWin32Thread();
 
    return pti->ppi->dwImeCompatFlags;
}

Referenced by IntImmProcessKey().

IntGetImeHotKeyById()

static PIMEHOTKEY FASTCALL IntGetImeHotKeyById ( PIMEHOTKEY  pList, DWORD  dwHotKeyId  )

static

Definition at line 146 of file ime.c.

{
    PIMEHOTKEY pNode;
    for (pNode = pList; pNode; pNode = pNode->pNext)
    {
        if (pNode->dwHotKeyId == dwHotKeyId)
            return pNode;
    }
    return NULL;
}

Referenced by IntSetImeHotKey(), and NtUserGetImeHotKey().

IntGetImeHotKeyByKey()

PIMEHOTKEY IntGetImeHotKeyByKey	(	PIMEHOTKEY	pList,
		UINT	uModKeys,
		UINT	uLeftRight,
		UINT	uVirtualKey
	)

Definition at line 214 of file ime.c.

{
    PIMEHOTKEY pNode, ret = NULL;
    PTHREADINFO pti = GetW32ThreadInfo();
    LANGID LangId;
    HKL hKL = IntGetActiveKeyboardLayout();
    BOOL fKorean = (PRIMARYLANGID(LOWORD(hKL)) == LANG_KOREAN);
    UINT nScore, nMaxScore = 0;
 
    for (pNode = pList; pNode; pNode = pNode->pNext)
    {
        if (pNode->uVirtualKey != uVirtualKey)
            continue;
 
        if ((pNode->uModifiers & MOD_IGNORE_ALL_MODIFIER))
        {
            ;
        }
        else if ((pNode->uModifiers & MOD_KEYS) != uModKeys)
        {
            continue;
        }
        else if ((pNode->uModifiers & uLeftRight) ||
                 (pNode->uModifiers & MOD_LEFT_RIGHT) == uLeftRight)
        {
            ;
        }
        else
        {
            continue;
        }
 
        LangId = IntGetImeHotKeyLangId(pNode->dwHotKeyId);
        nScore = IntGetImeHotKeyLanguageScore(hKL, LangId);
        if (nScore >= 3)
            return pNode;
 
        if (fKorean)
            continue;
 
        if (nScore == 0)
        {
            if (pNode->dwHotKeyId == IME_CHOTKEY_IME_NONIME_TOGGLE ||
                pNode->dwHotKeyId == IME_THOTKEY_IME_NONIME_TOGGLE)
            {
                if (LOWORD(pti->hklPrev) == LangId)
                    return pNode;
            }
        }
 
        if (nMaxScore < nScore)
        {
            nMaxScore = nScore;
            ret = pNode;
        }
    }
 
    return ret;
}

Referenced by IntCheckImeHotKey().

IntGetImeHotKeyByKeyAndLang()

static PIMEHOTKEY APIENTRY IntGetImeHotKeyByKeyAndLang ( PIMEHOTKEY  pList, UINT  uModKeys, UINT  uLeftRight, UINT  uVirtualKey, LANGID  TargetLangId  )

static

Definition at line 159 of file ime.c.

{
    PIMEHOTKEY pNode;
    LANGID LangID;
    UINT uModifiers;
 
    for (pNode = pList; pNode; pNode = pNode->pNext)
    {
        if (pNode->uVirtualKey != uVirtualKey)
            continue;
 
        LangID = IntGetImeHotKeyLangId(pNode->dwHotKeyId);
        if (LangID != TargetLangId && LangID != 0)
            continue;
 
        uModifiers = pNode->uModifiers;
        if (uModifiers & MOD_IGNORE_ALL_MODIFIER)
            return pNode;
 
        if ((uModifiers & MOD_KEYS) != uModKeys)
            continue;
 
        if ((uModifiers & uLeftRight) || (uModifiers & MOD_LEFT_RIGHT) == uLeftRight)
            return pNode;
    }
 
    return NULL;
}

Referenced by IntSetImeHotKey().

IntGetImeHotKeyLangId()

static LANGID FASTCALL IntGetImeHotKeyLangId ( DWORD  dwHotKeyId )

static

Definition at line 99 of file ime.c.

{
#define IME_CHOTKEY 0x10
#define IME_JHOTKEY 0x30
#define IME_KHOTKEY 0x50
#define IME_THOTKEY 0x70
#define IME_XHOTKEY 0x90
    static const LANGID s_array[] =
    {
        /* 0x00 */ (WORD)-1,
        /* 0x10 */ LANGID_CHINESE_SIMPLIFIED,
        /* 0x20 */ LANGID_CHINESE_SIMPLIFIED,
        /* 0x30 */ LANGID_JAPANESE,
        /* 0x40 */ LANGID_JAPANESE,
        /* 0x50 */ LANGID_KOREAN,
        /* 0x60 */ LANGID_KOREAN,
        /* 0x70 */ LANGID_CHINESE_TRADITIONAL,
        /* 0x80 */ LANGID_CHINESE_TRADITIONAL
    };
 
    if (IME_CHOTKEY <= dwHotKeyId && dwHotKeyId < IME_XHOTKEY)
        return s_array[(dwHotKeyId & 0xF0) >> 4];
    return LANGID_NEUTRAL;
}

Referenced by IntGetImeHotKeyByKey(), IntGetImeHotKeyByKeyAndLang(), and IntSetImeHotKey().

IntGetImeHotKeyLanguageScore()

UINT FASTCALL IntGetImeHotKeyLanguageScore	(	HKL	hKL,
		LANGID	HotKeyLangId
	)

Definition at line 53 of file ime.c.

{
    LCID lcid;
 
    if (HotKeyLangId == LANGID_NEUTRAL || HotKeyLangId == LOWORD(hKL))
        return 3;
 
    _SEH2_TRY
    {
        lcid = NtCurrentTeb()->CurrentLocale;
    }
    _SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER)
    {
        ERR("%p\n", NtCurrentTeb());
        lcid = MAKELCID(LANGID_NEUTRAL, SORT_DEFAULT);
    }
    _SEH2_END;
 
    if (HotKeyLangId == LANGIDFROMLCID(lcid))
        return 2;
 
    if (glcidSystem == 0)
        ZwQueryDefaultLocale(FALSE, &glcidSystem);
 
    if (HotKeyLangId == LANGIDFROMLCID(glcidSystem))
        return 1;
 
    return 0;
}

Referenced by IntGetImeHotKeyByKey().

IntGetLastTopMostWindowNoIME()

PWND FASTCALL IntGetLastTopMostWindowNoIME

(

PWND

pImeWnd

)

Definition at line 1219 of file ime.c.

{
    PWND pwndNode, pwndOwner, pwndLastTopMost = NULL;
    BOOL bFound;
 
    pwndNode = UserGetDesktopWindow();
    if (!pwndNode || pwndNode->spwndChild == NULL)
        return NULL;
 
    for (pwndNode = pwndNode->spwndChild;
         pwndNode && (pwndNode->ExStyle & WS_EX_TOPMOST);
         pwndNode = pwndNode->spwndNext)
    {
        bFound = FALSE;
 
        if (IS_WND_IMELIKE(pwndNode)) // An IME-like window
        {
            // Search the IME window from owners
            for (pwndOwner = pwndNode; pwndOwner; pwndOwner = pwndOwner->spwndOwner)
            {
                if (pImeWnd == pwndOwner)
                {
                    bFound = TRUE;
                    break;
                }
            }
        }
 
        if (!bFound)
            pwndLastTopMost = pwndNode;
    }
 
    return pwndLastTopMost;
}

Referenced by IntImeSetTopMost().

IntGetTopLevelWindow()

PWND FASTCALL IntGetTopLevelWindow

(

PWND

pwnd

)

Definition at line 487 of file ime.c.

{
    if (!pwnd)
        return NULL;
 
    while (pwnd->style & WS_CHILD)
        pwnd = pwnd->spwndParent;
 
    return pwnd;
}

Referenced by NtUserSetImeOwnerWindow().

IntImeCanDestroyDefIME()

BOOL FASTCALL IntImeCanDestroyDefIME	(	PWND	pImeWnd,
		PWND	pwndTarget
	)

Definition at line 2065 of file ime.c.

{
    PWND pwndNode;
    PIMEUI pimeui;
    IMEUI SafeImeUI;
 
    pimeui = ((PIMEWND)pImeWnd)->pimeui;
    if (!pimeui || (LONG_PTR)pimeui == (LONG_PTR)-1)
        return FALSE;
 
    // Check IMEUI.fDestroy
    _SEH2_TRY
    {
        ProbeForRead(pimeui, sizeof(IMEUI), 1);
        SafeImeUI = *pimeui;
        if (SafeImeUI.fDestroy)
            return FALSE;
    }
    _SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER)
    {
        ERR("%p\n", pimeui);
    }
    _SEH2_END;
 
    // Any ancestor of pImeWnd is pwndTarget?
    if (pImeWnd->spwndOwner)
    {
        for (pwndNode = pImeWnd->spwndOwner; pwndNode; pwndNode = pwndNode->spwndOwner)
        {
            if (pwndNode == pwndTarget)
                break;
        }
 
        if (!pwndNode)
            return FALSE;
    }
 
    // Any ancestor of pwndTarget is IME-like?
    for (pwndNode = pwndTarget; pwndNode; pwndNode = pwndNode->spwndOwner)
    {
        if (IS_WND_IMELIKE(pwndNode))
            return FALSE;
    }
 
    // Adjust the ordering and top-mode status
    IntImeSetFutureOwner(pImeWnd, pwndTarget);
    for (pwndNode = pImeWnd->spwndOwner; pwndNode; pwndNode = pwndNode->spwndNext)
    {
        if (pwndNode == pImeWnd)
            break;
    }
    if (pwndNode == pImeWnd)
        IntImeCheckTopmost(pImeWnd);
 
    // Is the owner of pImeWnd NULL or pwndTarget?
    if (pImeWnd->spwndOwner && pwndTarget != pImeWnd->spwndOwner)
        return FALSE;
 
    WndSetOwner(pImeWnd, NULL);
    return TRUE;
}

Referenced by co_UserDestroyWindow().

IntImeCanDestroyDefIMEforChild()

BOOL FASTCALL IntImeCanDestroyDefIMEforChild	(	PWND	pImeWnd,
		PWND	pwndTarget
	)

Definition at line 2020 of file ime.c.

{
    PWND pwndNode;
    PIMEUI pimeui;
    IMEUI SafeImeUI;
 
    pimeui = ((PIMEWND)pImeWnd)->pimeui;
    if (!pimeui || (LONG_PTR)pimeui == (LONG_PTR)-1)
        return FALSE;
 
    // Check IMEUI.fChildThreadDef
    _SEH2_TRY
    {
        ProbeForRead(pimeui, sizeof(IMEUI), 1);
        SafeImeUI = *pimeui;
        if (!SafeImeUI.fChildThreadDef)
            return FALSE;
    }
    _SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER)
    {
        ERR("%p\n", pimeui);
    }
    _SEH2_END;
 
    // The parent of pwndTarget is NULL or of the same thread of pwndTarget?
    if (pwndTarget->spwndParent == NULL ||
        pwndTarget->head.pti == pwndTarget->spwndParent->head.pti)
    {
        return FALSE;
    }
 
    for (pwndNode = pwndTarget; pwndNode; pwndNode = pwndNode->spwndParent)
    {
        if (pwndNode == pwndNode->head.rpdesk->pDeskInfo->spwnd)
            break;
 
        if (IntFindNonImeRelatedWndOfSameThread(pwndNode->spwndParent, pwndTarget))
            return FALSE;
    }
 
    return TRUE;
}

Referenced by co_UserDestroyWindow().

IntImeCheckTopmost()

VOID FASTCALL IntImeCheckTopmost

(

PWND

pImeWnd

)

Definition at line 1346 of file ime.c.

{
    BOOL bTopMost;
    PWND pwndOwner = pImeWnd->spwndOwner, pwndInsertBefore = NULL;
 
    if (!pwndOwner)
        return;
 
    if (pImeWnd->head.pti != gptiForeground)
        pwndInsertBefore = pwndOwner;
 
    bTopMost = !!(pwndOwner->ExStyle & WS_EX_TOPMOST);
    IntImeSetTopMost(pImeWnd, bTopMost, pwndInsertBefore);
}

Referenced by IntImeCanDestroyDefIME(), and NtUserSetImeOwnerWindow().

IntImeSetFutureOwner()

VOID FASTCALL IntImeSetFutureOwner	(	PWND	pImeWnd,
		PWND	pwndOwner
	)

Definition at line 1162 of file ime.c.

{
    PWND pwndNode, pwndNextOwner, pwndParent, pwndSibling;
    PTHREADINFO pti = pImeWnd->head.pti;
 
    if (!pwndOwner || (pwndOwner->style & WS_CHILD)) // invalid owner
        return;
 
    // Get the top-level owner of the same thread
    for (pwndNode = pwndOwner; ; pwndNode = pwndNextOwner)
    {
        pwndNextOwner = pwndNode->spwndOwner;
        if (!pwndNextOwner || pwndNextOwner->head.pti != pti)
            break;
    }
 
    // Don't choose the IME-like windows and the bottom-most windows unless necessary.
    if (IS_WND_IMELIKE(pwndNode) ||
        ((pwndNode->state2 & WNDS2_BOTTOMMOST) && !(pwndOwner->state2 & WNDS2_BOTTOMMOST)))
    {
        pwndNode = pwndOwner;
    }
 
    pwndParent = pwndNode->spwndParent;
    if (!pwndParent || pwndOwner != pwndNode)
    {
        WndSetOwner(pImeWnd, pwndNode);
        return;
    }
 
    for (pwndSibling = pwndParent->spwndChild; pwndSibling; pwndSibling = pwndSibling->spwndNext)
    {
        if (pwndNode->head.pti != pwndSibling->head.pti)
            continue;
 
        if (IS_WND_MENU(pwndSibling) || IS_WND_IMELIKE(pwndSibling))
            continue;
 
        if (pwndSibling->state2 & WNDS2_INDESTROY)
            continue;
 
        if (pwndNode == pwndSibling || (pwndSibling->style & WS_CHILD))
            continue;
 
        if (pwndSibling->spwndOwner == NULL ||
            pwndSibling->head.pti != pwndSibling->spwndOwner->head.pti)
        {
            pwndNode = pwndSibling;
            break;
        }
    }
 
    WndSetOwner(pImeWnd, pwndNode);
}

Referenced by IntImeCanDestroyDefIME(), and NtUserSetImeOwnerWindow().

IntImeSetTopMost()

VOID FASTCALL IntImeSetTopMost	(	PWND	pImeWnd,
		BOOL	bTopMost,
		PWND	pwndInsertBefore
	)

Definition at line 1256 of file ime.c.

{
    PWND pwndParent, pwndChild, pwndNode, pwndNext, pwndInsertAfter = NULL;
    PWND pwndInsertAfterSave;
 
    pwndParent = pImeWnd->spwndParent;
    if (!pwndParent)
        return;
 
    pwndChild = pwndParent->spwndChild;
 
    if (!bTopMost)
    {
        // Calculate pwndInsertAfter
        pwndInsertAfter = IntGetLastTopMostWindowNoIME(pImeWnd);
        if (pwndInsertBefore)
        {
            for (pwndNode = pwndInsertAfter; pwndNode; pwndNode = pwndNode->spwndNext)
            {
                if (pwndNode->spwndNext == pwndInsertBefore)
                    break;
 
                if (pwndNode == pImeWnd)
                    return;
            }
 
            if (!pwndNode)
                return;
 
            pwndInsertAfter = pwndNode;
        }
 
        // Adjust pwndInsertAfter if the owner is bottom-most
        if (pImeWnd->spwndOwner->state2 & WNDS2_BOTTOMMOST)
        {
            for (pwndNode = pwndInsertAfter; pwndNode; pwndNode = pwndNode->spwndNext)
            {
                if (pwndNode == pImeWnd->spwndOwner)
                    break;
 
                if (!IS_WND_IMELIKE(pwndNode))
                    pwndInsertAfter = pwndNode;
            }
        }
    }
 
    pwndInsertAfterSave = pwndInsertAfter;
 
    while (pwndChild)
    {
        pwndNext = pwndChild->spwndNext;
 
        // If pwndChild is a good IME-like window, ...
        if (IS_WND_IMELIKE(pwndChild) && pwndChild != pwndInsertAfter &&
            pwndChild->head.pti == pImeWnd->head.pti)
        {
            // Find pImeWnd from the owners
            for (pwndNode = pwndChild; pwndNode; pwndNode = pwndNode->spwndOwner)
            {
                if (pwndNode != pImeWnd)
                    continue;
 
                // Adjust the ordering and the linking
                IntUnlinkWindow(pwndChild);
 
                if (bTopMost)
                    pwndChild->ExStyle |= WS_EX_TOPMOST;
                else
                    pwndChild->ExStyle &= ~WS_EX_TOPMOST;
 
                if (!pwndInsertAfter)
                    IntLinkHwnd(pwndChild, HWND_TOP);
                else
                    IntLinkHwnd(pwndChild, UserHMGetHandle(pwndInsertAfter));
 
                // Update the preferred position
                pwndInsertAfter = pwndChild;
                break;
            }
        }
 
        // Get the next child, with ignoring pwndInsertAfterSave
        pwndChild = pwndNext;
        if (pwndChild && pwndChild == pwndInsertAfterSave && pwndInsertAfter)
            pwndChild = pwndInsertAfter->spwndNext;
    }
}

Referenced by IntImeCheckTopmost().

IntImmProcessKey()

UINT FASTCALL IntImmProcessKey	(	PUSER_MESSAGE_QUEUE	MessageQueue,
		PWND	pWnd,
		UINT	uMsg,
		WPARAM	wParam,
		LPARAM	lParam
	)

Definition at line 569 of file ime.c.

{
    UINT uVirtualKey, ret;
    DWORD dwHotKeyId;
    PKL pKL;
    PIMC pIMC;
    PIMEHOTKEY pImeHotKey;
    HKL hKL;
    HWND hWnd;
 
    ASSERT_REFS_CO(pWnd);
 
    switch (uMsg)
    {
        case WM_KEYDOWN:
        case WM_KEYUP:
        case WM_SYSKEYDOWN:
        case WM_SYSKEYUP:
            break;
 
        default:
            return 0;
    }
 
    pIMC = NULL;
    hWnd = UserHMGetHandle(pWnd);
    pKL = pWnd->head.pti->KeyboardLayout;
    if (!pKL)
        return 0;
 
    uVirtualKey = LOBYTE(wParam);
    pImeHotKey = IntCheckImeHotKey(MessageQueue, uVirtualKey, lParam);
    if (pImeHotKey)
    {
        dwHotKeyId = pImeHotKey->dwHotKeyId;
        hKL = pImeHotKey->hKL;
    }
    else
    {
        dwHotKeyId = INVALID_HOTKEY;
        hKL = NULL;
    }
 
    if (IME_HOTKEY_DSWITCH_FIRST <= dwHotKeyId && dwHotKeyId <= IME_HOTKEY_DSWITCH_LAST)
    {
        if (pKL->hkl != hKL)
        {
            UserPostMessage(hWnd, WM_INPUTLANGCHANGEREQUEST,
                            ((pKL->dwFontSigs & gSystemFS) ? INPUTLANGCHANGE_SYSCHARSET : 0),
                            (LPARAM)hKL);
        }
 
        if (IntGetImeCompatFlags(pWnd->head.pti) & 0x800000)
            return 0;
 
        return IPHK_HOTKEY;
    }
 
    if (!IS_IMM_MODE())
        return 0;
 
    if (dwHotKeyId == INVALID_HOTKEY)
    {
        if (!pKL->piiex)
            return 0;
 
        if (pWnd->hImc)
            pIMC = UserGetObject(gHandleTable, pWnd->hImc, TYPE_INPUTCONTEXT);
        if (!pIMC)
            return 0;
 
        if ((lParam & (KF_UP << 16)) &&
            (pKL->piiex->ImeInfo.fdwProperty & IME_PROP_IGNORE_UPKEYS))
        {
            return 0;
        }
 
        switch (uVirtualKey)
        {
            case VK_DBE_CODEINPUT:
            case VK_DBE_ENTERCONFIGMODE:
            case VK_DBE_ENTERWORDREGISTERMODE:
            case VK_DBE_HIRAGANA:
            case VK_DBE_KATAKANA:
            case VK_DBE_NOCODEINPUT:
            case VK_DBE_NOROMAN:
            case VK_DBE_ROMAN:
                break;
 
            default:
            {
                if (uMsg == WM_SYSKEYDOWN || uMsg == WM_SYSKEYUP)
                {
                    if (uVirtualKey != VK_MENU && uVirtualKey != VK_F10)
                        return 0;
                }
 
                if (!(pKL->piiex->ImeInfo.fdwProperty & IME_PROP_NEED_ALTKEY))
                {
                    if (uVirtualKey == VK_MENU || (lParam & 0x20000000))
                        return 0;
                }
                break;
            }
        }
    }
 
    if (LOBYTE(uVirtualKey) == VK_PACKET)
        uVirtualKey = MAKELONG(wParam, GetW32ThreadInfo()->wchInjected);
 
    ret = co_IntImmProcessKey(hWnd, pKL->hkl, uVirtualKey, lParam, dwHotKeyId);
 
    if (IntGetImeCompatFlags(pWnd->head.pti) & 0x800000)
        ret &= ~IPHK_HOTKEY;
 
    return ret;
}

Referenced by co_IntProcessKeyboardMessage().

IntNotifyImeShowStatus()

VOID FASTCALL IntNotifyImeShowStatus

(

PWND

pImeWnd

)

Definition at line 2326 of file ime.c.

{
    PIMEUI pimeui;
    PWND pWnd;
    PTHREADINFO pti, ptiIME;
    BOOL bShow, bSendNotify = FALSE;
    IMEUI SafeImeUI;
 
    if (!IS_IMM_MODE() || (pImeWnd->state2 & WNDS2_INDESTROY))
        return;
 
    pti = PsGetCurrentThreadWin32Thread();
    ptiIME = pImeWnd->head.pti;
 
    // Attach to the process if necessary
    if (pti != ptiIME)
        KeAttachProcess(&(ptiIME->ppi->peProcess->Pcb));
 
    // Get an IMEUI and check whether hwndIMC is valid and update fShowStatus
    _SEH2_TRY
    {
        ProbeForWrite(pImeWnd, sizeof(IMEWND), 1);
        pimeui = ((PIMEWND)pImeWnd)->pimeui;
        SafeImeUI = *pimeui;
 
        bShow = (gfIMEShowStatus == TRUE) && SafeImeUI.fCtrlShowStatus;
 
        pWnd = ValidateHwndNoErr(SafeImeUI.hwndIMC);
        if (!pWnd)
            pWnd = ptiIME->MessageQueue->spwndFocus;
 
        if (pWnd)
        {
            bSendNotify = TRUE;
            pimeui->fShowStatus = bShow;
        }
    }
    _SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER)
    {
        ERR("%p, %p\n", pImeWnd, pimeui);
 
        if (pti != ptiIME)
            KeDetachProcess();
 
        _SEH2_YIELD(return);
    }
    _SEH2_END;
 
    // Detach from the process if necessary
    if (pti != ptiIME)
        KeDetachProcess();
 
    if (bSendNotify)
        IntSendOpenStatusNotify(ptiIME, &SafeImeUI, pWnd, bShow);
 
    if (!(pImeWnd->state2 & WNDS2_INDESTROY))
        IntCheckImeShowStatus(pImeWnd, NULL);
}

Referenced by IntBroadcastImeShowStatusChange().

IntSendMessageToUI()

LRESULT FASTCALL IntSendMessageToUI	(	PTHREADINFO	ptiIME,
		PIMEUI	pimeui,
		UINT	uMsg,
		WPARAM	wParam,
		LPARAM	lParam
	)

Definition at line 2225 of file ime.c.

{
    PWND pwndUI;
    LRESULT ret = 0;
    IMEUI SafeImeUI;
    BOOL bDifferent = FALSE;
    USER_REFERENCE_ENTRY Ref;
 
    // Attach to the process if necessary
    if (ptiIME != GetW32ThreadInfo())
    {
        bDifferent = TRUE;
        KeAttachProcess(&(ptiIME->ppi->peProcess->Pcb));
    }
 
    // Get the pwndUI
    _SEH2_TRY
    {
        ProbeForRead(pimeui, sizeof(IMEUI), 1);
        SafeImeUI = *pimeui;
        pwndUI = ValidateHwndNoErr(SafeImeUI.hwndUI);
    }
    _SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER)
    {
        ERR("%p\n", pimeui);
        pwndUI = NULL;
    }
    _SEH2_END;
 
    if (!pwndUI)
        goto Quit;
 
    // Increment the recursion count of the IME procedure.
    // See also ImeWndProc_common of user32.
    _SEH2_TRY
    {
        ProbeForWrite(&pimeui->nCntInIMEProc, sizeof(LONG), 1);
        InterlockedIncrement(&pimeui->nCntInIMEProc);
    }
    _SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER)
    {
        ERR("%p\n", pimeui);
        _SEH2_YIELD(goto Quit);
    }
    _SEH2_END;
 
    // Detach from the process if necessary
    if (bDifferent)
        KeDetachProcess();
 
    UserRefObjectCo(pwndUI, &Ref);
    ret = co_IntSendMessage(UserHMGetHandle(pwndUI), uMsg, wParam, lParam);
    UserDerefObjectCo(pwndUI);
 
    // Attach to the process if necessary
    if (bDifferent)
        KeAttachProcess(&(ptiIME->ppi->peProcess->Pcb));
 
    // Decrement the recursion count of the IME procedure
    _SEH2_TRY
    {
        ProbeForWrite(&pimeui->nCntInIMEProc, sizeof(LONG), 1);
        InterlockedDecrement(&pimeui->nCntInIMEProc);
    }
    _SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER)
    {
        ERR("%p\n", pimeui);
        _SEH2_YIELD(goto Quit);
    }
    _SEH2_END;
 
Quit:
    // Detach from the process if necessary
    if (bDifferent)
        KeDetachProcess();
 
    return ret;
}

Referenced by IntSendOpenStatusNotify().

IntSendOpenStatusNotify()

VOID FASTCALL IntSendOpenStatusNotify	(	PTHREADINFO	ptiIME,
		PIMEUI	pimeui,
		PWND	pWnd,
		BOOL	bOpen
	)

Definition at line 2307 of file ime.c.

{
    WPARAM wParam = (bOpen ? IMN_OPENSTATUSWINDOW : IMN_CLOSESTATUSWINDOW);
    PTHREADINFO ptiWnd = pWnd->head.pti;
    USER_REFERENCE_ENTRY Ref;
 
    if (ptiWnd->dwExpWinVer >= WINVER_WINNT4 && pWnd->hImc)
    {
        UserRefObjectCo(pWnd, &Ref);
        co_IntSendMessage(UserHMGetHandle(pWnd), WM_IME_NOTIFY, wParam, 0);
        UserDerefObjectCo(pWnd);
    }
    else
    {
        IntSendMessageToUI(ptiIME, pimeui, WM_IME_NOTIFY, wParam, 0);
    }
}

Referenced by IntNotifyImeShowStatus().

IntSetImeHotKey()

static BOOL APIENTRY IntSetImeHotKey ( DWORD  dwHotKeyId, UINT  uModifiers, UINT  uVirtualKey, HKL  hKL, DWORD  dwAction  )

static

Definition at line 339 of file ime.c.

{
    PIMEHOTKEY pNode;
    LANGID LangId;
 
    switch (dwAction)
    {
        case SETIMEHOTKEY_DELETE:
            pNode = IntGetImeHotKeyById(gpImeHotKeyList, dwHotKeyId); /* Find hotkey by ID */
            if (!pNode)
            {
                ERR("dwHotKeyId: 0x%lX\n", dwHotKeyId);
                return FALSE;
            }
 
            IntDeleteImeHotKey(&gpImeHotKeyList, pNode); /* Delete it */
            return TRUE;
 
        case SETIMEHOTKEY_ADD:
            if (LOWORD(uVirtualKey) == VK_PACKET) /* In case of VK_PACKET */
                return FALSE;
 
            LangId = IntGetImeHotKeyLangId(dwHotKeyId);
            if (LangId == LANGID_KOREAN)
                return FALSE; /* Korean can't add IME hotkeys */
 
            /* Find hotkey by key and language */
            pNode = IntGetImeHotKeyByKeyAndLang(gpImeHotKeyList,
                                                (uModifiers & MOD_KEYS),
                                                (uModifiers & MOD_LEFT_RIGHT),
                                                uVirtualKey, LangId);
            if (pNode == NULL) /* If not found */
                pNode = IntGetImeHotKeyById(gpImeHotKeyList, dwHotKeyId); /* Find by ID */
 
            if (pNode) /* Already exists */
            {
                pNode->uModifiers = uModifiers;
                pNode->uVirtualKey = uVirtualKey;
                pNode->hKL = hKL;
                return TRUE;
            }
 
            /* Allocate new hotkey */
            pNode = ExAllocatePoolWithTag(PagedPool, sizeof(IMEHOTKEY), USERTAG_IMEHOTKEY);
            if (!pNode)
                return FALSE;
 
            /* Populate */
            pNode->pNext = NULL;
            pNode->dwHotKeyId = dwHotKeyId;
            pNode->uModifiers = uModifiers;
            pNode->uVirtualKey = uVirtualKey;
            pNode->hKL = hKL;
            IntAddImeHotKey(&gpImeHotKeyList, pNode); /* Add it */
            return TRUE;
 
        case SETIMEHOTKEY_INITIALIZE:
            IntFreeImeHotKeys(); /* Delete all the IME hotkeys */
            return TRUE;
 
        default:
            ERR("0x%lX\n", dwAction);
            return FALSE;
    }
}

Referenced by NtUserSetImeHotKey().

IntWantImeWindow()

BOOL FASTCALL IntWantImeWindow

(

PWND

pwndTarget

)

Definition at line 1917 of file ime.c.

{
    PDESKTOP rpdesk;
    PWINSTATION_OBJECT rpwinstaParent;
    PWND pwndNode, pwndParent = pwndTarget->spwndParent;
 
    if (gptiCurrent->TIF_flags & TIF_DISABLEIME)
        return FALSE;
 
    if (IS_WND_IMELIKE(pwndTarget))
        return FALSE;
 
    if (pwndTarget->fnid == FNID_DESKTOP || pwndTarget->fnid == FNID_MESSAGEWND)
        return FALSE;
 
    if (pwndTarget->state & WNDS_SERVERSIDEWINDOWPROC)
        return FALSE;
 
    rpdesk = pwndTarget->head.rpdesk;
    if (!rpdesk)
        return FALSE;
 
    rpwinstaParent = rpdesk->rpwinstaParent;
    if (!rpwinstaParent || (rpwinstaParent->Flags & WSS_NOIO))
        return FALSE;
 
    for (pwndNode = pwndParent; pwndNode; pwndNode = pwndNode->spwndParent)
    {
        if (rpdesk != pwndNode->head.rpdesk)
            break;
 
        if (pwndNode == rpdesk->spwndMessage)
            return FALSE;
    }
 
    return TRUE;
}

Referenced by co_UserCreateWindowEx().

NtUserAssociateInputContext()

DWORD NTAPI NtUserAssociateInputContext	(	HWND	hWnd,
		HIMC	hIMC,
		DWORD	dwFlags
	)

Definition at line 1702 of file ime.c.

{
    DWORD ret = 2;
    PWND pWnd;
    PIMC pIMC;
 
    UserEnterExclusive();
 
    if (!IS_IMM_MODE())
    {
        ERR("!IS_IMM_MODE()\n");
        goto Quit;
    }
 
    pWnd = ValidateHwndNoErr(hWnd);
    if (!pWnd)
        goto Quit;
 
    pIMC = (hIMC ? UserGetObjectNoErr(gHandleTable, hIMC, TYPE_INPUTCONTEXT) : NULL);
    ret = IntAssociateInputContextEx(pWnd, pIMC, dwFlags);
 
Quit:
    UserLeave();
    return ret;
}

Referenced by ImmAssociateContext(), and ImmAssociateContextEx().

NtUserBuildHimcList()

NTSTATUS NTAPI NtUserBuildHimcList	(	DWORD	dwThreadId,
		DWORD	dwCount,
		HIMC *	phList,
		LPDWORD	pdwCount
	)

Definition at line 690 of file ime.c.

{
    NTSTATUS ret = STATUS_UNSUCCESSFUL;
    DWORD dwRealCount;
    PTHREADINFO pti;
 
    UserEnterExclusive();
 
    if (!IS_IMM_MODE())
    {
        ERR("!IS_IMM_MODE()\n");
        EngSetLastError(ERROR_CALL_NOT_IMPLEMENTED);
        goto Quit;
    }
 
    if (dwThreadId == 0)
    {
        pti = gptiCurrent;
    }
    else if (dwThreadId == INVALID_THREAD_ID)
    {
        pti = NULL;
    }
    else
    {
        pti = IntTID2PTI(UlongToHandle(dwThreadId));
        if (!pti || !pti->rpdesk)
            goto Quit;
    }
 
    _SEH2_TRY
    {
        ProbeForWrite(phList, dwCount * sizeof(HIMC), 1);
        ProbeForWrite(pdwCount, sizeof(DWORD), 1);
        *pdwCount = dwRealCount = UserBuildHimcList(pti, dwCount, phList);
    }
    _SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER)
    {
        ERR("%p, %p\n", phList, pdwCount);
        _SEH2_YIELD(goto Quit);
    }
    _SEH2_END;
 
    if (dwCount < dwRealCount)
        ret = STATUS_BUFFER_TOO_SMALL;
    else
        ret = STATUS_SUCCESS;
 
Quit:
    UserLeave();
    return ret;
}

Referenced by Imm32BuildHimcList().

NtUserCheckImeHotKey()

DWORD NTAPI NtUserCheckImeHotKey	(	UINT	uVirtualKey,
		LPARAM	lParam
	)

Definition at line 467 of file ime.c.

{
    PIMEHOTKEY pNode;
    DWORD ret = INVALID_HOTKEY;
 
    UserEnterExclusive();
 
    if (!gpqForeground || !IS_IMM_MODE())
        goto Quit;
 
    pNode = IntCheckImeHotKey(gpqForeground, uVirtualKey, lParam);
    if (pNode)
        ret = pNode->dwHotKeyId;
 
Quit:
    UserLeave();
    return ret;
}

NtUserCreateInputContext()

HIMC NTAPI NtUserCreateInputContext

(

ULONG_PTR

dwClientImcData

)

Definition at line 1606 of file ime.c.

{
    PIMC pIMC;
    HIMC ret = NULL;
 
    UserEnterExclusive();
 
    if (!IS_IMM_MODE())
    {
        ERR("!IS_IMM_MODE()\n");
        EngSetLastError(ERROR_CALL_NOT_IMPLEMENTED);
        goto Quit;
    }
 
    if (!dwClientImcData)
    {
        EngSetLastError(ERROR_INVALID_PARAMETER);
        goto Quit;
    }
 
    pIMC = UserCreateInputContext(dwClientImcData);
    if (pIMC)
        ret = UserHMGetHandle(pIMC);
 
Quit:
    UserLeave();
    return ret;
}

Referenced by ImmCreateContext().

NtUserDestroyInputContext()

BOOL NTAPI NtUserDestroyInputContext

(

HIMC

hIMC

)

Definition at line 1535 of file ime.c.

{
    BOOL ret = FALSE;
    PIMC pIMC;
 
    UserEnterExclusive();
 
    if (!IS_IMM_MODE())
    {
        EngSetLastError(ERROR_CALL_NOT_IMPLEMENTED);
        goto Quit;
    }
 
    pIMC = UserGetObjectNoErr(gHandleTable, hIMC, TYPE_INPUTCONTEXT);
    if (pIMC)
        ret = IntDestroyInputContext(pIMC);
 
Quit:
    UserLeave();
    return ret;
}

Referenced by Imm32DestroyInputContext().

NtUserDisableThreadIme()

BOOL NTAPI NtUserDisableThreadIme

(

DWORD

dwThreadID

)

Definition at line 852 of file ime.c.

{
    PTHREADINFO pti, ptiCurrent;
    PPROCESSINFO ppi;
    BOOL ret = FALSE;
 
    UserEnterExclusive();
 
    if (!IS_IMM_MODE())
    {
        ERR("!IS_IMM_MODE()\n");
        EngSetLastError(ERROR_CALL_NOT_IMPLEMENTED);
        goto Quit;
    }
 
    ptiCurrent = GetW32ThreadInfo();
 
    if (dwThreadID == INVALID_THREAD_ID)
    {
        ppi = ptiCurrent->ppi;
        ppi->W32PF_flags |= W32PF_DISABLEIME;
 
Retry:
        for (pti = ppi->ptiList; pti; pti = pti->ptiSibling)
        {
            pti->TIF_flags |= TIF_DISABLEIME;
 
            if (pti->spwndDefaultIme)
            {
                co_UserDestroyWindow(pti->spwndDefaultIme);
                pti->spwndDefaultIme = NULL;
                goto Retry; /* The contents of ppi->ptiList may be changed. */
            }
        }
    }
    else
    {
        if (dwThreadID == 0)
        {
            pti = ptiCurrent;
        }
        else
        {
            pti = IntTID2PTI(UlongToHandle(dwThreadID));
 
            /* The thread needs to reside in the current process. */
            if (!pti || pti->ppi != ptiCurrent->ppi)
                goto Quit;
        }
 
        pti->TIF_flags |= TIF_DISABLEIME;
 
        if (pti->spwndDefaultIme)
        {
            co_UserDestroyWindow(pti->spwndDefaultIme);
            pti->spwndDefaultIme = NULL;
        }
    }
 
    ret = TRUE;
 
Quit:
    UserLeave();
    return ret;
}

Referenced by ImmDisableIME().

NtUserGetAppImeLevel()

DWORD NTAPI NtUserGetAppImeLevel

(

HWND

hWnd

)

Definition at line 921 of file ime.c.

{
    DWORD ret = 0;
    PWND pWnd;
    PTHREADINFO pti;
 
    UserEnterShared();
 
    pWnd = ValidateHwndNoErr(hWnd);
    if (!pWnd)
        goto Quit;
 
    if (!IS_IMM_MODE())
    {
        ERR("!IS_IMM_MODE()\n");
        EngSetLastError(ERROR_CALL_NOT_IMPLEMENTED);
        goto Quit;
    }
 
    pti = PsGetCurrentThreadWin32Thread();
    if (pWnd->head.pti->ppi == pti->ppi)
        ret = (DWORD)(ULONG_PTR)UserGetProp(pWnd, AtomImeLevel, TRUE);
 
Quit:
    UserLeave();
    return ret;
}

Referenced by ImmGenerateMessage(), and ImmPostMessages().

NtUserGetImeHotKey()

BOOL NTAPI NtUserGetImeHotKey	(	DWORD	dwHotKeyId,
		LPUINT	lpuModifiers,
		LPUINT	lpuVirtualKey,
		LPHKL	lphKL
	)

Definition at line 406 of file ime.c.

{
    PIMEHOTKEY pNode = NULL;
 
    UserEnterExclusive();
 
    _SEH2_TRY
    {
        ProbeForWrite(lpuModifiers, sizeof(UINT), 1);
        ProbeForWrite(lpuVirtualKey, sizeof(UINT), 1);
        if (lphKL)
            ProbeForWrite(lphKL, sizeof(HKL), 1);
    }
    _SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER)
    {
        ERR("%p, %p, %p\n", lpuModifiers, lpuVirtualKey, lphKL);
        _SEH2_YIELD(goto Quit);
    }
    _SEH2_END;
 
    pNode = IntGetImeHotKeyById(gpImeHotKeyList, dwHotKeyId);
    if (!pNode)
        goto Quit;
 
    _SEH2_TRY
    {
        *lpuModifiers = pNode->uModifiers;
        *lpuVirtualKey = pNode->uVirtualKey;
        if (lphKL)
            *lphKL = pNode->hKL;
    }
    _SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER)
    {
        ERR("%p, %p, %p, %p\n", pNode, lpuModifiers, lpuVirtualKey, lphKL);
        pNode = NULL;
    }
    _SEH2_END;
 
Quit:
    UserLeave();
    return !!pNode;
}

Referenced by CliSetDefaultImeHotKeys(), and ImmGetHotKey().

NtUserGetImeInfoEx()

BOOL NTAPI NtUserGetImeInfoEx	(	PIMEINFOEX	pImeInfoEx,
		IMEINFOEXCLASS	SearchType
	)

Definition at line 1008 of file ime.c.

{
    IMEINFOEX ImeInfoEx;
    BOOL ret = FALSE;
    PWINSTATION_OBJECT pWinSta;
 
    UserEnterShared();
 
    if (!IS_IMM_MODE())
    {
        ERR("!IS_IMM_MODE()\n");
        goto Quit;
    }
 
    _SEH2_TRY
    {
        ProbeForRead(pImeInfoEx, sizeof(*pImeInfoEx), 1);
        ImeInfoEx = *pImeInfoEx;
    }
    _SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER)
    {
        ERR("%p\n", pImeInfoEx);
        _SEH2_YIELD(goto Quit);
    }
    _SEH2_END;
 
    pWinSta = IntGetProcessWindowStation(NULL);
    ret = UserGetImeInfoEx(pWinSta, &ImeInfoEx, SearchType);
    if (!ret)
        goto Quit;
 
    _SEH2_TRY
    {
        ProbeForWrite(pImeInfoEx, sizeof(*pImeInfoEx), 1);
        *pImeInfoEx = ImeInfoEx;
    }
    _SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER)
    {
        ERR("%p\n", pImeInfoEx);
        ret = FALSE;
    }
    _SEH2_END;
 
Quit:
    UserLeave();
    return ret;
}

Referenced by ImmGetImeInfoEx().

NtUserNotifyIMEStatus()

DWORD NTAPI NtUserNotifyIMEStatus	(	HWND	hwnd,
		BOOL	fOpen,
		DWORD	dwConversion
	)

Definition at line 803 of file ime.c.

{
    PWND pwnd;
    PTHREADINFO pti;
    HKL hKL;
 
    UserEnterExclusive();
 
    if (!IS_IMM_MODE())
    {
        ERR("!IS_IMM_MODE()\n");
        goto Quit;
    }
 
    pwnd = ValidateHwndNoErr(hwnd);
    if (!pwnd)
        goto Quit;
 
    pti = pwnd->head.pti;
    if (!pti || !gptiForeground)
        goto Quit;
    if (pti != gptiForeground && pti->MessageQueue != gptiForeground->MessageQueue)
        goto Quit;
    if (ghIMC == pwnd->hImc && gfImeOpen == !!fOpen && gdwImeConversion == dwConversion)
        goto Quit;
 
    ghIMC = pwnd->hImc;
    if (ghIMC)
    {
        gfImeOpen = !!fOpen;
        gdwImeConversion = dwConversion;
        UserSetImeConversionKeyState(pti, (fOpen ? dwConversion : IME_CMODE_ALPHANUMERIC));
    }
 
    if (ISITHOOKED(WH_SHELL))
    {
        hKL = (pti->KeyboardLayout ? pti->KeyboardLayout->hkl : NULL);
        co_HOOK_CallHooks(WH_SHELL, HSHELL_LANGUAGE, (WPARAM)hwnd, (LPARAM)hKL);
    }
 
    // TODO:
 
Quit:
    UserLeave();
    return 0;
}

Referenced by ImeWnd_OnImeNotify(), Imm32SendNotificationProc(), ImmSetActiveContext(), ImmSetConversionStatus(), and ImmSetOpenStatus().

NtUserQueryInputContext()

DWORD_PTR NTAPI NtUserQueryInputContext	(	HIMC	hIMC,
		DWORD	dwType
	)

Definition at line 1791 of file ime.c.

{
    PIMC pIMC;
    PTHREADINFO ptiIMC;
    DWORD_PTR ret = 0;
 
    UserEnterExclusive();
 
    if (!IS_IMM_MODE())
    {
        ERR("!IS_IMM_MODE()\n");
        goto Quit;
    }
 
    pIMC = UserGetObject(gHandleTable, hIMC, TYPE_INPUTCONTEXT);
    if (!pIMC)
        goto Quit;
 
    ptiIMC = pIMC->head.pti;
 
    switch (dwType)
    {
        case QIC_INPUTPROCESSID:
            ret = (DWORD_PTR)PsGetThreadProcessId(ptiIMC->pEThread);
            break;
 
        case QIC_INPUTTHREADID:
            ret = (DWORD_PTR)PsGetThreadId(ptiIMC->pEThread);
            break;
 
        case QIC_DEFAULTWINDOWIME:
            if (ptiIMC->spwndDefaultIme)
                ret = (DWORD_PTR)UserHMGetHandle(ptiIMC->spwndDefaultIme);
            break;
 
        case QIC_DEFAULTIMC:
            if (ptiIMC->spDefaultImc)
                ret = (DWORD_PTR)UserHMGetHandle(ptiIMC->spDefaultImc);
            break;
    }
 
Quit:
    UserLeave();
    return ret;
}

Referenced by CtfImmGenerateMessage(), CtfImmGetGuidAtom(), CtfImmIsGuidMapEnable(), CtfImmTIMCreateInputContext(), Imm32CheckImcProcess(), Imm32GetImeMenuItemWInterProcess(), Imm32InternalLockIMC(), Imm32IsCrossThreadAccess(), Imm32MakeIMENotify(), ImmGetImeMenuItemsAW(), and ImmSetCompositionStringAW().

NtUserSetAppImeLevel()

BOOL NTAPI NtUserSetAppImeLevel	(	HWND	hWnd,
		DWORD	dwLevel
	)

Definition at line 1060 of file ime.c.

{
    BOOL ret = FALSE;
    PWND pWnd;
    PTHREADINFO pti;
 
    UserEnterExclusive();
 
    if (!IS_IMM_MODE())
    {
        ERR("!IS_IMM_MODE()\n");
        EngSetLastError(ERROR_CALL_NOT_IMPLEMENTED);
        goto Quit;
    }
 
    pWnd = ValidateHwndNoErr(hWnd);
    if (!pWnd)
        goto Quit;
 
    pti = PsGetCurrentThreadWin32Thread();
    if (pWnd->head.pti->ppi == pti->ppi)
        ret = UserSetProp(pWnd, AtomImeLevel, (HANDLE)(ULONG_PTR)dwLevel, TRUE);
 
Quit:
    UserLeave();
    return ret;
}

NtUserSetImeHotKey()

BOOL NTAPI NtUserSetImeHotKey	(	DWORD	dwHotKeyId,
		UINT	uModifiers,
		UINT	uVirtualKey,
		HKL	hKL,
		DWORD	dwAction
	)

Definition at line 451 of file ime.c.

{
    BOOL ret;
    UserEnterExclusive();
    ret = IntSetImeHotKey(dwHotKeyId, uModifiers, uVirtualKey, hKL, dwAction);
    UserLeave();
    return ret;
}

Referenced by CliImmInitializeHotKeys(), and CliImmSetHotKeyWorker().

NtUserSetImeInfoEx()

BOOL NTAPI NtUserSetImeInfoEx

(

PIMEINFOEX

pImeInfoEx

)

Definition at line 1126 of file ime.c.

{
    BOOL ret = FALSE;
    IMEINFOEX ImeInfoEx;
    PWINSTATION_OBJECT pWinSta;
 
    UserEnterExclusive();
 
    if (!IS_IMM_MODE())
    {
        ERR("!IS_IMM_MODE()\n");
        goto Quit;
    }
 
    _SEH2_TRY
    {
        ProbeForRead(pImeInfoEx, sizeof(*pImeInfoEx), 1);
        ImeInfoEx = *pImeInfoEx;
    }
    _SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER)
    {
        ERR("%p\n", pImeInfoEx);
        _SEH2_YIELD(goto Quit);
    }
    _SEH2_END;
 
    pWinSta = IntGetProcessWindowStation(NULL);
    ret = UserSetImeInfoEx(pWinSta, &ImeInfoEx);
 
Quit:
    UserLeave();
    return ret;
}

Referenced by Imm32LoadIME().

NtUserSetImeOwnerWindow()

BOOL NTAPI NtUserSetImeOwnerWindow	(	HWND	hImeWnd,
		HWND	hwndFocus
	)

Definition at line 1362 of file ime.c.

{
    BOOL ret = FALSE;
    PWND pImeWnd, pwndFocus, pwndTopLevel, pwndNode, pwndActive;
    PTHREADINFO ptiIme;
 
    UserEnterExclusive();
 
    if (!IS_IMM_MODE())
    {
        ERR("!IS_IMM_MODE()\n");
        goto Quit;
    }
 
    pImeWnd = ValidateHwndNoErr(hImeWnd);
    if (!pImeWnd || pImeWnd->fnid != FNID_IME)
        goto Quit;
 
    pwndFocus = ValidateHwndNoErr(hwndFocus);
    if (pwndFocus)
    {
        if (IS_WND_IMELIKE(pwndFocus))
            goto Quit;
 
        pwndTopLevel = IntGetTopLevelWindow(pwndFocus);
 
        for (pwndNode = pwndTopLevel; pwndNode; pwndNode = pwndNode->spwndOwner)
        {
            if (pwndNode->pcls->atomClassName == gpsi->atomSysClass[ICLS_IME])
            {
                pwndTopLevel = NULL;
                break;
            }
        }
 
        WndSetOwner(pImeWnd, pwndTopLevel);
        IntImeCheckTopmost(pImeWnd);
    }
    else
    {
        ptiIme = pImeWnd->head.pti;
        pwndActive = ptiIme->MessageQueue->spwndActive;
 
        if (!pwndActive || pwndActive != pImeWnd->spwndOwner)
        {
            if (pwndActive && ptiIme == pwndActive->head.pti && !IS_WND_IMELIKE(pwndActive))
            {
                WndSetOwner(pImeWnd, pwndActive);
            }
            else
            {
                IntImeSetFutureOwner(pImeWnd, pImeWnd->spwndOwner);
            }
 
            IntImeCheckTopmost(pImeWnd);
        }
    }
 
    ret = TRUE;
 
Quit:
    UserLeave();
    return ret;
}

Referenced by ImeWnd_OnImeSetContext().

NtUserSetThreadLayoutHandles()

DWORD NTAPI NtUserSetThreadLayoutHandles	(	HKL	hNewKL,
		HKL	hOldKL
	)

Definition at line 508 of file ime.c.

{
    PTHREADINFO pti;
    PKL pOldKL, pNewKL;
 
    UserEnterExclusive();
 
    pti = GetW32ThreadInfo();
    pOldKL = pti->KeyboardLayout;
    if (pOldKL && pOldKL->hkl != hOldKL)
        goto Quit;
 
    pNewKL = UserHklToKbl(hNewKL);
    if (!pNewKL)
        goto Quit;
 
    if (IS_IME_HKL(hNewKL) != IS_IME_HKL(hOldKL))
        pti->hklPrev = hOldKL;
 
    UserAssignmentLock((PVOID*)&pti->KeyboardLayout, pNewKL);
    pti->pClientInfo->hKL = pNewKL->hkl;
 
Quit:
    UserLeave();
    return 0;
}

Referenced by ImmActivateLayout().

NtUserUpdateInputContext()

BOOL NTAPI NtUserUpdateInputContext	(	HIMC	hIMC,
		DWORD	dwType,
		DWORD_PTR	dwValue
	)

Definition at line 1762 of file ime.c.

{
    PIMC pIMC;
    BOOL ret = FALSE;
 
    UserEnterExclusive();
 
    if (!IS_IMM_MODE())
    {
        ERR("!IS_IMM_MODE()\n");
        goto Quit;
    }
 
    pIMC = UserGetObject(gHandleTable, hIMC, TYPE_INPUTCONTEXT);
    if (!pIMC)
        goto Quit;
 
    ret = UserUpdateInputContext(pIMC, dwType, dwValue);
 
Quit:
    UserLeave();
    return ret;
}

Referenced by ImmLockClientImc(), and User32SetImeWindowOfImc().

UserBuildHimcList()

DWORD FASTCALL UserBuildHimcList	(	PTHREADINFO	pti,
		DWORD	dwCount,
		HIMC *	phList
	)

Definition at line 536 of file ime.c.

{
    PIMC pIMC;
    DWORD dwRealCount = 0;
 
    if (pti)
    {
        for (pIMC = pti->spDefaultImc; pIMC; pIMC = pIMC->pImcNext)
        {
            if (dwRealCount < dwCount)
                phList[dwRealCount] = UserHMGetHandle(pIMC);
 
            ++dwRealCount;
        }
    }
    else
    {
        for (pti = gptiCurrent->ppi->ptiList; pti; pti = pti->ptiSibling)
        {
            for (pIMC = pti->spDefaultImc; pIMC; pIMC = pIMC->pImcNext)
            {
                if (dwRealCount < dwCount)
                    phList[dwRealCount] = UserHMGetHandle(pIMC);
 
                ++dwRealCount;
            }
        }
    }
 
    return dwRealCount;
}

Referenced by NtUserBuildHimcList().

UserCreateInputContext()

PIMC FASTCALL UserCreateInputContext

(

ULONG_PTR

dwClientImcData

)

Definition at line 1558 of file ime.c.

{
    PIMC pIMC;
    PTHREADINFO pti = PsGetCurrentThreadWin32Thread();
    PDESKTOP pdesk = pti->rpdesk;
 
    if (!IS_IMM_MODE() || (pti->TIF_flags & TIF_DISABLEIME)) // Disabled?
    {
        ERR("IME is disabled\n");
        return NULL;
    }
 
    if (!pdesk) // No desktop?
        return NULL;
 
    // pti->spDefaultImc should be already set if non-first time.
    if (dwClientImcData && !pti->spDefaultImc)
        return NULL;
 
    // Create an input context user object.
    pIMC = UserCreateObject(gHandleTable, pdesk, pti, NULL, TYPE_INPUTCONTEXT, sizeof(IMC));
    if (!pIMC)
        return NULL;
 
    // Release the extra reference (UserCreateObject added 2 references).
    UserDereferenceObject(pIMC);
    ASSERT(pIMC->head.cLockObj == 1);
 
    if (dwClientImcData) // Non-first time.
    {
        // Insert pIMC to the second position (non-default) of the list.
        pIMC->pImcNext = pti->spDefaultImc->pImcNext;
        pti->spDefaultImc->pImcNext = pIMC;
    }
    else // First time. It's the default IMC.
    {
        // Add the first one (default) to the list.
        UserAssignmentLock((PVOID*)&pti->spDefaultImc, pIMC);
        pIMC->pImcNext = NULL;
        ASSERT(pIMC->head.cLockObj == 2); // UserAssignmentUnlock'ed at ExitThreadCallback
    }
 
    pIMC->dwClientImcData = dwClientImcData; // Set it.
    return pIMC;
}

Referenced by co_IntCreateDefaultImeWindow(), InitThreadCallback(), and NtUserCreateInputContext().

UserDestroyInputContext()

BOOLEAN UserDestroyInputContext

(

PVOID

Object

)

Definition at line 1484 of file ime.c.

{
    PIMC pIMC = Object;
    if (!pIMC)
        return TRUE;
 
    UserMarkObjectDestroy(pIMC);
    UserDeleteObject(UserHMGetHandle(pIMC), TYPE_INPUTCONTEXT);
    return TRUE;
}

UserFreeInputContext()

VOID UserFreeInputContext

(

PVOID

Object

)

Definition at line 1457 of file ime.c.

{
    PTHRDESKHEAD ObjHead = Object;
    PDESKTOP pDesk = ObjHead->rpdesk;
    PIMC pNode, pIMC = Object;
    PTHREADINFO pti;
 
    if (!pIMC)
        return;
 
    // Remove pIMC from the list except spDefaultImc
    pti = pIMC->head.pti;
    for (pNode = pti->spDefaultImc; pNode; pNode = pNode->pImcNext)
    {
        if (pNode->pImcNext == pIMC)
        {
            pNode->pImcNext = pIMC->pImcNext;
            break;
        }
    }
 
    DesktopHeapFree(pDesk, Object);
 
    pti->ppi->UserHandleCount--;
    IntDereferenceThreadInfo(pti);
}

UserGetImeInfoEx()

BOOL FASTCALL UserGetImeInfoEx	(	_Inout_ PWINSTATION_OBJECT	pWinSta,
		_Inout_ PIMEINFOEX	pInfoEx,
		_In_ IMEINFOEXCLASS	SearchType
	)

Definition at line 951 of file ime.c.

{
    PKL pkl, pklHead;
 
    if (!pWinSta || !gspklBaseLayout)
        return FALSE;
 
    pkl = pklHead = gspklBaseLayout;
 
    /* Find the matching entry from the list and get info */
    if (SearchType == ImeInfoExKeyboardLayout)
    {
        do
        {
            if (pInfoEx->hkl == pkl->hkl)
            {
                if (!pkl->piiex)
                {
                    ERR("!pkl->piiex at %p\n", pkl->hkl);
                    break;
                }
 
                *pInfoEx = *pkl->piiex;
                return TRUE;
            }
 
            pkl = pkl->pklNext;
        } while (pkl != pklHead);
    }
    else if (SearchType == ImeInfoExImeFileName)
    {
        do
        {
            if (pkl->piiex &&
                _wcsnicmp(pkl->piiex->wszImeFile, pInfoEx->wszImeFile,
                          RTL_NUMBER_OF(pkl->piiex->wszImeFile)) == 0)
            {
                *pInfoEx = *pkl->piiex;
                return TRUE;
            }
 
            pkl = pkl->pklNext;
        } while (pkl != pklHead);
    }
    else
    {
        ERR("SearchType: %d\n", SearchType);
    }
 
    return FALSE;
}

Referenced by NtUserGetImeInfoEx().

UserSetImeConversionKeyState()

static VOID FASTCALL UserSetImeConversionKeyState ( PTHREADINFO  pti, DWORD  dwConversion  )

static

Definition at line 744 of file ime.c.

{
    HKL hKL;
    LANGID LangID;
    LPBYTE KeyState;
    BOOL bAlphaNumeric, bKatakana, bHiragana, bFullShape, bRoman, bCharCode;
 
    if (!pti->KeyboardLayout)
        return;
 
    hKL = pti->KeyboardLayout->hkl;
    LangID = LOWORD(hKL);
    KeyState = pti->MessageQueue->afKeyState;
 
    switch (PRIMARYLANGID(LangID))
    {
        case LANG_JAPANESE:
            bAlphaNumeric = !(dwConversion & IME_CMODE_NATIVE);
            bKatakana = !bAlphaNumeric && (dwConversion & IME_CMODE_KATAKANA);
            bHiragana = !bAlphaNumeric && !(dwConversion & IME_CMODE_KATAKANA);
            SET_KEY_DOWN(KeyState, VK_DBE_ALPHANUMERIC, bAlphaNumeric);
            SET_KEY_LOCKED(KeyState, VK_DBE_ALPHANUMERIC, bAlphaNumeric);
            SET_KEY_DOWN(KeyState, VK_DBE_HIRAGANA, bHiragana);
            SET_KEY_LOCKED(KeyState, VK_DBE_HIRAGANA, bHiragana);
            SET_KEY_DOWN(KeyState, VK_DBE_KATAKANA, bKatakana);
            SET_KEY_LOCKED(KeyState, VK_DBE_KATAKANA, bKatakana);
 
            bFullShape = (dwConversion & IME_CMODE_FULLSHAPE);
            SET_KEY_DOWN(KeyState, VK_DBE_DBCSCHAR, bFullShape);
            SET_KEY_LOCKED(KeyState, VK_DBE_DBCSCHAR, bFullShape);
            SET_KEY_DOWN(KeyState, VK_DBE_SBCSCHAR, !bFullShape);
            SET_KEY_LOCKED(KeyState, VK_DBE_SBCSCHAR, !bFullShape);
 
            bRoman = (dwConversion & IME_CMODE_ROMAN);
            SET_KEY_DOWN(KeyState, VK_DBE_ROMAN, bRoman);
            SET_KEY_LOCKED(KeyState, VK_DBE_ROMAN, bRoman);
            SET_KEY_DOWN(KeyState, VK_DBE_NOROMAN, !bRoman);
            SET_KEY_LOCKED(KeyState, VK_DBE_NOROMAN, !bRoman);
 
            bCharCode = (dwConversion & IME_CMODE_CHARCODE);
            SET_KEY_DOWN(KeyState, VK_DBE_CODEINPUT, bCharCode);
            SET_KEY_LOCKED(KeyState, VK_DBE_CODEINPUT, bCharCode);
            SET_KEY_DOWN(KeyState, VK_DBE_NOCODEINPUT, !bCharCode);
            SET_KEY_LOCKED(KeyState, VK_DBE_NOCODEINPUT, !bCharCode);
            break;
 
        case LANG_KOREAN:
            SET_KEY_LOCKED(KeyState, VK_HANGUL, (dwConversion & IME_CMODE_NATIVE));
            SET_KEY_LOCKED(KeyState, VK_JUNJA, (dwConversion & IME_CMODE_FULLSHAPE));
            SET_KEY_LOCKED(KeyState, VK_HANJA, (dwConversion & IME_CMODE_HANJACONVERT));
            break;
 
        default:
            break;
    }
}

Referenced by NtUserNotifyIMEStatus().

UserSetImeInfoEx()

BOOL FASTCALL UserSetImeInfoEx	(	_Inout_ PWINSTATION_OBJECT	pWinSta,
		_Inout_ PIMEINFOEX	pImeInfoEx
	)

Definition at line 1090 of file ime.c.

{
    PKL pklHead, pkl;
 
    if (!pWinSta || !gspklBaseLayout)
        return FALSE;
 
    pkl = pklHead = gspklBaseLayout;
 
    do
    {
        if (pkl->hkl != pImeInfoEx->hkl)
        {
            pkl = pkl->pklNext;
            continue;
        }
 
        if (!pkl->piiex)
        {
            ERR("!pkl->piiex at %p\n", pkl->hkl);
            return FALSE;
        }
 
        if (!pkl->piiex->fLoadFlag)
            *pkl->piiex = *pImeInfoEx;
 
        return TRUE;
    } while (pkl != pklHead);
 
    return FALSE;
}

Referenced by NtUserSetImeInfoEx().

UserUpdateInputContext()

BOOL FASTCALL UserUpdateInputContext	(	PIMC	pIMC,
		DWORD	dwType,
		DWORD_PTR	dwValue
	)

Definition at line 1729 of file ime.c.

{
    PTHREADINFO pti = GetW32ThreadInfo();
    PTHREADINFO ptiIMC = pIMC->head.pti;
 
    if (pti->ppi != ptiIMC->ppi) // Different process?
        return FALSE;
 
    switch (dwType)
    {
        case UIC_CLIENTIMCDATA:
            if (pIMC->dwClientImcData)
                return FALSE; // Already set
 
            pIMC->dwClientImcData = dwValue;
            break;
 
        case UIC_IMEWINDOW:
            if (!ValidateHwndNoErr((HWND)dwValue))
                return FALSE; // Invalid HWND
 
            pIMC->hImeWnd = (HWND)dwValue;
            break;
 
        default:
            return FALSE;
    }
 
    return TRUE;
}

Referenced by NtUserUpdateInputContext().

Variable Documentation

gdwImeConversion

DWORD gdwImeConversion = (DWORD)-1

Definition at line 28 of file ime.c.

Referenced by NtUserNotifyIMEStatus().

gfImeOpen

BOOL gfImeOpen = (BOOL)-1

Definition at line 27 of file ime.c.

Referenced by NtUserNotifyIMEStatus().

gfIMEShowStatus

BOOL gfIMEShowStatus = (BOOL)-1

Definition at line 29 of file ime.c.

Referenced by IntBroadcastImeShowStatusChange(), IntNotifyImeShowStatus(), and NtUserCallNoParam().

ghIMC

HIMC ghIMC = NULL

Definition at line 26 of file ime.c.

Referenced by NtUserNotifyIMEStatus().

glcidSystem

LCID glcidSystem = 0

Definition at line 41 of file ime.c.

Referenced by IntGetImeHotKeyLanguageScore().

gpImeHotKeyList

PIMEHOTKEY gpImeHotKeyList = NULL

Definition at line 40 of file ime.c.

Referenced by IntCheckImeHotKey(), IntFreeImeHotKeys(), IntSetImeHotKey(), and NtUserGetImeHotKey().