editor_ui.hpp

Go to the documentation of this file.

#pragma once
 
#include <pulp/format/editor_assets.hpp>
#include <pulp/format/processor.hpp>
#include <pulp/runtime/alive_token.hpp>
#include <pulp/runtime/exceptions.hpp>
#include <pulp/runtime/log.hpp>
#include <pulp/state/store.hpp>
#include <pulp/view/auto_ui.hpp>
#include <pulp/view/scripted_ui.hpp>
#include <pulp/view/value_channel_set.hpp>
#include <atomic>
#include <filesystem>
#include <memory>
#include <optional>
#include <string>
#include <string_view>
#include <system_error>
#include <vector>
 
namespace pulp::format {

inline view::ValueChannelAccess processor_value_channel_access(
    Processor& processor, runtime::AliveToken::Handle owner_alive) {
    return [processor = &processor, owner = std::move(owner_alive)](
               const view::ValueChannelVisitor& visitor) {
        if (!runtime::AliveToken::is_alive(owner)) {
            visitor(nullptr);
            return;
        }
        PULP_TRY { processor->visit_value_channels(visitor); }
        PULP_CATCH_ALL { visitor(nullptr); }
    };
}
 
struct EditorUiInstance {
    std::unique_ptr<view::View> root;
    std::unique_ptr<view::ScriptedUiSession> scripted_ui;
    bool uses_script_ui = false;
};

inline std::optional<std::filesystem::path> configured_ui_script_path(const EditorAssets& assets) {
    if (assets.script_path == nullptr || assets.script_path[0] == '\0')
        return std::nullopt;
    return std::filesystem::path{assets.script_path};
}

inline std::optional<std::filesystem::path> configured_ui_theme_path(const EditorAssets& assets) {
    if (assets.theme_path == nullptr || assets.theme_path[0] == '\0')
        return std::nullopt;
    return std::filesystem::path{assets.theme_path};
}

inline std::vector<std::filesystem::path> configured_ui_asset_roots(const EditorAssets& assets) {
    std::vector<std::filesystem::path> roots;
    if (assets.asset_roots == nullptr)
        return roots;
    std::string_view raw{assets.asset_roots};
    while (!raw.empty()) {
        const auto split = raw.find('|');
        const auto item = raw.substr(0, split);
        if (!item.empty()) roots.emplace_back(std::string(item));
        if (split == std::string_view::npos) break;
        raw.remove_prefix(split + 1);
    }
    return roots;
}

inline std::optional<std::filesystem::path> configured_ui_script_path() {
    return configured_ui_script_path(registered_editor_assets());
}

inline std::optional<std::filesystem::path> configured_ui_theme_path() {
    return configured_ui_theme_path(registered_editor_assets());
}

inline std::vector<std::filesystem::path> configured_ui_asset_roots() {
    return configured_ui_asset_roots(registered_editor_assets());
}

inline std::vector<view::WidgetBridge::EmbeddedAsset>
embedded_ui_assets(const EditorAssets& assets) {
    std::vector<view::WidgetBridge::EmbeddedAsset> files;
    if (assets.files == nullptr)
        return files;
    files.reserve(assets.file_count);
    for (std::size_t i = 0; i < assets.file_count; ++i) {
        const auto& file = assets.files[i];
        if (file.name == nullptr || file.name[0] == '\0' || file.data == nullptr || file.size == 0)
            continue;
        files.push_back({file.name, file.data, file.size});
    }
    return files;
}

struct EditorUiSource {
    std::filesystem::path script_path;
    std::string script_source;
    std::string theme_source;
    std::string script_name;
    std::vector<view::WidgetBridge::EmbeddedAsset> embedded_assets;
    bool available() const noexcept {
        return !script_path.empty() || !script_source.empty();
    }
    bool embedded() const noexcept {
        return script_path.empty() && !script_source.empty();
    }

    std::string label() const {
        return script_path.empty() ? script_name : script_path.string();
    }
};

inline EditorUiSource select_editor_ui_source(const EditorAssets& assets, bool enable_hot_reload) {
    EditorUiSource source;
    const auto dev_script_path = configured_ui_script_path(assets);
    const bool dev_file_present = [&] {
        if (!dev_script_path)
            return false;
        std::error_code ec;
        return std::filesystem::is_regular_file(*dev_script_path, ec) && !ec;
    }();
    if (embeds_editor_script(assets) && !(enable_hot_reload && dev_file_present)) {
        source.script_source.assign(reinterpret_cast<const char*>(assets.script),
                                    assets.script_size);
        if (assets.theme != nullptr && assets.theme_size > 0)
            source.theme_source.assign(reinterpret_cast<const char*>(assets.theme),
                                       assets.theme_size);
        source.script_name = assets.script_name != nullptr && assets.script_name[0] != '\0'
                                 ? assets.script_name
                                 : "ui.js";
        source.embedded_assets = embedded_ui_assets(assets);
        return source;
    }
    if (dev_script_path)
        source.script_path = *dev_script_path;
    return source;
}

using ScriptedEditorBuilder = EditorUiInstance (*)(const EditorAssets& assets,
                                                   EditorUiSource source, state::StateStore& store,
                                                   bool enable_hot_reload, std::string* error,
                                                   view::ValueChannelAccess value_channel_access,
                                                   std::string_view storage_identity);

inline std::atomic<ScriptedEditorBuilder>& scripted_editor_builder_slot() noexcept {
    static std::atomic<ScriptedEditorBuilder> builder{nullptr};
    return builder;
}

inline EditorUiInstance build_editor_ui_for_assets(const EditorAssets& assets,
                                                   state::StateStore& store, bool enable_hot_reload,
                                                   std::string* error,
                                                   view::ValueChannelAccess value_channel_access,
                                                   std::string_view storage_identity = {}) {
    // Selected once here: choosing it stats the on-disk script, and the
    // builder evaluates exactly the document this check found.
    if (auto source = select_editor_ui_source(assets, enable_hot_reload); source.available()) {
        if (auto builder = scripted_editor_builder_slot().load(std::memory_order_acquire)) {
            auto instance = builder(assets, std::move(source), store, enable_hot_reload, error,
                                    std::move(value_channel_access), storage_identity);
            if (instance.root)
                return instance;
        } else {
            const std::string missing =
                "this binary declares a scripted editor but does not link the script runtime; "
                "declare UI_SCRIPT on the plug-in target or call "
                "pulp::format::install_scripted_editor_builder()";
            runtime::log_error("Scripted editor UI not built: {}. Falling back to AutoUi.",
                               missing);
            if (error && error->empty())
                *error = missing;
        }
    }
 
    auto root = view::AutoUi::build(store);
    if (!root && error) {
        *error = "AutoUi::build() returned nullptr";
    }
    return {std::move(root), nullptr, false};
}

inline EditorUiInstance
build_editor_ui_with_value_channel_access(state::StateStore& store, bool enable_hot_reload,
                                          std::string* error,
                                          view::ValueChannelAccess value_channel_access) {
    return build_editor_ui_for_assets(registered_editor_assets(), store, enable_hot_reload, error,
                                      std::move(value_channel_access));
}

inline EditorUiInstance build_editor_ui(state::StateStore& store,
                                        bool enable_hot_reload,
                                        std::string* error = nullptr,
                                        view::ValueChannelSet* value_channels = nullptr) {
    view::ValueChannelAccess access;
    if (value_channels != nullptr) {
        access = [value_channels](const view::ValueChannelVisitor& visitor) {
            visitor(value_channels);
        };
    }
    return build_editor_ui_with_value_channel_access(
        store, enable_hot_reload, error, std::move(access));
}
 
} // namespace pulp::format