ui_components.hpp

Go to the documentation of this file.

#pragma once

 
#include <pulp/view/view.hpp>
#include <pulp/view/accessibility.hpp>
#include <pulp/view/input_events.hpp>
#include <algorithm>
#include <pulp/view/animation.hpp>
#include <pulp/view/appearance_tracker.hpp>
#include <pulp/view/slider_core.hpp>  // Notify, queue_async_notification
#include <pulp/canvas/canvas.hpp>
#include <functional>
#include <string>
#include <string_view>
#include <vector>
#include <memory>
 
namespace pulp::view {
 
// Fit a label into `avail` px. Prefer SHRINKING the font from `base` toward
// `min` to show the full text; only ellipsize (in-place, with "...") if it still
// overflows at `min`. `width_at(s, f)` returns the rendered width of `s` at font
// size `f` (e.g. a canvas set_font + measure_text). Returns the chosen font
// size and rewrites `text` to the string to draw. Pure logic — unit-tested
// independently of any canvas (a ComboBox box is often sized tight to a design's
// own label, so truncating reads worse than a slightly smaller full label).
float fit_combo_label(std::string& text, float avail, float base, float min,
                      const std::function<float(const std::string&, float)>& width_at);
 
// ── ComboBox ─────────────────────────────────────────────────────────────

class ComboBox : public View {
public:
    // A ComboBox is a dropdown, not a continuous range. It announced itself
    // as AccessRole::slider until the role vocabulary grew `combo_box`, so
    // VoiceOver / Narrator / Orca all told the user "slider" and offered
    // increment/decrement instead of a list of choices.
    ComboBox() {
        set_focusable(true);
        set_access_role(AccessRole::combo_box);
        // Opening a dropdown IS this control's purpose, so a press on it while
        // a different overlay is open means "switch menus": the dismissal
        // policy lets that press through instead of spending it on the close.
        set_overlay_trigger(true);
    }
 
    // pulp #1818 — clear the popup slot if this dying ComboBox holds it.
    // Without this, an unmounted React dropdown leaves a dangling pointer that
    // the platform window host dereferences on the next mouseDown (PAC failure
    // on the vtable load — exact crash signature in the issue). Clears BOTH the
    // root-owned slot (S11, non-allocating) and the process-global shim mirror.
    // Pattern matches `~View()` for `active_overlay_` / `focused_input_`.
    ~ComboBox() override {
        if (RootInteractionState* s = existing_interaction(); s && s->active_popup == this)
            s->active_popup = nullptr;
        if (active_popup_ == this) active_popup_ = nullptr;
    }

    void set_items(std::vector<std::string> items) {
        items_ = std::move(items);
        set_access_value(selected_text());
    }
    const std::vector<std::string>& items() const { return items_; }
 
    int selected() const { return selected_; }
    void set_selected(int index);
    void set_selected(int index, Notify notify);
    void set_selected_silent(int index);
 
    const std::string& selected_text() const;

    std::function<void(int index)> on_change;
 
    void paint(canvas::Canvas& canvas) override;
    void on_mouse_event(const MouseEvent& event) override;
    void on_hover_move(Point local_pos) override;  // track hovered dropdown row
    bool on_key_event(const KeyEvent& event) override;
    bool accepts_navigation_input() const override { return open_; }
    void on_focus_changed(bool focused) override;
    View* hit_test(Point local_point) override;  // extend hit area over the open dropdown
    bool wants_mouse_input() const override { return true; }
 
    void on_text_input(const TextInputEvent& event) override;
 
    bool is_open() const { return open_; }
    void restore_open_state() { open_dropdown(); }
    bool flips_up() const { return dropdown_local_top() < 0.0f; }
    int hovered_index() const { return hover_index_; }
    float dropdown_width_hint() const;

    bool dropdown_window_rect(float& x, float& y, float& w, float& h) const;

    static void close_active_popup();
    static void close_active_popup(View& root);
    static void abandon_active_popup(View& root) noexcept;

    static ComboBox* active_popup_in(View& scope);

    static void notify_global_click(View* target);
 
private:
    void set_selected_impl(int index, Notify notify);
    void open_dropdown();
    void close_dropdown();
    // Top of the dropdown menu in this combo's LOCAL coords. Below the field normally;
    // negative (above the field) when flipped up because it would spill past the window.
    // Shared by paint, hit_test, and mouse hover so they always agree.
    float dropdown_local_top() const;
    // Flip/clamp/scroll-aware menu geometry in this combo's LOCAL coords, shared
    // by paint, hit_test, hover and mouse so they always agree. `top_local` is the
    // menu top relative to the field (negative = flipped above). `height` is the
    // painted menu height (clamped so the menu never spills past the window).
    // `first_row`/`visible_rows` select which items are drawn when the full list is
    // taller than the available space (scrolling via dropdown_scroll_).
    void dropdown_metrics(float& top_local, float& height,
                          int& first_row, int& visible_rows) const;
    // On-screen (overlay-space) geometry of the field: top-left x/y and the
    // height AND width of the nearest scroll viewport (root window when none).
    // The dropdown overlay paints at the root canvas with NO scroll translation,
    // so every ScrollView ancestor's scroll offset must be peeled off here —
    // otherwise the menu renders at the unscrolled position once the page is
    // scrolled, and the flip/clamp decisions compare against the wrong viewport.
    void overlay_anchor_(float& out_x, float& out_y, float& out_viewport_h,
                         float& out_viewport_w) const;
    void move_hover(int delta);  // keyboard: move the highlighted row, skipping separators
    void move_hover_to_edge(bool last);
 
    std::vector<std::string> items_;
    int selected_ = 0;
    int hover_index_ = -1;  
    int dropdown_scroll_ = 0;  
    bool open_ = false;
 
public:
    static ComboBox* active_popup_;
private:
    static const std::string empty_string_;
};
 
// ── Tooltip ──────────────────────────────────────────────────────────────

class Tooltip : public View {
public:
    explicit Tooltip(std::string text = {}) : text_(std::move(text)), opacity_(0.0f) {
        set_visible(false);
    }
 
    void set_text(std::string text) { text_ = std::move(text); }
    const std::string& text() const { return text_; }

    void show_at(Point position);

    void hide();
 
    void paint(canvas::Canvas& canvas) override;
 
    // Animation accessors for testing
    float opacity() const { return opacity_.value(); }
    void advance_animations(float dt) override;
 
private:
    std::string text_;
    ValueAnimation opacity_;
};
 
// ── ThemeModeControl ──────────────────────────────────────────────────────

class ThemeModeControl : public View {
public:
    ThemeModeControl() { set_focusable(true); }
    void set_mode(ThemeMode m) { if (m != mode_) { mode_ = m; request_repaint(); } }
    ThemeMode mode() const { return mode_; }
    std::function<void(ThemeMode)> on_mode_change;
    int hovered_segment() const { return hover_seg_; }  
    void paint(canvas::Canvas& canvas) override;
    void on_mouse_down(Point pos) override;
    void on_mouse_event(const MouseEvent& event) override;  // hover tracking
    bool wants_mouse_input() const override { return true; }
    float intrinsic_height() const override { return 28.0f; }
private:
    int segment_at_(Point pos) const;  // 0=system,1=light,2=dark, -1 outside
    ThemeMode mode_ = ThemeMode::system;
    int hover_seg_ = -1;
};
 
// ── ProgressBar ──────────────────────────────────────────────────────────

class ProgressBar : public View, public AccessibilityValueInterface {
public:
    ProgressBar() { set_access_role(AccessRole::progress_bar); }

    void set_progress(float value) { progress_ = value; }
    float progress() const { return progress_; }

    bool is_indeterminate() const { return progress_ < 0.0f; }
 
    // ── AccessibilityValueInterface ──────────────────────────────────────
    double get_current_value() const override {
        return is_indeterminate() ? 0.0
                                  : static_cast<double>(std::clamp(progress_, 0.0f, 1.0f));
    }

    void set_current_value(double value) override {
        set_progress(static_cast<float>(value));
    }
    double get_minimum_value() const override { return 0.0; }
    double get_maximum_value() const override { return 1.0; }
    std::string get_value_string() const override {
        if (is_indeterminate()) return "indeterminate";
        return AccessibilityValueInterface::get_value_string();
    }

    void set_label(std::string label) {
        label_ = std::move(label);
        set_derived_access_label(label_);
    }
 
    void paint(canvas::Canvas& canvas) override;
 
private:
    float progress_ = 0.0f;
    std::string label_;
};
 
// ── CallOutBox ───────────────────────────────────────────────────────────

class CallOutBox : public View {
public:
    CallOutBox() = default;
 
    void set_message(std::string msg) { message_ = std::move(msg); }
    const std::string& message() const { return message_; }

    std::function<void()> on_confirm;
    std::function<void()> on_cancel;

    float auto_dismiss_seconds = 0;

    static std::unique_ptr<CallOutBox> confirm(
        const std::string& message,
        std::function<void()> on_ok,
        std::function<void()> on_cancel = {});

    static std::unique_ptr<CallOutBox> notify(
        const std::string& message,
        float duration_seconds = 3.0f);
 
    void paint(canvas::Canvas& canvas) override;
    bool on_key_event(const KeyEvent& event) override;
 
private:
    std::string message_;
};
 
// ── TabPanel ─────────────────────────────────────────────────────────────

class TabPanel : public View {
public:
    struct Tab {
        std::string title;
        std::unique_ptr<View> content;
    };

    enum class TabBarStyle { filled, underline };
 
    // Reserve the tab-bar height as top padding so tab content flows BELOW the tab bar
    // (instead of painting over it). Uses flex padding so child hit-testing stays correct.
    // No AccessRole::tab_list here, deliberately. The tab strip is PAINTED;
    // TabPanel's child Views are the tab CONTENT panels, not the tabs. A
    // `tab_list` whose children are panels is worse than no role at all —
    // VoiceOver's tab navigation would walk content instead of tabs. The role
    // lands with per-tab `AccessRole::tab` elements (docs/guides/modules/view.md).
    TabPanel() {
        flex().padding_top = tab_height_;
    }
 
    void add_tab(std::string title, std::unique_ptr<View> content);
    void set_active_tab(int index, Notify notify = Notify::sync);
    int active_tab() const { return active_; }
    int tab_count() const { return static_cast<int>(tabs_.size()); }
    std::string_view tab_title(int index) const;
    int find_tab(std::string_view title) const;
    bool set_active_tab(std::string_view title, Notify notify = Notify::sync);

    void set_show_tab_bar(bool show) {
        show_tab_bar_ = show;
        flex().padding_top = show ? tab_height_ : 0.0f;
    }

    void set_tab_bar_style(TabBarStyle style) { tab_bar_style_ = style; }
    TabBarStyle tab_bar_style() const { return tab_bar_style_; }

    std::function<void(int index)> on_tab_change;
 
    void paint(canvas::Canvas& canvas) override;
    void on_mouse_event(const MouseEvent& event) override;
    bool wants_mouse_input() const override { return true; }
 
private:
    std::vector<Tab> tabs_;
    int active_ = 0;
    float tab_height_ = 32.0f;
    bool show_tab_bar_ = true;
    TabBarStyle tab_bar_style_ = TabBarStyle::filled;
};
 
// ── SegmentedControl ───────────────────────────────────────────────────────

class SegmentedControl : public View {
public:
    SegmentedControl() {
        set_focusable(true);
        set_access_role(AccessRole::group);
    }
 
    void set_segments(std::vector<std::string> segments) {
        segments_ = std::move(segments);
        if (selected_ >= static_cast<int>(segments_.size())) selected_ = 0;
        request_repaint();
    }
    const std::vector<std::string>& segments() const { return segments_; }
 
    int selected() const { return selected_; }
    void set_selected(int index);          
    void set_selected(int index, Notify notify);
    void set_selected_silent(int index);   

    std::function<void(int index)> on_change;
 
    int hovered_segment() const { return hover_; }  
    void set_designed_overlay(bool enabled) { designed_overlay_ = enabled; request_repaint(); }
    bool designed_overlay() const { return designed_overlay_; }
 
    void paint(canvas::Canvas& canvas) override;
    void on_mouse_event(const MouseEvent& event) override;
    bool on_key_event(const KeyEvent& event) override;
    bool wants_mouse_input() const override { return true; }
    float intrinsic_height() const override { return 28.0f; }
 
private:
    int segment_at_(Point pos) const;  
 
    std::vector<std::string> segments_;
    int selected_ = 0;
    int hover_ = -1;
    bool designed_overlay_ = false;
};
 
// ── ScrollView ───────────────────────────────────────────────────────────

class ScrollView : public View {
public:
    ScrollView() { mark_runtime_view_kind(RuntimeViewKind::scroll); }
    enum class Direction { vertical, horizontal, both };
 
    void set_direction(Direction d) { direction_ = d; }
    void set_content_size(Size size);
    void use_automatic_content_size();
    Size content_size() const { return content_size_; }
    bool wants_wheel_scroll() const override;
 
    float scroll_x() const { return smooth_scroll_x_.value(); }
    float scroll_y() const { return smooth_scroll_y_.value(); }
 
    // ScrollView is the richer widget over View's scrollable-overflow notion:
    // it answers the same queries so one call site works for either, and
    // reports its ANIMATED offset so the generic paint/hit-test pair and a
    // bounds walk all read the position it is actually drawn at.
    bool is_scroll_container() const override {
        return true;
    }
    float scroll_offset_x() const override {
        return smooth_scroll_x_.value();
    }
    float scroll_offset_y() const override {
        return smooth_scroll_y_.value();
    }
    bool set_scroll_offset(float x, float y) override {
        const float before_x = smooth_scroll_x_.value();
        const float before_y = smooth_scroll_y_.value();
        set_scroll(x, y);
        return smooth_scroll_x_.value() != before_x || smooth_scroll_y_.value() != before_y;
    }
    bool scroll_animating() const {
        return smooth_scroll_x_.animating() || smooth_scroll_y_.animating();
    }
    void set_scroll(float x, float y);

    void scroll_by(float dx, float dy, bool animate = true);
 
    void paint(canvas::Canvas& canvas) override;
    void paint_all(canvas::Canvas& canvas) override;

    bool applies_child_paint_offset() const override {
        return scroll_x() != 0.0f || scroll_y() != 0.0f;
    }

    Point child_paint_offset(const View& child) const override {
        if (child.position() == View::Position::sticky)
            return Point{-scroll_x(), 0.0f};
        return Point{-scroll_x(), -scroll_y()};
    }
 
    View* hit_test(Point local_point) override;
    void on_mouse_enter() override;
    void on_mouse_leave() override;

    void layout_children() override;
 
    // Scroll via mouse wheel, touch drag, or scrollbar drag
    void on_mouse_event(const MouseEvent& event) override;
    void on_mouse_drag(Point pos) override;
    bool wants_mouse_input() const override { return true; }
 
    // Animation accessors for testing
    float bar_opacity() const { return bar_opacity_.value(); }
    float bar_width() const { return bar_width_.value(); }
    float target_scroll_y() const { return target_scroll_y_; }
    void advance_animations(float dt) override;
 
private:
    static constexpr float kOverflowEpsilon = 1.0f;
 
    void update_automatic_content_size();
    void clamp_scroll_targets(bool clamp_current = false);
    float max_scroll_x() const;
    float max_scroll_y() const;
 
    Direction direction_ = Direction::vertical;
    Size content_size_{0, 0};
    bool automatic_content_size_ = true;
    float target_scroll_x_ = 0, target_scroll_y_ = 0;
    ValueAnimation smooth_scroll_x_{0.0f};  // smoothly interpolated scroll position
    ValueAnimation smooth_scroll_y_{0.0f};
    ValueAnimation bar_opacity_{0.0f};      // fade in/out on hover
    ValueAnimation bar_width_{4.0f};        // narrow when idle, wide on hover
 
    // Scrollbar drag state
    bool dragging_v_bar_ = false;
    bool dragging_h_bar_ = false;
    float drag_offset_ = 0;  // offset from top of thumb where drag started
};

ScrollView* find_scroll_view_at(View& root, Point root_point);

View* find_wheel_scroll_view_at(View& root, Point root_point);
 
// ── ListBox ──────────────────────────────────────────────────────────────

class ListBox : public View {
public:
    enum class SelectionStyle { standard, accent };
 
    // No AccessRole::list here, deliberately — same reason as TableListBox:
    // rows are painted, not child Views, so the role would export an empty
    // AXList ("list, 0 items"). See docs/guides/modules/view.md.
    ListBox() { set_focusable(true); }
 
    void set_items(std::vector<std::string> items) { items_ = std::move(items); }
    const std::vector<std::string>& items() const { return items_; }

    void set_icons(std::vector<std::string> icons) { icons_ = std::move(icons); }

    void set_selection_style(SelectionStyle s) { selection_style_ = s; }
    SelectionStyle selection_style() const { return selection_style_; }
 
    int selected() const { return selected_; }
    void set_selected(int index, Notify notify = Notify::sync);
 
    float row_height() const { return row_height_; }
    void set_row_height(float h) { row_height_ = h; }

    std::function<void(int index)> on_select;
    std::function<void(int index)> on_activate;
 
    void paint(canvas::Canvas& canvas) override;
    void on_mouse_event(const MouseEvent& event) override;
    bool on_key_event(const KeyEvent& event) override;
    bool wants_mouse_input() const override { return true; }

    void ensure_visible(int index);
 
private:
    std::vector<std::string> items_;
    std::vector<std::string> icons_;
    SelectionStyle selection_style_ = SelectionStyle::standard;
    int selected_ = -1;
    float row_height_ = 24.0f;
    float scroll_offset_ = 0.0f;
};
 
} // namespace pulp::view