Resolve EditableText's scrolling per edit in bevy_text

_release-content/migration-guides/editable_text_scrolling.md

@@ -0,0 +1,10 @@
+---
+title: "`EditableText` scrolling now uses `TextViewport`"
+pull_requests: [24634]
+---
+
+`bevy_ui::widget::TextScroll` has been removed. Editable text scroll state is now stored in `EditableText::viewport`, using the new `bevy_text::TextViewport` type. `EditableText::viewport.offset` is the direct replacement for `TextScroll`.
+
+The `scroll_editable_text` system has also been removed, cursor reveal behavior is now handled automatically when `TextEdit`s are applied. 
+
+A new system `sync_editable_text_viewports` in `bevy_ui` synchronizes each `EditableText`'s viewport size with the size of its respective `ComputedNode`.

crates/bevy_feathers/src/controls/number_input.rs

@@ -38,11 +38,9 @@ use bevy_text::{
     TextLayout,
 };
 use bevy_ui::{
-    percent, px,
-    widget::{Text, TextScroll},
-    AlignItems, AlignSelf, BackgroundGradient, ColorStop, ComputedNode, ComputedUiRenderTargetInfo,
-    Display, Gradient, InteractionDisabled, InterpolationColorSpace, JustifyContent,
-    LinearGradient, Node, PositionType, UiGlobalTransform, UiRect, UiScale,
+    percent, px, widget::Text, AlignItems, AlignSelf, BackgroundGradient, ColorStop, ComputedNode,
+    ComputedUiRenderTargetInfo, Display, Gradient, InteractionDisabled, InterpolationColorSpace,
+    JustifyContent, LinearGradient, Node, PositionType, UiGlobalTransform, UiRect, UiScale,
 };
 use bevy_ui_widgets::ValueChange;
 
@@ -813,7 +811,6 @@ fn scrubber_on_release(
         &ComputedNode,
         &ComputedUiRenderTargetInfo,
         &UiGlobalTransform,
-        &TextScroll,
     )>,
     q_scrubber: Query<(&ComputedNode, &UiGlobalTransform, &mut ScrubberDragState)>,
     q_root: Query<Has<InteractionDisabled>>,
@@ -823,8 +820,7 @@ fn scrubber_on_release(
 ) {
     if let Ok(&ChildOf(text_id)) = q_parent.get(release.event_target())
         && let Ok(&ChildOf(root_id)) = q_parent.get(text_id)
-        && let Ok((mut editable_text, node, target, transform, text_scroll)) =
-            q_text.get_mut(text_id)
+        && let Ok((mut editable_text, node, target, transform)) = q_text.get_mut(text_id)
         && let Ok((_, _, drag_state)) = q_scrubber.get(release.entity)
         && let Ok(disabled) = q_root.get(root_id)
     {
@@ -850,7 +846,7 @@ fn scrubber_on_release(
                 inverse.transform_point2(
                     release.pointer_location.position * target.scale_factor() / ui_scale.0,
                 ) - node.content_box().min
-                    + text_scroll.0
+                    + editable_text.viewport.offset
             }) else {
                 return;
             };

crates/bevy_text/src/editing.rs

@@ -73,13 +73,15 @@
 // and `bevy_ui`, such as text layout and font management.
 
 use crate::{
-    text_edit::{poll_and_apply_paste, TextEdit},
+    scroll::TextViewport,
+    text_edit::{poll_and_apply_paste, reveal_cursor, TextEdit},
     FontCx, FontHinting, LayoutCx, LineHeight, TextBrush, TextColor, TextFont, TextLayout,
 };
 use alloc::sync::Arc;
 use bevy_clipboard::ClipboardRead;
 use bevy_derive::{Deref, DerefMut};
 use bevy_ecs::prelude::*;
+use bevy_math::Vec2;
 use core::time::Duration;
 use parley::{FontContext, LayoutContext, PlainEditor, SplitString};
 
@@ -115,6 +117,8 @@ pub struct EditableText {
     /// These operations should generally be batched together to avoid redundant layout work.
     // The B: Brush generic here must match the brush used by `ComputedTextBlock` to ensure that the font system is compatible.
     pub editor: PlainEditor<TextBrush>,
+    /// The bounds of the visible portion of the text layout.
+    pub viewport: TextViewport,
     /// Text edit actions that have been requested but not yet applied.
     ///
     /// These edits are processed in first-in, first-out order.
@@ -128,6 +132,11 @@ pub struct EditableText {
     /// rather than draining further edits, so that everything after the paste stays correctly ordered *behind* it.
     // TODO: this may cause unexpected stalls if the clipboard read takes too long. We may want to add a timeout.
     pub pending_paste: Option<ClipboardRead>,
+    /// Cursor reveal margins as fractions of the viewport size.
+    ///
+    /// Each component is applied to both edges of its axis. Values are clamped
+    /// to `0.0..=0.5`, and non-finite values are treated as zero.
+    pub cursor_margin: Vec2,
     /// Cursor width, relative to font size
     pub cursor_width: f32,
     /// Cursor blink period in seconds.
@@ -151,6 +160,8 @@ impl Default for EditableText {
         Self {
             // Defaults selected to match `Text::default()`
             editor: PlainEditor::new(100.),
+            viewport: TextViewport::default(),
+            cursor_margin: Vec2::splat(0.2),
             pending_edits: Vec::new(),
             pending_paste: None,
             cursor_width: 0.2,
@@ -217,6 +228,8 @@ impl EditableText {
             pending_edits,
             pending_paste,
             max_characters,
+            viewport,
+            cursor_margin,
             ..
         } = self;
 
@@ -225,11 +238,15 @@ impl EditableText {
         // First: resolve any paste carried over from a previous frame. If it's still
         // pending, hold the remaining edits (untouched in `pending_edits`) for next frame
         // so ordering relative to the paste is preserved.
-        if let Some(mut read) = pending_paste.take()
-            && !poll_and_apply_paste(&mut read, &mut driver, *max_characters, &char_filter)
-        {
-            *pending_paste = Some(read);
-            return;
+        if let Some(mut read) = pending_paste.take() {
+            let generation = driver.editor.generation();
+            if !poll_and_apply_paste(&mut read, &mut driver, *max_characters, &char_filter) {
+                *pending_paste = Some(read);
+                return;
+            }
+            if generation != driver.editor.generation() {
+                reveal_cursor(&mut driver, viewport, *cursor_margin);
+            }
         }
 
         // Drain edits one at a time. A paste that resolves synchronously (always the case
@@ -239,15 +256,26 @@ impl EditableText {
         while let Some(edit) = edits.next() {
             match edit {
                 TextEdit::Paste => {
+                    let generation = driver.editor.generation();
                     let mut read = clipboard.fetch_text();
                     if !poll_and_apply_paste(&mut read, &mut driver, *max_characters, &char_filter)
                     {
                         *pending_paste = Some(read);
                         pending_edits.extend(edits);
                         return;
                     }
+                    if generation != driver.editor.generation() {
+                        reveal_cursor(&mut driver, viewport, *cursor_margin);
+                    }
                 }
-                other => other.apply(&mut driver, clipboard, *max_characters, &char_filter),
+                other => other.apply(
+                    &mut driver,
+                    viewport,
+                    *cursor_margin,
+                    clipboard,
+                    *max_characters,
+                    &char_filter,
+                ),
             }
         }
     }

crates/bevy_text/src/lib.rs

@@ -42,6 +42,7 @@ mod font_loader;
 mod glyph;
 mod parley_context;
 mod pipeline;
+mod scroll;
 mod text;
 mod text_access;
 mod text_edit;
@@ -57,6 +58,7 @@ pub use font_loader::*;
 pub use glyph::*;
 pub use parley_context::*;
 pub use pipeline::*;
+pub use scroll::*;
 pub use text::*;
 pub use text_access::*;
 pub use text_edit::*;