Source Code

#include <windows.h>
#include <wtypes.h>
#include <sstream>
#include <vector>
#include <iostream>
#include <thread>
#include <string>
#include <map>

bool getKeyState_(unsigned VKID) {
    return ((GetAsyncKeyState(VKID) & 0x8000) != 0);
}

class MouseLocker {
public:
    short m_resolutionHeight;
    short m_resolutionWidth;
    short m_update_interval;

    unsigned __int8 m_virtualkey_code;

    bool m_thread_terminator;
    bool m_cursor_worker_active;
    bool m_debug_thread_active;

    bool m_makesound;

    short m_soundFrequency;
    short m_soundDuration;

    std::thread* m_cursor_thread;
    std::thread* m_debug_thread;

    std::pair<std::string, long> executeCommand_(std::string command) {
        std::string command_output;

        FILE* read_pipe = _popen(command.c_str(), "r");

        if (!read_pipe) {
            std::cout << "Failed to open pipe to system command: " << command << std::endl;
            return std::make_pair(command_output, 1);
        }

        char buffer[1024];

        try {
            while (fgets(buffer, sizeof(buffer), read_pipe) != NULL)
                command_output.append(buffer);
        } catch (...) {
            std::cout << "Exception when reading from pipe." << std::endl;
            _pclose(read_pipe);
            return std::make_pair(command_output, 2);
        }

        return std::make_pair(command_output, 0);
    }

    void cursor_worker_() {
        std::pair<short, short> coordinates;
        coordinates.first = std::round(m_resolutionWidth / 2);
        coordinates.second = std::round(m_resolutionHeight / 2);

        while (!m_thread_terminator) {
            while (m_cursor_worker_active) {
                SetCursorPos(coordinates.first, coordinates.second);
                Sleep(m_update_interval);
            }
            Sleep(500);
        }
    }

    void debug_info_worker_() {
        while (!m_thread_terminator && m_debug_thread_active) {
            system("cls");
            std::stringstream vkid_hex; vkid_hex << std::uppercase << std::hex << (int)m_virtualkey_code;
            std::cout << "Virtual Key Code: 0x" << vkid_hex.str() << std::endl;
            std::cout << "Virtual Key State: " << (int)((GetAsyncKeyState(m_virtualkey_code) & 0x8000) != 0) << " (SLOW) " << std::endl;
            std::cout << "Cursor Worker Active: " << m_cursor_worker_active << std::endl;
            std::cout << "Base Resolution: " << m_resolutionWidth << "x" << m_resolutionHeight << std::endl;
            std::cout << "Cursor Target Position: " << std::round(m_resolutionWidth / 2) << "x" << std::round(m_resolutionHeight / 2) << std::endl;
            Sleep(500);
        }
    }

    MouseLocker() {
        /* Resolution setup */
        RECT desktopGeometry;
        HWND desktopWindow = GetDesktopWindow();
        GetWindowRect(desktopWindow, &desktopGeometry);
        m_resolutionHeight = desktopGeometry.bottom;
        m_resolutionWidth = desktopGeometry.right;

        /* Cursor Thread Setup */
        m_virtualkey_code = 0x6A;
        m_update_interval = 30;

        /* Threading Terminator Setup */
        m_cursor_worker_active = false;
        m_thread_terminator = false;
        m_debug_thread_active = false;

        /* Sound Setup */
        m_makesound = true;
        m_soundFrequency = 1000;
        m_soundDuration = 10;
    }

    void spawn () {
        /* Thrading Setup */
        m_cursor_thread = new std::thread(std::bind(&MouseLocker::cursor_worker_, this));
        m_debug_thread = new std::thread(std::bind(&MouseLocker::debug_info_worker_, this));
    }

    ~MouseLocker() {
        m_cursor_worker_active = false;
        m_thread_terminator = true;

        Sleep(1000);

        delete m_cursor_thread;
        delete m_debug_thread;
    }

    void start() {
        while (true) {
            bool VKID_State = (GetAsyncKeyState(m_virtualkey_code) & 0x8000) != 0;
            if (VKID_State) {
                m_cursor_worker_active = !m_cursor_worker_active;
                if(m_makesound) Beep(m_soundFrequency, m_soundDuration);
            }
            Sleep(100);
        }
    }
};

int main(int argc, char* argv[]) {
    MouseLocker mouseLocker = MouseLocker();
    std::vector<std::string> arguments;

    std::map<std::string, unsigned long*> resolver{
        { "vkid", (unsigned long*)&mouseLocker.m_virtualkey_code },
        { "width",(unsigned long*)&mouseLocker.m_resolutionWidth },
        { "height", (unsigned long*)&mouseLocker.m_resolutionHeight },
        { "debug", (unsigned long*)&mouseLocker.m_debug_thread_active },
        { "interval", (unsigned long*)&mouseLocker.m_update_interval },
        {"sound", (unsigned long*)&mouseLocker.m_makesound},
        {"sound_freq", (unsigned long*)&mouseLocker.m_soundFrequency},
        {"sound_dur", (unsigned long*)&mouseLocker.m_soundDuration}
    };

    for (int i = 1; i < argc; i++) arguments.push_back(std::string(argv[i]));
    for (int i = 0; i < arguments.size(); i++) {
        std::string& argument = arguments.at(i);
        std::vector<std::string> split;
        std::string buffer;

        for (int c = 0; c < argument.size(); c++) {
            char& cchar = argument.at(c);
            if (cchar == '=') {
                split.push_back(buffer);
                buffer.clear();
            } else {
                buffer.push_back(cchar);
            }
        }

        if (buffer.size() > 0) split.push_back(buffer);
        buffer.clear();

        std::string key = split.at(0);
        unsigned long value;

        bool hexadecimal = false;
        for (int c = 0; c < split.at(1).size(); c++) {
            char& cchar = split.at(1).at(c);
            if (cchar < 48 || cchar > 57) {
                hexadecimal = true;
                break;
            }
        }

        if (hexadecimal) {
            std::stringstream stream;
            stream << std::hex << split.at(1);
            stream >> value;
        } else {
            value = std::stoi(split.at(1));
        }

        *resolver.at(key) = value;
    }

    mouseLocker.spawn();
    mouseLocker.start();

    std::cin.get();
    return EXIT_SUCCESS;
}