context_menu.hpp

Go to the documentation of this file.

#pragma once

 
#include <pulp/view/view.hpp>
#include <pulp/view/widget_painter.hpp>
#include <pulp/view/widget_metrics.hpp>
#include <pulp/view/input_events.hpp>
#include <pulp/canvas/canvas.hpp>
#include <functional>
#include <algorithm>
#include <array>
#include <memory>
#include <optional>
#include <string>
#include <vector>
 
namespace pulp::view {

class ContextMenu : public View {
public:
    struct Item {
        enum class ControlKind { action, toggle, slider, choice };
        int id = 0;
        std::string label;
        bool enabled = true;
        bool checked = false;
        ControlKind control_kind = ControlKind::action;
        float normalized_value = 0.0f;
        std::string value_label;
        bool tab = false;
        float normalized_step = 0.05f;
        std::vector<std::string> choices;
        std::size_t choice_index = 0;
        std::function<void(const Item&)> on_change;
        bool separator = false;
        bool header = false;
        bool has_submenu = false;
        static Item make_separator() {
            Item i;
            i.separator = true;
            return i;
        }
        static Item make_header(std::string title) {
            Item i;
            i.label = std::move(title);
            i.enabled = false;
            i.header = true;
            return i;
        }
        static Item make_toggle(int id, std::string label, bool checked,
                                std::function<void(const Item&)> on_change) {
            Item i;
            i.id = id;
            i.label = std::move(label);
            i.checked = checked;
            i.control_kind = ControlKind::toggle;
            i.on_change = std::move(on_change);
            return i;
        }
        static Item make_slider(int id, std::string label, float normalized, float step,
                                std::function<void(const Item&)> on_change) {
            Item i;
            i.id = id;
            i.label = std::move(label);
            i.control_kind = ControlKind::slider;
            i.normalized_value = std::clamp(normalized, 0.0f, 1.0f);
            i.normalized_step = step > 0.0f ? step : 0.05f;
            i.on_change = std::move(on_change);
            return i;
        }
        static Item make_choice(int id, std::string label, std::vector<std::string> choices,
                                std::size_t selected, std::function<void(const Item&)> on_change) {
            Item i;
            i.id = id;
            i.label = std::move(label);
            i.control_kind = ControlKind::choice;
            i.choices = std::move(choices);
            i.choice_index = i.choices.empty() ? 0 : std::min(selected, i.choices.size() - 1);
            i.on_change = std::move(on_change);
            return i;
        }
        void set_toggled(bool value) {
            if (control_kind != ControlKind::toggle || checked == value)
                return;
            checked = value;
            if (on_change)
                on_change(*this);
        }
        void set_normalized_value(float value) {
            if (control_kind != ControlKind::slider)
                return;
            const float next = std::clamp(value, 0.0f, 1.0f);
            if (normalized_value == next)
                return;
            normalized_value = next;
            if (on_change)
                on_change(*this);
        }
        void set_choice_index(std::size_t value) {
            if (control_kind != ControlKind::choice || choices.empty())
                return;
            const auto next = std::min(value, choices.size() - 1);
            if (choice_index == next)
                return;
            choice_index = next;
            if (on_change)
                on_change(*this);
        }
    };
 
    ContextMenu() { set_focusable(true); }
 
    void set_items(std::vector<Item> items) {
        if (item_change_dispatch_depth_ != 0) {
            deferred_items_ = std::move(items);
            return;
        }
        replace_items(std::move(items));
    }

    void set_min_width(float width) {
        min_width_ = std::max(0.0f, width);
    }
    float min_width() const {
        return min_width_;
    }
    std::vector<Item>& items() {
        return items_;
    }
    const std::vector<Item>& items() const { return items_; }

    std::function<void(std::optional<int>)> on_close;

    void set_anchor(Point anchor) { anchor_ = anchor; }
 
    int hovered_index() const { return hover_index_; }  

    static ContextMenu* show(View* root, Point pos, std::vector<Item> items,
                             std::function<void(std::optional<int>)> on_close);
 
    void paint(canvas::Canvas& canvas) override;
    void on_mouse_event(const MouseEvent& event) override;
    bool on_key_event(const KeyEvent& event) override;
    bool accepts_navigation_input() const override { return !closed_; }
    View* hit_test(Point local_point) override;  // whole overlay is hit (catch outside clicks)
    bool wants_mouse_input() const override { return true; }

    struct MenuLayout {
        Rect box{};
        float border = 0.0f;         
        FontSpec font{};             
        std::vector<Rect> rows{};    
        float content_height = 0.0f;
        float max_scroll = 0.0f;
    };

    float scroll_offset() const {
        return scroll_;
    }

    MenuLayout layout() const;

    float measured_width() const { return layout().box.width; }

    struct ModulationLane {
        std::string label; 
        bool enabled = false;
        float rate_normalized = 0.25f;
        float depth_normalized = 0.0f;
        std::vector<std::string> shapes; 
        std::size_t shape_index = 0;
        std::function<void(const ModulationLane&)> on_change;
    };
 
    struct ModulationMenuSpec {
        std::string target_label;
        ModulationLane lanes[2];
        std::size_t lane_count = 2;
        std::function<void()> on_reset;
        std::function<void()> on_dismiss;
    };

    static std::vector<Item> make_modulation_items(const ModulationMenuSpec& spec);

    static ContextMenu* show_modulation(View* root, Point pos, ModulationMenuSpec spec);
 
  private:
    // Row index under a local point, or -1 if outside the box / on a non-row.
    int row_at(Point local_point, const MenuLayout& lay) const;
    // Keyboard nav must not move the hover somewhere the panel is not showing.
    void scroll_row_into_view(int index);
    void move_hover(int delta);    // keyboard nav, skipping separators + disabled
    void move_hover_to_edge(bool last);  // Home / End
    void adjust_control(Item& item, float delta);
    bool set_control_from_pointer(Item& item, const Rect& row, Point point);
    void fire_close(std::optional<int> result);
    void replace_items(std::vector<Item> items);
    void notify_item_change(Item& item);
    void flush_deferred_items();
 
    std::vector<Item> items_;
    Point anchor_{0, 0};
    int hover_index_ = -1;
    int active_slider_index_ = -1;
    int active_pointer_id_ = 0;
    bool closed_ = false;
    float scroll_ = 0.0f;
    static float slider_track_right(const Item& item, const Rect& row);
    static constexpr float kValueLabelWidth = 52.0f;
    float min_width_ = 0.0f;
    std::size_t item_change_dispatch_depth_ = 0;
    std::optional<std::vector<Item>> deferred_items_;
 
    static constexpr float kRowHeight = 24.0f;
    static constexpr float kHPad = 34.0f;   // total horizontal label padding
    static constexpr float kMinWidth = 120.0f;
    static constexpr float kRadius = 4.0f;
    static constexpr float kSeparatorHeight = 7.0f;
    static constexpr float kFontSize = 12.0f;
    static constexpr float kEdgeMargin = 4.0f;
};

using PopupMenu = ContextMenu;
 
} // namespace pulp::view