PowerToys/src/modules/shortcut_guide/target_state.cpp

251 lines
6.7 KiB
C++
Raw Normal View History

#include "pch.h"
#include "target_state.h"
#include <common/start_visible.h>
#include "keyboard_state.h"
#include <common/shared_constants.h>
#include <common/logger/logger.h>
TargetState::TargetState(int ms_delay) :
// TODO: All this processing should be done w/o a separate thread etc. in pre_wnd_proc of winkey_popup to avoid
// multithreading. Use SetTimer for delayed events
delay(std::chrono::milliseconds(ms_delay)),
thread(&TargetState::thread_proc, this)
{
}
constexpr unsigned VK_S = 0x53;
bool TargetState::signal_event(unsigned vk_code, bool key_down)
{
std::unique_lock lock(mutex);
// Ignore repeated key presses
if (!events.empty() && events.back().key_down == key_down && events.back().vk_code == vk_code)
{
return false;
}
// Hide the overlay when WinKey + Shift + S is pressed
if (key_down && state == Shown && vk_code == VK_S && (GetKeyState(VK_LSHIFT) || GetKeyState(VK_RSHIFT)))
{
// We cannot use normal hide() here, there is stuff that needs deinitialization.
// It can be safely done when the user releases the WinKey.
instance->quick_hide();
}
const bool win_key_released = !key_down && (vk_code == VK_LWIN || vk_code == VK_RWIN);
constexpr auto overlay_fade_in_animation_time = std::chrono::milliseconds(300);
const auto overlay_active = state == Shown && (std::chrono::system_clock::now() - signal_timestamp > overlay_fade_in_animation_time);
const bool suppress_win_release = win_key_released && (state == ForceShown || overlay_active) && !nonwin_key_was_pressed_during_shown;
events.push_back({ key_down, vk_code });
lock.unlock();
cv.notify_one();
if (suppress_win_release)
{
2020-09-22 19:12:19 +08:00
// Send a 0xFF VK code, which is outside of the VK code range, to prevent
// the start menu from appearing.
INPUT input[3] = { {}, {}, {} };
input[0].type = INPUT_KEYBOARD;
2020-09-22 19:12:19 +08:00
input[0].ki.wVk = 0xFF;
input[0].ki.dwExtraInfo = CommonSharedConstants::KEYBOARDMANAGER_INJECTED_FLAG;
input[1].type = INPUT_KEYBOARD;
2020-09-22 19:12:19 +08:00
input[1].ki.wVk = 0xFF;
input[1].ki.dwFlags = KEYEVENTF_KEYUP;
input[1].ki.dwExtraInfo = CommonSharedConstants::KEYBOARDMANAGER_INJECTED_FLAG;
input[2].type = INPUT_KEYBOARD;
input[2].ki.wVk = vk_code;
input[2].ki.dwFlags = KEYEVENTF_KEYUP;
input[2].ki.dwExtraInfo = CommonSharedConstants::KEYBOARDMANAGER_INJECTED_FLAG;
SendInput(3, input, sizeof(INPUT));
}
return suppress_win_release;
}
void TargetState::was_hidden()
{
std::unique_lock<std::recursive_mutex> lock(mutex);
// Ignore callbacks from the D2DOverlayWindow
if (state == ForceShown)
{
return;
}
state = Hidden;
events.clear();
lock.unlock();
cv.notify_one();
}
void TargetState::exit()
{
std::unique_lock lock(mutex);
events.clear();
state = Exiting;
lock.unlock();
cv.notify_one();
thread.join();
}
KeyEvent TargetState::next()
{
auto e = events.front();
events.pop_front();
return e;
}
void TargetState::handle_hidden()
{
std::unique_lock lock(mutex);
if (events.empty())
cv.wait(lock);
if (events.empty() || state == Exiting)
return;
auto event = next();
if (event.key_down && (event.vk_code == VK_LWIN || event.vk_code == VK_RWIN))
{
state = Timeout;
winkey_timestamp = std::chrono::system_clock::now();
}
}
void TargetState::handle_shown(const bool forced)
{
std::unique_lock lock(mutex);
if (events.empty())
{
cv.wait(lock);
}
if (events.empty() || state == Exiting)
{
return;
}
auto event = next();
if (event.vk_code == VK_LWIN || event.vk_code == VK_RWIN)
{
if (!forced && (!event.key_down || !winkey_held()))
{
state = Hidden;
}
return;
}
if (event.key_down)
{
nonwin_key_was_pressed_during_shown = true;
lock.unlock();
instance->on_held_press(event.vk_code);
}
}
void TargetState::thread_proc()
{
while (true)
{
switch (state)
{
case Hidden:
handle_hidden();
break;
case Timeout:
try
{
handle_timeout();
}
catch (...)
{
Logger::critical("Timeout, handle_timeout failed.");
}
break;
case Shown:
try
{
handle_shown(false);
}
catch (...)
{
Logger::critical("Shown, handle_shown failed.");
}
break;
case ForceShown:
try
{
handle_shown(true);
}
catch (...)
{
Logger::critical("ForceShown, handle_shown failed.");
}
break;
case Exiting:
default:
return;
}
}
}
void TargetState::handle_timeout()
{
std::unique_lock lock(mutex);
auto wait_time = delay - (std::chrono::system_clock::now() - winkey_timestamp);
if (events.empty())
{
cv.wait_for(lock, wait_time);
}
if (state == Exiting)
{
return;
}
// Skip all VK_*WIN-down events
while (!events.empty())
{
auto event = events.front();
if (event.key_down && (event.vk_code == VK_LWIN || event.vk_code == VK_RWIN))
events.pop_front();
else
break;
}
// If we've detected that a user is holding anything other than VK_*WIN or start menu is visible, we should hide
if (!events.empty() || !only_winkey_key_held() || is_start_visible())
{
state = Hidden;
return;
}
if (std::chrono::system_clock::now() - winkey_timestamp < delay)
{
return;
}
signal_timestamp = std::chrono::system_clock::now();
nonwin_key_was_pressed_during_shown = false;
state = Shown;
lock.unlock();
instance->on_held();
}
void TargetState::set_delay(int ms_delay)
{
std::unique_lock lock(mutex);
delay = std::chrono::milliseconds(ms_delay);
}
void TargetState::toggle_force_shown()
{
std::unique_lock lock(mutex);
events.clear();
if (state != ForceShown)
{
state = ForceShown;
instance->on_held();
}
else
{
state = Hidden;
}
}
bool TargetState::active() const
{
return state == ForceShown || state == Shown;
}