plusui-native-core 0.1.0

package/Core/include/display.hpp

@@ -0,0 +1,90 @@
+#ifndef PLUSUI_DISPLAY_H
+#define PLUSUI_DISPLAY_H
+
+#include <string>
+#include <vector>
+#include <memory>
+#include <functional>
+
+namespace plusui {
+
+struct DisplayMode {
+    int width = 0;
+    int height = 0;
+    int refreshRate = 60;
+    int bitDepth = 32;
+};
+
+struct DisplayBounds {
+    int x = 0;
+    int y = 0;
+    int width = 0;
+    int height = 0;
+};
+
+struct DisplayResolution {
+    int width = 0;
+    int height = 0;
+};
+
+struct Display {
+    int id = 0;
+    std::string name;
+    bool isPrimary = false;
+    DisplayBounds bounds;
+    DisplayBounds workArea;
+    DisplayResolution resolution;
+    DisplayMode currentMode;
+    double scaleFactor = 1.0;
+    double rotation = 0.0;
+    bool isInternal = false;
+    bool isConnected = true;
+};
+
+class DisplayManager {
+public:
+    DisplayManager();
+    ~DisplayManager();
+
+    static DisplayManager& instance();
+
+    std::vector<Display> getAllDisplays();
+    Display getPrimaryDisplay();
+    Display getDisplayAt(int x, int y);
+    Display getDisplayAtCursor();
+    Display getDisplayById(int id);
+
+    void onDisplayConnected(std::function<void(const Display&)> callback);
+    void onDisplayDisconnected(std::function<void(int displayId)> callback);
+    void onDisplayChanged(std::function<void(const Display&)> callback);
+
+    void refresh();
+
+    bool setDisplayMode(int displayId, const DisplayMode& mode);
+    bool setPosition(int displayId, int x, int y);
+    bool turnOff(int displayId);
+
+private:
+    struct Impl;
+    std::unique_ptr<Impl> pImpl;
+};
+
+class Screen {
+public:
+    static int getWidth();
+    static int getHeight();
+    static int getWidthMM();
+    static int getHeightMM();
+
+    static double getScaleFactor();
+    static double getRefreshRate();
+
+    static bool isMain();
+    static bool isMulti();
+
+    static std::string getName();
+};
+
+}
+
+#endif

package/Core/include/keyboard.hpp

@@ -0,0 +1,135 @@
+#ifndef PLUSUI_KEYBOARD_H
+#define PLUSUI_KEYBOARD_H
+
+#include <string>
+#include <vector>
+#include <functional>
+#include <map>
+
+namespace plusui {
+
+enum class KeyCode {
+    Unknown = 0,
+    Space = 32,
+    Apostrophe = 39,
+    Comma = 44,
+    Minus = 45,
+    Period = 46,
+    Slash = 47,
+    Num0 = 48, Num1 = 49, Num2 = 50, Num3 = 51, Num4 = 52,
+    Num5 = 53, Num6 = 54, Num7 = 55, Num8 = 56, Num9 = 57,
+    Semicolon = 59, Equal = 61,
+    A = 65, B = 66, C = 67, D = 68, E = 69, F = 70, G = 71,
+    H = 72, I = 73, J = 74, K = 75, L = 76, M = 77, N = 78,
+    O = 79, P = 80, Q = 81, R = 82, S = 83, T = 84, U = 85,
+    V = 86, W = 87, X = 88, Y = 89, Z = 90,
+    LeftBracket = 91, Backslash = 92, RightBracket = 93,
+    GraveAccent = 96,
+    World1 = 161, World2 = 162,
+    Escape = 256, Enter = 257, Tab = 258, Backspace = 259,
+    Insert = 260, Delete = 261,
+    Right = 262, Left = 263, Down = 264, Up = 265,
+    PageUp = 266, PageDown = 267, Home = 268, End = 269,
+    CapsLock = 280, ScrollLock = 281, NumLock = 282,
+    PrintScreen = 283, Pause = 284,
+    F1 = 290, F2 = 291, F3 = 292, F4 = 293, F5 = 294,
+    F6 = 295, F7 = 296, F8 = 297, F9 = 298, F10 = 299,
+    F11 = 300, F12 = 301, F13 = 302, F14 = 303, F15 = 304,
+    F16 = 305, F17 = 306, F18 = 307, F19 = 308,
+    Kp0 = 320, Kp1 = 321, Kp2 = 322, Kp3 = 323, Kp4 = 324,
+    Kp5 = 325, Kp6 = 326, Kp7 = 327, Kp8 = 328, Kp9 = 329,
+    KpDecimal = 330, KpDivide = 331, KpMultiply = 332,
+    KpSubtract = 333, KpAdd = 334, KpEnter = 335,
+    KpEqual = 336,
+    LeftShift = 340, LeftControl = 341, LeftAlt = 342,
+    LeftSuper = 343, RightShift = 344, RightControl = 345,
+    RightAlt = 346, RightSuper = 347,
+    Menu = 348
+};
+
+enum class KeyMod {
+    None = 0,
+    Shift = 1,
+    Control = 2,
+    Alt = 4,
+    Super = 8,
+    CapsLock = 16,
+    NumLock = 32
+};
+
+inline KeyMod operator|(KeyMod a, KeyMod b) {
+    return static_cast<KeyMod>(static_cast<int>(a) | static_cast<int>(b));
+}
+
+inline bool operator&(KeyMod a, KeyMod b) {
+    return (static_cast<int>(a) & static_cast<int>(b)) != 0;
+}
+
+struct KeyEvent {
+    KeyCode key = KeyCode::Unknown;
+    int scancode = 0;
+    KeyMod mods = KeyMod::None;
+    bool pressed = false;
+    bool repeat = false;
+    std::string description;
+};
+
+struct Shortcut {
+    KeyCode key = KeyCode::Unknown;
+    KeyMod mods = KeyMod::None;
+    
+    Shortcut() = default;
+    Shortcut(KeyCode k, KeyMod m = KeyMod::None) : key(k), mods(m) {}
+    
+    std::string toString() const;
+    static Shortcut parse(const std::string& str);
+};
+
+class Keyboard {
+public:
+    Keyboard();
+    ~Keyboard();
+
+    static Keyboard& instance();
+
+    void onKeyDown(std::function<void(const KeyEvent&)> callback);
+    void onKeyUp(std::function<void(const KeyEvent&)> callback);
+    void onKeyPress(std::function<void(const KeyEvent&)> callback);
+
+    bool isKeyPressed(KeyCode key) const;
+    bool areModsActive(KeyMod mods) const;
+
+    std::string getKeyName(KeyCode key) const;
+    KeyCode getKeyFromName(const std::string& name) const;
+
+    void setAutoRepeat(bool enabled);
+    bool getAutoRepeat() const;
+
+private:
+    struct Impl;
+    class Impl* pImpl;
+};
+
+class ShortcutManager {
+public:
+    ShortcutManager();
+    ~ShortcutManager();
+
+    static ShortcutManager& instance();
+
+    bool registerShortcut(const std::string& id, const Shortcut& shortcut, 
+                         std::function<void()> callback);
+    bool unregisterShortcut(const std::string& id);
+    void clearShortcuts();
+
+    bool isRegistered(const std::string& id) const;
+    Shortcut getShortcut(const std::string& id) const;
+
+    void onShortcutTriggered(std::function<void(const std::string& id)> callback);
+
+private:
+    struct Impl;
+    class Impl* pImpl;
+};
+
+}

package/Core/include/menu.hpp

@@ -0,0 +1,79 @@
+#ifndef PLUSUI_MENU_H
+#define PLUSUI_MENU_H
+
+#include <string>
+#include <vector>
+#include <memory>
+#include <functional>
+
+namespace plusui {
+
+enum class MenuItemType {
+    Normal,
+    Separator,
+    Submenu,
+    Checkbox,
+    Radio
+};
+
+struct MenuItem {
+    std::string id;
+    std::string label;
+    std::string accelerator;
+    std::string icon;
+    MenuItemType type = MenuItemType::Normal;
+    bool enabled = true;
+    bool checked = false;
+    std::vector<MenuItem> submenu;
+};
+
+struct MenuBar {
+    std::vector<MenuItem> items;
+};
+
+class Menu {
+public:
+    Menu();
+    ~Menu();
+
+    static Menu create(const std::vector<MenuItem>& items = {});
+
+    void setItems(const std::vector<MenuItem>& items);
+    std::vector<MenuItem> getItems() const;
+
+    void append(const MenuItem& item);
+    void insert(int index, const MenuItem& item);
+    void remove(const std::string& id);
+    void clear();
+
+    void popup(int x, int y);
+    void close();
+
+private:
+    struct Impl;
+    std::unique_ptr<Impl> pImpl;
+};
+
+class MenuBar {
+public:
+    MenuBar();
+    ~MenuBar();
+
+    static MenuBar& instance();
+
+    void setMenu(const ::plusui::MenuBar& menu);
+    ::plusui::MenuBar getMenu() const;
+
+    void append(const MenuItem& item);
+    void insert(int index, const MenuItem& item);
+    void remove(const std::string& id);
+    void clear();
+
+    void onMenuItemClick(std::function<void(const std::string& id)> callback);
+
+private:
+    struct Impl;
+    std::unique_ptr<Impl> pImpl;
+};
+
+}

package/Core/include/tray.hpp

@@ -0,0 +1,81 @@
+#ifndef PLUSUI_TRAY_H
+#define PLUSUI_TRAY_H
+
+#include <string>
+#include <vector>
+#include <memory>
+#include <functional>
+
+namespace plusui {
+
+struct TrayMenuItem {
+    std::string id;
+    std::string label;
+    std::string icon;
+    bool enabled = true;
+    bool checked = false;
+    bool separator = false;
+    std::vector<TrayMenuItem> submenu;
+};
+
+struct TrayIconData {
+    int id = 0;
+    std::string tooltip;
+    std::string iconPath;
+    bool isVisible = true;
+};
+
+class TrayIcon {
+public:
+    TrayIcon();
+    ~TrayIcon();
+
+    static TrayIcon create(const std::string& tooltip = "", const std::string& iconPath = "");
+
+    void setTooltip(const std::string& tooltip);
+    void setIcon(const std::string& iconPath);
+    void setIconFromData(const std::vector<uint8_t>& data, int width = 16, int height = 16);
+
+    void show();
+    void hide();
+    bool isVisible() const;
+
+    void setMenu(const std::vector<TrayMenuItem>& items);
+    void setContextMenu(const std::vector<TrayMenuItem>& items);
+
+    void onClick(std::function<void(int x, int y)> callback);
+    void onRightClick(std::function<void(int x, int y)> callback);
+    void onDoubleClick(std::function<void()> callback);
+    void onMenuItemClick(std::function<void(const std::string& id)> callback);
+
+    void dispose();
+
+private:
+    struct Impl;
+    std::unique_ptr<Impl> pImpl;
+};
+
+class TrayManager {
+public:
+    static TrayManager& instance();
+
+    std::vector<TrayIcon*> getIcons();
+
+    void onTrayCreated(std::function<void(TrayIcon& icon)> callback);
+    void onTrayDestroyed(std::function<void(int iconId)> callback);
+
+    void refresh();
+
+private:
+    TrayManager() = default;
+    ~TrayManager() = default;
+    TrayManager(const TrayManager&) = delete;
+    TrayManager& operator=(const TrayManager&) = delete;
+
+    struct Impl;
+    std::unique_ptr<Impl> pImpl;
+};
+
+}
+
+#endif

package/Core/include/window.hpp

@@ -0,0 +1,106 @@
+#ifndef PLUSUI_WINDOW_H
+#define PLUSUI_WINDOW_H
+
+#include <string>
+#include <functional>
+#include <memory>
+
+namespace plusui {
+
+struct WindowConfig {
+    int x = -1;
+    int y = -1;
+    int width = 800;
+    int height = 600;
+    int minWidth = 0;
+    int minHeight = 0;
+    int maxWidth = 0;
+    int maxHeight = 0;
+    std::string title = "PlusUI";
+    bool resizable = true;
+    bool fullscreen = false;
+    bool maximized = false;
+    bool minimizable = true;
+    bool closable = true;
+    bool alwaysOnTop = false;
+    bool center = true;
+};
+
+struct WindowState {
+    int x = 0;
+    int y = 0;
+    int width = 800;
+    int height = 600;
+    bool isFullscreen = false;
+    bool isMaximized = false;
+    bool isMinimized = false;
+    bool isFocused = true;
+    bool isVisible = true;
+};
+
+class Window {
+public:
+    Window();
+    ~Window();
+
+    static Window create(const WindowConfig& config = {});
+
+    void setTitle(const std::string& title);
+    std::string getTitle() const;
+
+    void setSize(int width, int height);
+    void getSize(int& width, int& height) const;
+
+    void setMinSize(int minWidth, int minHeight);
+    void setMaxSize(int maxWidth, int maxHeight);
+
+    void setPosition(int x, int y);
+    void getPosition(int& x, int& y) const;
+
+    void center();
+    void setFullscreen(bool enabled);
+    bool isFullscreen() const;
+
+    void minimize();
+    void maximize();
+    void restore();
+    bool isMaximized() const;
+    bool isMinimized() const;
+
+    void show();
+    void hide();
+    bool isVisible() const;
+
+    void focus();
+    bool isFocused() const;
+
+    void setAlwaysOnTop(bool enabled);
+    void setResizable(bool enabled);
+
+    void setDecorations(bool enabled);
+    void setSkipTaskbar(bool enabled);
+
+    WindowState getState() const;
+
+    using MoveCallback = std::function<void(int x, int y)>;
+    using ResizeCallback = std::function<void(int width, int height)>;
+    using CloseCallback = std::function<void()>;
+    using FocusCallback = std::function<void(bool focused)>;
+    using StateCallback = std::function<void(WindowState state)>;
+
+    void onMove(MoveCallback callback);
+    void onResize(ResizeCallback callback);
+    void onClose(CloseCallback callback);
+    void onFocus(FocusCallback callback);
+    void onStateChange(StateCallback callback);
+
+    void* nativeHandle() const;
+
+private:
+    struct Impl;
+    std::unique_ptr<Impl> pImpl;
+};
+
+}
+
+#endif