include/rive/text/text_selection_controller.hpp

#ifndef _RIVE_TEXT_SELECTION_CONTROLLER_HPP_
#define _RIVE_TEXT_SELECTION_CONTROLLER_HPP_

#ifdef WITH_RIVE_TEXT
#include "rive/input/focusable.hpp"
#include "rive/text/cursor.hpp"
#include "rive/shapes/paint/color.hpp"
#include "rive/selection_style.hpp"
#include <memory>
#include <string>

namespace rive
{
class Text;
class Artboard;
class Renderer;
class File;

// A host-owned selection region for regular Text. Add actual Text instances
// in reading order (including instances inside nested artboards). Registration
// opts each Text into selection; the Text continues to draw its own content.
// Advance the artboards before delivering input. Positions are in root
// artboard coordinates, before the host's canvas/view transform.
//
// This first core API deliberately leaves hit priority, pointer capture,
// clipboard access, scrolling, and focus ownership to the host. Pass the Text
// chosen by normal hit testing to pointerDown, and keep forwarding the captured
// pointer across object boundaries until up/cancel. The controller never edits
// text or requests an IME. Text modifiers and ellipsis are not supported yet.
class TextSelectionController
{
public:
  TextSelectionController();
  ~TextSelectionController();
  TextSelectionController(const TextSelectionController&) = delete;
  TextSelectionController& operator=(const TextSelectionController&) = delete;

  // A Text can belong to one controller. Removal/destruction of a participant
  // clears the active range; either controller or Text may be destroyed
  // first.
  bool add(Text* text, std::string separatorBefore = "\n");
  void remove(Text* text);

  // Discover opted-in Text instances, recursively including hosted artboards.
  // Existing registrations retain stable tokens; removed Text unregisters
  // through its destructor. These tokens are safe for host language bridges.
  void synchronize(Artboard* root);
  std::vector<uint32_t> targetIds() const;
  Text* target(uint32_t id) const;
  std::string sourceText(Text* text) const;
  bool isEligible(Text* text) const;
  AABB rootBounds(Text* text) const;
  bool hitTest(
      Text* text,
      Vec2D rootPosition,
      bool nearest,
      uint32_t& offset,
      float& distanceSquared);
  // A host coordinating native and external participants can supply each
  // local range. Source changes still invalidate these ranges.
  void setRange(Text* text, uint32_t start, uint32_t end);

  bool pointerDown(
      Text* hitText,
      Vec2D rootPosition,
      int pointerId = 0,
      bool extend = false);
  bool pointerMove(Vec2D rootPosition, int pointerId = 0);
  bool pointerUp(Vec2D rootPosition, int pointerId = 0);
  bool pointerCancel(int pointerId = 0);
  bool isDragging() const { return m_dragging; }

  // Offsets are Unicode code points, inclusive at the start and exclusive at
  // the end. Layout/line changes preserve the source range; source changes
  // clear it when the Text updates. Reversing endpoints preserves copy order.
  bool select(
      Text* anchorText,
      uint32_t anchorOffset,
      Text* extentText,
      uint32_t extentOffset);
  void selectAll();
  void clear();
  bool hasSelection() const;
  std::string selectedText() const;
  Cursor selection(Text* text) const;

  // Borrowed rectangles in the Text's shape coordinates. These share the
  // same cursor geometry as TextInput and are also used by Text::draw.
  Span<const AABB> selectionRects(Text* text);

  // One style for the whole selection, including nested targets. A host
  // override must outlive the controller; nullptr restores the root file's
  // default style, or the built-in default when no resource is authored.
  const SelectionStyle& style() const;
  void style(const SelectionStyle* value) { m_style = value; }

#ifdef TESTING
  size_t lookupBuildCount(Text* text) const;
#endif

  // Returns true only for selection commands (Escape and Cmd/Ctrl+A).
  // The host handles copy by reading selectedText(). Editing keys are
  // ignored.
  bool keyInput(Key key, KeyModifiers modifiers, bool isPressed);

private:
  friend class Text;
  struct Participant;
  struct Endpoint
  {
    Participant* participant = nullptr;
    CursorPosition position = CursorPosition::zero();
  };

  Participant* find(Text* text) const;
  TextLayoutView layout(Participant& participant);
  bool eligible(const Participant& participant) const;
  bool validSelection() const;
  bool endpointAt(Participant& participant, Vec2D rootPosition, Endpoint& out);
  bool nearestEndpoint(Vec2D rootPosition, Endpoint& out);
  void updateRanges();
  void textUpdated(Text* text, bool shapeChanged);
  void draw(Text* text, Renderer* renderer);

  std::vector<std::unique_ptr<Participant>> m_participants;
  Endpoint m_anchor;
  Endpoint m_extent;
  int m_pointerId = 0;
  bool m_dragging = false;
  bool m_externalRanges = false;
  uint32_t m_nextTargetId = 1;
  const SelectionStyle* m_style = nullptr;
  // Keep the default resource alive even if the host releases its root.
  rcp<const File> m_styleFile;
};
} // namespace rive
#endif
#endif