text_editor.hpp

Go to the documentation of this file.

#pragma once

 
#include <cstddef>
#include <functional>
#include <pulp/platform/clipboard.hpp>
#include <pulp/view/accessibility.hpp>
#include <pulp/view/caret.hpp>
#include <pulp/view/input_events.hpp>
#include <pulp/view/selectable_text.hpp>
#include <pulp/view/view.hpp>
#include <pulp/view/widget_metrics.hpp>
#include <pulp/view/widget_painter.hpp>
#include <string>
#include <string_view>
#include <utility>
#include <vector>
 
namespace pulp::view {

class TextEditor : public View, public AccessibilityTextInterface, public SelectableText {
  public:
    TextEditor() {
        set_access_role(AccessRole::text_field);
        set_focusable(true);
        set_cursor(CursorStyle::text);
        on_context_menu = [this](Point pos) { show_default_context_menu(pos); };
    }
    ~TextEditor() override;
 
    bool accepts_text_input() const override { return enabled() && !read_only; }
 
    // ── SelectableText ───────────────────────────────────────────────────
    //
    // Only a READ-ONLY editor joins a document-level selection. An editable
    // field owns its own selection the way an HTML `<input>` does: a document
    // selection that swallowed a live text field would fight the field's caret
    // over the same range, and Cmd-C would then be ambiguous between the two.
    // Read-only is exactly the case where the field is prose rather than a
    // control, and it is already the mode `copy_to_clipboard()` supports —
    // that gate is `has_selection()`, never `can_edit()`.
    SelectableText* as_selectable_text() override {
        return read_only ? this : nullptr;
    }
    std::string_view selectable_text() const override {
        return text_;
    }
    SelectableLayout selectable_layout() const override;
    void set_selection_highlight(int start_utf8, int end_utf8) override;
    bool selection_highlight(int& start_utf8, int& end_utf8) const override;
    View* selectable_view() override {
        return this;
    }

    int char_index_at_point(float x, float y) const;
    int char_index_at_x(float x) const;
 
    // ── AccessibilityTextInterface ───────────────────────────────────────
    //
    // Without this, `AccessRole::text_field` is a lie by omission: the role
    // says "edit field", and then macOS -accessibilityValue returns nil and
    // the Windows IValueProvider::get_Value returns a NULL BSTR, so VoiceOver
    // and Narrator announce "text field" and read NOTHING. The bridges resolve
    // an element's value through accessibility_value_string() (accessibility.
    // hpp), which finds this interface by dynamic_cast; the Windows provider
    // also routes IValueProvider::SetValue back through set_text() so
    // IsReadOnly and "editing works" finally agree.
    std::string get_text() const override { return text_; }
    void set_text(std::string_view t) override { set_text(std::string(t)); }
    void set_text(const char* t) { set_text(std::string(t ? t : "")); }
    bool is_editable() const override { return enabled() && !read_only; }
    std::pair<int, int> get_selection() const override { return selection_range(); }
    void set_selection(int start, int end) override;
    int get_character_count() const override {
        return static_cast<int>(text_.size());
    }
 
    static constexpr int kMaxUndoHistory = 1000;
 
    enum class TabBehavior {
        move_focus,  
        insert_tab,  
        commit,      
        ignore,      
    };
 
    enum class MultiLineReturnBehavior {
        insert_newline,        
        commit,                
        shift_inserts_newline, 
    };
 
    enum class ClipboardPolicy {
        standard,                 
        disabled,                 
        allow_password_contents,  
    };
 
    enum class LineEndingPolicy {
        normalize, 
        strip,     
        preserve,  
    };
 
    // ── Configuration ────────────────────────────────────────────────────

    bool multi_line = false;

    bool numeric_only = false;

    bool read_only = false;

    bool password_mode = false;
    char password_char = '*';

    bool select_on_focus = false;

    std::string placeholder;

    TabBehavior tab_behavior = TabBehavior::move_focus;

    MultiLineReturnBehavior multi_line_return_behavior = MultiLineReturnBehavior::insert_newline;

    ClipboardPolicy clipboard_policy = ClipboardPolicy::standard;

    LineEndingPolicy line_ending_policy = LineEndingPolicy::normalize;

    std::size_t max_length = 0;

    std::function<std::string(std::string_view)> input_filter;

    std::function<std::string(std::string_view)> paste_sanitizer;

    std::function<bool(std::string_view)> validator;

    bool allow_password_clipboard = false;
 
    // ── Callbacks ─────────────────────────────────────────────────────────

    std::function<void(const std::string& text)> on_return;

    std::function<void(const std::string& text)> on_tab_commit;

    std::function<void()> on_escape;

    std::function<void(const std::string& text)> on_change;

    std::function<void(const std::string& text)> on_focus_lost;
 
    // ── Frame geometry ───────────────────────────────────────────────────

    void set_text_align(canvas::TextAlign a) {
        text_align_ = a;
        invalidate_layout_cache();
        request_repaint();
    }
    canvas::TextAlign text_align() const { return text_align_; }

    void set_insets(EdgeInsets insets) {
        insets_ = insets;
        has_own_insets_ = true;
        invalidate_layout_cache();
        request_repaint();
    }
    EdgeInsets insets() const { return insets_; }

    void set_caret_width(float px) {
        caret_width_ = px;
        request_repaint();
    }
    float caret_width() const;

    void set_caret_visible(bool v) {
        caret_visible_ = v;
        request_repaint();
    }
    bool caret_visible() const { return caret_visible_; }
 
    // ── Text access ──────────────────────────────────────────────────────
 
    const std::string& text() const { return text_; }
    void set_text(const std::string& t);

    std::string selected_text() const;
 
    bool has_selection() const { return selection_start_ != selection_end_; }
    bool is_empty() const { return text_.empty(); }
 
    // ── Selection ─────────────────────────────────────────────────────────
 
    void select_all();
    void clear_selection();
    void set_caret_pos(int byte_offset);
    // set_selection(anchor, active) is declared above as the
    // AccessibilityTextInterface override — same contract, one definition.
    int selection_anchor() const { return selection_start_; }
    int selection_active() const { return selection_end_; }
    std::pair<int, int> selection_range() const;
 
    // ── Clipboard ─────────────────────────────────────────────────────────
 
    bool copy_to_clipboard();
    bool cut_to_clipboard();
    bool paste_from_clipboard();
 
    // ── Undo/Redo ────────────────────────────────────────────────────────
 
    bool undo();
    bool redo();
 
    // ── Layout ────────────────────────────────────────────────────────────

    float intrinsic_height() const override;
 
    // ── Painting ──────────────────────────────────────────────────────────
 
    void paint(canvas::Canvas& canvas) override;
 
    // ── Event handling ────────────────────────────────────────────────────
 
    void on_mouse_event(const MouseEvent& event) override;
    void on_mouse_down(Point pos) override;
    void on_mouse_drag(Point pos) override;
    void on_mouse_up(Point pos) override;
    bool on_key_event(const KeyEvent& event) override;
    void on_text_input(const TextInputEvent& event) override;
    void on_focus_changed(bool gained) override;
    bool wants_mouse_input() const override { return true; }
    void on_attached() override;
    void on_frame_clock_changed() override;
    void on_resized() override { invalidate_layout_cache(); }
 
    // ── Style ─────────────────────────────────────────────────────────────
 
    void set_font_size(float size) {
        if (font_size_ == size) return;
        font_size_ = size;
        invalidate_layout_cache();
    }
    float font_size() const { return font_size_; }

    void set_font_family(std::string family) {
        font_family_ = std::move(family);
        invalidate_layout_cache();
        request_repaint();
    }
    const std::string& font_family() const { return font_family_; }

    void set_content_inset_left(float px) {
        if (content_inset_left_ == px) return;
        content_inset_left_ = px;
        invalidate_layout_cache();
    }
    float content_inset_left() const { return content_inset_left_; }
 
    // ── IME composition (marked text) ────────────────────────────────────

    void set_marked_text(const std::string& marked,
                         int selected_byte_offset,
                         int selected_byte_length);

    void set_marked_text_utf16(const std::string& marked,
                               int selected_utf16_offset,
                               int selected_utf16_length);

    void unmark_text();

    bool has_marked_text() const { return !marked_text_.empty(); }

    std::pair<int, int> marked_range() const { return {marked_start_, static_cast<int>(marked_text_.size())}; }

    int caret_pos() const { return caret_position_; }

    void set_caret_style(CaretStyle style) { caret_style_ = style; request_repaint(); }
    CaretStyle caret_style() const { return caret_style_; }

    void set_caret_blink(const CaretBlinkConfig& config) {
        caret_blink_.set_config(config);
        request_repaint();
    }
    const CaretBlinkConfig& caret_blink() const { return caret_blink_.config(); }

    Rect caret_rect() const;

    float scroll_offset() const { return scroll_offset_; }
 
private:
    std::string text_;
    int caret_position_ = 0;     
    int selection_start_ = 0;    
    int selection_end_ = 0;      
    float font_size_ = 13.0f;
    std::string font_family_;
    float content_inset_left_ = 0.0f; 
    canvas::TextAlign text_align_ = canvas::TextAlign::left;
    EdgeInsets insets_{};
    bool has_own_insets_ = false;
    float caret_width_ = 0.0f;     
    bool caret_visible_ = true;
    float scroll_offset_ = 0.0f; 
    CaretBlink caret_blink_;     
    CaretStyle caret_style_ = default_caret_style();
    bool has_preferred_horizontal_ = false; 
    float preferred_visual_x_ = 0.0f;       
    int preferred_text_column_ = 0;         
    int caret_blink_sub_ = -1;      
    FrameClock* caret_blink_clock_ = nullptr;  
 
    // IME composition state
    std::string marked_text_;        
    int marked_start_ = 0;          
    int marked_selected_pos_ = 0;   
    int marked_selected_len_ = 0;
    bool marked_undo_active_ = false;
    bool drag_selecting_ = false;
    bool drag_selecting_words_ = false;
    int drag_anchor_ = 0;
    int drag_word_start_ = 0;
    int drag_word_end_ = 0;
    int drag_pointer_id_ = 0;
    bool has_drag_pointer_capture_ = false;
    bool suppress_next_legacy_mouse_down_ = false;
 
    struct UndoSnapshot {
        std::string text;
        int caret_position = 0;
        int selection_start = 0;
        int selection_end = 0;
        float scroll_offset = 0.0f;
    };
    enum class UndoCoalesce {
        none,
        typing,
        backspace,
        delete_forward,
    };
    std::vector<UndoSnapshot> undo_history_;
    std::vector<UndoSnapshot> redo_history_;
    UndoCoalesce last_undo_coalesce_ = UndoCoalesce::none;

    struct LayoutSnapshot {
        struct Line {
            int start = 0;
            int end = 0;
            float baseline_y = 0.f;
            float top_y = 0.f;
            float inner_x = 0.f;
            float line_height = 0.f;
            std::vector<float> x_offsets;
            std::vector<int> byte_offsets;
        };
        std::vector<Line> lines;
        bool multi_line = false;
        float fallback_char_w = 0.f;
    };
    mutable LayoutSnapshot last_layout_;

    struct LayoutCacheKey {
        std::size_t text_hash = 0;
        float font_size = 0.f;
        float bounds_width = 0.f;
        float bounds_height = 0.f;
        float scroll_offset = 0.f;
        bool multi_line = false;
        bool password_mode = false;
        bool placeholder_visible = false;
        bool operator==(const LayoutCacheKey& o) const noexcept {
            return text_hash == o.text_hash
                && font_size == o.font_size
                && bounds_width == o.bounds_width
                && bounds_height == o.bounds_height
                && scroll_offset == o.scroll_offset
                && multi_line == o.multi_line
                && password_mode == o.password_mode
                && placeholder_visible == o.placeholder_visible;
        }
    };
    mutable LayoutCacheKey last_layout_key_;
 
    void push_undo(UndoCoalesce coalesce = UndoCoalesce::none);
    void break_undo_coalescing();
    UndoSnapshot snapshot() const;
    void restore_snapshot(const UndoSnapshot& snapshot);
    void insert_text(const std::string& t);
    void delete_selection();
    void delete_char_before_caret();
    void delete_char_after_caret();
    void delete_word_before_caret();
    void delete_word_after_caret();
    void delete_to_line_start();
    void delete_to_line_end();
    bool replace_selection_or_insert(std::string text,
                                     UndoCoalesce coalesce = UndoCoalesce::none,
                                     bool from_paste = false);
    bool replace_marked_text(std::string text);
    bool delete_range(int start, int end, UndoCoalesce coalesce = UndoCoalesce::none);
    bool candidate_is_valid(int replace_start, int replace_end, std::string_view insertion) const;
    bool can_edit() const { return enabled() && !read_only; }
    bool clipboard_import_allowed() const;
    bool clipboard_export_allowed() const;
    bool password_contents_allowed() const;
    void invalidate_layout_cache() const;
 
    void move_caret(int delta, bool extend_selection);
    void move_word(int direction, bool extend_selection);
    void move_visual_line(int direction, bool extend_selection);
    void move_page(int direction, bool extend_selection);
    void move_paragraph(int direction, bool extend_selection);
    void move_to_line_start(bool extend_selection);
    void move_to_line_end(bool extend_selection);
    void move_to_start(bool extend_selection);
    void move_to_end(bool extend_selection);
 
    std::pair<int, int> word_range_at_position(int position) const;
    std::pair<int, int> line_range_at_position(int position) const;
    void show_default_context_menu(Point local_pos);
    void cancel_drag_selection(int pointer_id);
    void reset_preferred_horizontal();
    void keep_caret_solid();
    void advance_caret_blink(float dt);
    bool should_paint_caret() const;
    void ensure_caret_blink_subscription();
    void clear_caret_blink_subscription();
 
    void notify_change();
};
 
} // namespace pulp::view