window_manager.hpp

Go to the documentation of this file.

#pragma once
 
#include <pulp/view/window_host.hpp>
#include <pulp/view/theme.hpp>
#include <cstdint>
#include <functional>
#include <memory>
#include <mutex>
#include <string>
#include <unordered_map>
#include <vector>
 
namespace pulp::view {
 
// ── Window type hints ───────────────────────────────────────────────────────
 
enum class WindowType {
    main,       
    palette,    
    inspector,  
    popup,      
    dialog      
};
 
// ── Screen / monitor information ────────────────────────────────────────────
 
struct ScreenInfo {
    int id = 0;                  
    float x = 0, y = 0;         
    float width = 0;             
    float height = 0;            
    float scale_factor = 1.0f;   
    bool is_primary = false;     
    std::string name;            
};
 
// ── Window state for save / restore ─────────────────────────────────────────
 
struct WindowState {
    float x = 0, y = 0;
    float width = 400, height = 300;
    int screen_id = 0;           
    bool is_visible = true;
};
 
// ── Per-window record in the manager ────────────────────────────────────────
 
using WindowId = uint32_t;
 
struct WindowRecord {
    WindowId id = 0;
    WindowType type = WindowType::main;
    WindowId parent_id = 0;      
    WindowHost* host = nullptr;  
    View* root_view = nullptr;   
    WindowState state;
    bool alive = true;
};
 
// ── Inter-window message ────────────────────────────────────────────────────
 
struct WindowMessage {
    std::string type;            
    std::string payload;         
    WindowId source = 0;         
};
 
using MessageHandler = std::function<void(const WindowMessage&)>;
 
// ── WindowManager ───────────────────────────────────────────────────────────
//
// Coordination layer for multiple windows. Manages:
//   - Registry of active windows
//   - Parent-child relationships and cascading close
//   - Theme propagation across all windows
//   - Inter-window message passing
//   - Screen/monitor enumeration
//   - Window state save/restore
//   - Shared GPU device reference for Dawn-based rendering
//
// Thread safety: all public methods are safe to call from the main thread.
// Audio-thread code should not call WindowManager directly.
 
class WindowManager {
public:
    WindowManager();
    ~WindowManager();
 
    WindowManager(const WindowManager&) = delete;
    WindowManager& operator=(const WindowManager&) = delete;
 
    // ── Window registration ─────────────────────────────────────────────

    WindowId register_window(WindowHost* host, View* root_view,
                             WindowType type, WindowId parent_id = 0);

    void unregister_window(WindowId id);

    const WindowRecord* window(WindowId id) const;

    std::vector<WindowId> window_ids() const;

    std::vector<WindowId> children_of(WindowId parent_id) const;

    size_t window_count() const;
 
    // ── Cascading close ─────────────────────────────────────────────────

    void close_window(WindowId id);

    void set_on_window_closed(std::function<void(WindowId)> cb);
 
    // ── Theme propagation ───────────────────────────────────────────────

    void set_shared_theme(const Theme& theme);

    const Theme& shared_theme() const;
 
    // ── Inter-window messaging ──────────────────────────────────────────

    void send_message(WindowId target, const WindowMessage& msg);

    void broadcast_message(const WindowMessage& msg);

    void set_message_handler(WindowId id, MessageHandler handler);
 
    // ── Screen enumeration ──────────────────────────────────────────────

    static std::vector<ScreenInfo> available_screens();

    static ScreenInfo primary_screen();
 
    // ── Window state save / restore ─────────────────────────────────────

    std::unordered_map<WindowId, WindowState> save_all_states() const;

    void restore_state(WindowId id, const WindowState& state);
 
    // ── GPU device sharing ──────────────────────────────────────────────

    void set_shared_gpu_device(void* device_handle);

    void* shared_gpu_device() const;
 
    // ── Multi-window capability query ───────────────────────────────────

    static bool is_multi_window_supported();
 
private:
    WindowId next_id_ = 1;
 
    // Ordered map would give deterministic iteration, but unordered is fine
    // for the expected window count (< 20).
    std::unordered_map<WindowId, WindowRecord> windows_;
    std::unordered_map<WindowId, MessageHandler> handlers_;
 
    Theme shared_theme_;
    void* shared_gpu_device_ = nullptr;
 
    std::function<void(WindowId)> on_window_closed_;
 
    // Collect children recursively (depth-first).
    void collect_descendants(WindowId id, std::vector<WindowId>& out) const;
};
 
} // namespace pulp::view