kbdlayout.c File Reference

#include <win32k.h>
#include <immdev.h>

Include dependency graph for kbdlayout.c:

Go to the source code of this file.

Macros
#define	CP_ACP   0

Typedefs
typedef PVOID(*	PFN_KBDLAYERDESCRIPTOR) (VOID)

Functions
	DBG_DEFAULT_CHANNEL (UserKbdLayout)
PKL FASTCALL	IntHKLtoPKL (_Inout_ PTHREADINFO pti, _In_ HKL hKL)
static UINT APIENTRY	IntGetKeyboardLayoutList (_Inout_ PWINSTATION_OBJECT pWinSta, _In_ ULONG nBuff, _Out_ HKL *pHklBuff)
static BOOL	UserLoadKbdDll (WCHAR *pwszLayoutPath, HANDLE *phModule, PKBDTABLES *pKbdTables)
static PKBDFILE	UserLoadKbdFile (PUNICODE_STRING pwszKLID)
static PKL	co_UserLoadKbdLayout (PUNICODE_STRING pustrKLID, HKL hKL)
static VOID	UnloadKbdFile (_In_ PKBDFILE pkf)
BOOL	UserUnloadKbl (PKL pKl)
PKL	W32kGetDefaultKeyLayout (VOID)
PKL NTAPI	UserHklToKbl (HKL hKl)
VOID FASTCALL	IntReorderKeyboardLayouts (_Inout_ PWINSTATION_OBJECT pWinSta, _Inout_ PKL pNewKL)
BOOL NTAPI	UserSetDefaultInputLang (HKL hKl)
VOID APIENTRY	IntImmActivateLayout (_Inout_ PTHREADINFO pti, _Inout_ PKL pKL)
static VOID	co_IntSetKeyboardLayoutForProcess (PPROCESSINFO ppi, PKL pKL)
HKL APIENTRY	co_UserActivateKeyboardLayout (_Inout_ PKL pKL, _In_ ULONG uFlags, _In_opt_ PWND pWnd)
HKL APIENTRY	co_IntActivateKeyboardLayout (_Inout_ PWINSTATION_OBJECT pWinSta, _In_ HKL hKL, _In_ ULONG uFlags, _In_opt_ PWND pWnd)
static BOOL APIENTRY	co_IntUnloadKeyboardLayoutEx (_Inout_ PWINSTATION_OBJECT pWinSta, _Inout_ PKL pKL, _In_ DWORD dwFlags)
static BOOL APIENTRY	IntUnloadKeyboardLayout (_Inout_ PWINSTATION_OBJECT pWinSta, _In_ HKL hKL)
PIMEINFOEX FASTCALL	co_UserImmLoadLayout (_In_ HKL hKL)
	Invokes imm32!ImmLoadLayout and returns PIMEINFOEX.
HKL APIENTRY	co_IntLoadKeyboardLayoutEx (IN OUT PWINSTATION_OBJECT pWinSta, IN HANDLE hSafeFile, IN HKL hOldKL, IN PUNICODE_STRING puszSafeKLID, IN HKL hNewKL, IN UINT Flags)
HANDLE FASTCALL	IntVerifyKeyboardFileHandle (HANDLE hFile)
HKL FASTCALL	UserGetKeyboardLayout (DWORD dwThreadId)
UINT APIENTRY	NtUserGetKeyboardLayoutList (ULONG nBuff, HKL *pHklBuff)
BOOL APIENTRY	NtUserGetKeyboardLayoutName (_Inout_ PUNICODE_STRING pustrName)
HKL NTAPI	NtUserLoadKeyboardLayoutEx (IN HANDLE hFile, IN DWORD offTable, IN PVOID pTables, IN HKL hOldKL, IN PUNICODE_STRING puszKLID, IN DWORD dwNewKL, IN UINT Flags)
HKL NTAPI	NtUserActivateKeyboardLayout (HKL hKL, ULONG Flags)
BOOL APIENTRY	NtUserUnloadKeyboardLayout (HKL hKl)

Variables
PKL	gspklBaseLayout = NULL
PKBDFILE	gpkfList = NULL
DWORD	gSystemFS = 0
UINT	gSystemCPCharSet = 0
HKL	ghKLSentToShell = NULL

Macro Definition Documentation

CP_ACP

#define CP_ACP   0

Definition at line 18 of file kbdlayout.c.

Typedef Documentation

PFN_KBDLAYERDESCRIPTOR

typedef PVOID(* PFN_KBDLAYERDESCRIPTOR) (VOID)

Definition at line 28 of file kbdlayout.c.

Function Documentation

co_IntActivateKeyboardLayout()

HKL APIENTRY co_IntActivateKeyboardLayout	(	_Inout_ PWINSTATION_OBJECT	pWinSta,
		_In_ HKL	hKL,
		_In_ ULONG	uFlags,
		_In_opt_ PWND	pWnd
	)

Definition at line 782 of file kbdlayout.c.

{
    PKL pKL;
    PTHREADINFO pti = PsGetCurrentThreadWin32Thread();
 
    pKL = IntHKLtoPKL(pti, hKL);
    if (!pKL)
    {
        ERR("Invalid HKL %p!\n", hKL);
        return NULL;
    }
 
    if (uFlags & KLF_REORDER)
        IntReorderKeyboardLayouts(pWinSta, pKL);
 
    return co_UserActivateKeyboardLayout(pKL, uFlags, pWnd);
}

Referenced by NtUserActivateKeyboardLayout().

co_IntLoadKeyboardLayoutEx()

HKL APIENTRY co_IntLoadKeyboardLayoutEx	(	IN OUT PWINSTATION_OBJECT	pWinSta,
		IN HANDLE	hSafeFile,
		IN HKL	hOldKL,
		IN PUNICODE_STRING	puszSafeKLID,
		IN HKL	hNewKL,
		IN UINT	Flags
	)

Definition at line 885 of file kbdlayout.c.

{
    PKL pOldKL, pNewKL;
 
    UNREFERENCED_PARAMETER(hSafeFile);
 
    if (hNewKL == NULL || (pWinSta->Flags & WSS_NOIO))
        return NULL;
 
    /* If hOldKL is specified, unload it and load new layput as default */
    if (hOldKL && hOldKL != hNewKL)
    {
        pOldKL = UserHklToKbl(hOldKL);
        if (pOldKL)
            UserUnloadKbl(pOldKL);
    }
 
    /* FIXME: It seems KLF_RESET is only supported for WINLOGON */
 
    /* Let's see if layout was already loaded. */
    pNewKL = UserHklToKbl(hNewKL);
    if (!pNewKL)
    {
        /* It wasn't, so load it. */
        pNewKL = co_UserLoadKbdLayout(puszSafeKLID, hNewKL);
        if (!pNewKL)
            return NULL;
 
        if (gspklBaseLayout)
        {
            /* Find last not unloaded layout */
            PKL pLastKL = gspklBaseLayout->pklPrev;
            while (pLastKL != gspklBaseLayout && (pLastKL->dwKL_Flags & KL_UNLOAD))
                pLastKL = pLastKL->pklPrev;
 
            /* Add new layout to the list */
            pNewKL->pklNext = pLastKL->pklNext;
            pNewKL->pklPrev = pLastKL;
            pNewKL->pklNext->pklPrev = pNewKL;
            pNewKL->pklPrev->pklNext = pNewKL;
        }
        else
        {
            /* This is the first layout */
            pNewKL->pklNext = pNewKL;
            pNewKL->pklPrev = pNewKL;
            gspklBaseLayout = pNewKL;
        }
 
        pNewKL->piiex = co_UserImmLoadLayout(hNewKL);
    }
 
    /* If this layout was prepared to unload, undo it */
    pNewKL->dwKL_Flags &= ~KL_UNLOAD;
 
    /* Reorder if necessary */
    if (Flags & KLF_REORDER)
        IntReorderKeyboardLayouts(pWinSta, pNewKL);
 
    /* Activate this layout in current thread */
    if (Flags & KLF_ACTIVATE)
        co_UserActivateKeyboardLayout(pNewKL, Flags, NULL);
 
    /* Send shell message */
    if (!(Flags & KLF_NOTELLSHELL))
        co_IntShellHookNotify(HSHELL_LANGUAGE, 0, (LPARAM)hNewKL);
 
    /* FIXME: KLF_REPLACELANG */
 
    return hNewKL;
}

Referenced by NtUserLoadKeyboardLayoutEx().

co_IntSetKeyboardLayoutForProcess()

static VOID co_IntSetKeyboardLayoutForProcess ( PPROCESSINFO  ppi, PKL  pKL  )

static

Definition at line 632 of file kbdlayout.c.

{
    PTHREADINFO ptiNode, ptiNext;
    PCLIENTINFO pClientInfo;
    BOOL bImmMode = IS_IMM_MODE();
 
    for (ptiNode = ppi->ptiList; ptiNode; ptiNode = ptiNext)
    {
        IntReferenceThreadInfo(ptiNode);
        ptiNext = ptiNode->ptiSibling;
 
        /* Skip this thread if its keyboard layout is already the correct one, or if it's dying */
        if (ptiNode->KeyboardLayout == pKL || (ptiNode->TIF_flags & TIF_INCLEANUP))
        {
            IntDereferenceThreadInfo(ptiNode);
            continue;
        }
 
        if (bImmMode)
        {
            IntImmActivateLayout(ptiNode, pKL);
        }
        else
        {
            UserAssignmentLock((PVOID*)&ptiNode->KeyboardLayout, pKL);
            pClientInfo = ptiNode->pClientInfo;
            pClientInfo->CodePage = pKL->CodePage;
            pClientInfo->hKL = pKL->hkl;
        }
 
        IntDereferenceThreadInfo(ptiNode);
    }
}

Referenced by co_UserActivateKeyboardLayout().

co_IntUnloadKeyboardLayoutEx()

static BOOL APIENTRY co_IntUnloadKeyboardLayoutEx ( _Inout_ PWINSTATION_OBJECT  pWinSta, _Inout_ PKL  pKL, _In_ DWORD  dwFlags  )

static

Definition at line 805 of file kbdlayout.c.

{
    PKL pNextKL;
    USER_REFERENCE_ENTRY Ref1, Ref2;
    PTHREADINFO pti = gptiCurrent;
 
    if (pKL == gspklBaseLayout && !(dwFlags & UKL_NOACTIVATENEXT))
        return FALSE;
 
    UserRefObjectCo(pKL, &Ref1); /* Add reference */
 
    /* Regard as unloaded */
    UserMarkObjectDestroy(pKL);
    pKL->dwKL_Flags |= KL_UNLOAD;
 
    if (!(dwFlags & UKL_NOACTIVATENEXT) && pti->KeyboardLayout == pKL)
    {
        pNextKL = IntHKLtoPKL(pti, UlongToHandle(HKL_NEXT));
        if (pNextKL)
        {
            UserRefObjectCo(pNextKL, &Ref2); /* Add reference */
            co_UserActivateKeyboardLayout(pNextKL, dwFlags, NULL);
            UserDerefObjectCo(pNextKL); /* Release reference */
        }
    }
 
    if (gspklBaseLayout == pKL && pKL != pKL->pklNext)
    {
        /* Set next layout as default (FIXME: Use UserAssignmentLock?) */
        gspklBaseLayout = pKL->pklNext;
    }
 
    UserDerefObjectCo(pKL); /* Release reference */
 
    if (ISITHOOKED(WH_SHELL))
    {
        co_IntShellHookNotify(HSHELL_LANGUAGE, 0, 0);
        ghKLSentToShell = NULL;
    }
 
    return TRUE;
}

Referenced by IntUnloadKeyboardLayout().

co_UserActivateKeyboardLayout()

HKL APIENTRY co_UserActivateKeyboardLayout	(	_Inout_ PKL	pKL,
		_In_ ULONG	uFlags,
		_In_opt_ PWND	pWnd
	)

Definition at line 667 of file kbdlayout.c.

{
    HKL hOldKL = NULL;
    PKL pOldKL;
    PTHREADINFO pti = GetW32ThreadInfo();
    PWND pTargetWnd, pImeWnd;
    HWND hTargetWnd, hImeWnd;
    USER_REFERENCE_ENTRY Ref1, Ref2;
    PCLIENTINFO ClientInfo;
    BOOL bSetForProcess = !!(uFlags & KLF_SETFORPROCESS);
 
    IntReferenceThreadInfo(pti);
    ClientInfo = pti->pClientInfo;
 
    pOldKL = pti->KeyboardLayout;
    if (pOldKL)
        hOldKL = pOldKL->hkl;
 
    if (uFlags & KLF_RESET)
    {
        FIXME("KLF_RESET\n");
    }
 
    if (!bSetForProcess && pKL == pti->KeyboardLayout)
    {
        IntDereferenceThreadInfo(pti);
        return hOldKL;
    }
 
    pKL->wchDiacritic = UNICODE_NULL;
 
    if (pOldKL)
        UserRefObjectCo(pOldKL, &Ref1);
 
    if (pti->TIF_flags & TIF_CSRSSTHREAD)
    {
        UserAssignmentLock((PVOID*)&pti->KeyboardLayout, pKL);
        ClientInfo->CodePage = pKL->CodePage;
        ClientInfo->hKL = pKL->hkl;
    }
    else if (bSetForProcess)
    {
        co_IntSetKeyboardLayoutForProcess(pti->ppi, pKL);
    }
    else
    {
        if (IS_IMM_MODE())
            IntImmActivateLayout(pti, pKL);
        else
            UserAssignmentLock((PVOID*)&pti->KeyboardLayout, pKL);
 
        ClientInfo->CodePage = pKL->CodePage;
        ClientInfo->hKL = pKL->hkl;
    }
 
    /* Send shell message if necessary */
    if (gptiForeground && (gptiForeground->ppi == pti->ppi) && ISITHOOKED(WH_SHELL))
    {
        /* Send the HKL if needed and remember it */
        if (ghKLSentToShell != pKL->hkl)
        {
            co_IntShellHookNotify(HSHELL_LANGUAGE, 0, (LPARAM)pKL->hkl);
            ghKLSentToShell = pKL->hkl;
        }
    }
 
    if (pti->MessageQueue)
    {
        /* Determine the target window */
        pTargetWnd = pti->MessageQueue->spwndFocus;
        if (!pTargetWnd)
        {
            pTargetWnd = pti->MessageQueue->spwndActive;
            if (!pTargetWnd)
                pTargetWnd = pWnd;
        }
 
        /* Send WM_INPUTLANGCHANGE message */
        if (pTargetWnd)
        {
            UserRefObjectCo(pTargetWnd, &Ref2);
            hTargetWnd = UserHMGetHandle(pTargetWnd);
            co_IntSendMessage(hTargetWnd, WM_INPUTLANGCHANGE, pKL->iBaseCharset, (LPARAM)pKL->hkl);
            UserDerefObjectCo(pTargetWnd);
        }
    }
 
    // Refresh IME UI via WM_IME_SYSTEM:IMS_SENDNOTIFICATION messaging
    if (!(pti->TIF_flags & TIF_CSRSSTHREAD))
    {
        if (IS_IME_HKL(pKL->hkl) || (IS_CICERO_MODE() && !IS_16BIT_MODE()))
        {
            pImeWnd = pti->spwndDefaultIme;
            if (pImeWnd)
            {
                bSetForProcess &= !IS_16BIT_MODE();
                UserRefObjectCo(pImeWnd, &Ref2);
                hImeWnd = UserHMGetHandle(pImeWnd);
                co_IntSendMessage(hImeWnd, WM_IME_SYSTEM, IMS_SENDNOTIFICATION, bSetForProcess);
                UserDerefObjectCo(pImeWnd);
            }
        }
    }
 
    if (pOldKL)
        UserDerefObjectCo(pOldKL);
 
    IntDereferenceThreadInfo(pti);
    return hOldKL;
}

Referenced by co_IntActivateKeyboardLayout(), co_IntLoadKeyboardLayoutEx(), and co_IntUnloadKeyboardLayoutEx().

co_UserImmLoadLayout()

PIMEINFOEX FASTCALL co_UserImmLoadLayout

(

_In_ HKL

hKL

)

Invokes imm32!ImmLoadLayout and returns PIMEINFOEX.

Definition at line 864 of file kbdlayout.c.

{
    PIMEINFOEX piiex;
 
    if (!IS_IME_HKL(hKL) && !IS_CICERO_MODE())
        return NULL;
 
    piiex = ExAllocatePoolWithTag(PagedPool, sizeof(IMEINFOEX), USERTAG_IME);
    if (!piiex)
        return NULL;
 
    if (!co_ClientImmLoadLayout(hKL, piiex))
    {
        ExFreePoolWithTag(piiex, USERTAG_IME);
        return NULL;
    }
 
    return piiex;
}

Referenced by co_IntLoadKeyboardLayoutEx().

co_UserLoadKbdLayout()

static PKL co_UserLoadKbdLayout ( PUNICODE_STRING  pustrKLID, HKL  hKL  )

static

Definition at line 375 of file kbdlayout.c.

{
    LCID lCid;
    CHARSETINFO cs;
    PKL pKl;
 
    /* Create keyboard layout object */
    pKl = UserCreateObject(gHandleTable, NULL, NULL, NULL, TYPE_KBDLAYOUT, sizeof(KL));
    if (!pKl)
    {
        ERR("Failed to create object!\n");
        return NULL;
    }
 
    pKl->hkl = hKL;
    pKl->spkf = UserLoadKbdFile(pustrKLID);
 
    /* Dereference keyboard layout */
    UserDereferenceObject(pKl);
 
    /* If we failed, remove KL object */
    if (!pKl->spkf)
    {
        ERR("UserLoadKbdFile(%wZ) failed!\n", pustrKLID);
        UserDeleteObject(UserHMGetHandle(pKl), TYPE_KBDLAYOUT);
        return NULL;
    }
 
    // Up to Language Identifiers..
    if (!NT_SUCCESS(RtlUnicodeStringToInteger(pustrKLID, 16, (PULONG)&lCid)))
    {
        ERR("RtlUnicodeStringToInteger failed for '%wZ'\n", pustrKLID);
        UserDeleteObject(UserHMGetHandle(pKl), TYPE_KBDLAYOUT);
        return NULL;
    }
 
    TRACE("Language Identifiers %wZ LCID 0x%x\n", pustrKLID, lCid);
    if (co_IntGetCharsetInfo(lCid, &cs))
    {
       pKl->iBaseCharset = cs.ciCharset;
       pKl->dwFontSigs = cs.fs.fsCsb[0];
       pKl->CodePage = (USHORT)cs.ciACP;
       TRACE("Charset %u Font Sig %lu CodePage %u\n",
             pKl->iBaseCharset, pKl->dwFontSigs, pKl->CodePage);
    }
    else
    {
       pKl->iBaseCharset = ANSI_CHARSET;
       pKl->dwFontSigs = FS_LATIN1;
       pKl->CodePage = CP_ACP;
    }
 
    // Set initial system character set and font signature.
    if (gSystemFS == 0)
    {
       gSystemCPCharSet = pKl->iBaseCharset;
       gSystemFS = pKl->dwFontSigs;
    }
 
    return pKl;
}

Referenced by co_IntLoadKeyboardLayoutEx().

DBG_DEFAULT_CHANNEL()

DBG_DEFAULT_CHANNEL

(

UserKbdLayout

)

IntGetKeyboardLayoutList()

static UINT APIENTRY IntGetKeyboardLayoutList ( _Inout_ PWINSTATION_OBJECT  pWinSta, _In_ ULONG  nBuff, _Out_ HKL *  pHklBuff  )

static

Definition at line 96 of file kbdlayout.c.

{
    UINT ret = 0;
    PKL pKL, pFirstKL;
 
    pFirstKL = gspklBaseLayout; /* FIXME: Use pWinSta->spklList instead */
    if (!pWinSta || !pFirstKL)
        return 0;
 
    pKL = pFirstKL;
 
    if (nBuff == 0)
    {
        /* Count the effective PKLs */
        do
        {
            if (!(pKL->dwKL_Flags & KL_UNLOAD))
                ++ret;
            pKL = pKL->pklNext;
        } while (pKL != pFirstKL);
    }
    else
    {
        /* Copy the effective HKLs to pHklBuff */
        do
        {
            if (!(pKL->dwKL_Flags & KL_UNLOAD))
            {
                *pHklBuff = pKL->hkl;
                ++pHklBuff;
                ++ret;
                --nBuff;
 
                if (nBuff == 0)
                    break;
            }
            pKL = pKL->pklNext;
        } while (pKL != pFirstKL);
    }
 
    return ret;
}

Referenced by NtUserGetKeyboardLayoutList().

IntHKLtoPKL()

PKL FASTCALL IntHKLtoPKL	(	_Inout_ PTHREADINFO	pti,
		_In_ HKL	hKL
	)

Definition at line 36 of file kbdlayout.c.

{
    PKL pFirstKL, pKL;
 
    pFirstKL = pti->KeyboardLayout;
    if (!pFirstKL)
        return NULL;
 
    pKL = pFirstKL;
 
    /* hKL can have special value HKL_NEXT or HKL_PREV */
    if (hKL == UlongToHandle(HKL_NEXT)) /* Looking forward */
    {
        do
        {
            pKL = pKL->pklNext;
            if (!(pKL->dwKL_Flags & KL_UNLOAD))
                return pKL;
        } while (pKL != pFirstKL);
    }
    else if (hKL == UlongToHandle(HKL_PREV)) /* Looking backward */
    {
        do
        {
            pKL = pKL->pklPrev;
            if (!(pKL->dwKL_Flags & KL_UNLOAD))
                return pKL;
        } while (pKL != pFirstKL);
    }
    else if (HIWORD(hKL)) /* hKL is a full input locale identifier */
    {
        /* No KL_UNLOAD check */
        do
        {
            if (pKL->hkl == hKL)
                return pKL;
 
            pKL = pKL->pklNext;
        } while (pKL != pFirstKL);
    }
    else  /* Language only specified */
    {
        /* No KL_UNLOAD check */
        do
        {
            if (LOWORD(pKL->hkl) == LOWORD(hKL)) /* Low word is language ID */
                return pKL;
 
            pKL = pKL->pklNext;
        } while (pKL != pFirstKL);
    }
 
    return NULL;
}

Referenced by co_IntActivateKeyboardLayout(), co_IntUnloadKeyboardLayoutEx(), and IntUnloadKeyboardLayout().

IntImmActivateLayout()

VOID APIENTRY IntImmActivateLayout	(	_Inout_ PTHREADINFO	pti,
		_Inout_ PKL	pKL
	)

Definition at line 596 of file kbdlayout.c.

{
    PWND pImeWnd;
    HWND hImeWnd;
    USER_REFERENCE_ENTRY Ref;
 
    if (pti->KeyboardLayout == pKL)
        return;
 
    pImeWnd = pti->spwndDefaultIme;
    if (pImeWnd)
    {
        UserRefObjectCo(pImeWnd, &Ref);
        hImeWnd = UserHMGetHandle(pImeWnd);
        co_IntSendMessage(hImeWnd, WM_IME_SYSTEM, IMS_ACTIVATELAYOUT, (LPARAM)pKL->hkl);
        UserDerefObjectCo(pImeWnd);
    }
    else
    {
        /* Remember old keyboard layout to switch back for Chinese IMEs */
        pti->hklPrev = pti->KeyboardLayout->hkl;
 
        if (pti->spDefaultImc)
        {
            /* IME Activation is needed */
            pti->pClientInfo->CI_flags |= CI_IMMACTIVATE;
        }
    }
 
    UserAssignmentLock((PVOID*)&(pti->KeyboardLayout), pKL);
    pti->pClientInfo->hKL = pKL->hkl;
    pti->pClientInfo->CodePage = pKL->CodePage;
}

Referenced by co_IntSetKeyboardLayoutForProcess(), and co_UserActivateKeyboardLayout().

IntReorderKeyboardLayouts()

VOID FASTCALL IntReorderKeyboardLayouts	(	_Inout_ PWINSTATION_OBJECT	pWinSta,
		_Inout_ PKL	pNewKL
	)

Definition at line 558 of file kbdlayout.c.

{
    PKL pOldKL = gspklBaseLayout;
 
    if ((pWinSta->Flags & WSS_NOIO) || pNewKL == pOldKL)
        return;
 
    pNewKL->pklPrev->pklNext = pNewKL->pklNext;
    pNewKL->pklNext->pklPrev = pNewKL->pklPrev;
    pNewKL->pklNext = pOldKL;
    pNewKL->pklPrev = pOldKL->pklPrev;
    pOldKL->pklPrev->pklNext = pNewKL;
    pOldKL->pklPrev = pNewKL;
    gspklBaseLayout = pNewKL; /* Should we use UserAssignmentLock? */
}

Referenced by co_IntActivateKeyboardLayout(), co_IntLoadKeyboardLayoutEx(), and UserSetDefaultInputLang().

IntUnloadKeyboardLayout()

static BOOL APIENTRY IntUnloadKeyboardLayout ( _Inout_ PWINSTATION_OBJECT  pWinSta, _In_ HKL  hKL  )

static

Definition at line 852 of file kbdlayout.c.

{
    PKL pKL = IntHKLtoPKL(gptiCurrent, hKL);
    if (!pKL)
    {
        ERR("Invalid HKL %p!\n", hKL);
        return FALSE;
    }
    return co_IntUnloadKeyboardLayoutEx(pWinSta, pKL, 0);
}

Referenced by NtUserUnloadKeyboardLayout().

IntVerifyKeyboardFileHandle()

HANDLE FASTCALL IntVerifyKeyboardFileHandle

(

HANDLE

hFile

)

Definition at line 963 of file kbdlayout.c.

{
    PFILE_OBJECT FileObject;
    NTSTATUS Status;
 
    if (hFile == INVALID_HANDLE_VALUE)
        return NULL;
 
    Status = ObReferenceObjectByHandle(hFile, FILE_READ_DATA, NULL, UserMode,
                                       (PVOID*)&FileObject, NULL);
    if (!NT_SUCCESS(Status))
    {
        ERR("0x%08X\n", Status);
        return NULL;
    }
 
    /* FIXME: Is the file in the system directory? */
 
    if (FileObject)
        ObDereferenceObject(FileObject);
 
    return hFile;
}

Referenced by NtUserLoadKeyboardLayoutEx().

NtUserActivateKeyboardLayout()

HKL NTAPI NtUserActivateKeyboardLayout	(	HKL	hKL,
		ULONG	Flags
	)

Definition at line 1226 of file kbdlayout.c.

{
    PWINSTATION_OBJECT pWinSta;
    HKL hOldKL;
 
    UserEnterExclusive();
 
    /* FIXME */
 
    pWinSta = IntGetProcessWindowStation(NULL);
    hOldKL = co_IntActivateKeyboardLayout(pWinSta, hKL, Flags, NULL);
    UserLeave();
 
    return hOldKL;
}

Referenced by User32DefWindowProc().

NtUserGetKeyboardLayoutList()

UINT APIENTRY NtUserGetKeyboardLayoutList	(	ULONG	nBuff,
		HKL *	pHklBuff
	)

Definition at line 1038 of file kbdlayout.c.

{
    UINT ret = 0;
    PWINSTATION_OBJECT pWinSta;
 
    if (!pHklBuff)
        nBuff = 0;
 
    UserEnterShared();
 
    if (nBuff > MAXULONG / sizeof(HKL))
    {
        SetLastNtError(ERROR_INVALID_PARAMETER);
        goto Quit;
    }
 
    _SEH2_TRY
    {
        ProbeForWrite(pHklBuff, nBuff * sizeof(HKL), 1);
    }
    _SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER)
    {
        SetLastNtError(_SEH2_GetExceptionCode());
        goto Quit;
    }
    _SEH2_END;
 
    pWinSta = IntGetProcessWindowStation(NULL);
 
    _SEH2_TRY
    {
        ret = IntGetKeyboardLayoutList(pWinSta, nBuff, pHklBuff);
    }
    _SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER)
    {
        SetLastNtError(_SEH2_GetExceptionCode());
        goto Quit;
    }
    _SEH2_END;
 
Quit:
    UserLeave();
    return ret;
}

Referenced by CliImmInitializeHotKeys().

NtUserGetKeyboardLayoutName()

BOOL APIENTRY NtUserGetKeyboardLayoutName

(

_Inout_ PUNICODE_STRING

pustrName

)

Definition at line 1092 of file kbdlayout.c.

{
    BOOL bRet = FALSE;
    PKL pKl;
    PTHREADINFO pti;
    UNICODE_STRING ustrNameSafe;
    NTSTATUS Status;
 
    UserEnterShared();
 
    pti = PsGetCurrentThreadWin32Thread();
    pKl = pti->KeyboardLayout;
 
    if (!pKl)
        goto cleanup;
 
    _SEH2_TRY
    {
        ProbeForWriteUnicodeString(pustrName);
        ustrNameSafe = *pustrName;
 
        ProbeForWrite(ustrNameSafe.Buffer, ustrNameSafe.MaximumLength, 1);
 
        if (IS_IME_HKL(pKl->hkl))
        {
            Status = RtlIntegerToUnicodeString(HandleToUlong(pKl->hkl), 16, &ustrNameSafe);
        }
        else
        {
            if (ustrNameSafe.MaximumLength < KL_NAMELENGTH * sizeof(WCHAR))
            {
                EngSetLastError(ERROR_INVALID_PARAMETER);
                goto cleanup;
            }
 
            /* FIXME: Do not use awchKF */
            ustrNameSafe.Length = 0;
            Status = RtlAppendUnicodeToString(&ustrNameSafe, pKl->spkf->awchKF);
        }
 
        if (NT_SUCCESS(Status))
        {
            *pustrName = ustrNameSafe;
            bRet = TRUE;
        }
    }
    _SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER)
    {
        SetLastNtError(_SEH2_GetExceptionCode());
    }
    _SEH2_END;
 
cleanup:
    UserLeave();
    return bRet;
}

Referenced by GetKeyboardLayoutNameW(), and START_TEST().

NtUserLoadKeyboardLayoutEx()

HKL NTAPI NtUserLoadKeyboardLayoutEx	(	IN HANDLE	hFile,
		IN DWORD	offTable,
		IN PVOID	pTables,
		IN HKL	hOldKL,
		IN PUNICODE_STRING	puszKLID,
		IN DWORD	dwNewKL,
		IN UINT	Flags
	)

Definition at line 1161 of file kbdlayout.c.

{
    HKL hRetKL;
    WCHAR Buffer[KL_NAMELENGTH];
    UNICODE_STRING uszSafeKLID;
    PWINSTATION_OBJECT pWinSta;
    HANDLE hSafeFile;
 
    UNREFERENCED_PARAMETER(offTable);
    UNREFERENCED_PARAMETER(pTables);
 
    if (Flags & ~(KLF_ACTIVATE|KLF_NOTELLSHELL|KLF_REORDER|KLF_REPLACELANG|
                  KLF_SUBSTITUTE_OK|KLF_SETFORPROCESS|KLF_UNLOADPREVIOUS|
                  KLF_RESET|KLF_SHIFTLOCK))
    {
        ERR("Invalid flags: %x\n", Flags);
        EngSetLastError(ERROR_INVALID_FLAGS);
        return NULL;
    }
 
    RtlInitEmptyUnicodeString(&uszSafeKLID, Buffer, sizeof(Buffer));
    _SEH2_TRY
    {
        ProbeForRead(puszKLID, sizeof(*puszKLID), 1);
        ProbeForRead(puszKLID->Buffer, sizeof(puszKLID->Length), 1);
        RtlCopyUnicodeString(&uszSafeKLID, puszKLID);
    }
    _SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER)
    {
        SetLastNtError(_SEH2_GetExceptionCode());
        _SEH2_YIELD(return NULL);
    }
    _SEH2_END;
 
    UserEnterExclusive();
 
    hSafeFile = (hFile ? IntVerifyKeyboardFileHandle(hFile) : NULL);
    pWinSta = IntGetProcessWindowStation(NULL);
    hRetKL = co_IntLoadKeyboardLayoutEx(pWinSta,
                                        hSafeFile,
                                        hOldKL,
                                        &uszSafeKLID,
                                        UlongToHandle(dwNewKL),
                                        Flags);
    if (hSafeFile)
        ZwClose(hSafeFile);
 
    UserLeave();
    return hRetKL;
}

Referenced by IntLoadKeyboardLayout().

NtUserUnloadKeyboardLayout()

BOOL APIENTRY NtUserUnloadKeyboardLayout

(

HKL

hKl

)

Definition at line 1251 of file kbdlayout.c.

{
    BOOL ret;
    PWINSTATION_OBJECT pWinSta;
 
    UserEnterExclusive();
 
    pWinSta = IntGetProcessWindowStation(NULL);
    ret = IntUnloadKeyboardLayout(pWinSta, hKl);
 
    UserLeave();
    return ret;
}

Referenced by UnloadKeyboardLayout().

UnloadKbdFile()

static VOID UnloadKbdFile ( _In_ PKBDFILE  pkf )

static

Definition at line 444 of file kbdlayout.c.

{
    PKBDFILE *ppkfLink = &gpkfList;
    NT_ASSERT(pkf != NULL);
 
    /* Find previous object */
    while (*ppkfLink)
    {
        if (*ppkfLink == pkf)
            break;
 
        ppkfLink = &(*ppkfLink)->pkfNext;
    }
 
    if (*ppkfLink == pkf)
        *ppkfLink = pkf->pkfNext;
 
    EngUnloadImage(pkf->hBase);
    UserDeleteObject(UserHMGetHandle(pkf), TYPE_KBDFILE);
}

Referenced by UserUnloadKbl().

UserGetKeyboardLayout()

HKL FASTCALL UserGetKeyboardLayout

(

DWORD

dwThreadId

)

Definition at line 995 of file kbdlayout.c.

{
    PTHREADINFO pti;
    PLIST_ENTRY ListEntry;
    PKL pKl;
 
    pti = PsGetCurrentThreadWin32Thread();
 
    if (!dwThreadId)
    {
        pKl = pti->KeyboardLayout;
        return pKl ? pKl->hkl : NULL;
    }
 
    ListEntry = pti->rpdesk->PtiList.Flink;
 
    //
    // Search the Desktop Thread list for related Desktop active Threads.
    //
    while(ListEntry != &pti->rpdesk->PtiList)
    {
        pti = CONTAINING_RECORD(ListEntry, THREADINFO, PtiLink);
 
        if (PsGetThreadId(pti->pEThread) == UlongToHandle(dwThreadId))
        {
           pKl = pti->KeyboardLayout;
           return pKl ? pKl->hkl : NULL;
        }
 
        ListEntry = ListEntry->Flink;
    }
 
    return NULL;
}

Referenced by IntGetActiveKeyboardLayout(), and NtUserCallOneParam().

UserHklToKbl()

PKL NTAPI UserHklToKbl

(

HKL

hKl

)

Definition at line 539 of file kbdlayout.c.

{
    PKL pKl = gspklBaseLayout;
 
    if (!gspklBaseLayout)
        return NULL;
 
    do
    {
        if (pKl->hkl == hKl)
            return pKl;
 
        pKl = pKl->pklNext;
    } while (pKl != gspklBaseLayout);
 
    return NULL;
}

Referenced by co_IntLoadKeyboardLayoutEx(), NtUserMapVirtualKeyEx(), NtUserSetThreadLayoutHandles(), NtUserToUnicodeEx(), NtUserVkKeyScanEx(), and UserSetDefaultInputLang().

UserLoadKbdDll()

static BOOL UserLoadKbdDll ( WCHAR *  pwszLayoutPath, HANDLE *  phModule, PKBDTABLES *  pKbdTables  )

static

Definition at line 248 of file kbdlayout.c.

{
    PFN_KBDLAYERDESCRIPTOR pfnKbdLayerDescriptor;
 
    /* Load keyboard layout DLL */
    TRACE("Loading Keyboard DLL %ws\n", pwszLayoutPath);
    *phModule = EngLoadImage(pwszLayoutPath);
    if (!(*phModule))
    {
        ERR("Failed to load dll %ws\n", pwszLayoutPath);
        return FALSE;
    }
 
    /* Find KbdLayerDescriptor function and get layout tables */
    TRACE("Loaded %ws\n", pwszLayoutPath);
    pfnKbdLayerDescriptor = EngFindImageProcAddress(*phModule, "KbdLayerDescriptor");
 
    /* FIXME: Windows reads file instead of executing!
              It's not safe to kbdlayout DLL in kernel mode! */
 
    if (pfnKbdLayerDescriptor)
        *pKbdTables = pfnKbdLayerDescriptor();
    else
        ERR("Error: %ws has no KbdLayerDescriptor()\n", pwszLayoutPath);
 
    if (!pfnKbdLayerDescriptor || !*pKbdTables)
    {
        ERR("Failed to load the keyboard layout.\n");
        EngUnloadImage(*phModule);
        return FALSE;
    }
 
#if 0 && DBG
    /* Dump keyboard layout */
    DumpKbdLayout(*pKbdTables);
#endif
 
    return TRUE;
}

Referenced by UserLoadKbdFile().

UserLoadKbdFile()

static PKBDFILE UserLoadKbdFile ( PUNICODE_STRING  pwszKLID )

static

Definition at line 296 of file kbdlayout.c.

{
    PKBDFILE pkf, pRet = NULL;
    NTSTATUS Status;
    ULONG cbSize;
    HKEY hKey = NULL;
    WCHAR wszLayoutPath[MAX_PATH] = L"\\SystemRoot\\System32\\";
    WCHAR wszLayoutRegKey[256] = L"\\REGISTRY\\Machine\\SYSTEM\\CurrentControlSet\\"
                                 L"Control\\Keyboard Layouts\\";
 
    /* Create keyboard layout file object */
    pkf = UserCreateObject(gHandleTable, NULL, NULL, NULL, TYPE_KBDFILE, sizeof(KBDFILE));
    if (!pkf)
    {
        ERR("Failed to create object!\n");
        return NULL;
    }
 
    /* Set keyboard layout name */
    swprintf(pkf->awchKF, L"%wZ", pwszKLID);
 
    /* Open layout registry key */
    RtlStringCbCatW(wszLayoutRegKey, sizeof(wszLayoutRegKey), pkf->awchKF);
    Status = RegOpenKey(wszLayoutRegKey, &hKey);
    if (!NT_SUCCESS(Status))
    {
        ERR("Failed to open keyboard layouts registry key %ws (%lx)\n", wszLayoutRegKey, Status);
        goto cleanup;
    }
 
    /* Read filename of layout DLL */
    cbSize = (ULONG)(sizeof(wszLayoutPath) - wcslen(wszLayoutPath)*sizeof(WCHAR));
    Status = RegQueryValue(hKey,
                           L"Layout File",
                           REG_SZ,
                           wszLayoutPath + wcslen(wszLayoutPath),
                           &cbSize);
 
    if (!NT_SUCCESS(Status))
    {
        ERR("Can't get layout filename for %wZ (%lx)\n", pwszKLID, Status);
        goto cleanup;
    }
 
    /* Load keyboard file now */
    if (!UserLoadKbdDll(wszLayoutPath, &pkf->hBase, &pkf->pKbdTbl))
    {
        ERR("Failed to load %ws dll!\n", wszLayoutPath);
        goto cleanup;
    }
 
    /* Update next field */
    pkf->pkfNext = gpkfList;
    gpkfList = pkf;
 
    /* Return keyboard file */
    pRet = pkf;
 
cleanup:
    if (hKey)
        ZwClose(hKey);
    if (pkf)
        UserDereferenceObject(pkf); // we dont need ptr anymore
    if (!pRet)
    {
        /* We have failed - destroy created object */
        if (pkf)
            UserDeleteObject(UserHMGetHandle(pkf), TYPE_KBDFILE);
    }
 
    return pRet;
}

Referenced by co_UserLoadKbdLayout().

UserSetDefaultInputLang()

BOOL NTAPI UserSetDefaultInputLang

(

HKL

hKl

)

Definition at line 583 of file kbdlayout.c.

{
    PKL pKl;
 
    pKl = UserHklToKbl(hKl);
    if (!pKl)
        return FALSE;
 
    IntReorderKeyboardLayouts(IntGetProcessWindowStation(NULL), pKl);
    return TRUE;
}

Referenced by SpiGetSet().

UserUnloadKbl()

BOOL UserUnloadKbl

(

PKL

pKl

)

Definition at line 471 of file kbdlayout.c.

{
    /* According to msdn, UnloadKeyboardLayout can fail
       if the keyboard layout identifier was preloaded. */
    if (pKl == gspklBaseLayout)
    {
        if (pKl->pklNext == pKl->pklPrev)
        {
            /* There is only one layout */
            return FALSE;
        }
 
        /* Set next layout as default */
        gspklBaseLayout = pKl->pklNext;
    }
 
    if (pKl->head.cLockObj > 1)
    {
        /* Layout is used by other threads */
        pKl->dwKL_Flags |= KL_UNLOAD;
        return FALSE;
    }
 
    /* Unload the layout */
    pKl->pklPrev->pklNext = pKl->pklNext;
    pKl->pklNext->pklPrev = pKl->pklPrev;
    UnloadKbdFile(pKl->spkf);
    if (pKl->piiex)
    {
        ExFreePoolWithTag(pKl->piiex, USERTAG_IME);
    }
    UserDeleteObject(UserHMGetHandle(pKl), TYPE_KBDLAYOUT);
    return TRUE;
}

Referenced by co_IntLoadKeyboardLayoutEx().

W32kGetDefaultKeyLayout()

PKL W32kGetDefaultKeyLayout

(

VOID

)

Definition at line 512 of file kbdlayout.c.

{
    PKL pKl = gspklBaseLayout;
 
    if (!pKl)
        return NULL;
 
    /* Return not unloaded layout */
    do
    {
        if (!(pKl->dwKL_Flags & KL_UNLOAD))
            return pKl;
 
        pKl = pKl->pklPrev; /* Confirmed on Win2k */
    } while(pKl != gspklBaseLayout);
 
    /* We have not found proper KL */
    return NULL;
}

Referenced by InitThreadCallback(), IntTranslateKbdMessage(), UserProcessKeyboardInput(), and UserSendKeyboardInput().

Variable Documentation

ghKLSentToShell

HKL ghKLSentToShell = NULL

Definition at line 26 of file kbdlayout.c.

Referenced by co_IntUnloadKeyboardLayoutEx(), and co_UserActivateKeyboardLayout().

gpkfList

PKBDFILE gpkfList = NULL

Definition at line 23 of file kbdlayout.c.

Referenced by UnloadKbdFile(), and UserLoadKbdFile().

gspklBaseLayout

PKL gspklBaseLayout = NULL

Definition at line 22 of file kbdlayout.c.

Referenced by co_IntLoadKeyboardLayoutEx(), co_IntUnloadKeyboardLayoutEx(), IntGetKeyboardLayoutList(), IntReorderKeyboardLayouts(), SpiGetSet(), UserGetImeInfoEx(), UserHklToKbl(), UserSetImeInfoEx(), UserUnloadKbl(), and W32kGetDefaultKeyLayout().

gSystemCPCharSet

UINT gSystemCPCharSet = 0

Definition at line 25 of file kbdlayout.c.

Referenced by co_UserLoadKbdLayout().

gSystemFS

DWORD gSystemFS = 0

Definition at line 24 of file kbdlayout.c.

Referenced by co_UserLoadKbdLayout(), IntImmProcessKey(), and IntLanguageToggle().