hotkey.h File Reference

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

Go to the source code of this file.

Classes
struct	_HOT_KEY

Macros
#define	IDHK_F12   -5
#define	IDHK_SHIFTF12   -6
#define	IDHK_WINKEY   -7
#define	IDHK_WNDKEY   -8 /* WM_SETHOTKEY */
#define	IDHK_SNAP_LEFT   -10
#define	IDHK_SNAP_RIGHT   -11
#define	IDHK_SNAP_UP   -12
#define	IDHK_SNAP_DOWN   -13

Typedefs
typedef struct _HOT_KEY	HOT_KEY
typedef struct _HOT_KEY *	PHOT_KEY

Functions
VOID FASTCALL	UnregisterWindowHotKeys (PWND Window)
VOID FASTCALL	UnregisterThreadHotKeys (PTHREADINFO pti)
BOOL NTAPI	co_UserProcessHotKeys (WORD wVk, BOOL bIsDown)
UINT FASTCALL	DefWndGetHotKey (PWND pWnd)
INT FASTCALL	DefWndSetHotKey (PWND pWnd, WPARAM wParam)
VOID FASTCALL	SetDebugHotKeys (VOID)
BOOL FASTCALL	UserRegisterHotKey (PWND pWnd, int id, UINT fsModifiers, UINT vk)
BOOL FASTCALL	UserUnregisterHotKey (PWND pWnd, int id)

Macro Definition Documentation

IDHK_F12

#define IDHK_F12   -5

Definition at line 14 of file hotkey.h.

IDHK_SHIFTF12

#define IDHK_SHIFTF12   -6

Definition at line 15 of file hotkey.h.

IDHK_SNAP_DOWN

#define IDHK_SNAP_DOWN   -13

Definition at line 23 of file hotkey.h.

IDHK_SNAP_LEFT

#define IDHK_SNAP_LEFT   -10

Definition at line 20 of file hotkey.h.

IDHK_SNAP_RIGHT

#define IDHK_SNAP_RIGHT   -11

Definition at line 21 of file hotkey.h.

IDHK_SNAP_UP

#define IDHK_SNAP_UP   -12

Definition at line 22 of file hotkey.h.

IDHK_WINKEY

#define IDHK_WINKEY   -7

Definition at line 16 of file hotkey.h.

IDHK_WNDKEY

#define IDHK_WNDKEY   -8 /* WM_SETHOTKEY */

Definition at line 17 of file hotkey.h.

Typedef Documentation

HOT_KEY

typedef struct _HOT_KEY HOT_KEY

PHOT_KEY

typedef struct _HOT_KEY * PHOT_KEY

Function Documentation

co_UserProcessHotKeys()

BOOL NTAPI co_UserProcessHotKeys	(	WORD	wVk,
		BOOL	bIsDown
	)

Definition at line 191 of file hotkey.c.

{
    UINT fModifiers;
    PHOT_KEY pHotKey;
    PWND pWnd;
    BOOL DoNotPostMsg = FALSE;
    BOOL IsModifier = FALSE;
 
    if (wVk == VK_SHIFT || wVk == VK_CONTROL || wVk == VK_MENU ||
        wVk == VK_LWIN || wVk == VK_RWIN)
    {
        /* Remember that this was a modifier */
        IsModifier = TRUE;
    }
 
    fModifiers = IntGetModifiers(gafAsyncKeyState);
 
    if (bIsDown)
    {
        if (IsModifier)
        {
            /* Modifier key down -- no hotkey trigger, but remember this */
            gfsModOnlyCandidate = fModifiers;
            return FALSE;
        }
        else
        {
            /* Regular key down -- check for hotkey, and reset mod candidates */
            pHotKey = IsHotKey(fModifiers, wVk);
            gfsModOnlyCandidate = 0;
        }
    }
    else
    {
        if (IsModifier)
        {
            /* Modifier key up -- modifier-only keys are triggered here */
            pHotKey = IsHotKey(gfsModOnlyCandidate, 0);
            gfsModOnlyCandidate = 0;
        }
        else
        {
            /* Regular key up -- no hotkey, but reset mod-only candidates */
            gfsModOnlyCandidate = 0;
            return FALSE;
        }
    }
 
    if (pHotKey)
    {
        TRACE("Hot key pressed (pWnd %p, id %d)\n", pHotKey->pWnd, pHotKey->id);
 
        /* FIXME: See comment about "UserDebuggerHotKey" on top of this file. */
        if (pHotKey->id == IDHK_SHIFTF12 || pHotKey->id == IDHK_F12)
        {
            if (bIsDown)
            {
                ERR("Hot key pressed for Debug Activation! ShiftF12 = %d or F12 = %d\n",pHotKey->id == IDHK_SHIFTF12 , pHotKey->id == IDHK_F12);
                //DoNotPostMsg = co_ActivateDebugger(); // FIXME
            }
            return DoNotPostMsg;
        }
 
        /* WIN and F12 keys are not hardcoded here. See comments on top of this file. */
        if (pHotKey->id == IDHK_WINKEY)
        {
            ASSERT(!bIsDown);
            pWnd = ValidateHwndNoErr(InputWindowStation->ShellWindow);
            if (pWnd)
            {
               TRACE("System Hot key Id %d Key %u\n", pHotKey->id, wVk );
               UserPostMessage(UserHMGetHandle(pWnd), WM_SYSCOMMAND, SC_TASKLIST, 0);
               co_IntShellHookNotify(HSHELL_TASKMAN, 0, 0);
               return FALSE;
            }
        }
        
        if (pHotKey->id == IDHK_SNAP_LEFT ||
            pHotKey->id == IDHK_SNAP_RIGHT ||
            pHotKey->id == IDHK_SNAP_UP ||
            pHotKey->id == IDHK_SNAP_DOWN)
        {
            HWND topWnd = UserGetForegroundWindow();
            if (topWnd)
            {
                UserPostMessage(topWnd, WM_KEYDOWN, wVk, 0);
            }
            return TRUE;
        }
 
        if (!pHotKey->pWnd)
        {
            TRACE("UPTM Hot key Id %d Key %u\n", pHotKey->id, wVk );
            UserPostThreadMessage(pHotKey->pti, WM_HOTKEY, pHotKey->id, MAKELONG(fModifiers, wVk));
            //ptiLastInput = pHotKey->pti;
            return TRUE; /* Don't send any message */
        }
        else
        {
            pWnd = pHotKey->pWnd;
            if (pWnd == PWND_BOTTOM)
            {
                if (gpqForeground == NULL)
                    return FALSE;
 
                pWnd = gpqForeground->spwndFocus;
            }
 
            if (pWnd)
            {
                //  pWnd->head.rpdesk->pDeskInfo->spwndShell needs testing.
                if (pWnd == ValidateHwndNoErr(InputWindowStation->ShellWindow) && pHotKey->id == SC_TASKLIST)
                {
                    UserPostMessage(UserHMGetHandle(pWnd), WM_SYSCOMMAND, SC_TASKLIST, 0);
                    co_IntShellHookNotify(HSHELL_TASKMAN, 0, 0);
                }
                else if (IsWindowHotKey(pHotKey))
                {
                    /* WM_SETHOTKEY notifies with WM_SYSCOMMAND, not WM_HOTKEY */
                    if (bIsDown)
                    {
                        if (gpqForeground && gpqForeground->spwndActive)
                            pWnd = gpqForeground->spwndActive;
                        UserPostMessage(UserHMGetHandle(pWnd), WM_SYSCOMMAND,
                                        SC_HOTKEY, (LPARAM)UserHMGetHandle(pHotKey->pWnd));
                    }
                }
                else
                {
                    TRACE("UPM Hot key Id %d Key %u\n", pHotKey->id, wVk );
                    UserPostMessage(UserHMGetHandle(pWnd), WM_HOTKEY, pHotKey->id, MAKELONG(fModifiers, wVk));
                }
                //ptiLastInput = pWnd->head.pti;
                return TRUE; /* Don't send any message */
            }
        }
    }
    return FALSE;
}

Referenced by ProcessKeyEvent().

DefWndGetHotKey()

UINT FASTCALL DefWndGetHotKey

(

PWND

pWnd

)

Definition at line 336 of file hotkey.c.

{
    PHOT_KEY pHotKey = gphkFirst;
 
    WARN("DefWndGetHotKey\n");
 
    while (pHotKey)
    {
        if (pHotKey->pWnd == pWnd && IsWindowHotKey(pHotKey))
        {
            /* We have found it */
            return MAKEWORD(pHotKey->vk, IntSwapModHKF(pHotKey->fsModifiers));
        }
 
        /* Move to the next entry */
        pHotKey = pHotKey->pNext;
    }
 
    return 0;
}

Referenced by IntDefWindowProc().

DefWndSetHotKey()

INT FASTCALL DefWndSetHotKey	(	PWND	pWnd,
		WPARAM	wParam
	)

Definition at line 361 of file hotkey.c.

{
    const UINT fsModifiers = IntSwapModHKF(HIBYTE(wParam));
    const UINT vk = LOBYTE(wParam);
    PHOT_KEY pHotKey, *pLink;
    INT iRet = 1;
 
    WARN("DefWndSetHotKey wParam 0x%x\n", wParam);
 
    // A hot key cannot be associated with a child window.
    if (pWnd->style & WS_CHILD)
        return 0;
 
    // VK_ESCAPE, VK_SPACE, VK_TAB and VK_PACKET are invalid hot keys.
    if (vk == VK_ESCAPE || vk == VK_SPACE || vk == VK_TAB || vk == VK_PACKET)
    {
        return -1;
    }
 
    if (wParam)
    {
        pHotKey = gphkFirst;
        while (pHotKey)
        {
            if (pHotKey->fsModifiers == fsModifiers &&
                pHotKey->vk == vk &&
                IsWindowHotKey(pHotKey))
            {
                if (pHotKey->pWnd != pWnd)
                    iRet = 2; // Another window already has the same hot key.
                break;
            }
 
            /* Move to the next entry */
            pHotKey = pHotKey->pNext;
        }
    }
 
    pHotKey = gphkFirst;
    pLink = &gphkFirst;
    while (pHotKey)
    {
        if (pHotKey->pWnd == pWnd && IsWindowHotKey(pHotKey))
        {
            /* This window has already hotkey registered */
            break;
        }
 
        /* Move to the next entry */
        pLink = &pHotKey->pNext;
        pHotKey = pHotKey->pNext;
    }
 
    if (wParam)
    {
        if (!pHotKey)
        {
            /* Create new hotkey */
            pHotKey = ExAllocatePoolWithTag(PagedPool, sizeof(HOT_KEY), USERTAG_HOTKEY);
            if (pHotKey == NULL)
                return 0;
 
            pHotKey->pWnd = pWnd;
            pHotKey->id = IDHK_WNDKEY; // Don't care, these hot keys are unrelated to the hot keys set by RegisterHotKey
            pHotKey->pNext = gphkFirst;
            gphkFirst = pHotKey;
        }
 
        /* A window can only have one hot key. If the window already has a
           hot key associated with it, the new hot key replaces the old one. */
        pHotKey->pti = NULL; /* IsWindowHotKey */
        pHotKey->fsModifiers = fsModifiers;
        pHotKey->vk = vk;
    }
    else if (pHotKey)
    {
        /* Remove hotkey */
        *pLink = pHotKey->pNext;
        ExFreePoolWithTag(pHotKey, USERTAG_HOTKEY);
    }
 
    return iRet;
}

Referenced by IntDefWindowProc().

SetDebugHotKeys()

VOID FASTCALL SetDebugHotKeys

(

VOID

)

Definition at line 46 of file hotkey.c.

{
    UINT vk = VK_F12;
    if (!ENHANCED_KEYBOARD(gKeyboardInfo.KeyboardIdentifier))
        vk = VK_SUBTRACT;
 
    UserUnregisterHotKey(PWND_BOTTOM, IDHK_F12);
    UserUnregisterHotKey(PWND_BOTTOM, IDHK_SHIFTF12);
    UserRegisterHotKey(PWND_BOTTOM, IDHK_SHIFTF12, MOD_SHIFT, vk);
    UserRegisterHotKey(PWND_BOTTOM, IDHK_F12, 0, vk);
 
    TRACE("Debugger hotkeys set up! If you see this you enabled Debug Prints. Congrats!\n");
}

Referenced by RawInputThreadMain().

UnregisterThreadHotKeys()

VOID FASTCALL UnregisterThreadHotKeys

(

PTHREADINFO

pti

)

Definition at line 135 of file hotkey.c.

{
    PHOT_KEY pHotKey = gphkFirst, phkNext, *pLink = &gphkFirst;
 
    while (pHotKey)
    {
        /* Save next ptr for later use */
        phkNext = pHotKey->pNext;
 
        /* Should we delete this hotkey? */
        if (pHotKey->pti == pti)
        {
            /* Update next ptr for previous hotkey and free memory */
            *pLink = phkNext;
            ExFreePoolWithTag(pHotKey, USERTAG_HOTKEY);
        }
        else /* This hotkey will stay, use its next ptr */
            pLink = &pHotKey->pNext;
 
        /* Move to the next entry */
        pHotKey = phkNext;
    }
}

Referenced by ExitThreadCallback().

UnregisterWindowHotKeys()

VOID FASTCALL UnregisterWindowHotKeys

(

PWND

Window

)

Definition at line 105 of file hotkey.c.

{
    PHOT_KEY pHotKey = gphkFirst, phkNext, *pLink = &gphkFirst;
 
    while (pHotKey)
    {
        /* Save next ptr for later use */
        phkNext = pHotKey->pNext;
 
        /* Should we delete this hotkey? */
        if (pHotKey->pWnd == pWnd)
        {
            /* Update next ptr for previous hotkey and free memory */
            *pLink = phkNext;
            ExFreePoolWithTag(pHotKey, USERTAG_HOTKEY);
        }
        else /* This hotkey will stay, use its next ptr */
            pLink = &pHotKey->pNext;
 
        /* Move to the next entry */
        pHotKey = phkNext;
    }
}

Referenced by co_UserFreeWindow().

UserRegisterHotKey()

BOOL FASTCALL UserRegisterHotKey	(	PWND	pWnd,
		int	id,
		UINT	fsModifiers,
		UINT	vk
	)

Definition at line 447 of file hotkey.c.

{
    PHOT_KEY pHotKey;
    PTHREADINFO pHotKeyThread;
 
    /* Find the hotkey thread */
    if (pWnd == NULL || pWnd == PWND_BOTTOM)
    {
        pHotKeyThread = PsGetCurrentThreadWin32Thread(); // gptiCurrent;
    }
    else
    {
        pHotKeyThread = pWnd->head.pti;
    }
 
    /* Ignore the VK_PACKET key since it is not a real keyboard input */
    if (vk == VK_PACKET)
        return FALSE;
 
    /* Check whether we modify an existing hotkey */
    if (IsHotKey(fsModifiers, vk))
    {
        EngSetLastError(ERROR_HOTKEY_ALREADY_REGISTERED);
        WARN("Hotkey already exists\n");
        return FALSE;
    }
 
    /* Create a new hotkey */
    pHotKey = ExAllocatePoolWithTag(PagedPool, sizeof(HOT_KEY), USERTAG_HOTKEY);
    if (pHotKey == NULL)
    {
        EngSetLastError(ERROR_NOT_ENOUGH_MEMORY);
        return FALSE;
    }
 
    pHotKey->pti = pHotKeyThread;
    pHotKey->pWnd = pWnd;
    pHotKey->fsModifiers = fsModifiers;
    pHotKey->vk = vk;
    pHotKey->id = id;
 
    /* Insert the hotkey into the global list */
    pHotKey->pNext = gphkFirst;
    gphkFirst = pHotKey;
 
    return TRUE;
}

Referenced by NtUserRegisterHotKey(), NtUserSetShellWindowEx(), RawInputThreadMain(), and SetDebugHotKeys().

UserUnregisterHotKey()

BOOL FASTCALL UserUnregisterHotKey	(	PWND	pWnd,
		int	id
	)

Definition at line 499 of file hotkey.c.

{
    PHOT_KEY pHotKey = gphkFirst, phkNext, *pLink = &gphkFirst;
    BOOL bRet = FALSE;
 
    while (pHotKey)
    {
        /* Save next ptr for later use */
        phkNext = pHotKey->pNext;
 
        /* Should we delete this hotkey? */
        if (pHotKey->pWnd == pWnd && pHotKey->id == id)
        {
            /* Update next ptr for previous hotkey and free memory */
            *pLink = phkNext;
            ExFreePoolWithTag(pHotKey, USERTAG_HOTKEY);
 
            bRet = TRUE;
        }
        else
        {
            /* This hotkey will stay, use its next ptr */
            pLink = &pHotKey->pNext;
        }
 
        /* Move to the next entry */
        pHotKey = phkNext;
    }
 
    return bRet;
}

Referenced by NtUserUnregisterHotKey(), and SetDebugHotKeys().