hotkey.c File Reference

#include <win32k.h>

Include dependency graph for hotkey.c:

Go to the source code of this file.

Macros
#define	IsWindowHotKey(pHK)   ( (pHK)->pti == NULL && (pHK)->id == IDHK_WNDKEY )

Functions
	DBG_DEFAULT_CHANNEL (UserHotkey)
VOID FASTCALL	StartDebugHotKeys (VOID)
static UINT FASTCALL	IntGetModifiers (PBYTE pKeyState)
static UCHAR	IntSwapModHKF (UINT Input)
VOID FASTCALL	UnregisterWindowHotKeys (PWND pWnd)
VOID FASTCALL	UnregisterThreadHotKeys (PTHREADINFO pti)
static PHOT_KEY FASTCALL	IsHotKey (UINT fsModifiers, WORD wVk)
BOOL NTAPI	co_UserProcessHotKeys (WORD wVk, BOOL bIsDown)
UINT FASTCALL	DefWndGetHotKey (PWND pWnd)
INT FASTCALL	DefWndSetHotKey (PWND pWnd, WPARAM wParam)
BOOL FASTCALL	UserRegisterHotKey (PWND pWnd, int id, UINT fsModifiers, UINT vk)
BOOL FASTCALL	UserUnregisterHotKey (PWND pWnd, int id)
BOOL APIENTRY	NtUserRegisterHotKey (HWND hWnd, int id, UINT fsModifiers, UINT vk)
BOOL APIENTRY	NtUserUnregisterHotKey (HWND hWnd, int id)

Variables
PHOT_KEY	gphkFirst = NULL
UINT	gfsModOnlyCandidate

Macro Definition Documentation

IsWindowHotKey

#define IsWindowHotKey

(

pHK

)

( (pHK)->pti == NULL && (pHK)->id == IDHK_WNDKEY )

Definition at line 43 of file hotkey.c.

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

DBG_DEFAULT_CHANNEL()

DBG_DEFAULT_CHANNEL

(

UserHotkey

)

DefWndGetHotKey()

UINT FASTCALL DefWndGetHotKey

(

PWND

pWnd

)

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

IntGetModifiers()

static UINT FASTCALL IntGetModifiers ( PBYTE  pKeyState )

static

Definition at line 68 of file hotkey.c.

{
    UINT fModifiers = 0;
 
    if (IS_KEY_DOWN(pKeyState, VK_SHIFT))
        fModifiers |= MOD_SHIFT;
 
    if (IS_KEY_DOWN(pKeyState, VK_CONTROL))
        fModifiers |= MOD_CONTROL;
 
    if (IS_KEY_DOWN(pKeyState, VK_MENU))
        fModifiers |= MOD_ALT;
 
    if (IS_KEY_DOWN(pKeyState, VK_LWIN) || IS_KEY_DOWN(pKeyState, VK_RWIN))
        fModifiers |= MOD_WIN;
 
    return fModifiers;
}

Referenced by co_UserProcessHotKeys().

IntSwapModHKF()

static UCHAR IntSwapModHKF ( UINT  Input )

inlinestatic

Definition at line 94 of file hotkey.c.

{
    return (Input & 2) | ((Input & 1) << 2) | ((Input >> 2) & 1);
}

Referenced by DefWndGetHotKey(), and DefWndSetHotKey().

IsHotKey()

static PHOT_KEY FASTCALL IsHotKey ( UINT  fsModifiers, WORD  wVk  )

static

Definition at line 165 of file hotkey.c.

{
    PHOT_KEY pHotKey = gphkFirst;
 
    while (pHotKey)
    {
        if (pHotKey->fsModifiers == fsModifiers &&
            pHotKey->vk == wVk)
        {
            /* We have found it */
            return pHotKey;
        }
 
        /* Move to the next entry */
        pHotKey = pHotKey->pNext;
    }
 
    return NULL;
}

Referenced by co_UserProcessHotKeys(), NtUserRegisterHotKey(), and UserRegisterHotKey().

NtUserRegisterHotKey()

BOOL APIENTRY NtUserRegisterHotKey	(	HWND	hWnd,
		int	id,
		UINT	fsModifiers,
		UINT	vk
	)

Definition at line 532 of file hotkey.c.

{
    PHOT_KEY pHotKey;
    PWND pWnd = NULL;
    PTHREADINFO pHotKeyThread;
    BOOL bRet = FALSE;
 
    TRACE("Enter NtUserRegisterHotKey\n");
 
    if (fsModifiers & ~(MOD_ALT|MOD_CONTROL|MOD_SHIFT|MOD_WIN)) // FIXME: Does Win2k3 support MOD_NOREPEAT?
    {
        WARN("Invalid modifiers: %x\n", fsModifiers);
        EngSetLastError(ERROR_INVALID_FLAGS);
        return 0;
    }
 
    UserEnterExclusive();
 
    /* Find hotkey thread */
    if (hWnd == NULL)
    {
        pHotKeyThread = gptiCurrent;
    }
    else
    {
        pWnd = UserGetWindowObject(hWnd);
        if (!pWnd)
            goto cleanup;
 
        pHotKeyThread = pWnd->head.pti;
 
        /* Fix wine msg "Window on another thread" test_hotkey */
        if (pWnd->head.pti != gptiCurrent)
        {
           EngSetLastError(ERROR_WINDOW_OF_OTHER_THREAD);
           WARN("Must be from the same Thread.\n");
           goto cleanup;
        }
    }
 
    /* Check for existing hotkey */
    if (IsHotKey(fsModifiers, vk))
    {
        EngSetLastError(ERROR_HOTKEY_ALREADY_REGISTERED);
        WARN("Hotkey already exists\n");
        goto cleanup;
    }
 
    /* Create new hotkey */
    pHotKey = ExAllocatePoolWithTag(PagedPool, sizeof(HOT_KEY), USERTAG_HOTKEY);
    if (pHotKey == NULL)
    {
        EngSetLastError(ERROR_NOT_ENOUGH_MEMORY);
        goto cleanup;
    }
 
    pHotKey->pti = pHotKeyThread;
    pHotKey->pWnd = pWnd;
    pHotKey->fsModifiers = fsModifiers;
    pHotKey->vk = vk;
    pHotKey->id = id;
 
    /* Insert hotkey to the global list */
    pHotKey->pNext = gphkFirst;
    gphkFirst = pHotKey;
 
    bRet = TRUE;
 
cleanup:
    TRACE("Leave NtUserRegisterHotKey, ret=%i\n", bRet);
    UserLeave();
    return bRet;
}

Referenced by RegisterHotKey().

NtUserUnregisterHotKey()

BOOL APIENTRY NtUserUnregisterHotKey	(	HWND	hWnd,
		int	id
	)

Definition at line 611 of file hotkey.c.

{
    PHOT_KEY pHotKey = gphkFirst, phkNext, *pLink = &gphkFirst;
    BOOL bRet = FALSE;
    PWND pWnd = NULL;
 
    TRACE("Enter NtUserUnregisterHotKey\n");
    UserEnterExclusive();
 
    /* Fail if given window is invalid */
    if (hWnd && !(pWnd = UserGetWindowObject(hWnd)))
        goto cleanup;
 
    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;
    }
 
cleanup:
    TRACE("Leave NtUserUnregisterHotKey, ret=%i\n", bRet);
    UserLeave();
    return bRet;
}

StartDebugHotKeys()

VOID FASTCALL StartDebugHotKeys

(

VOID

)

Definition at line 46 of file hotkey.c.

{
    UINT vk = VK_F12;
    UserUnregisterHotKey(PWND_BOTTOM, IDHK_F12);
    UserUnregisterHotKey(PWND_BOTTOM, IDHK_SHIFTF12);
    if (!ENHANCED_KEYBOARD(gKeyboardInfo.KeyboardIdentifier))
    {
        vk = VK_SUBTRACT;
    }
    UserRegisterHotKey(PWND_BOTTOM, IDHK_SHIFTF12, MOD_SHIFT, vk);
    UserRegisterHotKey(PWND_BOTTOM, IDHK_F12, 0, vk);
    TRACE("Start up the debugger hotkeys!! If you see this you enabled debugprints. 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

pWnd

)

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 451 of file hotkey.c.

{
    PHOT_KEY pHotKey;
    PTHREADINFO pHotKeyThread;
 
    /* Find hotkey thread */
    if (pWnd == NULL || pWnd == PWND_BOTTOM)
    {
        pHotKeyThread = PsGetCurrentThreadWin32Thread();
    }
    else
    {
        pHotKeyThread = pWnd->head.pti;
    }
 
    /* Check for existing hotkey */
    if (IsHotKey(fsModifiers, vk))
    {
        EngSetLastError(ERROR_HOTKEY_ALREADY_REGISTERED);
        WARN("Hotkey already exists\n");
        return FALSE;
    }
 
    /* Create 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 hotkey to the global list */
    pHotKey->pNext = gphkFirst;
    gphkFirst = pHotKey;
 
    return TRUE;
}

Referenced by NtUserSetShellWindowEx(), RawInputThreadMain(), and StartDebugHotKeys().

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

Variable Documentation

gfsModOnlyCandidate

UINT gfsModOnlyCandidate

Definition at line 39 of file hotkey.c.

Referenced by co_UserProcessHotKeys().

gphkFirst

PHOT_KEY gphkFirst = NULL

Definition at line 38 of file hotkey.c.

Referenced by DefWndGetHotKey(), DefWndSetHotKey(), IsHotKey(), NtUserRegisterHotKey(), NtUserUnregisterHotKey(), UnregisterThreadHotKeys(), UnregisterWindowHotKeys(), UserRegisterHotKey(), and UserUnregisterHotKey().