Хуки и заморозка курсора во время отладки

#ifndef HOOKS_H
#define HOOKS_H
 
#include <QDebug>
#include <Windows.h>
#include <iostream>
#include <thread>
#include "datacontainer.h"
 
struct KeyInfo
{
    const char* keyName;
    int vkCode;
};
const KeyInfo allKeys[] = {
    { "VK_LBUTTON", VK_LBUTTON },
    { "VK_RBUTTON", VK_RBUTTON },
    { "VK_CANCEL", VK_CANCEL },
    { "VK_MBUTTON", VK_MBUTTON },
    { "VK_XBUTTON1", VK_XBUTTON1 },
    { "VK_XBUTTON2", VK_XBUTTON2 },
    { "VK_BACK", VK_BACK },
    { "VK_TAB", VK_TAB },
    { "VK_CLEAR", VK_CLEAR },
    { "VK_RETURN", VK_RETURN },
    { "VK_SHIFT", VK_SHIFT },
    { "VK_CONTROL", VK_CONTROL },
    { "VK_MENU", VK_MENU },
    { "VK_PAUSE", VK_PAUSE },
    { "VK_CAPITAL", VK_CAPITAL },
    { "VK_KANA", VK_KANA },
    { "VK_HANGUL", VK_HANGUL },
    { "VK_IME_ON", VK_IME_ON },
    { "VK_JUNJA", VK_JUNJA },
    { "VK_FINAL", VK_FINAL },
    { "VK_HANJA", VK_HANJA },
    { "VK_KANJI", VK_KANJI },
    { "VK_IME_OFF", VK_IME_OFF },
    { "VK_ESCAPE", VK_ESCAPE },
    { "VK_CONVERT", VK_CONVERT },
    { "VK_NONCONVERT", VK_NONCONVERT },
    { "VK_ACCEPT", VK_ACCEPT },
    { "VK_MODECHANGE", VK_MODECHANGE },
    { "VK_SPACE", VK_SPACE },
    { "VK_PRIOR", VK_PRIOR },
    { "VK_NEXT", VK_NEXT },
    { "VK_END", VK_END },
    { "VK_HOME", VK_HOME },
    { "VK_LEFT", VK_LEFT },
    { "VK_UP", VK_UP },
    { "VK_RIGHT", VK_RIGHT },
    { "VK_DOWN", VK_DOWN },
    { "VK_SELECT", VK_SELECT },
    { "VK_PRINT", VK_PRINT },
    { "VK_EXECUTE", VK_EXECUTE },
    { "VK_SNAPSHOT", VK_SNAPSHOT },
    { "VK_INSERT", VK_INSERT },
    { "VK_DELETE", VK_DELETE },
    { "VK_HELP", VK_HELP },
    { "VK_0", 0x30 },
    { "VK_1", 0x31 },
    { "VK_2", 0x32 },
    { "VK_3", 0x33 },
    { "VK_4", 0x34 },
    { "VK_5", 0x35 },
    { "VK_6", 0x36 },
    { "VK_7", 0x37 },
    { "VK_8", 0x38 },
    { "VK_9", 0x39 },
    { "VK_A", 0x41 },
    { "VK_B", 0x42 },
    { "VK_C", 0x43 },
    { "VK_D", 0x44 },
    { "VK_E", 0x45 },
    { "VK_F", 0x46 },
    { "VK_G", 0x47 },
    { "VK_H", 0x48 },
    { "VK_I", 0x49 },
    { "VK_J", 0x4A },
    { "VK_K", 0x4B },
    { "VK_L", 0x4C },
    { "VK_M", 0x4D },
    { "VK_N", 0x4E },
    { "VK_O", 0x4F },
    { "VK_P", 0x50 },
    { "VK_Q", 0x51 },
    { "VK_R", 0x52 },
    { "VK_S", 0x53 },
    { "VK_T", 0x54 },
    { "VK_U", 0x55 },
    { "VK_V", 0x56 },
    { "VK_W", 0x57 },
    { "VK_X", 0x58 },
    { "VK_Y", 0x59 },
    { "VK_Z", 0x5A },
    { "VK_LWIN", VK_LWIN },
    { "VK_RWIN", VK_RWIN },
    { "VK_APPS", VK_APPS },
    { "VK_SLEEP", VK_SLEEP },
    { "VK_NUMPAD0", VK_NUMPAD0 },
    { "VK_NUMPAD1", VK_NUMPAD1 },
    { "VK_NUMPAD2", VK_NUMPAD2 },
    { "VK_NUMPAD3", VK_NUMPAD3 },
    { "VK_NUMPAD4", VK_NUMPAD4 },
    { "VK_NUMPAD5", VK_NUMPAD5 },
    { "VK_NUMPAD6", VK_NUMPAD6 },
    { "VK_NUMPAD7", VK_NUMPAD7 },
    { "VK_NUMPAD8", VK_NUMPAD8 },
    { "VK_NUMPAD9", VK_NUMPAD9 },
    { "VK_MULTIPLY", VK_MULTIPLY },
    { "VK_ADD", VK_ADD },
    { "VK_SEPARATOR", VK_SEPARATOR },
    { "VK_SUBTRACT", VK_SUBTRACT },
    { "VK_DECIMAL", VK_DECIMAL },
    { "VK_DIVIDE", VK_DIVIDE },
    { "VK_F1", VK_F1 },
    { "VK_F2", VK_F2 },
    { "VK_F3", VK_F3 },
    { "VK_F4", VK_F4 },
    { "VK_F5", VK_F5 },
    { "VK_F6", VK_F6 },
    { "VK_F7", VK_F7 },
    { "VK_F8", VK_F8 },
    { "VK_F9", VK_F9 },
    { "VK_F10", VK_F10 },
    { "VK_F11", VK_F11 },
    { "VK_F12", VK_F12 },
    { "VK_F13", VK_F13 },
    { "VK_F14", VK_F14 },
    { "VK_F15", VK_F15 },
    { "VK_F16", VK_F16 },
    { "VK_F17", VK_F17 },
    { "VK_F18", VK_F18 },
    { "VK_F19", VK_F19 },
    { "VK_F20", VK_F20 },
    { "VK_F21", VK_F21 },
    { "VK_F22", VK_F22 },
    { "VK_F23", VK_F23 },
    { "VK_F24", VK_F24 }
};
 
class HOOKS
{
public:
    static HHOOK _hook;
    static HHOOK _mouseHook;
    static KBDLLHOOKSTRUCT kbdStruct;
    static std::thread hookThread; // Поток для хука
    static bool SetupHook;
    static std::string SetupHookName;
    static bool SetupPressHook;
    static std::string SetupPressHookName;
    static DWORD threadId; //
    static bool DebugHookOFF;
 
    static void initializeHook()
    {
        running = true;
        // Запуск хука в новом потоке
        if (!DebugHookOFF) {
            hookThread = std::thread(thLogic);
        }
 
    }
 
 
    static void destroyInstance()
    {
        // Дополнительные действия при удалении экземпляра (если необходимо)
        // ...
        running = false;
        PostThreadMessage(threadId, WM_QUIT, 0, 0);
 
        ReleaseHook();
 
        //hookThread.~thread();
        // Дождитесь завершения потока
        if (hookThread.joinable())
            hookThread.join();
 
    }
    static const char* GetKeyName(int vkCode)
    {
        for (const auto& key : allKeys)
        {
            if (key.vkCode == vkCode)
            {
                return key.keyName;
            }
        }
        return "Unknown";
    }
    static int GetKeyCode(const std::string& keyName) {
        for (const auto& key : allKeys) {
            if (key.keyName == keyName) {
                return key.vkCode;
            }
        }
        std::cout << "Неизвестное название ключа: " << keyName << std::endl;
        return -1; // Вернуть какой-то недопустимый код (например, -1)
    }
 
private:
 
    static std::atomic<bool> running;
    static void thLogic() {
        threadId = GetCurrentThreadId();
        SetHook();
        MSG msg;
        while (running && GetMessage(&msg, NULL, 0, 0))
        {
            // Обработка сообщений
        }
 
    }
 
 
    static void SetHook() {
 
        if (!(_hook = SetWindowsHookEx(WH_KEYBOARD_LL, HookCallback, NULL, 0)))
        {
            qDebug() << "Failed to install hook!" << "";
 
        }
        // Установка хука для событий мыши
        if (!(_mouseHook = SetWindowsHookEx(WH_MOUSE_LL, MouseHookCallback, NULL, 0))) {
            qDebug() << "Failed to install mouse hook!";
        }
 
    };
    static LRESULT __stdcall HookCallback(int nCode, WPARAM wParam, LPARAM lParam) {
 
        if (nCode >= 0)
        {
            // the action is valid: HC_ACTION.
            if (wParam == WM_KEYDOWN)
            {
                // lParam is the pointer to the struct containing the data needed, so cast and assign it to kdbStruct.
                kbdStruct = *((KBDLLHOOKSTRUCT*)lParam);
 
                //std::cout << "Key Down >>" << " - " << GetKeyName(kbdStruct.vkCode) << " Key int "<< kbdStruct.vkCode << std::endl;
                DataContainer::instance().KeyDownSend(kbdStruct.vkCode);
 
                std::string KeyString(GetKeyName(kbdStruct.vkCode));
               
            }
            else if (wParam == WM_KEYUP) {
                kbdStruct = *((KBDLLHOOKSTRUCT*)lParam);
                //std::cout << "Key Up >>" << " - " << GetKeyName(kbdStruct.vkCode) << std::endl;
                DataContainer::instance().KeyUpSend(kbdStruct.vkCode);
 
                std::string KeyString(GetKeyName(kbdStruct.vkCode));
               
            }
 
        }
 
        // call the next hook in the hook chain. This is nessecary or your hook chain will break and the hook stops
        return CallNextHookEx(_hook, nCode, wParam, lParam);
 
    };
    static LRESULT __stdcall MouseHookCallback(int nCode, WPARAM wParam, LPARAM lParam) {
 
        if (nCode >= 0)
        {
 
            // the action is valid: HC_ACTION.
            if (wParam == WM_LBUTTONDOWN) {
                // Получение координат клика
                POINT cursorPos;
                GetCursorPos(&cursorPos);
                std::cout << "Left Mouse Button Down >> X: " << cursorPos.x << ", Y: " << cursorPos.y << std::endl;
                DataContainer::instance().LeftMouseClickSend(cursorPos.x, cursorPos.y);
            }
            else if (wParam == WM_RBUTTONDOWN) {
                // Получение координат клика
                POINT cursorPos;
                GetCursorPos(&cursorPos);
                std::cout << "Right Mouse Button Down >> X: " << cursorPos.x << ", Y: " << cursorPos.y << std::endl;
                DataContainer::instance().RightMouseClickSend(cursorPos.x, cursorPos.y);
            }
            else if (wParam == WM_MBUTTONDOWN) {
                // Получение координат клика
                POINT cursorPos;
                GetCursorPos(&cursorPos);
                std::cout << "Middle Mouse Button Down >> X: " << cursorPos.x << ", Y: " << cursorPos.y << std::endl;
                DataContainer::instance().MiddleMouseClickSend(cursorPos.x, cursorPos.y);
 
            }
            else if (wParam == WM_MOUSEWHEEL) {
                MSLLHOOKSTRUCT* mouselparam = (MSLLHOOKSTRUCT*)lParam;
                short delta = HIWORD(mouselparam->mouseData);
                std::cout << "Mouse Wheel Scrolled >> " << delta << std::endl;
                DataContainer::instance().MouseWheelSend(delta);
            }
 
 
        }
 
        // call the next hook in the hook chain. This is nessecary or your hook chain will break and the hook stops
        return CallNextHookEx(_hook, nCode, wParam, lParam);
 
    };
    static void ReleaseHook()
    {
        UnhookWindowsHookEx(_hook);
        UnhookWindowsHookEx(_mouseHook);
        qDebug() << "[ReleaseHook] hook deleted" << "";
    }
 
 
};
 
#endif // HOOKS_H