window_classes.hpp

Go to the documentation of this file.

#pragma once
 
// High-level window classes.
//
// The low-level `WindowHost` contract owns native chrome,
// `attach_native_child_view`, and multi-window plumbing via WindowManager.
// These Pulp-native wrappers cover the three window patterns a standalone app
// — or a plugin's secondary window — needs in practice:
//
//   - `DocumentWindow` — a top-level document/editor window with a stored menu
//     descriptor, a content area that hosts a View tree, and a close-confirmation hook
//     ("Save changes?") that fires before the close actually happens.
//
//   - `DialogWindow` — a modal/quasi-modal dialog with explicit OK / Cancel
//     buttons. Dispatches a `DialogResult` (`ok` / `cancel` / `closed`) to
//     a user-supplied completion handler.
//
//   - `AlertWindow` — a simple titled message + N labeled buttons + an
//     icon hint (info / warning / error / question). Convenience overloads
//     for the three most common shapes: `info()`, `confirm()`, `error()`.
//
// All three are composition wrappers around `pulp::view::WindowHost`. They do
// NOT subclass it — that keeps the test surface small and avoids leaking
// platform plumbing into the high-level API. Headless tests construct them
// without a window factory and drive the lifecycle hooks directly.
 
#include <pulp/view/view.hpp>
#include <pulp/view/window_host.hpp>
 
#include <functional>
#include <memory>
#include <string>
#include <vector>
 
namespace pulp::view {
 
// ── DocumentWindow ─────────────────────────────────────────────────────────
 
class DocumentWindow {
public:
    using CloseConfirmationHandler = std::function<bool()>;

    struct MenuItem {
        std::string title;
        std::function<void()> action;
        // Future: shortcut, enabled flag, submenu pointer. Kept minimal so
        // the API can grow additively without breaking callers.
    };

    struct Menu {
        std::string title;
        std::vector<MenuItem> items;
    };
 
    DocumentWindow(const std::string& title, View& content_root);
    ~DocumentWindow();
 
    DocumentWindow(const DocumentWindow&) = delete;
    DocumentWindow& operator=(const DocumentWindow&) = delete;
    DocumentWindow(DocumentWindow&&) = delete;
    DocumentWindow& operator=(DocumentWindow&&) = delete;

    void set_menus(std::vector<Menu> menus);
    const std::vector<Menu>& menus() const { return menus_; }

    CloseConfirmationHandler set_close_confirmation_handler(CloseConfirmationHandler handler);

    bool request_close();

    View& content() { return *content_root_; }
    const View& content() const { return *content_root_; }

    const std::string& title() const { return title_; }

    WindowHost* host() { return host_.get(); }

    bool show();

    void hide();

    bool has_native_window() const { return host_ != nullptr; }
 
private:
    std::string title_;
    View* content_root_ = nullptr;
    std::vector<Menu> menus_;
    CloseConfirmationHandler close_handler_;
    std::unique_ptr<WindowHost> host_;
};
 
// ── DialogWindow ───────────────────────────────────────────────────────────
 
enum class DialogResult {
    ok,
    cancel,
    closed,  
};
 
class DialogWindow {
public:
    using CompletionHandler = std::function<void(DialogResult)>;
 
    DialogWindow(const std::string& title, View& content_root);
    ~DialogWindow();
 
    DialogWindow(const DialogWindow&) = delete;
    DialogWindow& operator=(const DialogWindow&) = delete;

    void set_ok_label(std::string label) { ok_label_ = std::move(label); }
    const std::string& ok_label() const { return ok_label_; }

    void set_cancel_label(std::string label) { cancel_label_ = std::move(label); }
    const std::string& cancel_label() const { return cancel_label_; }

    void set_completion_handler(CompletionHandler handler) {
        completion_ = std::move(handler);
    }

    bool show(bool modal = true);

    void dismiss(DialogResult result);
 
    bool is_dismissed() const { return dismissed_; }
    DialogResult last_result() const { return last_result_; }
    bool is_modal() const { return modal_; }
    const std::string& title() const { return title_; }
 
    View& content() { return *content_root_; }
    WindowHost* host() { return host_.get(); }
 
private:
    std::string title_;
    View* content_root_ = nullptr;
    std::string ok_label_ = "OK";
    std::string cancel_label_ = "Cancel";
    CompletionHandler completion_;
    std::unique_ptr<WindowHost> host_;
    bool dismissed_ = false;
    bool modal_ = false;
    DialogResult last_result_ = DialogResult::closed;
};
 
// ── AlertWindow ────────────────────────────────────────────────────────────
 
enum class AlertIcon {
    none,
    info,
    warning,
    error,
    question,
};
 
class AlertWindow {
public:
    using ButtonHandler = std::function<void(std::size_t /*index*/)>;
 
    AlertWindow(const std::string& title, const std::string& message,
                AlertIcon icon = AlertIcon::info);
    ~AlertWindow();
 
    AlertWindow(const AlertWindow&) = delete;
    AlertWindow& operator=(const AlertWindow&) = delete;

    std::size_t add_button(std::string label);

    void set_button_handler(ButtonHandler handler) {
        button_handler_ = std::move(handler);
    }

    bool show();

    void click_button(std::size_t index);
 
    bool is_dismissed() const { return dismissed_; }
    std::size_t button_count() const { return buttons_.size(); }
    const std::string& button_label(std::size_t i) const { return buttons_.at(i); }
    AlertIcon icon() const { return icon_; }
    const std::string& title() const { return title_; }
    const std::string& message() const { return message_; }
    WindowHost* host() { return host_.get(); }
 
    // ── Convenience factories ────────────────────────────────────────────

    static std::unique_ptr<AlertWindow> info(const std::string& title,
                                             const std::string& message,
                                             ButtonHandler handler = {});

    static std::unique_ptr<AlertWindow> confirm(const std::string& title,
                                                const std::string& message,
                                                ButtonHandler handler = {});

    static std::unique_ptr<AlertWindow> error(const std::string& title,
                                              const std::string& message,
                                              ButtonHandler handler = {});

    static std::unique_ptr<AlertWindow> warning(const std::string& title,
                                                const std::string& message,
                                                ButtonHandler handler = {});
 
    // ── Styled-variant theme tokens ───────────────────────────────────

    struct StyleTokens {
        const char* icon_color = "";       
        const char* accent_color = "";     
        const char* glyph = "";            
    };

    static StyleTokens style_tokens_for(AlertIcon icon);

    StyleTokens style_tokens() const { return style_tokens_for(icon_); }
 
private:
    std::string title_;
    std::string message_;
    AlertIcon icon_;
    std::vector<std::string> buttons_;
    ButtonHandler button_handler_;
    std::unique_ptr<View> root_view_;
    std::unique_ptr<WindowHost> host_;
    bool dismissed_ = false;
};
 
} // namespace pulp::view