Switch keyboard shortcuts depending on the running program

[PJMiller]

I have an idea for how Antimicrox could be improved.

What if the program had several sets of keystrokes stored and assigned to specific programs and switched between them depending on which program had the focus (the program which will receive the keystroke). If the program which was to receive the keystroke had no keymap assigned then there would be a Default set of keystrokes which could be used.

I am not a programmer so I asked an AI to generate this for me as an example, in this example the keymaps are stored as .XML files : -

#include <iostream>
#include <fstream>
#include <string>
#include <vector>
#include <map>
#include <unistd.h>
#include <fcntl.h>
#include <linux/input.h>
#include <X11/Xlib.h>
#include <X11/Xutil.h>
#include <X11/extensions/XTest.h>
#include <tinyxml2.h>

// Helper function to convert key name string to X11 keycode
KeyCode stringToKeyCode(Display* display, const std::string& keyName) {
    if (keyName == "A") return XKeysymToKeycode(display, XK_A);
    if (keyName == "B") return XKeysymToKeycode(display, XK_B);
    if (keyName == "C") return XKeysymToKeycode(display, XK_C);
    if (keyName == "D") return XKeysymToKeycode(display, XK_D);
    if (keyName == "E") return XKeysymToKeycode(display, XK_E);
    if (keyName == "F") return XKeysymToKeycode(display, XK_F);
    if (keyName == "G") return XKeysymToKeycode(display, XK_G);
    if (keyName == "H") return XKeysymToKeycode(display, XK_H);
    if (keyName == "I") return XKeysymToKeycode(display, XK_I);
    if (keyName == "J") return XKeysymToKeycode(display, XK_J);
    if (keyName == "K") return XKeysymToKeycode(display, XK_K);
    if (keyName == "L") return XKeysymToKeycode(display, XK_L);
    if (keyName == "M") return XKeysymToKeycode(display, XK_M);
    if (keyName == "N") return XKeysymToKeycode(display, XK_N);
    if (keyName == "O") return XKeysymToKeycode(display, XK_O);
    if (keyName == "P") return XKeysymToKeycode(display, XK_P);
    if (keyName == "Q") return XKeysymToKeycode(display, XK_Q);
    if (keyName == "R") return XKeysymToKeycode(display, XK_R);
    if (keyName == "S") return XKeysymToKeycode(display, XK_S);
    if (keyName == "T") return XKeysymToKeycode(display, XK_T);
    if (keyName == "U") return XKeysymToKeycode(display, XK_U);
    if (keyName == "V") return XKeysymToKeycode(display, XK_V);
    if (keyName == "W") return XKeysymToKeycode(display, XK_W);
    if (keyName == "X") return XKeysymToKeycode(display, XK_X);
    if (keyName == "Y") return XKeysymToKeycode(display, XK_Y);
    if (keyName == "Z") return XKeysymToKeycode(display, XK_Z);
    if (keyName == "SPACE") return XKeysymToKeycode(display, XK_space);
    if (keyName == "RETURN") return XKeysymToKeycode(display, XK_Return);
    if (keyName == "ESC") return XKeysymToKeycode(display, XK_Escape);
    if (keyName == "F1") return XKeysymToKeycode(display, XK_F1);
    if (keyName == "F2") return XKeysymToKeycode(display, XK_F2);
    if (keyName == "F3") return XKeysymToKeycode(display, XK_F3);
    if (keyName == "F4") return XKeysymToKeycode(display, XK_F4);
    if (keyName == "F5") return XKeysymToKeycode(display, XK_F5);
    if (keyName == "LEFT") return XKeysymToKeycode(display, XK_Left);
    if (keyName == "RIGHT") return XKeysymToKeycode(display, XK_Right);
    if (keyName == "UP") return XKeysymToKeycode(display, XK_Up);
    if (keyName == "DOWN") return XKeysymToKeycode(display, XK_Down);
    
    return 0;
}

// Parse key combination like "CTRL+A" or "CTRL+SHIFT+T"
void sendKeyCombination(Display* display, const std::string& keyCombo) {
    std::vector<std::string> modifiers;
    std::string mainKey = keyCombo;
    
    size_t pos = 0;
    while ((pos = mainKey.find('+')) != std::string::npos) {
        modifiers.push_back(mainKey.substr(0, pos));
        mainKey.erase(0, pos + 1);
    }
    
    KeyCode keyCode = stringToKeyCode(display, mainKey);
    if (keyCode == 0) {
        std::cerr << "Unknown key: " << mainKey << std::endl;
        return;
    }
    
    // Press modifiers
    for (const auto& mod : modifiers) {
        if (mod == "CTRL") XTestFakeKeyEvent(display, XKeysymToKeycode(display, XK_Control_L), True, 0);
        else if (mod == "ALT") XTestFakeKeyEvent(display, XKeysymToKeycode(display, XK_Alt_L), True, 0);
        else if (mod == "SHIFT") XTestFakeKeyEvent(display, XKeysymToKeycode(display, XK_Shift_L), True, 0);
        else if (mod == "SUPER") XTestFakeKeyEvent(display, XKeysymToKeycode(display, XK_Super_L), True, 0);
    }
    
    // Press and release main key
    XTestFakeKeyEvent(display, keyCode, True, 0);
    XTestFakeKeyEvent(display, keyCode, False, 0);
    
    // Release modifiers
    for (auto it = modifiers.rbegin(); it != modifiers.rend(); ++it) {
        if (*it == "CTRL") XTestFakeKeyEvent(display, XKeysymToKeycode(display, XK_Control_L), False, 0);
        else if (*it == "ALT") XTestFakeKeyEvent(display, XKeysymToKeycode(display, XK_Alt_L), False, 0);
        else if (*it == "SHIFT") XTestFakeKeyEvent(display, XKeysymToKeycode(display, XK_Shift_L), False, 0);
        else if (*it == "SUPER") XTestFakeKeyEvent(display, XKeysymToKeycode(display, XK_Super_L), False, 0);
    }
    
    XFlush(display);
}

class JoystickToKeyMapper {
private:
    std::map<std::string, std::map<int, std::string>> appMappings;
    std::map<int, std::string> defaultMappings;
    int joystickFd;
    Display* display;
    
    std::string getActiveWindowProcess() {
        Display* dpy = XOpenDisplay(NULL);
        if (!dpy) return "";
        
        Window focused;
        int revert;
        XGetInputFocus(dpy, &focused, &revert);
        
        if (focused == None || focused == PointerRoot) {
            XCloseDisplay(dpy);
            return "";
        }
        
        // Get PID of the focused window
        Atom prop = XInternAtom(dpy, "_NET_WM_PID", True);
        if (prop != None) {
            Atom type;
            int format;
            unsigned long nItems, bytesAfter;
            unsigned char* data = NULL;
            
            if (XGetWindowProperty(dpy, focused, prop, 0, 1, False, XA_CARDINAL,
                                   &type, &format, &nItems, &bytesAfter, &data) == Success) {
                if (data) {
                    pid_t pid = *(pid_t*)data;
                    XFree(data);
                    
                    // Read process name from /proc
                    std::string path = "/proc/" + std::to_string(pid) + "/comm";
                    std::ifstream commFile(path);
                    std::string processName;
                    if (std::getline(commFile, processName)) {
                        // Remove trailing newline
                        while (!processName.empty() && (processName.back() == '\n' || processName.back() == '\r'))
                            processName.pop_back();
                        XCloseDisplay(dpy);
                        return processName;
                    }
                }
            }
        }
        
        XCloseDisplay(dpy);
        return "";
    }
    
    bool loadConfig(const std::string& configFile) {
        tinyxml2::XMLDocument doc;
        if (doc.LoadFile(configFile.c_str()) != tinyxml2::XML_SUCCESS) {
            std::cerr << "Failed to load config file: " << configFile << std::endl;
            return false;
        }
        
        tinyxml2::XMLElement* root = doc.FirstChildElement("joystick2keymap");
        if (!root) return false;
        
        // Load default mappings
        tinyxml2::XMLElement* defaultElem = root->FirstChildElement("default");
        if (defaultElem) {
            for (tinyxml2::XMLElement* mapping = defaultElem->FirstChildElement("mapping");
                 mapping; mapping = mapping->NextSiblingElement("mapping")) {
                int button = mapping->IntAttribute("button");
                const char* key = mapping->Attribute("key");
                if (key) {
                    defaultMappings[button] = std::string(key);
                }
            }
        }
        
        // Load application-specific mappings
        for (tinyxml2::XMLElement* appElem = root->FirstChildElement("application");
             appElem; appElem = appElem->NextSiblingElement("application")) {
            const char* appName = appElem->Attribute("name");
            if (!appName) continue;
            
            std::map<int, std::string> buttonMap;
            for (tinyxml2::XMLElement* mapping = appElem->FirstChildElement("mapping");
                 mapping; mapping = mapping->NextSiblingElement("mapping")) {
                int button = mapping->IntAttribute("button");
                const char* key = mapping->Attribute("key");
                if (key) {
                    buttonMap[button] = std::string(key);
                }
            }
            appMappings[std::string(appName)] = buttonMap;
        }
        
        return true;
    }
    
public:
    JoystickToKeyMapper(const std::string& joystickDevice, const std::string& configFile) {
        joystickFd = open(joystickDevice.c_str(), O_RDONLY);
        if (joystickFd < 0) {
            throw std::runtime_error("Failed to open joystick device");
        }
        
        display = XOpenDisplay(NULL);
        if (!display) {
            close(joystickFd);
            throw std::runtime_error("Failed to open X display");
        }
        
        if (!loadConfig(configFile)) {
            close(joystickFd);
            XCloseDisplay(display);
            throw std::runtime_error("Failed to load configuration");
        }
    }
    
    ~JoystickToKeyMapper() {
        if (joystickFd >= 0) close(joystickFd);
        if (display) XCloseDisplay(display);
    }
    
    void run() {
        struct input_event ev;
        std::string currentApp = "";
        
        std::cout << "Joystick to Key Mapper started. Press Ctrl+C to exit." << std::endl;
        
        while (true) {
            ssize_t bytes = read(joystickFd, &ev, sizeof(ev));
            if (bytes < (ssize_t)sizeof(ev)) {
                std::cerr << "Error reading from joystick" << std::endl;
                break;
            }
            
            // Only process button events (type 1 = EV_KEY)
            if (ev.type == EV_KEY && ev.value == 1) {  // Button press
                // Get current foreground app
                std::string foregroundApp = getActiveWindowProcess();
                if (foregroundApp != currentApp) {
                    currentApp = foregroundApp;
                    std::cout << "Foreground app changed to: " << (currentApp.empty() ? "unknown" : currentApp) << std::endl;
                }
                
                // Find the mapping
                std::string keyToSend;
                auto appIt = appMappings.find(foregroundApp);
                if (appIt != appMappings.end()) {
                    auto buttonIt = appIt->second.find(ev.code);
                    if (buttonIt != appIt->second.end()) {
                        keyToSend = buttonIt->second;
                    }
                }
                
                // If no app-specific mapping, try default
                if (keyToSend.empty()) {
                    auto defaultIt = defaultMappings.find(ev.code);
                    if (defaultIt != defaultMappings.end()) {
                        keyToSend = defaultIt->second;
                    }
                }
                
                // Send the keypress if found
                if (!keyToSend.empty()) {
                    std::cout << "Button " << ev.code << " pressed -> sending: " << keyToSend 
                              << " (app: " << (foregroundApp.empty() ? "default" : foregroundApp) << ")" << std::endl;
                    sendKeyCombination(display, keyToSend);
                } else {
                    std::cout << "Button " << ev.code << " pressed -> no mapping for app: " 
                              << (foregroundApp.empty() ? "default" : foregroundApp) << std::endl;
                }
            }
            
            usleep(10000);  // Small delay to prevent CPU spinning
        }
    }
};

int main(int argc, char* argv[]) {
    if (argc != 3) {
        std::cerr << "Usage: " << argv[0] << " <joystick_device> <config_file>" << std::endl;
        std::cerr << "Example: " << argv[0] << " /dev/input/js0 joystick2keymap.xml" << std::endl;
        return 1;
    }
    
    // Daemonize (run in background)
    pid_t pid = fork();
    if (pid < 0) {
        std::cerr << "Fork failed" << std::endl;
        return 1;
    }
    
    if (pid > 0) {
        // Parent exits
        std::cout << "Daemon started with PID: " << pid << std::endl;
        return 0;
    }
    
    // Child becomes session leader
    setsid();
    
    // Change to root directory
    chdir("/");
    
    // Close standard file descriptors
    close(STDIN_FILENO);
    close(STDOUT_FILENO);
    close(STDERR_FILENO);
    
    // Redirect stdout/stderr to syslog or a log file
    openlog("joystick2key", LOG_PID, LOG_DAEMON);
    
    try {
        JoystickToKeyMapper mapper(argv[1], argv[2]);
        mapper.run();
    } catch (const std::exception& e) {
        syslog(LOG_ERR, "Error: %s", e.what());
        return 1;
    }
    
    return 0;
}

And an example .XML file : -

<?xml version="1.0" encoding="UTF-8"?>
<joystick2keymap>
    <!-- Global default mapping (used when foreground app is not recognized) -->
    <default>
        <mapping button="0" key="A"/>
        <mapping button="1" key="B"/>
        <mapping button="2" key="X"/>
        <mapping button="3" key="Y"/>
        <mapping button="4" key="SPACE"/>
    </default>

    <!-- Application-specific mappings -->
    <application name="firefox">
        <mapping button="0" key="CTRL+T"/>
        <mapping button="1" key="CTRL+W"/>
        <mapping button="2" key="F5"/>
        <mapping button="3" key="CTRL+R"/>
    </application>

    <application name="vlc">
        <mapping button="0" key="SPACE"/>
        <mapping button="1" key="F"/>
        <mapping button="2" key="RIGHT"/>
        <mapping button="3" key="LEFT"/>
        <mapping button="4" key="UP"/>
        <mapping button="5" key="DOWN"/>
    </application>

    <application name="dolphin-emu">
        <mapping button="0" key="RETURN"/>
        <mapping button="1" key="ESC"/>
    </application>
</joystick2keymap>

So you could have several different keymaps defined for several different programs and Antimicrox would switch between them automatically as the user switched between the open programs without having to switch keymaps in Antimicrox.

Just a thought.

[pktiuk]

Please don't paste random AI slop into community discussions.

Before generating it you should ask whether such a functionality already exists. (seatch for auto profile)