Function UpdateModifierState

Source/hook_include.cpp:210–647

#ifdef INCLUDE_KEYBD_HOOK
void UpdateModifierState(KBDLLHOOKSTRUCT &event, vk_type vk, sc_type sc, bool key_up, bool aIsSuppressed)
// Always use the parameter vk rather than event.vkCode because the caller or caller's caller
// might have adjusted vk, namely to make it a left/right specific modifier key rather than a
// neutral one.
{
	// This part is done even if the key is being ignored because we always want their status
	// to be correct *regardless* of whether the key is ignored.  This is especially important
	// in cases such as Shift-Alt-Tab and Alt-Tab both have substitutes.  NOTE: We don't want
	// the CapsLock/Numlock/Scrolllock section up here with it because for those cases, we
	// genuinely want to ignore them entirely when the hook itself sends a keybd_event for one
	// of them.
	// Since low-level (but not high level) keyboard hook supports left/right VKs, use
	// them in pref. to scan code because it's much more likely to be compatible with
	// non-English or non-std keyboards.

	// Below excludes KEY_IGNORE_ALL_EXCEPT_MODIFIER since that type of event should not
	// be ignored by this function.  UPDATE: KEY_PHYS_IGNORE is now considered to be something
	// that should not be ignored because if more than one instance has the hook installed,
	// it is possible for g_modifiersLR_logical_non_ignored to say that a key is down in one
	// instance when that instance's g_modifiersLR_logical doesn't say it's down, which is
	// definitely wrong.  So is now omitted from the below:
	bool is_not_ignored = event.dwExtraInfo != KEY_IGNORE;

	switch (vk)
	{
	// Normally (for physical key presses) the vk will be left/right specific.  However,
	// if another app calls keybd_event() or a similar function to inject input,
	// the generic key will be received if that's what was sent.
	// Try to keep the most often-pressed keys at the top for potentially better
	// performance (depends on how the compiler implements the switch stmt: jump table
	// vs. if-then-else tree):
	case VK_LSHIFT:
		if (key_up)
		{
			if (!aIsSuppressed)
			{
				g_modifiersLR_logical &= ~MOD_LSHIFT;
				// Even if is_not_ignored == true, this is updated unconditionally on key-up events
				// to ensure that g_modifiersLR_logical_non_ignored never says a key is down when
				// g_modifiersLR_logical says its up, which might otherwise happen in cases such
				// as alt-tab.  See this comment further below, where the operative word is "relied":
				// "key pushed ALT down, or relied upon it already being down, so go up".  UPDATE:
				// The above is no longer a concern because KeyEvent() now defaults to the mode
				// which causes our var "is_not_ignored" to be true here.  Only the Send command
				// overrides this default, and it takes responsibility for ensuring that the older
				// comment above never happens by forcing any down-modifiers to be up if they're
				// not logically down as reflected in g_modifiersLR_logical.  There's more
				// explanation for g_modifiersLR_logical_non_ignored in keyboard.h:
				if (is_not_ignored)
					g_modifiersLR_logical_non_ignored &= ~MOD_LSHIFT;
			}
			if (EventIsPhysical(event, vk, sc, key_up)) // Note that ignored events can be physical via KEYEVENT_PHYS()
			{
				g_modifiersLR_physical &= ~MOD_LSHIFT;
				g_PhysicalKeyState[VK_LSHIFT] = 0;
				g_PhysicalKeyState[VK_SHIFT] = g_PhysicalKeyState[VK_RSHIFT];  // Neutral is down if right is down.
			}
		}