plugin_manager_panel.hpp

Go to the documentation of this file.

#pragma once

 
#include <pulp/canvas/canvas.hpp>
#include <pulp/view/input_events.hpp>
#include <pulp/view/view.hpp>
 
// iOS skip: pulp::host is not linked or installed on iOS (App Store policy
// disallows dlopen of third-party plugins), so the host scanner headers are
// not on the include path there. `__has_include` lets downstream code
// include this header unconditionally and key feature presence on the
// `PULP_VIEW_HAS_PLUGIN_MANAGER_PANEL` macro defined below.
// PluginManagerPanel is an opt-in host-backed widget, not part of the
// view-only link surface. Desktop consumers that instantiate it must link
// both `pulp::view` and `pulp::host`.
#if defined(__has_include) && __has_include(<pulp/host/scanner.hpp>)
#define PULP_VIEW_HAS_PLUGIN_MANAGER_PANEL 1
 
#include <pulp/host/scan_blacklist.hpp>
#include <pulp/host/scanner.hpp>
 
#include <algorithm>
#include <atomic>
#include <chrono>
#include <functional>
#include <memory>
#include <optional>
#include <string>
#include <unordered_map>
#include <vector>
 
namespace pulp::view {

struct PluginManagerRow {
    pulp::host::PluginFormat format = pulp::host::PluginFormat::CLAP;
    std::string name;                
    std::string path;                
    std::string reason;              
    std::int64_t last_scan_unix = 0; 
 
    // ── Item 4.3 — drag-add identity ─────────────────────────────────────
    // The fields below are populated by the model so a drag-add into a
    // SignalGraph can synthesize the PluginInfo without having to re-scan
    // or look the row up by path. They are intentionally optional — older
    // models that pre-date item 4.3 leave them at defaults and the
    // resulting drop produces an "unresolved" graph node (PluginSlot::load
    // is still attempted via `to_plugin_info`).
    std::string manufacturer;
    std::string version;
    std::string unique_id;
    int num_inputs = 2;
    int num_outputs = 2;
    bool is_instrument = false;
    bool is_effect = true;

    pulp::host::PluginInfo to_plugin_info() const {
        pulp::host::PluginInfo info;
        info.name = name;
        info.manufacturer = manufacturer;
        info.version = version;
        info.path = path;
        info.unique_id = unique_id;
        info.format = format;
        info.is_instrument = is_instrument;
        info.is_effect = is_effect;
        info.num_inputs = num_inputs;
        info.num_outputs = num_outputs;
        return info;
    }
};

enum class PluginManagerBucket : std::uint8_t {
    scanned = 0,
    failed = 1,
    blacklisted = 2,
};

class PluginManagerModel {
  public:
    virtual ~PluginManagerModel() = default;

    virtual std::vector<PluginManagerRow> rows(PluginManagerBucket bucket) const = 0;

    virtual std::vector<std::string> search_paths(pulp::host::PluginFormat fmt) const = 0;
    virtual void add_search_path(pulp::host::PluginFormat fmt, std::string path) = 0;
    virtual void remove_search_path(pulp::host::PluginFormat fmt, const std::string& path) = 0;

    virtual void start_rescan() = 0;

    virtual void start_rescan(const std::string& path) = 0;

    virtual float progress_fraction() const = 0;

    virtual bool is_scanning() const = 0;

    virtual bool is_blacklisted(const std::string& path) const = 0;
    virtual void set_blacklisted(const std::string& path, bool blacklisted,
                                 const std::string& reason = "user") = 0;

    virtual void reveal_in_file_manager(const std::string& /*path*/) {}
};
 
// ── Mock / in-memory model for tests and examples ────────────────────────

class InMemoryPluginManagerModel : public PluginManagerModel {
  public:
    std::vector<PluginManagerRow> scanned_rows;
    std::vector<PluginManagerRow> failed_rows;
    std::unordered_map<int, std::vector<std::string>> paths_by_format;
    pulp::host::ScanBlacklist blacklist;
 
    // Externally observable progress state — tests can tick this by hand.
    std::atomic<float> progress{1.0f};
    std::atomic<bool> scanning{false};

    int rescan_count = 0;
    int single_rescan_count = 0;
    std::string last_single_rescan_path;
    int reveal_count = 0;
    std::string last_reveal_path;
 
    std::vector<PluginManagerRow> rows(PluginManagerBucket bucket) const override {
        switch (bucket) {
        case PluginManagerBucket::scanned:
            return filter_scanned();
        case PluginManagerBucket::failed:
            return failed_rows;
        case PluginManagerBucket::blacklisted:
            return blacklist_rows();
        }
        return {};
    }
 
    std::vector<std::string> search_paths(pulp::host::PluginFormat fmt) const override {
        auto it = paths_by_format.find(static_cast<int>(fmt));
        if (it == paths_by_format.end())
            return {};
        return it->second;
    }
    void add_search_path(pulp::host::PluginFormat fmt, std::string path) override {
        auto& v = paths_by_format[static_cast<int>(fmt)];
        if (std::find(v.begin(), v.end(), path) == v.end())
            v.push_back(std::move(path));
    }
    void remove_search_path(pulp::host::PluginFormat fmt, const std::string& path) override {
        auto& v = paths_by_format[static_cast<int>(fmt)];
        v.erase(std::remove(v.begin(), v.end(), path), v.end());
    }
 
    void start_rescan() override {
        ++rescan_count;
    }
    void start_rescan(const std::string& path) override {
        ++single_rescan_count;
        last_single_rescan_path = path;
    }
    float progress_fraction() const override {
        return progress.load();
    }
    bool is_scanning() const override {
        return scanning.load();
    }
 
    bool is_blacklisted(const std::string& path) const override {
        return blacklist.is_blacklisted(path);
    }
    void set_blacklisted(const std::string& path, bool on, const std::string& reason) override {
        if (on)
            blacklist.blacklist(path, reason.empty() ? "user" : reason);
        else
            blacklist.clear(path);
    }
    void reveal_in_file_manager(const std::string& path) override {
        ++reveal_count;
        last_reveal_path = path;
    }
 
  private:
    std::vector<PluginManagerRow> filter_scanned() const {
        // Scanned bucket excludes anything the user has blacklisted.
        std::vector<PluginManagerRow> out;
        out.reserve(scanned_rows.size());
        for (const auto& r : scanned_rows) {
            if (!blacklist.is_blacklisted(r.path))
                out.push_back(r);
        }
        return out;
    }
    std::vector<PluginManagerRow> blacklist_rows() const {
        std::vector<PluginManagerRow> out;
        for (const auto& [path, entry] : blacklist.entries()) {
            PluginManagerRow row;
            row.path = path;
            row.reason = entry.reason;
            row.last_scan_unix = entry.mtime;
            // Pull format / name from the scanned list if we remember it.
            for (const auto& s : scanned_rows) {
                if (s.path == path) {
                    row.format = s.format;
                    row.name = s.name;
                    break;
                }
            }
            out.push_back(std::move(row));
        }
        return out;
    }
};
 
// ── The widget itself ────────────────────────────────────────────────────

class PluginManagerPanel : public View {
  public:
    explicit PluginManagerPanel(PluginManagerModel& model) : model_(&model) {
        set_focusable(true);
        set_access_role(AccessRole::group);
        set_access_label("Plugin manager");
        refresh();
    }
 
    // ── Observable state (public for tests) ──────────────────────────────

    void refresh() {
        scanned_ = model_->rows(PluginManagerBucket::scanned);
        failed_ = model_->rows(PluginManagerBucket::failed);
        blacklisted_ = model_->rows(PluginManagerBucket::blacklisted);
        apply_filter();
    }

    int visible_count(PluginManagerBucket b) const {
        return static_cast<int>(visible(b).size());
    }
    const std::vector<PluginManagerRow>& rows(PluginManagerBucket b) const {
        return visible(b);
    }

    void set_filter(std::string text) {
        filter_ = std::move(text);
        apply_filter();
    }
    const std::string& filter() const {
        return filter_;
    }

    PluginManagerModel& model() {
        return *model_;
    }
    const PluginManagerModel& model() const {
        return *model_;
    }
 
    // ── Rescan button ────────────────────────────────────────────────────

    void trigger_rescan() {
        model_->start_rescan();
    }

    void trigger_rescan(const std::string& path) {
        model_->start_rescan(path);
    }

    void toggle_blacklist(const std::string& path) {
        const bool now = !model_->is_blacklisted(path);
        model_->set_blacklisted(path, now, "user");
        refresh();
    }

    void reveal_in_file_manager(const std::string& path) {
        model_->reveal_in_file_manager(path);
    }
 
    // ── Per-format search paths ──────────────────────────────────────────
 
    std::vector<std::string> search_paths(pulp::host::PluginFormat fmt) const {
        return model_->search_paths(fmt);
    }
    void add_search_path(pulp::host::PluginFormat fmt, std::string path) {
        model_->add_search_path(fmt, std::move(path));
    }
    void remove_search_path(pulp::host::PluginFormat fmt, const std::string& path) {
        model_->remove_search_path(fmt, path);
    }
 
    // ── Context menu (right-click) ───────────────────────────────────────

    const std::string& context_menu_path() const {
        return context_menu_path_;
    }
    PluginManagerBucket context_menu_bucket() const {
        return context_menu_bucket_;
    }

    enum class ContextItem : std::uint8_t {
        rescan_this = 0,
        toggle_blacklist = 1,
        reveal_in_file_manager = 2,
    };
    static std::vector<ContextItem> context_menu_items() {
        return {ContextItem::rescan_this, ContextItem::toggle_blacklist,
                ContextItem::reveal_in_file_manager};
    }

    std::string context_menu_label(ContextItem item) const {
        switch (item) {
        case ContextItem::rescan_this:
            return "Rescan just this plugin";
        case ContextItem::toggle_blacklist:
            if (!context_menu_path_.empty() && model_->is_blacklisted(context_menu_path_))
                return "Remove from blacklist";
            return "Add to blacklist";
        case ContextItem::reveal_in_file_manager:
#if defined(_WIN32)
            return "Show in Explorer";
#elif defined(__APPLE__)
            return "Show in Finder";
#else
            return "Show in file manager";
#endif
        }
        return {};
    }

    void activate_context_item(ContextItem item) {
        if (context_menu_path_.empty())
            return;
        switch (item) {
        case ContextItem::rescan_this:
            trigger_rescan(context_menu_path_);
            break;
        case ContextItem::toggle_blacklist:
            toggle_blacklist(context_menu_path_);
            break;
        case ContextItem::reveal_in_file_manager:
            reveal_in_file_manager(context_menu_path_);
            break;
        }
    }

    void open_context_menu(PluginManagerBucket b, const std::string& path) {
        context_menu_bucket_ = b;
        context_menu_path_ = path;
    }
    void close_context_menu() {
        context_menu_path_.clear();
    }
 
    // ── Accessibility labels for the three columns ──────────────────────
    //
    // Exposed so external a11y checkers and tests can verify that each
    // column carries a meaningful screen-reader label independent of the
    // visual rendering. Values deliberately include the row counts.
    std::string column_access_label(PluginManagerBucket b) const {
        const auto& v = visible(b);
        const char* name = b == PluginManagerBucket::scanned  ? "Scanned plugins"
                           : b == PluginManagerBucket::failed ? "Failed plugins"
                                                              : "Blacklisted plugins";
        return std::string(name) + " — " + std::to_string(v.size()) +
               (v.size() == 1 ? " entry" : " entries");
    }
 
    // ── View overrides ──────────────────────────────────────────────────
 
    void paint(canvas::Canvas& canvas) override {
        const auto b = local_bounds();
 
        canvas.set_fill_color(resolve_color("plugin_manager_bg", canvas::Color::hex(0x16213e)));
        canvas.fill_rounded_rect(b.x, b.y, b.width, b.height, 6);
 
        // ── Toolbar: search + rescan + progress bar ──────────────────────
        const float toolbar_h = 28.0f;
        canvas.set_fill_color(resolve_color("surface", canvas::Color::hex(0x1a1a2e)));
        canvas.fill_rect(b.x, b.y, b.width, toolbar_h);
 
        canvas.set_font("system", 12);
        canvas.set_fill_color(resolve_color("text", canvas::Color::hex(0xe0e0e0)));
        const std::string filter_label =
            filter_.empty() ? "Search: (type to filter)" : "Search: " + filter_;
        canvas.fill_text(filter_label, b.x + 8, b.y + 18);
 
        const float button_w = 96.0f;
        const float button_x = b.x + b.width - button_w - 8.0f;
        canvas.set_fill_color(resolve_color("accent", canvas::Color::hex(0xe94560)));
        canvas.fill_rounded_rect(button_x, b.y + 4, button_w, toolbar_h - 8, 4);
        canvas.set_fill_color(canvas::Color::hex(0xffffff));
        canvas.fill_text(model_->is_scanning() ? "Scanning…" : "Rescan", button_x + 12, b.y + 18);
 
        if (model_->is_scanning()) {
            const float pb_x = b.x + b.width - button_w - 8.0f - 120.0f;
            const float pb_w = 110.0f;
            canvas.set_fill_color(resolve_color("progress_track", canvas::Color::hex(0x0f3460)));
            canvas.fill_rect(pb_x, b.y + 10, pb_w, 8);
            canvas.set_fill_color(resolve_color("progress_fill", canvas::Color::hex(0x4ade80)));
            const float f = std::clamp(model_->progress_fraction(), 0.0f, 1.0f);
            canvas.fill_rect(pb_x, b.y + 10, pb_w * f, 8);
        }
 
        // ── Three columns ───────────────────────────────────────────────
        const float col_w = (b.width - 16.0f) / 3.0f;
        const float col_y = b.y + toolbar_h + 4.0f;
        const float col_h = b.height - toolbar_h - 8.0f;
 
        paint_column(canvas, b.x + 4.0f, col_y, col_w, col_h, PluginManagerBucket::scanned,
                     "Scanned");
        paint_column(canvas, b.x + 4.0f + col_w, col_y, col_w, col_h, PluginManagerBucket::failed,
                     "Failed");
        paint_column(canvas, b.x + 4.0f + col_w * 2.0f, col_y, col_w, col_h,
                     PluginManagerBucket::blacklisted, "Blacklisted");
    }
 
    void on_mouse_event(const MouseEvent& event) override {
        if (!event.is_down)
            return;
 
        const auto b = local_bounds();
        const float toolbar_h = 28.0f;
 
        // Rescan button
        const float button_w = 96.0f;
        const float button_x = b.x + b.width - button_w - 8.0f;
        if (event.position.y < toolbar_h && event.position.x >= button_x &&
            event.position.x <= button_x + button_w) {
            trigger_rescan();
            return;
        }
 
        // Column hit test
        const float col_w = (b.width - 16.0f) / 3.0f;
        const int col_idx = static_cast<int>((event.position.x - 4.0f) / col_w);
        const PluginManagerBucket bucket = col_idx <= 0   ? PluginManagerBucket::scanned
                                           : col_idx == 1 ? PluginManagerBucket::failed
                                                          : PluginManagerBucket::blacklisted;
 
        const float col_y = toolbar_h + 4.0f;
        const float header_h = 20.0f;
        const float row_y = event.position.y - col_y - header_h;
        if (row_y < 0)
            return;
 
        const auto& rows_vec = visible(bucket);
        const int row = static_cast<int>(row_y / row_height_);
        if (row < 0 || row >= static_cast<int>(rows_vec.size())) {
            close_context_menu();
            return;
        }
 
        const auto& hit = rows_vec[static_cast<size_t>(row)];
        if (event.button == MouseButton::right) {
            open_context_menu(bucket, hit.path);
        } else {
            selected_path_ = hit.path;
            selected_bucket_ = bucket;
            if (on_row_selected)
                on_row_selected(bucket, hit);
        }
    }
 
    // ── Drag-add into a SignalGraph (item 4.3) ───────────────────────────
    //
    // The panel itself is rendering-only — it does not know what surface
    // (graph editor, mixer column, etc.) the user is dropping onto. We
    // emit a `on_row_drag_start` callback when the user presses on a
    // scanned row and drags past `drag_threshold_px_`. The host is
    // responsible for taking the row's `PluginInfo` and adding the node
    // to whichever `SignalGraph` the drop landed on (see
    // `pulp::host::add_plugin_node_from_drop`).
    //
    // The drag callback fires only for rows in the `scanned` bucket —
    // dragging a failed or blacklisted entry into the graph would create
    // a node that can never load, so the panel suppresses it.
 
    void on_mouse_down(Point pos) override {
        drag_origin_ = pos;
        drag_origin_set_ = true;
        drag_started_ = false;
        drag_row_ = identify_row_at(pos);
    }
    void on_mouse_drag(Point pos) override {
        if (drag_origin_set_ && !drag_started_ && drag_row_.has_value()) {
            const float dx = pos.x - drag_origin_.x;
            const float dy = pos.y - drag_origin_.y;
            if (dx * dx + dy * dy >= drag_threshold_px_ * drag_threshold_px_) {
                drag_started_ = true;
                if (on_row_drag_start && drag_row_->first == PluginManagerBucket::scanned) {
                    on_row_drag_start(drag_row_->first, drag_row_->second, pos);
                }
            }
        }
    }
    void on_mouse_up(Point pos) override {
        if (drag_started_ && drag_row_.has_value() && on_row_drag_end) {
            on_row_drag_end(drag_row_->first, drag_row_->second, pos);
        }
        drag_origin_set_ = false;
        drag_started_ = false;
        drag_row_.reset();
    }
    bool wants_mouse_input() const override {
        return true;
    }

    bool simulate_row_drag(PluginManagerBucket bucket, const std::string& path,
                           Point drop_position = {0, 0}) {
        const auto& rows_vec = visible(bucket);
        for (const auto& r : rows_vec) {
            if (r.path == path) {
                if (bucket == PluginManagerBucket::scanned && on_row_drag_start) {
                    on_row_drag_start(bucket, r, drop_position);
                }
                if (on_row_drag_end) {
                    on_row_drag_end(bucket, r, drop_position);
                }
                return true;
            }
        }
        return false;
    }

    float drag_threshold_px() const {
        return drag_threshold_px_;
    }
    void set_drag_threshold_px(float px) {
        drag_threshold_px_ = px;
    }

    std::function<void(PluginManagerBucket, const PluginManagerRow&, Point)> on_row_drag_start;

    std::function<void(PluginManagerBucket, const PluginManagerRow&, Point)> on_row_drag_end;
 
    bool on_key_event(const KeyEvent& event) override {
        if (!event.is_down)
            return false;
        // Type-to-filter: printable keys land in `on_text_input` on most
        // backends, but we also support backspace here so focus-only flows
        // still work in tests.
        if (event.key == KeyCode::backspace && !filter_.empty()) {
            filter_.pop_back();
            apply_filter();
            return true;
        }
        return false;
    }
    void on_text_input(const TextInputEvent& event) override {
        filter_ += event.text;
        apply_filter();
    }
 
    // Callback fired when a row is left-clicked. Optional.
    std::function<void(PluginManagerBucket, const PluginManagerRow&)> on_row_selected;
 
    // Row height is exposed so tests can synthesize click coordinates.
    float row_height() const {
        return row_height_;
    }
    void set_row_height(float h) {
        row_height_ = h;
    }
 
  private:
    PluginManagerModel* model_;
 
    std::vector<PluginManagerRow> scanned_, failed_, blacklisted_;
    std::vector<PluginManagerRow> scanned_view_, failed_view_, blacklisted_view_;
 
    std::string filter_;
    std::string selected_path_;
    PluginManagerBucket selected_bucket_ = PluginManagerBucket::scanned;
 
    std::string context_menu_path_;
    PluginManagerBucket context_menu_bucket_ = PluginManagerBucket::scanned;
 
    float row_height_ = 22.0f;
 
    // Drag-add state (item 4.3)
    Point drag_origin_{0, 0};
    bool drag_origin_set_ = false;
    bool drag_started_ = false;
    std::optional<std::pair<PluginManagerBucket, PluginManagerRow>> drag_row_;
    float drag_threshold_px_ = 4.0f;
 
    std::optional<std::pair<PluginManagerBucket, PluginManagerRow>>
    identify_row_at(Point pos) const {
        const auto b = local_bounds();
        const float toolbar_h = 28.0f;
        if (pos.y < toolbar_h)
            return std::nullopt;
 
        const float col_w = (b.width - 16.0f) / 3.0f;
        const int col_idx = static_cast<int>((pos.x - 4.0f) / col_w);
        const PluginManagerBucket bucket = col_idx <= 0   ? PluginManagerBucket::scanned
                                           : col_idx == 1 ? PluginManagerBucket::failed
                                                          : PluginManagerBucket::blacklisted;
 
        const float header_h = 20.0f;
        const float row_y = pos.y - toolbar_h - 4.0f - header_h;
        if (row_y < 0)
            return std::nullopt;
 
        const auto& rows_vec = visible(bucket);
        const int row = static_cast<int>(row_y / row_height_);
        if (row < 0 || row >= static_cast<int>(rows_vec.size()))
            return std::nullopt;
        return std::make_pair(bucket, rows_vec[static_cast<size_t>(row)]);
    }
 
    const std::vector<PluginManagerRow>& visible(PluginManagerBucket b) const {
        switch (b) {
        case PluginManagerBucket::scanned:
            return scanned_view_;
        case PluginManagerBucket::failed:
            return failed_view_;
        case PluginManagerBucket::blacklisted:
            return blacklisted_view_;
        }
        return scanned_view_;
    }
 
    static std::string to_lower(std::string s) {
        std::transform(s.begin(), s.end(), s.begin(),
                       [](unsigned char c) { return static_cast<char>(std::tolower(c)); });
        return s;
    }
 
    void apply_filter() {
        scanned_view_ = apply_filter_to(scanned_);
        failed_view_ = apply_filter_to(failed_);
        blacklisted_view_ = apply_filter_to(blacklisted_);
    }
    std::vector<PluginManagerRow> apply_filter_to(const std::vector<PluginManagerRow>& in) const {
        if (filter_.empty())
            return in;
        const std::string f = to_lower(filter_);
        std::vector<PluginManagerRow> out;
        out.reserve(in.size());
        for (const auto& r : in) {
            if (to_lower(r.name).find(f) != std::string::npos ||
                to_lower(r.path).find(f) != std::string::npos) {
                out.push_back(r);
            }
        }
        return out;
    }
 
    static const char* format_label(pulp::host::PluginFormat f) {
        switch (f) {
        case pulp::host::PluginFormat::VST3:
            return "VST3";
        case pulp::host::PluginFormat::AudioUnit:
            return "AU";
        case pulp::host::PluginFormat::AudioUnitV3:
            return "AUv3";
        case pulp::host::PluginFormat::CLAP:
            return "CLAP";
        case pulp::host::PluginFormat::LV2:
            return "LV2";
        }
        return "?";
    }
 
    static std::string format_time(std::int64_t unix_seconds) {
        if (unix_seconds <= 0)
            return "never";
        std::time_t t = static_cast<std::time_t>(unix_seconds);
        std::tm tm{};
#if defined(_WIN32)
        localtime_s(&tm, &t);
#else
        localtime_r(&t, &tm);
#endif
        char buf[32];
        std::strftime(buf, sizeof(buf), "%Y-%m-%d %H:%M", &tm);
        return buf;
    }
 
    void paint_column(canvas::Canvas& canvas, float x, float y, float w, float h,
                      PluginManagerBucket bucket, const char* title) {
        canvas.set_fill_color(resolve_color("list_bg", canvas::Color::hex(0x0d1b33)));
        canvas.fill_rect(x, y, w, h);
 
        // Column header
        const float header_h = 20.0f;
        canvas.set_fill_color(resolve_color("surface", canvas::Color::hex(0x1a1a2e)));
        canvas.fill_rect(x, y, w, header_h);
 
        canvas.set_font("system", 12);
        canvas.set_fill_color(resolve_color("text", canvas::Color::hex(0xe0e0e0)));
        const std::string label =
            std::string(title) + " (" + std::to_string(visible(bucket).size()) + ")";
        canvas.fill_text(label, x + 6, y + 14);
 
        // Rows
        canvas.save();
        canvas.clip_rect(x, y + header_h, w, h - header_h);
        float ry = y + header_h + 2.0f;
        const auto& rows_vec = visible(bucket);
        for (const auto& r : rows_vec) {
            canvas.set_font("system", 11);
            const std::string fmt_name = format_label(r.format);
            const std::string headline = fmt_name + "  " + (r.name.empty() ? r.path : r.name);
            canvas.set_fill_color(resolve_color("text", canvas::Color::hex(0xe0e0e0)));
            canvas.fill_text(headline, x + 6, ry + 12);
            canvas.set_fill_color(resolve_color("text_muted", canvas::Color::hex(0x808090)));
            canvas.set_font("system", 10);
            canvas.fill_text(format_time(r.last_scan_unix), x + 6, ry + 24);
            ry += row_height_;
            if (ry > y + h)
                break;
        }
        canvas.restore();
    }
};
 
} // namespace pulp::view
 
#else // !__has_include(<pulp/host/scanner.hpp>)
#define PULP_VIEW_HAS_PLUGIN_MANAGER_PANEL 0
#endif