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_REACTOS   -8
#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	StartDebugHotKeys (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_REACTOS

#define IDHK_REACTOS   -8

Definition at line 17 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.

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 177 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
                {
                    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 313 of file hotkey.c.

{
    PHOT_KEY pHotKey = gphkFirst;
 
    WARN("DefWndGetHotKey\n");
 
    while (pHotKey)
    {
        if (pHotKey->pWnd == pWnd && pHotKey->id == IDHK_REACTOS)
        {
            /* We have found it */
            return MAKELONG(pHotKey->vk, 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 340 of file hotkey.c.

{
    UINT fsModifiers, vk;
    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, and VK_TAB are invalid hot keys.
    if (LOWORD(wParam) == VK_ESCAPE ||
        LOWORD(wParam) == VK_SPACE ||
        LOWORD(wParam) == VK_TAB)
    {
        return -1;
    }
 
    vk = LOWORD(wParam);
    fsModifiers = HIWORD(wParam);
 
    if (wParam)
    {
        pHotKey = gphkFirst;
        while (pHotKey)
        {
            if (pHotKey->fsModifiers == fsModifiers &&
                pHotKey->vk == vk &&
                pHotKey->id == IDHK_REACTOS)
            {
                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 &&
            pHotKey->id == IDHK_REACTOS)
        {
            /* 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_REACTOS; // 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;
        pHotKey->fsModifiers = fsModifiers;
        pHotKey->vk = vk;
    }
    else if (pHotKey)
    {
        /* Remove hotkey */
        *pLink = pHotKey->pNext;
        ExFreePoolWithTag(pHotKey, USERTAG_HOTKEY);
    }
 
    return iRet;
}

Referenced by IntDefWindowProc().

StartDebugHotKeys()

VOID FASTCALL StartDebugHotKeys

(

VOID

)

Definition at line 44 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 121 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 91 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 431 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 479 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().