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	SetDebugHotKeys (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(), and UserRegisterHotKey().

NtUserRegisterHotKey()

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

Definition at line 539 of file hotkey.c.

{
    PWND pWnd = NULL;
    BOOL bRet = FALSE;
 
    TRACE("Enter NtUserRegisterHotKey\n");
 
    // FIXME: Does Win2k3 support MOD_NOREPEAT?
    if (fsModifiers & ~(MOD_ALT | MOD_CONTROL | MOD_SHIFT | MOD_WIN))
    {
        WARN("Invalid modifiers: %x\n", fsModifiers);
        EngSetLastError(ERROR_INVALID_FLAGS);
        return FALSE;
    }
 
    UserEnterExclusive();
 
    /* Check the hotkey thread */
    if (hWnd == NULL)
    {
        pWnd = NULL;
    }
    else
    {
        pWnd = UserGetWindowObject(hWnd);
        if (!pWnd)
            goto cleanup;
 
        /* FIXME?? "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;
        }
    }
 
    bRet = UserRegisterHotKey(pWnd, id, fsModifiers, vk);
 
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 588 of file hotkey.c.

{
    BOOL bRet = FALSE;
    PWND pWnd = NULL;
 
    TRACE("Enter NtUserUnregisterHotKey\n");
    UserEnterExclusive();
 
    /* Fail if the given window is invalid */
    if (hWnd && !(pWnd = UserGetWindowObject(hWnd)))
        goto cleanup;
 
    bRet = UserUnregisterHotKey(pWnd, id);
 
cleanup:
    TRACE("Leave NtUserUnregisterHotKey, ret=%i\n", bRet);
    UserLeave();
    return bRet;
}

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

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

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(), UnregisterThreadHotKeys(), UnregisterWindowHotKeys(), UserRegisterHotKey(), and UserUnregisterHotKey().