windowpp 0.1.1

package/framework/src/Input/input_service.cpp

@@ -0,0 +1,584 @@
+#include "input_service.h"
+
+#include <algorithm>
+#include <cctype>
+#include <map>
+#include <mutex>
+#include <set>
+#include <stdexcept>
+#include <unordered_map>
+#include <utility>
+#include <vector>
+
+namespace wpp::input {
+namespace {
+
+using KeyListener = Service::KeyListener;
+using ShortcutHandler = Service::ShortcutHandler;
+using ListenerId = Service::ListenerId;
+
+struct RegisteredShortcut {
+    Shortcut shortcut;
+    ShortcutOptions options;
+    ShortcutHandler handler;
+};
+
+struct State {
+    std::mutex mutex;
+    ListenerId next_listener_id = 1;
+    std::unordered_map<ListenerId, KeyListener> listeners;
+    std::unordered_map<std::string, RegisteredShortcut> shortcuts;
+    std::set<Key> pressed;
+    std::vector<Key> pressed_order;
+    detail::DispatchFn dispatch;
+    detail::GlobalRegisterFn register_global;
+    detail::GlobalUnregisterFn unregister_global;
+};
+
+State& state() {
+    static State instance;
+    return instance;
+}
+
+std::string trim(std::string value) {
+    auto is_space = [](unsigned char ch) { return std::isspace(ch) != 0; };
+    value.erase(value.begin(), std::find_if(value.begin(), value.end(), [&](unsigned char ch) { return !is_space(ch); }));
+    value.erase(std::find_if(value.rbegin(), value.rend(), [&](unsigned char ch) { return !is_space(ch); }).base(), value.end());
+    return value;
+}
+
+std::string uppercase(std::string value) {
+    std::transform(value.begin(), value.end(), value.begin(), [](unsigned char ch) {
+        return static_cast<char>(std::toupper(ch));
+    });
+    return value;
+}
+
+std::string canonical_token(std::string value) {
+    value = trim(std::move(value));
+    value.erase(std::remove_if(value.begin(), value.end(), [](unsigned char ch) {
+        return std::isspace(ch) != 0 || ch == '_';
+    }), value.end());
+    return uppercase(std::move(value));
+}
+
+bool is_modifier_token(const std::string& token) {
+    return token == "CTRL" || token == "CONTROL" || token == "SHIFT" ||
+           token == "ALT" || token == "OPTION" || token == "CMD" ||
+           token == "COMMAND" || token == "WIN" || token == "META" || token == "SUPER";
+}
+
+Key key_from_token(const std::string& token) {
+    static const std::unordered_map<std::string, Key> key_map = {
+        {"A", Key::A}, {"B", Key::B}, {"C", Key::C}, {"D", Key::D},
+        {"E", Key::E}, {"F", Key::F}, {"G", Key::G}, {"H", Key::H},
+        {"I", Key::I}, {"J", Key::J}, {"K", Key::K}, {"L", Key::L},
+        {"M", Key::M}, {"N", Key::N}, {"O", Key::O}, {"P", Key::P},
+        {"Q", Key::Q}, {"R", Key::R}, {"S", Key::S}, {"T", Key::T},
+        {"U", Key::U}, {"V", Key::V}, {"W", Key::W}, {"X", Key::X},
+        {"Y", Key::Y}, {"Z", Key::Z},
+        {"0", Key::Digit0}, {"1", Key::Digit1}, {"2", Key::Digit2}, {"3", Key::Digit3},
+        {"4", Key::Digit4}, {"5", Key::Digit5}, {"6", Key::Digit6}, {"7", Key::Digit7},
+        {"8", Key::Digit8}, {"9", Key::Digit9},
+        {"SPACE", Key::Space},
+        {"ENTER", Key::Enter}, {"RETURN", Key::Enter},
+        {"ESC", Key::Escape}, {"ESCAPE", Key::Escape},
+        {"TAB", Key::Tab},
+        {"BACKSPACE", Key::Backspace},
+        {"DELETE", Key::Delete}, {"DEL", Key::Delete},
+        {"INSERT", Key::Insert},
+        {"HOME", Key::Home},
+        {"END", Key::End},
+        {"PAGEUP", Key::PageUp},
+        {"PAGEDOWN", Key::PageDown},
+        {"LEFT", Key::Left},
+        {"RIGHT", Key::Right},
+        {"UP", Key::Up},
+        {"DOWN", Key::Down},
+        {"CAPS", Key::CapsLock}, {"CAPSLOCK", Key::CapsLock},
+        {"SHIFT", Key::Shift},
+        {"CTRL", Key::Control}, {"CONTROL", Key::Control},
+        {"ALT", Key::Alt}, {"OPTION", Key::Alt},
+        {"META", Key::Meta}, {"SUPER", Key::Meta}, {"WIN", Key::Meta}, {"COMMAND", Key::Meta}, {"CMD", Key::Meta},
+        {"F1", Key::F1}, {"F2", Key::F2}, {"F3", Key::F3}, {"F4", Key::F4},
+        {"F5", Key::F5}, {"F6", Key::F6}, {"F7", Key::F7}, {"F8", Key::F8},
+        {"F9", Key::F9}, {"F10", Key::F10}, {"F11", Key::F11}, {"F12", Key::F12},
+    };
+
+    auto it = key_map.find(token);
+    return it == key_map.end() ? Key::Unknown : it->second;
+}
+
+bool shortcut_matches_event(const Shortcut& shortcut, const KeyEvent& event) {
+    return shortcut.key == event.key &&
+           shortcut.ctrl == event.ctrl &&
+           shortcut.shift == event.shift &&
+           shortcut.alt == event.alt &&
+           shortcut.meta == event.meta;
+}
+
+bool pressed_for_modifier(const KeyEvent& event, Key modifier, bool current_flag) {
+    if (event.key == modifier) {
+        return event.type == KeyEventType::KeyDown;
+    }
+    return current_flag;
+}
+
+void reconcile_modifier_state(std::set<Key>& pressed, const KeyEvent& event) {
+    if (pressed_for_modifier(event, Key::Control, event.ctrl)) {
+        pressed.insert(Key::Control);
+    } else {
+        pressed.erase(Key::Control);
+    }
+
+    if (pressed_for_modifier(event, Key::Shift, event.shift)) {
+        pressed.insert(Key::Shift);
+    } else {
+        pressed.erase(Key::Shift);
+    }
+
+    if (pressed_for_modifier(event, Key::Alt, event.alt)) {
+        pressed.insert(Key::Alt);
+    } else {
+        pressed.erase(Key::Alt);
+    }
+
+    if (pressed_for_modifier(event, Key::Meta, event.meta)) {
+        pressed.insert(Key::Meta);
+    } else {
+        pressed.erase(Key::Meta);
+    }
+}
+
+void set_pressed_key(State& current, Key key, bool is_pressed) {
+    if (key == Key::Unknown) {
+        return;
+    }
+
+    if (is_pressed) {
+        const auto inserted = current.pressed.insert(key).second;
+        if (inserted) {
+            current.pressed_order.push_back(key);
+        }
+        return;
+    }
+
+    current.pressed.erase(key);
+    current.pressed_order.erase(
+        std::remove(current.pressed_order.begin(), current.pressed_order.end(), key),
+        current.pressed_order.end());
+}
+
+void reconcile_modifier_state(State& current, const KeyEvent& event) {
+    set_pressed_key(current, Key::Control, pressed_for_modifier(event, Key::Control, event.ctrl));
+    set_pressed_key(current, Key::Shift, pressed_for_modifier(event, Key::Shift, event.shift));
+    set_pressed_key(current, Key::Alt, pressed_for_modifier(event, Key::Alt, event.alt));
+    set_pressed_key(current, Key::Meta, pressed_for_modifier(event, Key::Meta, event.meta));
+}
+
+KeyEvent make_shortcut_event(const RegisteredShortcut& registration) {
+    KeyEvent event{};
+    event.key = registration.shortcut.key;
+    event.type = registration.options.trigger_on_key_up ? KeyEventType::KeyUp : KeyEventType::KeyDown;
+    event.key_name = key_to_string(registration.shortcut.key);
+    event.ctrl = registration.shortcut.ctrl;
+    event.shift = registration.shortcut.shift;
+    event.alt = registration.shortcut.alt;
+    event.meta = registration.shortcut.meta;
+    event.is_repeat = false;
+    event.is_global = registration.options.global;
+    event.window_id = registration.options.window_id;
+    return event;
+}
+
+std::vector<KeyListener> collect_listeners_locked(const State& current) {
+    std::vector<KeyListener> listeners;
+    listeners.reserve(current.listeners.size());
+    for (const auto& entry : current.listeners) {
+        listeners.push_back(entry.second);
+    }
+    return listeners;
+}
+
+std::vector<ShortcutHandler> collect_matching_handlers_locked(const State& current, const KeyEvent& event) {
+    std::vector<ShortcutHandler> handlers;
+    for (const auto& entry : current.shortcuts) {
+        const auto& registration = entry.second;
+        if (registration.options.global) {
+            continue;
+        }
+        if (!registration.options.window_id.empty() && registration.options.window_id != event.window_id) {
+            continue;
+        }
+        if (registration.options.trigger_on_key_up) {
+            if (event.type != KeyEventType::KeyUp) {
+                continue;
+            }
+        } else {
+            if (event.type != KeyEventType::KeyDown) {
+                continue;
+            }
+            if (event.is_repeat && !registration.options.allow_repeat) {
+                continue;
+            }
+        }
+        if (!shortcut_matches_event(registration.shortcut, event)) {
+            continue;
+        }
+        handlers.push_back(registration.handler);
+    }
+    return handlers;
+}
+
+void invoke_listeners(const std::vector<KeyListener>& listeners, const KeyEvent& event) {
+    for (const auto& listener : listeners) {
+        if (listener) {
+            listener(event);
+        }
+    }
+}
+
+void invoke_handlers(const std::vector<ShortcutHandler>& handlers, const KeyEvent& event) {
+    for (const auto& handler : handlers) {
+        if (handler) {
+            handler(event);
+        }
+    }
+}
+
+} // namespace
+
+Service& Service::instance() {
+    static Service instance;
+    return instance;
+}
+
+Service& service() {
+    return Service::instance();
+}
+
+Service::ListenerId Service::add_key_listener(KeyListener listener) {
+    auto& current = state();
+    std::lock_guard<std::mutex> lock(current.mutex);
+    const auto id = current.next_listener_id++;
+    current.listeners.emplace(id, std::move(listener));
+    return id;
+}
+
+void Service::remove_key_listener(ListenerId id) {
+    auto& current = state();
+    std::lock_guard<std::mutex> lock(current.mutex);
+    current.listeners.erase(id);
+}
+
+Shortcut Service::parse_shortcut(const std::string& text) const {
+    const auto trimmed = trim(text);
+    if (trimmed.empty()) {
+        throw std::invalid_argument("Shortcut cannot be empty");
+    }
+
+    Shortcut shortcut;
+    shortcut.text = trimmed;
+
+    size_t start = 0;
+    std::vector<std::string> parts;
+    while (start <= trimmed.size()) {
+        const auto end = trimmed.find('+', start);
+        parts.push_back(trim(trimmed.substr(start, end == std::string::npos ? std::string::npos : end - start)));
+        if (end == std::string::npos) {
+            break;
+        }
+        start = end + 1;
+    }
+
+    if (parts.empty()) {
+        throw std::invalid_argument("Shortcut cannot be empty");
+    }
+
+    for (size_t index = 0; index < parts.size(); ++index) {
+        const auto token = canonical_token(parts[index]);
+        if (token.empty()) {
+            continue;
+        }
+
+        const bool last = index == parts.size() - 1;
+        if (!last && is_modifier_token(token)) {
+            if (token == "CTRL" || token == "CONTROL") shortcut.ctrl = true;
+            else if (token == "SHIFT") shortcut.shift = true;
+            else if (token == "ALT" || token == "OPTION") shortcut.alt = true;
+            else shortcut.meta = true;
+            continue;
+        }
+
+        const auto key = key_from_token(token);
+        if (key == Key::Unknown) {
+            throw std::invalid_argument("Unknown key in shortcut: " + parts[index]);
+        }
+
+        if (!last && is_modifier_token(token)) {
+            if (key == Key::Control) shortcut.ctrl = true;
+            else if (key == Key::Shift) shortcut.shift = true;
+            else if (key == Key::Alt) shortcut.alt = true;
+            else if (key == Key::Meta) shortcut.meta = true;
+            continue;
+        }
+
+        shortcut.key = key;
+    }
+
+    if (shortcut.key == Key::Unknown) {
+        throw std::invalid_argument("Shortcut is missing a key");
+    }
+
+    shortcut.text = format_shortcut(shortcut);
+    return shortcut;
+}
+
+std::string Service::format_shortcut(const Shortcut& shortcut) const {
+    std::vector<std::string> parts;
+    if (shortcut.ctrl) parts.push_back("Ctrl");
+    if (shortcut.shift) parts.push_back("Shift");
+    if (shortcut.alt) parts.push_back("Alt");
+    if (shortcut.meta) parts.push_back("Meta");
+    parts.push_back(key_to_string(shortcut.key));
+
+    std::string result;
+    for (size_t index = 0; index < parts.size(); ++index) {
+        if (index > 0) {
+            result += '+';
+        }
+        result += parts[index];
+    }
+    return result;
+}
+
+void Service::register_shortcut(const std::string& id,
+                                const std::string& shortcut_text,
+                                ShortcutHandler handler,
+                                ShortcutOptions options) {
+    if (id.empty()) {
+        throw std::invalid_argument("Shortcut id cannot be empty");
+    }
+
+    auto parsed = parse_shortcut(shortcut_text);
+    auto& current = state();
+
+    std::lock_guard<std::mutex> lock(current.mutex);
+    auto existing = current.shortcuts.find(id);
+    if (existing != current.shortcuts.end() && existing->second.options.global && current.unregister_global) {
+        current.unregister_global(id);
+    }
+
+    RegisteredShortcut registration{parsed, std::move(options), std::move(handler)};
+    if (registration.options.global) {
+        if (!current.register_global) {
+            throw std::runtime_error("Global hotkeys are not available on this platform yet");
+        }
+        std::string error;
+        if (!current.register_global(id, registration.shortcut, &error)) {
+            throw std::runtime_error(error.empty() ? "Failed to register global hotkey" : error);
+        }
+    }
+
+    current.shortcuts[id] = std::move(registration);
+}
+
+void Service::unregister_shortcut(const std::string& id) {
+    auto& current = state();
+    std::lock_guard<std::mutex> lock(current.mutex);
+    auto it = current.shortcuts.find(id);
+    if (it == current.shortcuts.end()) {
+        return;
+    }
+    if (it->second.options.global && current.unregister_global) {
+        current.unregister_global(id);
+    }
+    current.shortcuts.erase(it);
+}
+
+void Service::clear_shortcuts() {
+    auto& current = state();
+    std::lock_guard<std::mutex> lock(current.mutex);
+    if (current.unregister_global) {
+        for (const auto& entry : current.shortcuts) {
+            if (entry.second.options.global) {
+                current.unregister_global(entry.first);
+            }
+        }
+    }
+    current.shortcuts.clear();
+    current.pressed.clear();
+    current.pressed_order.clear();
+}
+
+bool Service::is_pressed(Key key) const {
+    auto& current = state();
+    std::lock_guard<std::mutex> lock(current.mutex);
+    return current.pressed.find(key) != current.pressed.end();
+}
+
+std::vector<Key> Service::pressed_keys() const {
+    auto& current = state();
+    std::lock_guard<std::mutex> lock(current.mutex);
+    return current.pressed_order;
+}
+
+std::string key_to_string(Key key) {
+    switch (key) {
+        case Key::A: return "A";
+        case Key::B: return "B";
+        case Key::C: return "C";
+        case Key::D: return "D";
+        case Key::E: return "E";
+        case Key::F: return "F";
+        case Key::G: return "G";
+        case Key::H: return "H";
+        case Key::I: return "I";
+        case Key::J: return "J";
+        case Key::K: return "K";
+        case Key::L: return "L";
+        case Key::M: return "M";
+        case Key::N: return "N";
+        case Key::O: return "O";
+        case Key::P: return "P";
+        case Key::Q: return "Q";
+        case Key::R: return "R";
+        case Key::S: return "S";
+        case Key::T: return "T";
+        case Key::U: return "U";
+        case Key::V: return "V";
+        case Key::W: return "W";
+        case Key::X: return "X";
+        case Key::Y: return "Y";
+        case Key::Z: return "Z";
+        case Key::Digit0: return "0";
+        case Key::Digit1: return "1";
+        case Key::Digit2: return "2";
+        case Key::Digit3: return "3";
+        case Key::Digit4: return "4";
+        case Key::Digit5: return "5";
+        case Key::Digit6: return "6";
+        case Key::Digit7: return "7";
+        case Key::Digit8: return "8";
+        case Key::Digit9: return "9";
+        case Key::Space: return "Space";
+        case Key::Enter: return "Enter";
+        case Key::Escape: return "Escape";
+        case Key::Tab: return "Tab";
+        case Key::Backspace: return "Backspace";
+        case Key::Delete: return "Delete";
+        case Key::Insert: return "Insert";
+        case Key::Home: return "Home";
+        case Key::End: return "End";
+        case Key::PageUp: return "PageUp";
+        case Key::PageDown: return "PageDown";
+        case Key::Left: return "Left";
+        case Key::Right: return "Right";
+        case Key::Up: return "Up";
+        case Key::Down: return "Down";
+        case Key::CapsLock: return "CapsLock";
+        case Key::Shift: return "Shift";
+        case Key::Control: return "Ctrl";
+        case Key::Alt: return "Alt";
+        case Key::Meta: return "Meta";
+        case Key::F1: return "F1";
+        case Key::F2: return "F2";
+        case Key::F3: return "F3";
+        case Key::F4: return "F4";
+        case Key::F5: return "F5";
+        case Key::F6: return "F6";
+        case Key::F7: return "F7";
+        case Key::F8: return "F8";
+        case Key::F9: return "F9";
+        case Key::F10: return "F10";
+        case Key::F11: return "F11";
+        case Key::F12: return "F12";
+        default: return "Unknown";
+    }
+}
+
+namespace detail {
+
+void set_dispatch(DispatchFn dispatch) {
+    auto& current = state();
+    std::lock_guard<std::mutex> lock(current.mutex);
+    current.dispatch = std::move(dispatch);
+}
+
+void set_global_backend(GlobalRegisterFn reg, GlobalUnregisterFn unreg) {
+    auto& current = state();
+    std::lock_guard<std::mutex> lock(current.mutex);
+    current.register_global = std::move(reg);
+    current.unregister_global = std::move(unreg);
+}
+
+void clear_global_backend() {
+    auto& current = state();
+    std::lock_guard<std::mutex> lock(current.mutex);
+    current.register_global = {};
+    current.unregister_global = {};
+}
+
+void emit_key_event(const KeyEvent& event) {
+    std::vector<KeyListener> listeners;
+    std::vector<ShortcutHandler> handlers;
+    KeyEvent enriched = event;
+
+    {
+        auto& current = state();
+        std::lock_guard<std::mutex> lock(current.mutex);
+        if (event.type == KeyEventType::KeyDown) {
+            reconcile_modifier_state(current, event);
+            if (event.key != Key::Control && event.key != Key::Shift && event.key != Key::Alt && event.key != Key::Meta) {
+                set_pressed_key(current, event.key, true);
+            }
+        } else {
+            if (event.key != Key::Control && event.key != Key::Shift && event.key != Key::Alt && event.key != Key::Meta) {
+                set_pressed_key(current, event.key, false);
+            }
+            reconcile_modifier_state(current, event);
+        }
+        enriched.pressed_keys = current.pressed_order;
+        listeners = collect_listeners_locked(current);
+        handlers = collect_matching_handlers_locked(current, enriched);
+    }
+
+    invoke_listeners(listeners, enriched);
+    invoke_handlers(handlers, enriched);
+}
+
+void trigger_global_shortcut(const std::string& id) {
+    std::vector<KeyListener> listeners;
+    ShortcutHandler handler;
+    KeyEvent event{};
+    DispatchFn dispatch_fn;
+
+    {
+        auto& current = state();
+        std::lock_guard<std::mutex> lock(current.mutex);
+        auto it = current.shortcuts.find(id);
+        if (it == current.shortcuts.end() || !it->second.options.global) {
+            return;
+        }
+        listeners = collect_listeners_locked(current);
+        handler = it->second.handler;
+        event = make_shortcut_event(it->second);
+        dispatch_fn = current.dispatch;
+    }
+
+    auto dispatch = [listeners = std::move(listeners), event, handler = std::move(handler)]() {
+        invoke_listeners(listeners, event);
+        if (handler) {
+            handler(event);
+        }
+    };
+
+    if (dispatch_fn) {
+        dispatch_fn(std::move(dispatch));
+        return;
+    }
+    dispatch();
+}
+
+} // namespace detail
+} // namespace wpp::input

package/framework/src/Input/input_service.h

@@ -0,0 +1,21 @@
+#pragma once
+
+#include <functional>
+#include <string>
+
+#include <windowpp/windowpp.h>
+
+namespace wpp::input::detail {
+
+using DispatchFn = std::function<void(std::function<void()>)>;
+using GlobalRegisterFn = std::function<bool(const std::string& id, const Shortcut& shortcut, std::string* error)>;
+using GlobalUnregisterFn = std::function<void(const std::string& id)>;
+
+void set_dispatch(DispatchFn dispatch);
+void set_global_backend(GlobalRegisterFn reg, GlobalUnregisterFn unreg);
+void clear_global_backend();
+
+void emit_key_event(const KeyEvent& event);
+void trigger_global_shortcut(const std::string& id);
+
+} // namespace wpp::input::detail

package/framework/src/application.cpp

@@ -0,0 +1,29 @@
+// ============================================================================
+//  application.cpp — Platform dispatch and factory
+// ============================================================================
+
+#include <windowpp/windowpp.h>
+
+#if defined(WIN32)
+#include "platform/win32/app_win32.h"
+#elif defined(__APPLE__)
+#include "platform/macos/app_macos.h"
+#elif defined(__linux__)
+#include "platform/linux/app_linux.h"
+#else
+#error "Unsupported platform"
+#endif
+
+namespace wpp {
+
+std::unique_ptr<Application> create_app(const AppConfig& config) {
+#if defined(WIN32)
+    return std::make_unique<Win32Application>(config);
+#elif defined(__APPLE__)
+    return std::make_unique<MacOSApplication>(config);
+#elif defined(__linux__)
+    return std::make_unique<LinuxApplication>(config);
+#endif
+}
+
+} // namespace wpp

package/framework/src/common/hit_test.cpp

@@ -0,0 +1,40 @@
+// ============================================================================
+//  hit_test.cpp — Cross-platform hit-test logic for frameless windows
+// ============================================================================
+
+#include <windowpp/windowpp.h>
+
+namespace wpp {
+
+HitTestRegion default_hit_test(Point cursor, Size window_size,
+                                int border_width, int caption_height,
+                                bool resizable) {
+    const int w = window_size.width;
+    const int h = window_size.height;
+    const int b = border_width;
+
+    const bool at_left   = cursor.x < b;
+    const bool at_right  = cursor.x >= w - b;
+    const bool at_top    = cursor.y < b;
+    const bool at_bottom = cursor.y >= h - b;
+
+    if (resizable) {
+        if (at_top    && at_left)  return HitTestRegion::ResizeTopLeft;
+        if (at_top    && at_right) return HitTestRegion::ResizeTopRight;
+        if (at_bottom && at_left)  return HitTestRegion::ResizeBottomLeft;
+        if (at_bottom && at_right) return HitTestRegion::ResizeBottomRight;
+
+        if (at_top)    return HitTestRegion::ResizeTop;
+        if (at_bottom) return HitTestRegion::ResizeBottom;
+        if (at_left)   return HitTestRegion::ResizeLeft;
+        if (at_right)  return HitTestRegion::ResizeRight;
+    }
+
+    if (cursor.y < caption_height) {
+        return HitTestRegion::Caption;
+    }
+
+    return HitTestRegion::Client;
+}
+
+} // namespace wpp

package/framework/src/common/image_loader.cpp

@@ -0,0 +1,24 @@
+// ============================================================================
+//  image_loader.cpp — PNG/ICO loading using stb_image
+// ============================================================================
+
+#define STB_IMAGE_IMPLEMENTATION
+#include <stb_image.h>
+
+namespace wpp {
+
+ImageData load_image_from_file(const std::string& path, int* width, int* height, int* channels) {
+    ImageData data;
+    data.pixels = stbi_load(path.c_str(), width, height, channels, STBI_rgb_alpha);
+    data.size = *width * *height * 4;
+    return data;
+}
+
+void free_image_data(ImageData& data) {
+    if (data.pixels) {
+        stbi_image_free(data.pixels);
+        data.pixels = nullptr;
+    }
+}
+
+} // namespace wpp