feat(editor - text input): expose trigger property to focus on text i… (#12975) 50fdb3bb9f

* feat(editor - text input): expose trigger property to focus on text input

* add text keyboard shortcuts

* add text selection from pointers

Co-authored-by: hernan <hernan@rive.app>

Author: bodymovin

.rive_head

@@ -1 +1 @@
-d6079802297ddfbac2ca28c2d467d5e2686010f5
+50fdb3bb9fe4efb95a7cf94f005d4ea1ad86e5c7

include/rive/animation/text_input_listener_group.hpp

@@ -2,6 +2,7 @@
 #define _RIVE_TEXT_INPUT_LISTENER_GROUP_HPP_
 
 #include "rive/listener_group.hpp"
+#include "rive/math/vec2d.hpp"
 
 namespace rive
 {
@@ -31,8 +32,20 @@ class TextInputListenerGroup : public ListenerGroup
         StateMachineInstance* stateMachineInstance) override;
 
 private:
+    // Returns a timestamp in microseconds for multi-click detection. Uses the
+    // passed-in (deterministic) timeStamp when File::deterministicMode is set,
+    // otherwise wall-clock time, mirroring ScrollPhysics.
+    long long nowMicros(float timeStamp) const;
+
     TextInput* m_textInput;
     bool m_isDragging = false;
+
+    // Multi-click (double/triple-click) detection state.
+    int m_clickCount = 0;
+    long long m_lastClickTime = 0; // microseconds
+    Vec2D m_lastClickPosition = Vec2D(0, 0);
+    static constexpr long long kMultiClickIntervalUs = 500000; // 0.5s
+    static constexpr float kMultiClickDistance = 16.0f;        // world units
 };
 
 } // namespace rive

include/rive/text/raw_text_input.hpp

@@ -111,6 +111,12 @@ class RawTextInput
     // Selects the word at the cursor.
     void selectWord();
 
+    // Selects the entire text.
+    void selectAll();
+
+    // Selects the visual line at the cursor.
+    void selectLine();
+
     std::string text() const;
     void text(std::string value);
     void textPreserveCursor(std::string value);

include/rive/text/text_input.hpp

@@ -71,6 +71,12 @@ class TextInput : public TextInputBase,
     /// Called when the user ends dragging on the text input.
     void endDrag(Vec2D worldPosition);
 
+    /// Selects the word at the current cursor (e.g. on double-click).
+    void selectWord();
+
+    /// Selects the visual line at the current cursor (e.g. on triple-click).
+    void selectLine();
+
     /// Advance edge scrolling during drag. Returns true if still scrolling.
     bool advanceDrag(float elapsedSeconds);
     bool advanceComponent(float elapsedSeconds,

src/animation/text_input_listener_group.cpp

@@ -1,12 +1,25 @@
 #include "rive/animation/text_input_listener_group.hpp"
 #include "rive/animation/state_machine_instance.hpp"
+#include "rive/file.hpp"
 #include "rive/focus_data.hpp"
 #include "rive/input/focus_manager.hpp"
 #include "rive/input/focus_node.hpp"
 #include "rive/text/text_input.hpp"
+#include <chrono>
 
 using namespace rive;
 
+long long TextInputListenerGroup::nowMicros(float timeStamp) const
+{
+    if (File::deterministicMode)
+    {
+        return (long long)(timeStamp * 1000000.0f);
+    }
+    return std::chrono::duration_cast<std::chrono::microseconds>(
+               std::chrono::high_resolution_clock::now().time_since_epoch())
+        .count();
+}
+
 TextInputListenerGroup::TextInputListenerGroup(
     TextInput* textInput,
     StateMachineInstance* stateMachineInstance) :
@@ -64,6 +77,23 @@ ProcessEventResult TextInputListenerGroup::processEvent(
     if (prevPhase != GestureClickPhase::down &&
         newPhase == GestureClickPhase::down)
     {
+        // Detect double/triple-click from the time and distance since the
+        // previous click.
+        long long now = nowMicros(timeStamp);
+        long long dt = now - m_lastClickTime;
+        float dist = Vec2D::distance(position, m_lastClickPosition);
+        if (dt >= 0 && dt <= kMultiClickIntervalUs &&
+            dist <= kMultiClickDistance)
+        {
+            m_clickCount = m_clickCount >= 3 ? 1 : m_clickCount + 1;
+        }
+        else
+        {
+            m_clickCount = 1;
+        }
+        m_lastClickTime = now;
+        m_lastClickPosition = position;
+
         m_textInput->startDrag(position);
         m_isDragging = true;
 
@@ -83,6 +113,17 @@ ProcessEventResult TextInputListenerGroup::processEvent(
                 }
             }
         }
+
+        // Select the word (double-click) or visual line (triple-click) at the
+        // cursor that startDrag just placed.
+        if (m_clickCount == 2)
+        {
+            m_textInput->selectWord();
+        }
+        else if (m_clickCount == 3)
+        {
+            m_textInput->selectLine();
+        }
         return ProcessEventResult::scroll;
     }
     // Handle drag continue: pointer is moving while down

src/text/raw_text_input.cpp

@@ -470,6 +470,36 @@ void RawTextInput::selectWord()
     flag(Flags::selectionDirty);
 }
 
+void RawTextInput::selectAll()
+{
+    ensureShape();
+    m_idealCursorX = -1.0f;
+    CursorPosition start = CursorPosition::atIndex(0, m_shape);
+    CursorPosition end = CursorPosition::atIndex((uint32_t)length(), m_shape);
+    m_cursor = Cursor(start, end);
+    flag(Flags::selectionDirty);
+}
+
+void RawTextInput::selectLine()
+{
+    ensureShape();
+    m_idealCursorX = -1.0f;
+    CursorPosition cursor = m_cursor.start();
+    cursor.resolveLine(m_shape);
+    const OrderedLine* line = orderedLine(cursor);
+    if (line == nullptr)
+    {
+        return;
+    }
+    const auto& glyphLookup = m_shape.glyphLookup();
+    CursorPosition start(cursor.lineIndex(),
+                         line->firstCodePointIndex(glyphLookup));
+    CursorPosition end(cursor.lineIndex(),
+                       line->lastCodePointIndex(glyphLookup));
+    m_cursor = Cursor(start, end);
+    flag(Flags::selectionDirty);
+}
+
 const OrderedLine* RawTextInput::orderedLine(CursorPosition position) const
 {
     const std::vector<OrderedLine>& orderedLines = m_shape.orderedLines();

src/text/text_input.cpp

@@ -395,6 +395,26 @@ bool TextInput::keyInput(Key value,
                     return true;
                 }
                 break;
+            case Key::a:
+                if ((modifiers & systemModifier()) != KeyModifiers::none)
+                {
+                    m_rawTextInput.selectAll();
+                    markPaintDirty();
+                    return true;
+                }
+                break;
+            case Key::home:
+                m_rawTextInput.cursorLeft(CursorBoundary::line,
+                                          (modifiers & KeyModifiers::shift) !=
+                                              KeyModifiers::none);
+                markPaintDirty();
+                return true;
+            case Key::end:
+                m_rawTextInput.cursorRight(CursorBoundary::line,
+                                           (modifiers & KeyModifiers::shift) !=
+                                               KeyModifiers::none);
+                markPaintDirty();
+                return true;
             case Key::backspace:
                 m_rawTextInput.backspace(-1);
                 syncSourceTextFromRaw();
@@ -668,6 +688,22 @@ void TextInput::endDrag(Vec2D worldPosition)
     m_scrollY = 0.0f;
 }
 
+void TextInput::selectWord()
+{
+#ifdef WITH_RIVE_TEXT
+    m_rawTextInput.selectWord();
+    markPaintDirty();
+#endif
+}
+
+void TextInput::selectLine()
+{
+#ifdef WITH_RIVE_TEXT
+    m_rawTextInput.selectLine();
+    markPaintDirty();
+#endif
+}
+
 bool TextInput::advanceDrag(float elapsedSeconds)
 {
 #ifdef WITH_RIVE_TEXT