key_handling.cc

#include <vector>
#include <iostream>

enum KeyState {
    UP,
    DOWN
};

class KeyHandler{
public:
    KeyState state;
    bool press_handled = false;
    bool release_handled = false;
    std::vector<void (*)()> on_press_callbacks;
    std::vector<void (*)()> on_release_callbacks;
    std::vector<void (*)()> on_hold_callbacks;
    KeyHandler() : state(KeyState::UP) {}

    void press() {
        state = KeyState::DOWN;
        for (auto &callback : on_press_callbacks) {
            callback();
        }
        press_handled = true;
        release_handled = false;
    }

    void release() {
        state = KeyState::UP;
        for (auto &callback : on_release_callbacks) {
            callback();
        }
        press_handled = false;
        release_handled = true;
    }

    void tick() {
        if (isPressed() && press_handled) {
            for (auto &callback : on_hold_callbacks) {
                callback();
            }
        }
    }

    bool isPressed() {
        return state == KeyState::DOWN;
    }

    bool isReleased() {
        return state == KeyState::UP;
    }

    void add_on_press_handler(void (*callback)()) {
        on_press_callbacks.push_back(callback);
    }

    void add_on_release_handler(void (*callback)()) {
        on_release_callbacks.push_back(callback);
    }

    // function to handle polling when key is held
    void add_on_hold_handler(void (*callback)()) {
        on_hold_callbacks.push_back(callback);
    }
};

int main() {
    KeyHandler key;
    key.add_on_press_handler([]() { std::cout << "Key pressed" << std::endl; });
    key.add_on_release_handler([]() { std::cout << "Key released" << std::endl; });
    key.add_on_hold_handler([]() { std::cout << "Key held" << std::endl; });

    // simulate key press
    for(int t = 0;; t++){
        if(t == 0){
            key.press();
        }

        key.tick();

        if(t >= 10) {
            key.release();
            break;
        }
    }
    return 0;
}