input.h File Reference

#include <ndk/kbd.h>
#include <hidclass.h>

Include dependency graph for input.h:

This graph shows which files directly or indirectly include this file:

Go to the source code of this file.

Classes
struct	tagKBDNLSLAYER
struct	tagKBDFILE
struct	tagKL
struct	_ATTACHINFO
struct	_MOUSE_DEVICE_INFO
struct	_KEYBOARD_DEVICE_INFO
struct	_HID_DEVICE_INFO
struct	_INPUT_DEVICE_INFO

Macros
#define	KS_DOWN_BIT   0x80
#define	KS_LOCK_BIT   0x01
#define	SC_KEY_UP   0x8000
#define	LP_DO_NOT_CARE_BIT   (1<<25)
#define	ThreadHasInputAccess(W32Thread)   (TRUE)
#define	GET_KS_BYTE(vk)   ((vk) * 2 / 8)
#define	GET_KS_DOWN_BIT(vk)   (1 << (((vk) % 4)*2))
#define	GET_KS_LOCK_BIT(vk)   (1 << (((vk) % 4)*2 + 1))
#define	IS_KEY_DOWN(ks, vk)   (((ks)[GET_KS_BYTE(vk)] & GET_KS_DOWN_BIT(vk)) ? TRUE : FALSE)
#define	IS_KEY_LOCKED(ks, vk)   (((ks)[GET_KS_BYTE(vk)] & GET_KS_LOCK_BIT(vk)) ? TRUE : FALSE)
#define	SET_KEY_DOWN(ks, vk, down)
#define	SET_KEY_LOCKED(ks, vk, down)

Typedefs
typedef struct tagKBDNLSLAYER	KBDNLSLAYER
typedef struct tagKBDNLSLAYER *	PKBDNLSLAYER
typedef struct tagKBDFILE	KBDFILE
typedef struct tagKBDFILE *	PKBDFILE
typedef struct tagKL	KL
typedef struct tagKL *	PKL
typedef struct _ATTACHINFO	ATTACHINFO
typedef struct _ATTACHINFO *	PATTACHINFO
typedef struct _MOUSE_DEVICE_INFO	MOUSE_DEVICE_INFO
typedef struct _MOUSE_DEVICE_INFO *	PMOUSE_DEVICE_INFO
typedef struct _KEYBOARD_DEVICE_INFO	KEYBOARD_DEVICE_INFO
typedef struct _KEYBOARD_DEVICE_INFO *	PKEYBOARD_DEVICE_INFO
typedef struct _HID_DEVICE_INFO	HID_DEVICE_INFO
typedef struct _HID_DEVICE_INFO *	PHID_DEVICE_INFO
typedef struct _INPUT_DEVICE_INFO	INPUT_DEVICE_INFO
typedef struct _INPUT_DEVICE_INFO *	PINPUT_DEVICE_INFO

Functions
	CODE_SEG ("INIT") NTSTATUS NTAPI InitInputImpl(VOID)
VOID NTAPI	RawInputThreadMain (VOID)
BOOL FASTCALL	IntBlockInput (PTHREADINFO W32Thread, BOOL BlockIt)
NTSTATUS FASTCALL	UserAttachThreadInput (PTHREADINFO, PTHREADINFO, BOOL)
BOOL FASTCALL	IsRemoveAttachThread (PTHREADINFO)
VOID FASTCALL	DoTheScreenSaver (VOID)
VOID NTAPI	UserInitKeyboard (HANDLE hKeyboardDevice)
PKL	W32kGetDefaultKeyLayout (VOID)
VOID NTAPI	UserProcessKeyboardInput (PINPUT_DEVICE_INFO pDeviceInfo, PKEYBOARD_INPUT_DATA pKeyInput)
BOOL NTAPI	UserSendKeyboardInput (KEYBDINPUT *pKbdInput, BOOL bInjected)
PKL NTAPI	UserHklToKbl (HKL hKl)
BOOL NTAPI	UserSetDefaultInputLang (HKL hKl)
WORD FASTCALL	UserGetMouseButtonsState (VOID)
VOID NTAPI	UserProcessMouseInput (PINPUT_DEVICE_INFO pDeviceInfo, PMOUSE_INPUT_DATA pMouseInputData)
BOOL NTAPI	UserSendMouseInput (MOUSEINPUT *pMouseInput, BOOL bInjected)
HRAWINPUT FASTCALL	UserCreateRawInput (PTHREADINFO pti, DWORD dwType, HANDLE hDevice, WPARAM wParam, CONST VOID *pData, UINT cbData)
BOOL FASTCALL	UserGetRawInputTarget (DWORD dwType, PTHREADINFO *ppti, HWND *phwndTarget, WPARAM *pwParam)
BOOL FASTCALL	UserFreeRawInput (PUSER_MESSAGE_QUEUE MessageQueue, HRAWINPUT hRawInput)
VOID FASTCALL	UserUpdatePrevRawInput (PTHREADINFO pti, CONST MSG *pMsg)
VOID FASTCALL	UserCleanupRawInput (PUSER_MESSAGE_QUEUE MessageQueue)
UINT FASTCALL	IntImmProcessKey (_In_ PUSER_MESSAGE_QUEUE MessageQueue, _In_ PWND pWnd, _In_ UINT uMsg, _In_ WPARAM wParam, _In_ LPARAM lParam)
VOID FASTCALL	IntFreeImeHotKeys (VOID)
FORCEINLINE VOID	AcquireDeviceInfoListMutex (VOID)
FORCEINLINE VOID	ReleaseDeviceInfoListMutex (VOID)

Variables
PATTACHINFO	gpai
DWORD	gdwLanguageToggleKey
DWORD	gdwLayoutToggleKey
BOOL	gbEnableHexNumpad
BOOLEAN	RawInputEnabled
DWORD	gSystemFS
UINT	gSystemCPCharSet
HANDLE	ghKeyboardDevice
PTHREADINFO	ptiRawInput
BYTE	gafAsyncKeyState [256 *2/8]
PINPUT_DEVICE_INFO	gpInputDeviceInfo
PERESOURCE	gpDeviceInfoListMutex
PKL	gspklBaseLayout
KEYBOARD_ATTRIBUTES	gKeyboardInfo

Macro Definition Documentation

GET_KS_BYTE

#define GET_KS_BYTE

(

vk

)

((vk) * 2 / 8)

Definition at line 171 of file input.h.

GET_KS_DOWN_BIT

#define GET_KS_DOWN_BIT

(

vk

)

(1 << (((vk) % 4)*2))

Definition at line 172 of file input.h.

GET_KS_LOCK_BIT

#define GET_KS_LOCK_BIT

(

vk

)

(1 << (((vk) % 4)*2 + 1))

Definition at line 173 of file input.h.

IS_KEY_DOWN

#define IS_KEY_DOWN	(		ks,
			vk
	)		(((ks)[GET_KS_BYTE(vk)] & GET_KS_DOWN_BIT(vk)) ? TRUE : FALSE)

Definition at line 174 of file input.h.

IS_KEY_LOCKED

#define IS_KEY_LOCKED	(		ks,
			vk
	)		(((ks)[GET_KS_BYTE(vk)] & GET_KS_LOCK_BIT(vk)) ? TRUE : FALSE)

Definition at line 175 of file input.h.

KS_DOWN_BIT

#define KS_DOWN_BIT   0x80

Definition at line 88 of file input.h.

KS_LOCK_BIT

#define KS_LOCK_BIT   0x01

Definition at line 89 of file input.h.

LP_DO_NOT_CARE_BIT

#define LP_DO_NOT_CARE_BIT   (1<<25)

Definition at line 93 of file input.h.

SC_KEY_UP

#define SC_KEY_UP   0x8000

Definition at line 91 of file input.h.

SET_KEY_DOWN

#define SET_KEY_DOWN	(		ks,
			vk,
			down
	)

Value:

                                                            (ks)[GET_KS_BYTE(vk)] = ((down) ? \
                                                            ((ks)[GET_KS_BYTE(vk)] | GET_KS_DOWN_BIT(vk)) : \
                                                            ((ks)[GET_KS_BYTE(vk)] & ~GET_KS_DOWN_BIT(vk)))

Definition at line 176 of file input.h.

SET_KEY_LOCKED

#define SET_KEY_LOCKED	(		ks,
			vk,
			down
	)

Value:

                                                              (ks)[GET_KS_BYTE(vk)] = ((down) ? \
                                                              ((ks)[GET_KS_BYTE(vk)] | GET_KS_LOCK_BIT(vk)) : \
                                                              ((ks)[GET_KS_BYTE(vk)] & ~GET_KS_LOCK_BIT(vk)))

Definition at line 179 of file input.h.

ThreadHasInputAccess

#define ThreadHasInputAccess

(

W32Thread

)

(TRUE)

Definition at line 103 of file input.h.

Typedef Documentation

ATTACHINFO

typedef struct _ATTACHINFO ATTACHINFO

HID_DEVICE_INFO

typedef struct _HID_DEVICE_INFO HID_DEVICE_INFO

INPUT_DEVICE_INFO

typedef struct _INPUT_DEVICE_INFO INPUT_DEVICE_INFO

KBDFILE

typedef struct tagKBDFILE KBDFILE

KBDNLSLAYER

typedef struct tagKBDNLSLAYER KBDNLSLAYER

KEYBOARD_DEVICE_INFO

typedef struct _KEYBOARD_DEVICE_INFO KEYBOARD_DEVICE_INFO

KL

typedef struct tagKL KL

MOUSE_DEVICE_INFO

typedef struct _MOUSE_DEVICE_INFO MOUSE_DEVICE_INFO

PATTACHINFO

typedef struct _ATTACHINFO * PATTACHINFO

PHID_DEVICE_INFO

typedef struct _HID_DEVICE_INFO * PHID_DEVICE_INFO

PINPUT_DEVICE_INFO

typedef struct _INPUT_DEVICE_INFO * PINPUT_DEVICE_INFO

PKBDFILE

typedef struct tagKBDFILE * PKBDFILE

PKBDNLSLAYER

typedef struct tagKBDNLSLAYER * PKBDNLSLAYER

PKEYBOARD_DEVICE_INFO

typedef struct _KEYBOARD_DEVICE_INFO * PKEYBOARD_DEVICE_INFO

PKL

typedef struct tagKL * PKL

PMOUSE_DEVICE_INFO

typedef struct _MOUSE_DEVICE_INFO * PMOUSE_DEVICE_INFO

Function Documentation

AcquireDeviceInfoListMutex()

FORCEINLINE VOID AcquireDeviceInfoListMutex

(

VOID

)

Definition at line 157 of file input.h.

{
    KeEnterCriticalRegion();
    ExAcquireResourceExclusiveLite(gpDeviceInfoListMutex, TRUE);
}

Referenced by NtUserGetRawInputDeviceInfo(), and NtUserGetRawInputDeviceList().

CODE_SEG()

CODE_SEG

(

"INIT"

)

Definition at line 1810 of file Interface.c.

{
    UNICODE_STRING DeviceName = RTL_CONSTANT_STRING(L"\\FileSystem\\Filters\\"DRIVER_NAME);
    PDEVICE_OBJECT RawDeviceObject;
    PDEVICE_OBJECT DeviceObject;
    PFILE_OBJECT RawFileObject;
    UNICODE_STRING ObjectName;
    UNICODE_STRING SymLink;
 
    NTSTATUS Status;
 
    RtlZeroMemory(&DriverData, sizeof(DRIVER_DATA));
    DriverData.DriverObject = DriverObject;
 
    /* Save the registry key for this driver */
    DriverData.ServiceKey.Length = RegistryPath->Length;
    DriverData.ServiceKey.MaximumLength = RegistryPath->MaximumLength;
    DriverData.ServiceKey.Buffer = (PWCHAR)ExAllocatePoolWithTag(NonPagedPool,
                                                                 RegistryPath->MaximumLength,
                                                                 FM_TAG_REGISTRY_DATA);
    if (!DriverData.ServiceKey.Buffer) return STATUS_INSUFFICIENT_RESOURCES;
    RtlCopyUnicodeString(&DriverData.ServiceKey, RegistryPath);
 
    /* Do some initialization */
    ExInitializeFastMutex(&DriverData.FilterAttachLock);
 
    /* Create the main filter manager device object */
    Status = IoCreateDevice(DriverObject,
                            0,
                            &DeviceName,
                            FILE_DEVICE_DISK_FILE_SYSTEM,
                            FILE_DEVICE_SECURE_OPEN,
                            FALSE,
                            &DeviceObject);
    if (!NT_SUCCESS(Status))
    {
        DPRINT1("fltmgr IoCreateDevice failed.  Status = %X\n", Status);
        goto Cleanup;
    }
 
    /* Store a global reference so we can access from callbacks */
    DriverData.DeviceObject = DeviceObject;
 
    /* Generate the symbolic link name */
    RtlInitUnicodeString(&SymLink, L"\\??\\"DRIVER_NAME);
    Status = IoCreateSymbolicLink(&SymLink, &DeviceName);
    if (!NT_SUCCESS(Status)) goto Cleanup;
 
    /* Create the callbacks for the dispatch table, FastIo and FS callbacks */
    Status = SetupDispatchAndCallbacksTables(DriverObject);
    if (!NT_SUCCESS(Status)) goto Cleanup;
 
    /* Initialize the comms objects */
    Status = FltpSetupCommunicationObjects(DriverObject);
    if (!NT_SUCCESS(Status)) goto Cleanup;
 
    /* Register for notifications when a new file system is loaded. This also enumerates any existing file systems */
    Status = IoRegisterFsRegistrationChange(DriverObject, FltpFsNotification);
    FLT_ASSERT(Status != STATUS_DEVICE_ALREADY_ATTACHED); // Windows checks for this, I'm not sure how it can happen. Needs investigation??
    if (!NT_SUCCESS(Status))  goto Cleanup;
 
    InitializeListHead(&FilterList);
    ExInitializeResourceLite(&FilterListLock);
 
    /* IoRegisterFsRegistrationChange isn't notified about the raw  file systems, so we attach to them manually */
    RtlInitUnicodeString(&ObjectName, L"\\Device\\RawDisk");
    Status = IoGetDeviceObjectPointer(&ObjectName,
                                      FILE_READ_ATTRIBUTES,
                                      &RawFileObject,
                                      &RawDeviceObject);
    if (NT_SUCCESS(Status))
    {
        FltpFsNotification(RawDeviceObject, TRUE);
        ObDereferenceObject(RawFileObject);
    }
 
    RtlInitUnicodeString(&ObjectName, L"\\Device\\RawCdRom");
    Status = IoGetDeviceObjectPointer(&ObjectName,
                                      FILE_READ_ATTRIBUTES,
                                      &RawFileObject,
                                      &RawDeviceObject);
    if (NT_SUCCESS(Status))
    {
        FltpFsNotification(RawDeviceObject, TRUE);
        ObDereferenceObject(RawFileObject);
    }
 
    /* We're done, clear the initializing flag */
    ClearFlag(DeviceObject->Flags, DO_DEVICE_INITIALIZING);
    Status = STATUS_SUCCESS;
 
Cleanup:
 
    if (!NT_SUCCESS(Status))
    {
        if (DriverData.FastIoDispatch)
        {
            DriverObject->FastIoDispatch = NULL;
            ExFreePoolWithTag(DriverData.FastIoDispatch, FM_TAG_DISPATCH_TABLE);
        }
 
        IoDeleteSymbolicLink(&SymLink);
 
        if (DeviceObject)
            IoDeleteDevice(DeviceObject);
 
        if (DriverData.ServiceKey.Buffer)
            ExFreePoolWithTag(DriverData.ServiceKey.Buffer, FM_TAG_REGISTRY_DATA);
    }
 
    return Status;
}

DoTheScreenSaver()

VOID FASTCALL DoTheScreenSaver

(

VOID

)

Definition at line 66 of file input.c.

{
    DWORD Test, TO;
 
    if (gspv.iScrSaverTimeout > 0) // Zero means Off.
    {
        Test = EngGetTickCount32();
        Test = Test - LastInputTick;
        TO = 1000 * gspv.iScrSaverTimeout;
        if (Test > TO)
        {
            TRACE("Screensaver Message Start! Tick %lu Timeout %d \n", Test, gspv.iScrSaverTimeout);
 
            if (ppiScrnSaver) // We are or we are not the screensaver, prevent reentry...
            {
                if (!(ppiScrnSaver->W32PF_flags & W32PF_IDLESCREENSAVER))
                {
                    ppiScrnSaver->W32PF_flags |= W32PF_IDLESCREENSAVER;
                    ERR("Screensaver is Idle\n");
                }
            }
            else
            {
                PUSER_MESSAGE_QUEUE ForegroundQueue = IntGetFocusMessageQueue();
                if (ForegroundQueue && ForegroundQueue->spwndActive)
                    UserPostMessage(hwndSAS, WM_LOGONNOTIFY, LN_START_SCREENSAVE, 1); // lParam 1 == Secure
                else
                    UserPostMessage(hwndSAS, WM_LOGONNOTIFY, LN_START_SCREENSAVE, 0);
            }
        }
    }
}

Referenced by HungAppSysTimerProc().

IntBlockInput()

BOOL FASTCALL IntBlockInput	(	PTHREADINFO	W32Thread,
		BOOL	BlockIt
	)

Definition at line 419 of file input.c.

{
    PTHREADINFO OldBlock;
    ASSERT(pti);
 
    if(!pti->rpdesk || ((pti->TIF_flags & TIF_INCLEANUP) && BlockIt))
    {
        /*
         * Fail blocking if exiting the thread
         */
 
        return FALSE;
    }
 
    /*
     * FIXME: Check access rights of the window station
     *        e.g. services running in the service window station cannot block input
     */
    if(!ThreadHasInputAccess(pti) ||
       !IntIsActiveDesktop(pti->rpdesk))
    {
        EngSetLastError(ERROR_ACCESS_DENIED);
        return FALSE;
    }
 
    ASSERT(pti->rpdesk);
    OldBlock = pti->rpdesk->BlockInputThread;
    if(OldBlock)
    {
        if(OldBlock != pti)
        {
            EngSetLastError(ERROR_ACCESS_DENIED);
            return FALSE;
        }
        pti->rpdesk->BlockInputThread = (BlockIt ? pti : NULL);
        return OldBlock == NULL;
    }
 
    pti->rpdesk->BlockInputThread = (BlockIt ? pti : NULL);
    return OldBlock == NULL;
}

Referenced by ExitThreadCallback(), and NtUserBlockInput().

IntFreeImeHotKeys()

VOID FASTCALL IntFreeImeHotKeys

(

VOID

)

Definition at line 345 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().

IntImmProcessKey()

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

Definition at line 603 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())
    {
        if (dwHotKeyId != INVALID_HOTKEY)
            WARN("!IS_IMM_MODE(): dwHotKeyId 0x%X\n", dwHotKeyId);
 
        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 ((HIWORD(lParam) & KF_UP) &&
            (pKL->piiex->ImeInfo.fdwProperty & IME_PROP_IGNORE_UPKEYS))
        {
            return 0;
        }
 
        switch (uVirtualKey)
        {
            case VK_DBE_CODEINPUT:
            case VK_DBE_ENTERIMECONFIGMODE:
            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 || (HIWORD(lParam) & KF_ALTDOWN))
                        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().

IsRemoveAttachThread()

BOOL FASTCALL IsRemoveAttachThread

(

PTHREADINFO

pti

)

Definition at line 481 of file input.c.

{
    NTSTATUS Status;
    PATTACHINFO pai;
    BOOL Ret = TRUE;
    PTHREADINFO ptiFrom = NULL, ptiTo = NULL;
 
    do
    {
       if (!gpai) return TRUE;
 
       pai = gpai; // Bottom of the list.
 
       do
       {
          if (pai->pti2 == pti)
          {
             ptiFrom = pai->pti1;
             ptiTo = pti;
             break;
          }
          if (pai->pti1 == pti)
          {
             ptiFrom = pti;
             ptiTo = pai->pti2;
             break;
          }
          pai = pai->paiNext;
 
       } while (pai);
 
       if (!pai && !ptiFrom && !ptiTo) break;
 
       Status = UserAttachThreadInput(ptiFrom, ptiTo, FALSE);
       if (!NT_SUCCESS(Status)) Ret = FALSE;
 
    } while (Ret);
 
    return Ret;
}

Referenced by ExitThreadCallback().

RawInputThreadMain()

VOID NTAPI RawInputThreadMain

(

VOID

)

Definition at line 142 of file input.c.

{
    NTSTATUS MouStatus = STATUS_UNSUCCESSFUL, KbdStatus = STATUS_UNSUCCESSFUL, Status;
    IO_STATUS_BLOCK MouIosb, KbdIosb;
    PFILE_OBJECT pKbdDevice = NULL, pMouDevice = NULL;
    LARGE_INTEGER ByteOffset;
    //LARGE_INTEGER WaitTimeout;
    PVOID WaitObjects[4], pSignaledObject = NULL;
    KWAIT_BLOCK WaitBlockArray[RTL_NUMBER_OF(WaitObjects)];
    ULONG cWaitObjects = 0, cMaxWaitObjects = 2;
    MOUSE_INPUT_DATA MouseInput;
    KEYBOARD_INPUT_DATA KeyInput;
    PVOID ShutdownEvent;
    HWINSTA hWinSta;
    INPUT_DEVICE_INFO Mouse;
    INPUT_DEVICE_INFO Keyboard;
 
    RtlZeroMemory(&Mouse, sizeof(Mouse));
    Mouse.DeviceType = RIM_TYPEMOUSE;
    RtlInitUnicodeString(&Mouse.DeviceName, L"\\Device\\PointerClass0");
    Mouse.Mouse.Attributes.NumberOfButtons = 2;
 
    RtlZeroMemory(&Keyboard, sizeof(Keyboard));
    Keyboard.DeviceType = RIM_TYPEKEYBOARD;
    RtlInitUnicodeString(&Keyboard.DeviceName, L"\\Device\\KeyboardClass0");
 
    ByteOffset.QuadPart = (LONGLONG)0;
    //WaitTimeout.QuadPart = (LONGLONG)(-10000000);
 
    ptiRawInput = GetW32ThreadInfo();
    ptiRawInput->TIF_flags |= TIF_SYSTEMTHREAD;
    ptiRawInput->pClientInfo->dwTIFlags = ptiRawInput->TIF_flags;
 
    TRACE("Raw Input Thread %p\n", ptiRawInput);
 
    KeSetPriorityThread(&PsGetCurrentThread()->Tcb,
                        LOW_REALTIME_PRIORITY + 3);
 
    Status = ObOpenObjectByPointer(InputWindowStation,
                                   0,
                                   NULL,
                                   MAXIMUM_ALLOWED,
                                   ExWindowStationObjectType,
                                   UserMode,
                                   (PHANDLE)&hWinSta);
    if (NT_SUCCESS(Status))
    {
        UserSetProcessWindowStation(hWinSta);
    }
    else
    {
        ASSERT(FALSE);
        /* Failed to open the interactive winsta! What now? */
    }
 
    gpDeviceInfoListMutex = ExAllocatePoolWithTag(NonPagedPool, sizeof(*gpDeviceInfoListMutex), USERTAG_SYSTEM);
    ASSERT(gpDeviceInfoListMutex);
    Status = ExInitializeResourceLite(gpDeviceInfoListMutex);
    ASSERT(NT_SUCCESS(Status));
 
    UserEnterExclusive();
    StartTheTimers();
    UserLeave();
 
    NT_ASSERT(ghMouseDevice == NULL);
    NT_ASSERT(ghKeyboardDevice == NULL);
 
    PoRequestShutdownEvent(&ShutdownEvent);
    for (;;)
    {
        if (!ghMouseDevice)
        {
            /* Check if mouse device already exists */
            Status = OpenInputDevice(&ghMouseDevice, &pMouDevice, Mouse.DeviceName.Buffer);
            if (NT_SUCCESS(Status))
            {
                ++cMaxWaitObjects;
                TRACE("Mouse connected!\n");
                Mouse.Handle = ghMouseDevice;
                Mouse.pNextDeviceInfo = gpInputDeviceInfo;
                gpInputDeviceInfo = &Mouse;
            }
        }
        if (!ghKeyboardDevice)
        {
            /* Check if keyboard device already exists */
            Status = OpenInputDevice(&ghKeyboardDevice, &pKbdDevice, Keyboard.DeviceName.Buffer);
            if (NT_SUCCESS(Status))
            {
                ++cMaxWaitObjects;
                TRACE("Keyboard connected!\n");
                Keyboard.Handle = ghKeyboardDevice;
                Keyboard.pNextDeviceInfo = gpInputDeviceInfo;
                gpInputDeviceInfo = &Keyboard;
                // Get and load keyboard attributes.
                UserInitKeyboard(ghKeyboardDevice);
                Keyboard.Keyboard.Attributes = gKeyboardInfo;
                UserEnterExclusive();
                // Register the Window hotkey.
                UserRegisterHotKey(PWND_BOTTOM, IDHK_WINKEY, MOD_WIN, 0);
                // Register the Window Snap hotkey.
                UserRegisterHotKey(PWND_BOTTOM, IDHK_SNAP_LEFT, MOD_WIN, VK_LEFT);
                UserRegisterHotKey(PWND_BOTTOM, IDHK_SNAP_RIGHT, MOD_WIN, VK_RIGHT);
                UserRegisterHotKey(PWND_BOTTOM, IDHK_SNAP_UP, MOD_WIN, VK_UP);
                UserRegisterHotKey(PWND_BOTTOM, IDHK_SNAP_DOWN, MOD_WIN, VK_DOWN);
                // Register the debug hotkeys.
                SetDebugHotKeys();
                UserLeave();
            }
        }
 
        /* Reset WaitHandles array */
        cWaitObjects = 0;
        WaitObjects[cWaitObjects++] = ShutdownEvent;
        WaitObjects[cWaitObjects++] = MasterTimer;
 
        if (ghMouseDevice)
        {
            /* Try to read from mouse if previous reading is not pending */
            if (MouStatus != STATUS_PENDING)
            {
                MouStatus = ZwReadFile(ghMouseDevice,
                                       NULL,
                                       NULL,
                                       NULL,
                                       &MouIosb,
                                       &MouseInput,
                                       sizeof(MOUSE_INPUT_DATA),
                                       &ByteOffset,
                                       NULL);
            }
 
            if (MouStatus == STATUS_PENDING)
                WaitObjects[cWaitObjects++] = &pMouDevice->Event;
        }
 
        if (ghKeyboardDevice)
        {
            /* Try to read from keyboard if previous reading is not pending */
            if (KbdStatus != STATUS_PENDING)
            {
                KbdStatus = ZwReadFile(ghKeyboardDevice,
                                       NULL,
                                       NULL,
                                       NULL,
                                       &KbdIosb,
                                       &KeyInput,
                                       sizeof(KEYBOARD_INPUT_DATA),
                                       &ByteOffset,
                                       NULL);
 
            }
            if (KbdStatus == STATUS_PENDING)
                WaitObjects[cWaitObjects++] = &pKbdDevice->Event;
        }
 
        /* If all objects are pending, wait for them */
        if (cWaitObjects == cMaxWaitObjects)
        {
            Status = KeWaitForMultipleObjects(cWaitObjects,
                                              WaitObjects,
                                              WaitAny,
                                              UserRequest,
                                              KernelMode,
                                              TRUE,
                                              NULL,//&WaitTimeout,
                                              WaitBlockArray);
 
            if ((Status >= STATUS_WAIT_0) &&
                (Status < (STATUS_WAIT_0 + (LONG)cWaitObjects)))
            {
                /* Some device has finished reading */
                pSignaledObject = WaitObjects[Status - STATUS_WAIT_0];
 
                /* Check if it is mouse or keyboard and update status */
                if ((MouStatus == STATUS_PENDING) &&
                    (pSignaledObject == &pMouDevice->Event))
                {
                    MouStatus = MouIosb.Status;
                }
                else if ((KbdStatus == STATUS_PENDING) &&
                         (pSignaledObject == &pKbdDevice->Event))
                {
                    KbdStatus = KbdIosb.Status;
                }
                else if (pSignaledObject == MasterTimer)
                {
                    ProcessTimers();
                }
                else if (pSignaledObject == ShutdownEvent)
                {
                    break;
                }
                else ASSERT(FALSE);
            }
        }
 
        /* Have we successed reading from mouse? */
        if (NT_SUCCESS(MouStatus) && MouStatus != STATUS_PENDING)
        {
            TRACE("MouseEvent\n");
 
            /* Set LastInputTick */
            IntLastInputTick(TRUE);
 
            /* Process data */
            UserEnterExclusive();
            UserProcessMouseInput(&Mouse, &MouseInput);
            UserLeave();
        }
        else if (MouStatus != STATUS_PENDING)
            ERR("Failed to read from mouse: %x.\n", MouStatus);
 
        /* Have we successed reading from keyboard? */
        if (NT_SUCCESS(KbdStatus) && KbdStatus != STATUS_PENDING)
        {
            TRACE("KeyboardEvent: %s %04x\n",
                  (KeyInput.Flags & KEY_BREAK) ? "up" : "down",
                  KeyInput.MakeCode);
 
            /* Set LastInputTick */
            IntLastInputTick(TRUE);
 
            /* Process data */
            UserEnterExclusive();
            UserProcessKeyboardInput(&Keyboard, &KeyInput);
            UserLeave();
        }
        else if (KbdStatus != STATUS_PENDING)
            ERR("Failed to read from keyboard: %x.\n", KbdStatus);
    }
 
    if (ghMouseDevice)
    {
        (void)ZwCancelIoFile(ghMouseDevice, &MouIosb);
        ObCloseHandle(ghMouseDevice, KernelMode);
        ObDereferenceObject(pMouDevice);
        ghMouseDevice = NULL;
    }
 
    if (ghKeyboardDevice)
    {
        (void)ZwCancelIoFile(ghKeyboardDevice, &KbdIosb);
        ObCloseHandle(ghKeyboardDevice, KernelMode);
        ObDereferenceObject(pKbdDevice);
        ghKeyboardDevice = NULL;
    }
 
    ExDeleteResourceLite(gpDeviceInfoListMutex);
    ExFreePoolWithTag(gpDeviceInfoListMutex, USERTAG_SYSTEM);
 
    ERR("Raw Input Thread Exit!\n");
}

Referenced by UserSystemThreadProc().

ReleaseDeviceInfoListMutex()

FORCEINLINE VOID ReleaseDeviceInfoListMutex

(

VOID

)

Definition at line 165 of file input.h.

{
    ExReleaseResourceLite(gpDeviceInfoListMutex);
    KeLeaveCriticalRegion();
}

Referenced by NtUserGetRawInputDeviceInfo(), and NtUserGetRawInputDeviceList().

UserAttachThreadInput()

NTSTATUS FASTCALL UserAttachThreadInput	(	PTHREADINFO	ptiFrom,
		PTHREADINFO	ptiTo,
		BOOL	fAttach
	)

Definition at line 523 of file input.c.

{
    MSG msg;
    PATTACHINFO pai;
    PCURICON_OBJECT CurIcon;
 
    /* Can not be the same thread. */
    if (ptiFrom == ptiTo) return STATUS_INVALID_PARAMETER;
 
    /* Do not attach to system threads or between different desktops. */
    if (ptiFrom->TIF_flags & TIF_DONTATTACHQUEUE ||
        ptiTo->TIF_flags & TIF_DONTATTACHQUEUE ||
        ptiFrom->rpdesk != ptiTo->rpdesk)
        return STATUS_ACCESS_DENIED;
 
    /* MSDN Note:
       Keyboard and mouse events received by both threads are processed by the thread specified by the idAttachTo.
     */
 
    /* If Attach set, allocate and link. */
    if (fAttach)
    {
        pai = ExAllocatePoolWithTag(PagedPool, sizeof(ATTACHINFO), USERTAG_ATTACHINFO);
        if (!pai) return STATUS_NO_MEMORY;
 
        pai->paiNext = gpai;
        pai->pti1 = ptiFrom;
        pai->pti2 = ptiTo;
        gpai = pai;
        paiCount++;
        ERR("Attach Allocated! ptiFrom 0x%p  ptiTo 0x%p paiCount %d\n",ptiFrom,ptiTo,paiCount);
 
        if (ptiTo->MessageQueue != ptiFrom->MessageQueue)
        {
 
           ptiTo->MessageQueue->iCursorLevel -= ptiFrom->iCursorLevel;
 
           if (ptiFrom->MessageQueue == gpqForeground)
           {
              ERR("ptiFrom is Foreground\n");
              ptiTo->MessageQueue->spwndActive  = ptiFrom->MessageQueue->spwndActive;
              ptiTo->MessageQueue->spwndFocus   = ptiFrom->MessageQueue->spwndFocus;
              ptiTo->MessageQueue->spwndCapture = ptiFrom->MessageQueue->spwndCapture;
              ptiTo->MessageQueue->QF_flags    ^= ((ptiTo->MessageQueue->QF_flags ^ ptiFrom->MessageQueue->QF_flags) & QF_CAPTURELOCKED);
              RtlCopyMemory(&ptiTo->MessageQueue->CaretInfo,
                            &ptiFrom->MessageQueue->CaretInfo,
                            sizeof(ptiTo->MessageQueue->CaretInfo));
              IntSetFocusMessageQueue(NULL);
              IntSetFocusMessageQueue(ptiTo->MessageQueue);
              gptiForeground = ptiTo;
           }
           else
           {
              ERR("ptiFrom NOT Foreground\n");
              if ( ptiTo->MessageQueue->spwndActive == 0 )
                  ptiTo->MessageQueue->spwndActive = ptiFrom->MessageQueue->spwndActive;
              if ( ptiTo->MessageQueue->spwndFocus == 0 )
                  ptiTo->MessageQueue->spwndFocus  = ptiFrom->MessageQueue->spwndFocus;
           }
 
           CurIcon = ptiFrom->MessageQueue->CursorObject;
 
           MsqDestroyMessageQueue(ptiFrom);
 
           if (CurIcon)
           {
              // Could be global. Keep it above the water line!
              UserReferenceObject(CurIcon);
           }
 
           if (CurIcon && UserObjectInDestroy(UserHMGetHandle(CurIcon)))
           {
              UserDereferenceObject(CurIcon);
              CurIcon = NULL;
           }
 
           ptiFrom->MessageQueue = ptiTo->MessageQueue;
 
           // Pass cursor From if To is null. Pass test_SetCursor parent_id == current pti ID.
           if (CurIcon && ptiTo->MessageQueue->CursorObject == NULL)
           {
              ERR("ptiTo receiving ptiFrom Cursor\n");
              ptiTo->MessageQueue->CursorObject = CurIcon;
           }
 
           ptiFrom->MessageQueue->cThreads++;
           ERR("ptiTo S Share count %u\n", ptiFrom->MessageQueue->cThreads);
 
           IntReferenceMessageQueue(ptiTo->MessageQueue);
        }
        else
        {
           ERR("Attach Threads are already associated!\n");
        }
    }
    else /* If clear, unlink and free it. */
    {
        BOOL Hit = FALSE;
        PATTACHINFO *ppai;
 
        if (!gpai) return STATUS_INVALID_PARAMETER;
 
        /* Search list and free if found or return false. */
        ppai = &gpai;
        while (*ppai != NULL)
        {
           if ( (*ppai)->pti2 == ptiTo && (*ppai)->pti1 == ptiFrom )
           {
              pai = *ppai;
              /* Remove it from the list */
              *ppai = (*ppai)->paiNext;
              ExFreePoolWithTag(pai, USERTAG_ATTACHINFO);
              paiCount--;
              Hit = TRUE;
              break;
           }
           ppai = &((*ppai)->paiNext);
        }
 
        if (!Hit) return STATUS_INVALID_PARAMETER;
 
        ERR("Attach Free! ptiFrom 0x%p  ptiTo 0x%p paiCount %d\n",ptiFrom,ptiTo,paiCount);
 
        if (ptiTo->MessageQueue == ptiFrom->MessageQueue)
        {
           PWND spwndActive = ptiTo->MessageQueue->spwndActive;
           PWND spwndFocus  = ptiTo->MessageQueue->spwndFocus;
 
           if (gptiForeground == ptiFrom)
           {
              ERR("ptiTo is now pti FG.\n");
              // MessageQueue foreground is set so switch threads.
              gptiForeground = ptiTo;
           }
           ptiTo->MessageQueue->cThreads--;
           ERR("ptiTo E Share count %u\n", ptiTo->MessageQueue->cThreads);
           ASSERT(ptiTo->MessageQueue->cThreads >= 1);
 
           IntDereferenceMessageQueue(ptiTo->MessageQueue);
 
           ptiFrom->MessageQueue = MsqCreateMessageQueue(ptiFrom);
 
           if (spwndActive)
           {
              if (spwndActive->head.pti == ptiFrom)
              {
                 ptiFrom->MessageQueue->spwndActive = spwndActive;
                 ptiTo->MessageQueue->spwndActive = 0;
              }
           }
           if (spwndFocus)
           {
              if (spwndFocus->head.pti == ptiFrom)
              {
                 ptiFrom->MessageQueue->spwndFocus = spwndFocus;
                 ptiTo->MessageQueue->spwndFocus = 0;
              }
           }
           ptiTo->MessageQueue->iCursorLevel -= ptiFrom->iCursorLevel;
        }
        else
        {
           ERR("Detaching Threads are not associated!\n");
        }
    }
    /* Note that key state, which can be ascertained by calls to the GetKeyState
       or GetKeyboardState function, is reset after a call to AttachThreadInput.
       ATM which one?
     */
    RtlCopyMemory(ptiTo->MessageQueue->afKeyState, gafAsyncKeyState, sizeof(gafAsyncKeyState));
 
    ptiTo->MessageQueue->msgDblClk.message = 0;
 
    /* Generate mouse move message */
    msg.message = WM_MOUSEMOVE;
    msg.wParam = UserGetMouseButtonsState();
    msg.lParam = MAKELPARAM(gpsi->ptCursor.x, gpsi->ptCursor.y);
    msg.pt = gpsi->ptCursor;
    co_MsqInsertMouseMessage(&msg, 0, 0, TRUE);
 
    return STATUS_SUCCESS;
}

Referenced by co_IntSetParent(), co_UserCreateWindowEx(), co_UserDestroyWindow(), IntCreateWindow(), IntProcessOwnerSwap(), IsRemoveAttachThread(), and NtUserAttachThreadInput().

UserCleanupRawInput()

VOID FASTCALL UserCleanupRawInput

(

PUSER_MESSAGE_QUEUE

MessageQueue

)

Definition at line 398 of file rawinput.c.

{
    while (!IsListEmpty(&MessageQueue->RawInputListHead))
    {
        PUSER_RAWINPUT RawEntry;
        RawEntry = CONTAINING_RECORD(MessageQueue->RawInputListHead.Flink,
                                     USER_RAWINPUT,
                                     ListEntry);
        RawInputFreeEntry(MessageQueue, RawEntry);
    }
}

Referenced by MsqCleanupMessageQueue().

UserCreateRawInput()

HRAWINPUT FASTCALL UserCreateRawInput	(	PTHREADINFO	pti,
		DWORD	dwType,
		HANDLE	hDevice,
		WPARAM	wParam,
		CONST VOID *	pData,
		UINT	cbData
	)

Definition at line 323 of file rawinput.c.

{
    PUSER_RAWINPUT RawEntry;
 
    if (!pti || !pti->MessageQueue || !pData)
        return NULL;
 
    ASSERT(cbData <= sizeof(RawEntry->RawInput.data));
    if (cbData > sizeof(RawEntry->RawInput.data))
        return NULL;
 
    if (pti->MessageQueue->cRawInput >= MAX_RAWINPUT_PER_QUEUE)
    {
        DPRINT("Dropping raw input, queue %p is not being pumped\n", pti->MessageQueue);
        return NULL;
    }
 
    RawEntry = ExAllocateFromPagedLookasideList(&gRawInputLookasideList);
    if (!RawEntry)
        return NULL;
 
    RtlZeroMemory(RawEntry, sizeof(*RawEntry));
    RawEntry->RawInput.header.dwType = dwType;
    RawEntry->RawInput.header.dwSize = sizeof(RAWINPUTHEADER) + cbData;
    RawEntry->RawInput.header.hDevice = hDevice;
    RawEntry->RawInput.header.wParam = wParam;
    RtlCopyMemory(&RawEntry->RawInput.data, pData, cbData);
 
    InsertTailList(&pti->MessageQueue->RawInputListHead, &RawEntry->ListEntry);
    pti->MessageQueue->cRawInput++;
    return (HRAWINPUT)&RawEntry->RawInput;
}

Referenced by UserRawInputMouseProcess(), and UserRawInputProcessKeyboardInput().

UserFreeRawInput()

BOOL FASTCALL UserFreeRawInput	(	PUSER_MESSAGE_QUEUE	MessageQueue,
		HRAWINPUT	hRawInput
	)

Definition at line 364 of file rawinput.c.

{
    PUSER_RAWINPUT RawEntry = RawInputEntryFromHandle(MessageQueue, hRawInput);
 
    if (!RawEntry)
        return FALSE;
 
    RawInputFreeEntry(MessageQueue, RawEntry);
    return TRUE;
}

Referenced by MsqCleanupMessageQueue(), UserRawInputMouseProcess(), UserRawInputProcessKeyboardInput(), and UserUpdatePrevRawInput().

UserGetMouseButtonsState()

WORD FASTCALL UserGetMouseButtonsState

(

VOID

)

Definition at line 22 of file mouse.c.

{
    WORD wRet = 0;
 
    wRet = IntGetSysCursorInfo()->ButtonsDown;
 
    if (IS_KEY_DOWN(gafAsyncKeyState, VK_SHIFT)) wRet |= MK_SHIFT;
    if (IS_KEY_DOWN(gafAsyncKeyState, VK_CONTROL)) wRet |= MK_CONTROL;
 
    return wRet;
}

Referenced by co_UserDestroyWindow(), co_WinPosSetWindowPos(), IntDeactivateWindow(), UserAttachThreadInput(), UserDeleteW32Thread(), UserSendMouseInput(), and UserSetCursorPos().

UserGetRawInputTarget()

BOOL FASTCALL UserGetRawInputTarget	(	DWORD	dwType,
		PTHREADINFO *	ppti,
		HWND *	phwndTarget,
		WPARAM *	pwParam
	)

Definition at line 413 of file rawinput.c.

{
    PRAWINPUTDEVICE Registration;
    PUSER_MESSAGE_QUEUE pFocusQueue;
    PWND pWnd = NULL;
    PTHREADINFO pti;
 
    Registration = RawInputRegistrationFromType(dwType);
    if (!Registration)
        return FALSE;
 
    pFocusQueue = IntGetFocusMessageQueue();
    if (!pFocusQueue)
        return FALSE;
 
    if (Registration->hwndTarget)
    {
        pWnd = UserGetWindowObject(Registration->hwndTarget);
        if (!pWnd)
            return FALSE;
    }
    else
    {
        pWnd = pFocusQueue->spwndFocus;
        if (!pWnd)
            pWnd = pFocusQueue->spwndActive;
        if (!pWnd)
            return FALSE;
    }
 
    pti = pWnd->head.pti;
    if (!pti)
        return FALSE;
 
    if (pFocusQueue->ptiKeyboard && pti->rpdesk != pFocusQueue->ptiKeyboard->rpdesk)
        return FALSE;
 
    if (Registration->dwFlags & RIDEV_INPUTSINK)
    {
        *pwParam = (pti->MessageQueue == pFocusQueue) ? RIM_INPUT : RIM_INPUTSINK;
        *phwndTarget = UserHMGetHandle(pWnd);
        *ppti = pti;
        return TRUE;
    }
 
    if (Registration->dwFlags & RIDEV_EXINPUTSINK)
    {
        if (pti->MessageQueue != pFocusQueue)
            return FALSE; /* FIXME: Needs per-process arbitration like Windows */
 
        *pwParam = RIM_INPUT;
        *phwndTarget = UserHMGetHandle(pWnd);
        *ppti = pti;
        return TRUE;
    }
 
    if (pti->MessageQueue != pFocusQueue)
        return FALSE;
 
    *pwParam = RIM_INPUT;
    *phwndTarget = UserHMGetHandle(pWnd);
    *ppti = pti;
    return TRUE;
}

Referenced by UserRawInputMouseProcess(), and UserRawInputProcessKeyboardInput().

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().

UserInitKeyboard()

VOID NTAPI UserInitKeyboard

(

HANDLE

hKeyboardDevice

)

Definition at line 178 of file keyboard.c.

{
    NTSTATUS Status;
    IO_STATUS_BLOCK Block;
 
    IntKeyboardGetIndicatorTrans(hKeyboardDevice, &gpKeyboardIndicatorTrans);
 
    Status = ZwDeviceIoControlFile(hKeyboardDevice,
                                   NULL,
                                   NULL,
                                   NULL,
                                   &Block,
                                   IOCTL_KEYBOARD_QUERY_INDICATORS,
                                   NULL, 0,
                                   &gIndicators,
                                   sizeof(gIndicators));
 
    if (!NT_SUCCESS(Status))
    {
        WARN("NtDeviceIoControlFile() failed, ignored\n");
        gIndicators.LedFlags = 0;
        gIndicators.UnitId = 0;
    }
 
    SET_KEY_LOCKED(gafAsyncKeyState, VK_CAPITAL,
                   gIndicators.LedFlags & KEYBOARD_CAPS_LOCK_ON);
    SET_KEY_LOCKED(gafAsyncKeyState, VK_NUMLOCK,
                   gIndicators.LedFlags & KEYBOARD_NUM_LOCK_ON);
    SET_KEY_LOCKED(gafAsyncKeyState, VK_SCROLL,
                   gIndicators.LedFlags & KEYBOARD_SCROLL_LOCK_ON);
 
    // FIXME: Need device driver to work! HID support more than one!!!!
    Status = ZwDeviceIoControlFile(hKeyboardDevice,
                                   NULL,
                                   NULL,
                                   NULL,
                                   &Block,
                                   IOCTL_KEYBOARD_QUERY_ATTRIBUTES,
                                   NULL, 0,
                                   &gKeyboardInfo, sizeof(gKeyboardInfo));
 
    if (!NT_SUCCESS(Status))
    {
        ERR("NtDeviceIoControlFile() failed, ignored\n");
    }
    TRACE("Keyboard type %u, subtype %u and number of func keys %u\n",
             gKeyboardInfo.KeyboardIdentifier.Type,
             gKeyboardInfo.KeyboardIdentifier.Subtype,
             gKeyboardInfo.NumberOfFunctionKeys);
}

Referenced by RawInputThreadMain().

UserProcessKeyboardInput()

VOID NTAPI UserProcessKeyboardInput	(	PINPUT_DEVICE_INFO	pDeviceInfo,
		PKEYBOARD_INPUT_DATA	pKeyInput
	)

Definition at line 1474 of file keyboard.c.

{
    WORD wScanCode, wVk;
    PKL pKl = NULL;
    PKBDTABLES pKbdTbl;
    PUSER_MESSAGE_QUEUE pFocusQueue;
 
    /* Calculate scan code with prefix */
    wScanCode = pKbdInputData->MakeCode & 0x7F;
    if (pKbdInputData->Flags & KEY_E0)
        wScanCode |= 0xE000;
    if (pKbdInputData->Flags & KEY_E1)
        wScanCode |= 0xE100;
 
    /* Find the target thread whose locale is in effect */
    pFocusQueue = IntGetFocusMessageQueue();
 
    if (pFocusQueue && pFocusQueue->ptiKeyboard)
    {
        pKl = pFocusQueue->ptiKeyboard->KeyboardLayout;
    }
 
    if (!pKl)
        pKl = W32kGetDefaultKeyLayout();
    if (!pKl)
        return;
 
    pKbdTbl = pKl->spkf->pKbdTbl;
 
    /* Convert scan code to virtual key.
       Note: We could call UserSendKeyboardInput using scan code,
             but it wouldn't interpret E1 key(s) properly */
    wVk = IntVscToVk(wScanCode, pKbdTbl);
    TRACE("UserProcessKeyboardInput: %x (break: %u) -> %x\n",
          wScanCode, (pKbdInputData->Flags & KEY_BREAK) ? 1u : 0, wVk);
 
    if (RawInputEnabled == TRUE)
        UserRawInputProcessKeyboardInput(pDeviceInfo, pKbdInputData, wScanCode, wVk);
 
    if (wVk)
    {
        KEYBDINPUT KbdInput;
 
        /* Support numlock */
        if ((wVk & KBDNUMPAD) && IS_KEY_LOCKED(gafAsyncKeyState, VK_NUMLOCK))
        {
            wVk = IntTranslateNumpadKey(wVk & 0xFF);
        }
 
        /* Send keyboard input */
        KbdInput.wVk = wVk & 0xFF;
        KbdInput.wScan = wScanCode & 0x7F;
        KbdInput.dwFlags = 0;
        if (pKbdInputData->Flags & KEY_BREAK)
            KbdInput.dwFlags |= KEYEVENTF_KEYUP;
 
        if (wVk & KBDEXT)
            KbdInput.dwFlags |= KEYEVENTF_EXTENDEDKEY;
        //
        // Based on wine input:test_Input_blackbox this is okay. It seems the
        // bit did not get set and more research is needed. Now the right
        // shift works.
        //
        if (wVk == VK_RSHIFT)
            KbdInput.dwFlags |= KEYEVENTF_EXTENDEDKEY;
 
        KbdInput.time = 0;
        KbdInput.dwExtraInfo = pKbdInputData->ExtraInformation;
        UserSendKeyboardInput(&KbdInput, FALSE);
 
        /* E1 keys don't have break code */
        if (pKbdInputData->Flags & KEY_E1)
        {
            /* Send key up event */
            KbdInput.dwFlags |= KEYEVENTF_KEYUP;
            UserSendKeyboardInput(&KbdInput, FALSE);
        }
    }
}

Referenced by RawInputThreadMain().

UserProcessMouseInput()

VOID NTAPI UserProcessMouseInput	(	PINPUT_DEVICE_INFO	pDeviceInfo,
		PMOUSE_INPUT_DATA	pMouseInputData
	)

Definition at line 104 of file mouse.c.

{
    MOUSEINPUT mi;
 
    /* Convert MOUSE_INPUT_DATA to MOUSEINPUT. First init all fields. */
    mi.dx = mid->LastX;
    mi.dy = mid->LastY;
    mi.mouseData = 0;
    mi.dwFlags = 0;
    mi.time = 0;
    mi.dwExtraInfo = mid->ExtraInformation;
 
    if (RawInputEnabled == TRUE)
        UserRawInputMouseProcess(pDeviceInfo, mid);
 
    /* Mouse position */
    if (mi.dx != 0 || mi.dy != 0)
        mi.dwFlags |= MOUSEEVENTF_MOVE;
 
    /* Flags for absolute move */
    if (mid->Flags & MOUSE_MOVE_ABSOLUTE)
        mi.dwFlags |= MOUSEEVENTF_ABSOLUTE;
    if (mid->Flags & MOUSE_VIRTUAL_DESKTOP)
        mi.dwFlags |= MOUSEEVENTF_VIRTUALDESK;
 
    /* Left button */
    if (mid->ButtonFlags & MOUSE_LEFT_BUTTON_DOWN)
        mi.dwFlags |= MOUSEEVENTF_LEFTDOWN;
    if (mid->ButtonFlags & MOUSE_LEFT_BUTTON_UP)
        mi.dwFlags |= MOUSEEVENTF_LEFTUP;
 
    /* Middle button */
    if (mid->ButtonFlags & MOUSE_MIDDLE_BUTTON_DOWN)
        mi.dwFlags |= MOUSEEVENTF_MIDDLEDOWN;
    if (mid->ButtonFlags & MOUSE_MIDDLE_BUTTON_UP)
        mi.dwFlags |= MOUSEEVENTF_MIDDLEUP;
 
    /* Right button */
    if (mid->ButtonFlags & MOUSE_RIGHT_BUTTON_DOWN)
        mi.dwFlags |= MOUSEEVENTF_RIGHTDOWN;
    if (mid->ButtonFlags & MOUSE_RIGHT_BUTTON_UP)
        mi.dwFlags |= MOUSEEVENTF_RIGHTUP;
 
    /* Note: Next buttons use mouseData field so they cannot be sent in one call */
 
    /* Button 4 */
    if (mid->ButtonFlags & MOUSE_BUTTON_4_DOWN)
    {
        mi.dwFlags |= MOUSEEVENTF_XDOWN;
        mi.mouseData |= XBUTTON1;
    }
    if (mid->ButtonFlags & MOUSE_BUTTON_4_UP)
    {
        mi.dwFlags |= MOUSEEVENTF_XUP;
        mi.mouseData |= XBUTTON1;
    }
 
    /* If mouseData is used by button 4, send input and clear mi */
    if (mi.dwFlags & (MOUSEEVENTF_XDOWN | MOUSEEVENTF_XUP))
    {
        UserSendMouseInput(&mi, FALSE);
        RtlZeroMemory(&mi, sizeof(mi));
    }
 
    /* Button 5 */
    if (mid->ButtonFlags & MOUSE_BUTTON_5_DOWN)
    {
        mi.mouseData |= XBUTTON2;
        mi.dwFlags |= MOUSEEVENTF_XDOWN;
    }
    if (mid->ButtonFlags & MOUSE_BUTTON_5_UP)
    {
        mi.mouseData |= XBUTTON2;
        mi.dwFlags |= MOUSEEVENTF_XUP;
    }
 
    /* If mouseData is used by button 5, send input and clear mi */
    if (mi.dwFlags & (MOUSEEVENTF_XDOWN | MOUSEEVENTF_XUP))
    {
        UserSendMouseInput(&mi, FALSE);
        RtlZeroMemory(&mi, sizeof(mi));
    }
 
    /* Mouse wheel */
    if (mid->ButtonFlags & MOUSE_WHEEL)
    {
        mi.mouseData = mid->ButtonData;
        mi.dwFlags |= MOUSEEVENTF_WHEEL;
    }
 
    /* If something has changed, send input to user */
    if (mi.dwFlags)
        UserSendMouseInput(&mi, FALSE);
}

Referenced by RawInputThreadMain().

UserSendKeyboardInput()

BOOL NTAPI UserSendKeyboardInput	(	KEYBDINPUT *	pKbdInput,
		BOOL	bInjected
	)

Definition at line 1333 of file keyboard.c.

{
    WORD wScanCode, wVk;
    PKL pKl = NULL;
    PKBDTABLES pKbdTbl;
    PUSER_MESSAGE_QUEUE pFocusQueue;
    DWORD dwTime;
    BOOL bExt = (pKbdInput->dwFlags & KEYEVENTF_EXTENDEDKEY) ? TRUE : FALSE;
 
    gppiInputProvider = ((PTHREADINFO)PsGetCurrentThreadWin32Thread())->ppi;
 
    /* Find the target thread whose locale is in effect */
    pFocusQueue = IntGetFocusMessageQueue();
 
    if (pFocusQueue && pFocusQueue->ptiKeyboard)
    {
        pKl = pFocusQueue->ptiKeyboard->KeyboardLayout;
    }
 
    if (!pKl)
        pKl = W32kGetDefaultKeyLayout();
    if (!pKl)
    {
        ERR("No keyboard layout!\n");
        return FALSE;
    }
 
    pKbdTbl = pKl->spkf->pKbdTbl;
 
    /* Note: wScan field is always used */
    wScanCode = pKbdInput->wScan;
 
    if (pKbdInput->dwFlags & KEYEVENTF_UNICODE)
    {
        /* Generate WM_KEYDOWN msg with wParam == VK_PACKET and
           high order word of lParam == pKbdInput->wScan */
        wVk = VK_PACKET;
    }
    else
    {
        wScanCode &= 0x7F;
        if (pKbdInput->dwFlags & KEYEVENTF_SCANCODE)
        {
            /* Don't ignore invalid scan codes */
            wVk = IntVscToVk(wScanCode | (bExt ? 0xE000 : 0), pKbdTbl);
            if (!wVk) /* use 0xFF if vsc is invalid */
                wVk = 0xFF;
        }
        else
        {
            wVk = pKbdInput->wVk;
        }
 
        /* Remove all virtual key flags (KBDEXT, KBDMULTIVK, KBDSPECIAL, KBDNUMPAD) */
        wVk &= 0xFF;
    }
 
    /* If time is given, use it */
    if (pKbdInput->time)
        dwTime = pKbdInput->time;
    else
    {
        dwTime = EngGetTickCount32();
    }
 
    if (wVk == VK_RMENU && (pKbdTbl->fLocaleFlags & KLLF_ALTGR))
    {
        /* For AltGr keyboards RALT generates CTRL events */
        ProcessKeyEvent(VK_LCONTROL, 0, pKbdInput->dwFlags & KEYEVENTF_KEYUP, bInjected, dwTime, 0);
    }
 
    /* Finally process this key */
    return ProcessKeyEvent(wVk, wScanCode, pKbdInput->dwFlags, bInjected, dwTime, pKbdInput->dwExtraInfo);
}

Referenced by NtUserSendInput(), and UserProcessKeyboardInput().

UserSendMouseInput()

BOOL NTAPI UserSendMouseInput	(	MOUSEINPUT *	pMouseInput,
		BOOL	bInjected
	)

Definition at line 235 of file mouse.c.

{
    POINT ptCursor;
    PSYSTEM_CURSORINFO pCurInfo;
    MSG Msg;
    DWORD dwFlags;
 
    ASSERT(pmi);
 
    pCurInfo = IntGetSysCursorInfo();
    ptCursor = gpsi->ptCursor;
    dwFlags = IntFixMouseInputButtons(pmi->dwFlags);
 
    gppiInputProvider = ((PTHREADINFO)PsGetCurrentThreadWin32Thread())->ppi;
 
    if (pmi->dwFlags & MOUSEEVENTF_MOVE)
    {
        /* Mouse has changes position */
        if (!(pmi->dwFlags & MOUSEEVENTF_ABSOLUTE))
        {
            /* Relative move */
            ptCursor.x += pmi->dx;
            ptCursor.y += pmi->dy;
        }
        else if (pmi->dwFlags & MOUSEEVENTF_VIRTUALDESK)
        {
            /* Absolute move in virtual screen units */
            ptCursor.x = pmi->dx * UserGetSystemMetrics(SM_CXVIRTUALSCREEN) >> 16;
            ptCursor.y = pmi->dy * UserGetSystemMetrics(SM_CYVIRTUALSCREEN) >> 16;
        }
        else
        {
            /* Absolute move in primary monitor units */
            ptCursor.x = pmi->dx * UserGetSystemMetrics(SM_CXSCREEN) >> 16;
            ptCursor.y = pmi->dy * UserGetSystemMetrics(SM_CYSCREEN) >> 16;
        }
    }
 
    /* Init message fields */
    Msg.wParam = UserGetMouseButtonsState();
    Msg.lParam = MAKELPARAM(ptCursor.x, ptCursor.y);
    Msg.pt = ptCursor;
    Msg.time = pmi->time;
    if (!Msg.time)
    {
        Msg.time = EngGetTickCount32();
    }
 
    /* Do GetMouseMovePointsEx FIFO. */
    gMouseHistoryOfMoves[gcMouseHistoryOfMoves].x = ptCursor.x;
    gMouseHistoryOfMoves[gcMouseHistoryOfMoves].y = ptCursor.y;
    gMouseHistoryOfMoves[gcMouseHistoryOfMoves].time = Msg.time;
    gMouseHistoryOfMoves[gcMouseHistoryOfMoves].dwExtraInfo = pmi->dwExtraInfo;
    if (++gcMouseHistoryOfMoves == ARRAYSIZE(gMouseHistoryOfMoves))
       gcMouseHistoryOfMoves = 0; // 0 - 63 is 64, FIFO forwards.
 
    /* Update cursor position */
    if (dwFlags & MOUSEEVENTF_MOVE)
    {
        UserSetCursorPos(ptCursor.x, ptCursor.y, bInjected, pmi->dwExtraInfo, TRUE);
    }
 
    if (IS_KEY_DOWN(gafAsyncKeyState, VK_SHIFT))
        pCurInfo->ButtonsDown |= MK_SHIFT;
    else
        pCurInfo->ButtonsDown &= ~MK_SHIFT;
 
    if (IS_KEY_DOWN(gafAsyncKeyState, VK_CONTROL))
        pCurInfo->ButtonsDown |= MK_CONTROL;
    else
        pCurInfo->ButtonsDown &= ~MK_CONTROL;
 
    /* Left button */
    if (dwFlags & MOUSEEVENTF_LEFTDOWN)
    {
        SET_KEY_DOWN(gafAsyncKeyState, VK_LBUTTON, TRUE);
        Msg.message = WM_LBUTTONDOWN;
        pCurInfo->ButtonsDown |= MK_LBUTTON;
        Msg.wParam |= MK_LBUTTON;
        co_MsqInsertMouseMessage(&Msg, bInjected, pmi->dwExtraInfo, TRUE);
    }
    else if (dwFlags & MOUSEEVENTF_LEFTUP)
    {
        SET_KEY_DOWN(gafAsyncKeyState, VK_LBUTTON, FALSE);
        Msg.message = WM_LBUTTONUP;
        pCurInfo->ButtonsDown &= ~MK_LBUTTON;
        Msg.wParam &= ~MK_LBUTTON;
        co_MsqInsertMouseMessage(&Msg, bInjected, pmi->dwExtraInfo, TRUE);
    }
 
    /* Middle button */
    if (dwFlags & MOUSEEVENTF_MIDDLEDOWN)
    {
        SET_KEY_DOWN(gafAsyncKeyState, VK_MBUTTON, TRUE);
        Msg.message = WM_MBUTTONDOWN;
        pCurInfo->ButtonsDown |= MK_MBUTTON;
        Msg.wParam |= MK_MBUTTON;
        co_MsqInsertMouseMessage(&Msg, bInjected, pmi->dwExtraInfo, TRUE);
    }
    else if (dwFlags & MOUSEEVENTF_MIDDLEUP)
    {
        SET_KEY_DOWN(gafAsyncKeyState, VK_MBUTTON, FALSE);
        Msg.message = WM_MBUTTONUP;
        pCurInfo->ButtonsDown &= ~MK_MBUTTON;
        Msg.wParam &= ~MK_MBUTTON;
        co_MsqInsertMouseMessage(&Msg, bInjected, pmi->dwExtraInfo, TRUE);
    }
 
    /* Right button */
    if (dwFlags & MOUSEEVENTF_RIGHTDOWN)
    {
        SET_KEY_DOWN(gafAsyncKeyState, VK_RBUTTON, TRUE);
        Msg.message = WM_RBUTTONDOWN;
        pCurInfo->ButtonsDown |= MK_RBUTTON;
        Msg.wParam |= MK_RBUTTON;
        co_MsqInsertMouseMessage(&Msg, bInjected, pmi->dwExtraInfo, TRUE);
    }
    else if (dwFlags & MOUSEEVENTF_RIGHTUP)
    {
        SET_KEY_DOWN(gafAsyncKeyState, VK_RBUTTON, FALSE);
        Msg.message = WM_RBUTTONUP;
        pCurInfo->ButtonsDown &= ~MK_RBUTTON;
        Msg.wParam &= ~MK_RBUTTON;
        co_MsqInsertMouseMessage(&Msg, bInjected, pmi->dwExtraInfo, TRUE);
    }
 
    if((dwFlags & (MOUSEEVENTF_XDOWN | MOUSEEVENTF_XUP)) &&
       (dwFlags & MOUSEEVENTF_WHEEL))
    {
        /* Fail because both types of events use the mouseData field */
        WARN("Invalid flags!\n");
        return FALSE;
    }
 
    /* X-Button (4 or 5) */
    if (dwFlags & MOUSEEVENTF_XDOWN)
    {
        Msg.message = WM_XBUTTONDOWN;
        if (pmi->mouseData & XBUTTON1)
        {
            SET_KEY_DOWN(gafAsyncKeyState, VK_XBUTTON1, TRUE);
            pCurInfo->ButtonsDown |= MK_XBUTTON1;
            Msg.wParam |= MAKEWPARAM(MK_XBUTTON1, XBUTTON1);
            co_MsqInsertMouseMessage(&Msg, bInjected, pmi->dwExtraInfo, TRUE);
        }
        if (pmi->mouseData & XBUTTON2)
        {
            SET_KEY_DOWN(gafAsyncKeyState, VK_XBUTTON2, TRUE);
            pCurInfo->ButtonsDown |= MK_XBUTTON2;
            Msg.wParam |= MAKEWPARAM(MK_XBUTTON2, XBUTTON2);
            co_MsqInsertMouseMessage(&Msg, bInjected, pmi->dwExtraInfo, TRUE);
        }
    }
    else if (dwFlags & MOUSEEVENTF_XUP)
    {
        Msg.message = WM_XBUTTONUP;
        if(pmi->mouseData & XBUTTON1)
        {
            SET_KEY_DOWN(gafAsyncKeyState, VK_XBUTTON1, FALSE);
            pCurInfo->ButtonsDown &= ~MK_XBUTTON1;
            Msg.wParam &= ~MK_XBUTTON1;
            Msg.wParam |= MAKEWPARAM(0, XBUTTON1);
            co_MsqInsertMouseMessage(&Msg, bInjected, pmi->dwExtraInfo, TRUE);
        }
        if (pmi->mouseData & XBUTTON2)
        {
            SET_KEY_DOWN(gafAsyncKeyState, VK_XBUTTON2, FALSE);
            pCurInfo->ButtonsDown &= ~MK_XBUTTON2;
            Msg.wParam &= ~MK_XBUTTON2;
            Msg.wParam |= MAKEWPARAM(0, XBUTTON2);
            co_MsqInsertMouseMessage(&Msg, bInjected, pmi->dwExtraInfo, TRUE);
        }
    }
 
    /* Mouse wheel */
    if (dwFlags & MOUSEEVENTF_WHEEL)
    {
        Msg.message = WM_MOUSEWHEEL;
        Msg.wParam = MAKEWPARAM(pCurInfo->ButtonsDown, pmi->mouseData);
        co_MsqInsertMouseMessage(&Msg, bInjected, pmi->dwExtraInfo, TRUE);
    }
 
    return TRUE;
}

Referenced by co_UserSetCapture(), NtUserSendInput(), and UserProcessMouseInput().

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().

UserUpdatePrevRawInput()

VOID FASTCALL UserUpdatePrevRawInput	(	PTHREADINFO	pti,
		CONST MSG *	pMsg
	)

Definition at line 379 of file rawinput.c.

{
    if (pti->hPrevRawInput)
    {
        UserFreeRawInput(pti->MessageQueue, pti->hPrevRawInput);
        pti->hPrevRawInput = NULL;
    }
 
    if (pMsg->message == WM_INPUT &&
        (pMsg->wParam == RIM_INPUT || pMsg->wParam == RIM_INPUTSINK))
    {
        pti->hPrevRawInput = (HRAWINPUT)pMsg->lParam;
    }
}

Referenced by co_IntPeekMessage().

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

gafAsyncKeyState

BYTE gafAsyncKeyState[256 *2/8]

extern

Definition at line 13 of file keyboard.c.

Referenced by co_CallLowLevelKeyboardHook(), co_UserProcessHotKeys(), InitKeyboardImpl(), IntCheckLanguageToggle(), IntDefWindowProc(), IntHandleAltNumpad(), MsqInitializeMessageQueue(), NtUserGetAsyncKeyState(), ProcessKeyEvent(), UpdateAsyncKeyState(), UserAttachThreadInput(), UserGetMouseButtonsState(), UserInitKeyboard(), UserProcessKeyboardInput(), and UserSendMouseInput().

gbEnableHexNumpad

BOOL gbEnableHexNumpad

extern

Definition at line 36 of file keyboard.c.

Referenced by IntHandleAltNumpad(), and SpiUpdatePerUserSystemParameters().

gdwLanguageToggleKey

DWORD gdwLanguageToggleKey

extern

Definition at line 19 of file keyboard.c.

Referenced by ProcessKeyEvent(), SpiGetSet(), and SpiUpdatePerUserSystemParameters().

gdwLayoutToggleKey

DWORD gdwLayoutToggleKey

extern

Definition at line 21 of file keyboard.c.

Referenced by ProcessKeyEvent(), SpiGetSet(), and SpiUpdatePerUserSystemParameters().

ghKeyboardDevice

HANDLE ghKeyboardDevice

extern

Definition at line 26 of file input.c.

Referenced by ProcessKeyEvent(), and RawInputThreadMain().

gKeyboardInfo

KEYBOARD_ATTRIBUTES gKeyboardInfo

extern

Definition at line 17 of file keyboard.c.

Referenced by InitKeyboardImpl(), RawInputThreadMain(), SetDebugHotKeys(), UserGetKeyboardType(), and UserInitKeyboard().

gpai

PATTACHINFO gpai

extern

Definition at line 24 of file input.c.

Referenced by IsRemoveAttachThread(), and UserAttachThreadInput().

gpDeviceInfoListMutex

PERESOURCE gpDeviceInfoListMutex

extern

Definition at line 28 of file input.c.

Referenced by AcquireDeviceInfoListMutex(), RawInputThreadMain(), and ReleaseDeviceInfoListMutex().

gpInputDeviceInfo

PINPUT_DEVICE_INFO gpInputDeviceInfo

extern

Definition at line 27 of file input.c.

Referenced by NtUserGetRawInputDeviceInfo(), NtUserGetRawInputDeviceList(), and RawInputThreadMain().

gspklBaseLayout

PKL gspklBaseLayout

extern

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

extern

Definition at line 25 of file kbdlayout.c.

Referenced by co_UserLoadKbdLayout().

gSystemFS

DWORD gSystemFS

extern

Definition at line 24 of file kbdlayout.c.

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

ptiRawInput

PTHREADINFO ptiRawInput

extern

Definition at line 22 of file input.c.

Referenced by IntSetTimer(), and RawInputThreadMain().

RawInputEnabled

BOOLEAN RawInputEnabled

extern

Definition at line 38 of file rawinput.c.

Referenced by NtUserRegisterRawInputDevices(), UserProcessKeyboardInput(), and UserProcessMouseInput().