view_bridge.hpp

Go to the documentation of this file.

#pragma once
 
#include <atomic>
#include <cstdlib>
#include <functional>
#include <memory>
#include <pulp/format/processor.hpp>
#include <pulp/runtime/alive_token.hpp>
#include <pulp/view/plugin_view_host.hpp>
#include <pulp/view/view.hpp>
#include <string>
#include <string_view>
#include <vector>
 
namespace pulp::view {
class ScriptedUiSession;
} // namespace pulp::view
 
namespace pulp::format {

inline bool dev_editor_hot_reload_enabled() {
    const char* v = std::getenv("PULP_DEV_HOT_RELOAD");
    if (!v) return false;
    switch (v[0]) {
        case '1': case 't': case 'T': case 'y': case 'Y': return true;
        default: return false;
    }
}

inline bool editor_content_first_open_enabled() {
    const char* v = std::getenv("PULP_EDITOR_OPEN");
    return !(v && std::string_view(v) == "view-first");
}

enum class ViewRole {
    Editor,
    Inspector,
};

std::uint32_t resolve_editor_background(const Processor& processor,
                                        const view::View* root) noexcept;
 
class ViewBridge {
public:
    struct Options {
        bool enable_hot_reload = false;  
        ViewRole role = ViewRole::Editor;
        bool defer_document_load = false;

        bool content_first_open = false;

        static Options hosted_editor() {
            return Options{.enable_hot_reload = dev_editor_hot_reload_enabled(),
                           .role = ViewRole::Editor,
                           .defer_document_load = true,
                           .content_first_open = editor_content_first_open_enabled()};
        }
    };
 
    ViewBridge(Processor& processor, state::StateStore& store);
    ViewBridge(Processor& processor, state::StateStore& store, Options options);
    ViewBridge(Processor& processor, state::StateStore& store,
               runtime::AliveToken::Handle owner_alive);
    ViewBridge(Processor& processor, state::StateStore& store,
               runtime::AliveToken::Handle owner_alive, Options options);
    ~ViewBridge();
 
    ViewBridge(const ViewBridge&) = delete;
    ViewBridge& operator=(const ViewBridge&) = delete;

    bool open(std::string* error = nullptr);

    bool prepare_first_frame(view::PluginViewHost& host);
 
    static constexpr int kFirstFrameSettleRounds = 8;
    static constexpr double kFirstFrameSettleBudgetMs = 120.0;

    void notify_attached();

    std::unique_ptr<view::View> release_view();

    void close();

    void resize(uint32_t width, uint32_t height);

    void notify_processor_destroyed() noexcept {
        if (owner_alive_) owner_alive_->store(false, std::memory_order_release);
        notify_owner_released();
    }

    bool notify_owner_released() noexcept;

    bool owner_is_alive() const noexcept {
        return runtime::AliveToken::is_alive(owner_alive_);
    }

    bool set_preferred_size(uint32_t width, uint32_t height);

    bool poll_editor_reload();

    bool rebuild_primary_view();
 
    bool is_open() const { return view_raw_ != nullptr; }
    ViewRole role() const { return options_.role; }
    view::View* view() { return view_raw_; }
    const view::View* view() const { return view_raw_; }
 
    bool uses_script_ui() const { return uses_script_ui_; }

    view::HostParamSurface* host_params();

    void set_host_actions(view::HostActionSurface* actions);
    view::HostActionSurface* host_actions() const { return host_actions_; }

    const std::shared_ptr<std::atomic<bool>>& alive_token() const { return alive_; }

    view::ScriptedUiSession* scripted_ui();
    const view::ScriptedUiSession* scripted_ui() const;

    void visit_scripted_ui(
        const std::function<void(view::ScriptedUiSession*)>& visitor);
    void visit_scripted_ui(
        const std::function<void(const view::ScriptedUiSession*)>& visitor) const;
 
    uint32_t width() const { return width_; }
    uint32_t height() const { return height_; }
    const ViewSize& size_hints() const { return size_hints_; }

    std::uint32_t editor_background_rgb() const { return editor_background_rgb_; }
 
    const std::string& last_error() const { return last_error_; }

    view::View* attach_secondary_view(std::unique_ptr<view::View> view, ViewRole role);

    bool detach_secondary_view(view::View* view);

    size_t view_count() const;

    view::View* view_at(size_t index);

    ViewRole role_at(size_t index) const;
 
private:
    bool poll_state_restore();

    void pump_store_listeners();

    std::size_t sync_design_frames_from_host();

    friend std::function<void()> make_editor_idle_pump(ViewBridge&);
    friend struct ViewBridgeTestAccess;
    Processor& processor_;
    state::StateStore& store_;
    Options options_;
    bool supports_editor_reload_ = false;
    runtime::AliveToken local_owner_alive_;
    runtime::AliveToken::Handle owner_alive_;
 
    std::unique_ptr<view::View> view_;
    view::View* view_raw_ = nullptr;  
    std::unique_ptr<view::StateStoreHostParamSurface> host_param_surface_;
    view::HostActionSurface* host_actions_ = nullptr;  
    std::unique_ptr<view::ScriptedUiSession> scripted_ui_;
    bool in_place_scripted_ui_reload_ = false;
    bool uses_script_ui_ = false;
    bool uses_auto_ui_ = false;  
    bool attached_ = false;  
    bool owner_release_notified_ = false; 
    bool released_ = false;  
    uint64_t last_reload_generation_ = 0;  
    uint64_t last_state_restore_revision_ = 0;
    std::shared_ptr<std::atomic<bool>> alive_ =
        std::make_shared<std::atomic<bool>>(true);
 
    struct Secondary {
        std::unique_ptr<view::View> view;
        ViewRole role;
    };
    std::vector<Secondary> secondaries_;
 
    ViewSize size_hints_;
    std::uint32_t editor_background_rgb_ = view::kEditorHostClearRgb;
    uint32_t width_ = 0;
    uint32_t height_ = 0;
    std::string last_error_;
};
 
namespace detail {

template <typename HostRequest>
bool negotiate_preferred_size(ViewBridge& bridge,
                              uint32_t width, uint32_t height,
                              HostRequest&& request) {
    const auto previous = bridge.size_hints();
    if (!bridge.set_preferred_size(width, height)) return false;
    if (request(width, height)) return true;
 
    // The declared bounds never change in set_preferred_size(), so a preferred
    // size that was valid before the transaction remains valid for rollback.
    bridge.set_preferred_size(previous.preferred_width,
                              previous.preferred_height);
    return false;
}

void view_editor_prewarm_scheduler(const Processor::EditorPrewarm& request);
 
} // namespace detail
 
} // namespace pulp::format