Avoid cloning text in TextEdit for Arc<str> text buffers

crates/egui/src/data/output.rs

@@ -1,5 +1,7 @@
 //! All the data egui returns to the backend at the end of each frame.
 
+use std::sync::Arc;
+
 use crate::{OrderedViewportIdMap, RepaintCause, ViewportOutput, WidgetType};
 
 /// What egui emits each frame from [`crate::Context::run`].
@@ -495,10 +497,10 @@ pub struct WidgetInfo {
     pub label: Option<String>,
 
     /// The contents of some editable text (for [`TextEdit`](crate::TextEdit) fields).
-    pub current_text_value: Option<String>,
+    pub current_text_value: Option<Arc<str>>,
 
     /// The previous text value.
-    pub prev_text_value: Option<String>,
+    pub prev_text_value: Option<Arc<str>>,
 
     /// The current value of checkboxes and radio buttons.
     pub selected: Option<bool>,
@@ -618,12 +620,12 @@ impl WidgetInfo {
     #[expect(clippy::needless_pass_by_value)]
     pub fn text_edit(
         enabled: bool,
-        prev_text_value: impl ToString,
-        text_value: impl ToString,
+        prev_text_value: impl Into<Arc<str>>,
+        text_value: impl Into<Arc<str>>,
         hint_text: impl ToString,
     ) -> Self {
-        let text_value = text_value.to_string();
-        let prev_text_value = prev_text_value.to_string();
+        let text_value = text_value.into();
+        let prev_text_value = prev_text_value.into();
         let hint_text = hint_text.to_string();
         let prev_text_value = if text_value == prev_text_value {
             None
@@ -639,16 +641,15 @@ impl WidgetInfo {
         }
     }
 
-    #[expect(clippy::needless_pass_by_value)]
     pub fn text_selection_changed(
         enabled: bool,
         text_selection: std::ops::RangeInclusive<usize>,
-        current_text_value: impl ToString,
+        current_text_value: impl Into<Arc<str>>,
     ) -> Self {
         Self {
             enabled,
             text_selection: Some(text_selection),
-            current_text_value: Some(current_text_value.to_string()),
+            current_text_value: Some(current_text_value.into()),
             ..Self::new(WidgetType::TextEdit)
         }
     }

crates/egui/src/painter.rs

@@ -555,7 +555,7 @@ impl Painter {
     /// Paint the results with [`Self::galley`].
     #[inline]
     #[must_use]
-    pub fn layout_job(&self, layout_job: LayoutJob) -> Arc<Galley> {
+    pub fn layout_job(&self, layout_job: impl Into<Arc<LayoutJob>>) -> Arc<Galley> {
         self.fonts_mut(|f| f.layout_job(layout_job))
     }
 

crates/egui/src/response.rs

@@ -874,7 +874,7 @@ impl Response {
             }
         }
         if let Some(value) = info.current_text_value {
-            builder.set_value(value);
+            builder.set_value((*value).to_owned());
         }
         if let Some(value) = info.value {
             builder.set_numeric_value(value);

crates/egui/src/widgets/text_edit/builder.rs

@@ -500,7 +500,7 @@ impl TextEdit<'_> {
             // .unwrap_or_else(|| ui.style().interact(&response).text_color()); // too bright
             .unwrap_or_else(|| ui.visuals().widgets.inactive.text_color());
 
-        let prev_text = text.as_str().to_owned();
+        let prev_text = text.clone_to_arc();
         let hint_text_str = hint_text.text().to_owned();
 
         let font_id = font_selection.resolve(ui.style());
@@ -516,7 +516,8 @@ impl TextEdit<'_> {
 
         let font_id_clone = font_id.clone();
         let mut default_layouter = move |ui: &Ui, text: &dyn TextBuffer, wrap_width: f32| {
-            let text = mask_if_password(password, text.as_str());
+            // TODO(afishhh): Keep as `Arc<str>` instead of cloning to a `String`
+            let text = (*mask_if_password(password, text.clone_to_arc())).to_owned();
             let layout_job = if multiline {
                 LayoutJob::simple(text, font_id_clone.clone(), text_color, wrap_width)
             } else {
@@ -819,8 +820,8 @@ impl TextEdit<'_> {
             response.widget_info(|| {
                 WidgetInfo::text_edit(
                     ui.is_enabled(),
-                    mask_if_password(password, prev_text.as_str()),
-                    mask_if_password(password, text.as_str()),
+                    mask_if_password(password, prev_text.clone()),
+                    mask_if_password(password, text.clone_to_arc()),
                     hint_text_str.as_str(),
                 )
             });
@@ -830,15 +831,15 @@ impl TextEdit<'_> {
             let info = WidgetInfo::text_selection_changed(
                 ui.is_enabled(),
                 char_range,
-                mask_if_password(password, text.as_str()),
+                mask_if_password(password, text.clone_to_arc()),
             );
             response.output_event(OutputEvent::TextSelectionChanged(info));
         } else {
             response.widget_info(|| {
                 WidgetInfo::text_edit(
                     ui.is_enabled(),
-                    mask_if_password(password, prev_text.as_str()),
-                    mask_if_password(password, text.as_str()),
+                    mask_if_password(password, prev_text.clone()),
+                    mask_if_password(password, text.clone_to_arc()),
                     hint_text_str.as_str(),
                 )
             });
@@ -875,7 +876,7 @@ impl TextEdit<'_> {
     }
 }
 
-fn mask_if_password(is_password: bool, text: &str) -> String {
+fn mask_if_password(is_password: bool, text: Arc<str>) -> Arc<str> {
     fn mask_password(text: &str) -> String {
         std::iter::repeat_n(
             epaint::text::PASSWORD_REPLACEMENT_CHAR,
@@ -885,9 +886,9 @@ fn mask_if_password(is_password: bool, text: &str) -> String {
     }
 
     if is_password {
-        mask_password(text)
+        mask_password(&text).into()
     } else {
-        text.to_owned()
+        text
     }
 }
 
@@ -916,10 +917,10 @@ fn events(
 
     // We feed state to the undoer both before and after handling input
     // so that the undoer creates automatic saves even when there are no events for a while.
-    state.undoer.lock().feed_state(
-        ui.input(|i| i.time),
-        &(cursor_range, text.as_str().to_owned()),
-    );
+    state
+        .undoer
+        .lock()
+        .feed_state(ui.input(|i| i.time), &(cursor_range, text.clone_to_arc()));
 
     let copy_if_not_password = |ui: &Ui, text: String| {
         if !password {
@@ -1030,7 +1031,7 @@ fn events(
                 if let Some((redo_ccursor_range, redo_txt)) = state
                     .undoer
                     .lock()
-                    .redo(&(cursor_range, text.as_str().to_owned()))
+                    .redo(&(cursor_range, text.clone_to_arc()))
                 {
                     text.replace_with(redo_txt);
                     Some(*redo_ccursor_range)
@@ -1048,7 +1049,7 @@ fn events(
                 if let Some((undo_ccursor_range, undo_txt)) = state
                     .undoer
                     .lock()
-                    .undo(&(cursor_range, text.as_str().to_owned()))
+                    .undo(&(cursor_range, text.clone_to_arc()))
                 {
                     text.replace_with(undo_txt);
                     Some(*undo_ccursor_range)
@@ -1126,10 +1127,10 @@ fn events(
 
     state.cursor.set_char_range(Some(cursor_range));
 
-    state.undoer.lock().feed_state(
-        ui.input(|i| i.time),
-        &(cursor_range, text.as_str().to_owned()),
-    );
+    state
+        .undoer
+        .lock()
+        .feed_state(ui.input(|i| i.time), &(cursor_range, text.clone_to_arc()));
 
     (any_change, cursor_range)
 }

crates/egui/src/widgets/text_edit/state.rs

@@ -7,7 +7,7 @@ use crate::{
     text_selection::{CCursorRange, TextCursorState},
 };
 
-pub type TextEditUndoer = crate::util::undoer::Undoer<(CCursorRange, String)>;
+pub type TextEditUndoer = crate::util::undoer::Undoer<(CCursorRange, Arc<str>)>;
 
 /// The text edit state stored between frames.
 ///

crates/egui/src/widgets/text_edit/text_buffer.rs

@@ -1,4 +1,4 @@
-use std::{borrow::Cow, ops::Range};
+use std::{borrow::Cow, ops::Range, sync::Arc};
 
 use epaint::{
     Galley,
@@ -24,6 +24,17 @@ pub trait TextBuffer {
     /// Returns this buffer as a `str`.
     fn as_str(&self) -> &str;
 
+    /// Clone this buffer to an [`Arc<str>`].
+    ///
+    /// By default this is implemented by creating a new [`Arc`] from the result
+    /// of [`as_str`]. However, if the buffer is already managed by an [`Arc`],
+    /// this can be implemented more efficiently and avoid some cloning.
+    ///
+    /// [`as_str`]: Self::as_str
+    fn clone_to_arc(&self) -> Arc<str> {
+        Arc::from(self.as_str())
+    }
+
     /// Inserts text `text` into this buffer at character index `char_index`.
     ///
     /// # Notes
@@ -315,3 +326,28 @@ impl TextBuffer for &str {
         std::any::TypeId::of::<&str>()
     }
 }
+
+/// Immutable view of an [`Arc<str>`]
+impl TextBuffer for Arc<str> {
+    fn is_mutable(&self) -> bool {
+        false
+    }
+
+    fn as_str(&self) -> &str {
+        self
+    }
+
+    fn clone_to_arc(&self) -> Arc<str> {
+        self.clone()
+    }
+
+    fn insert_text(&mut self, _text: &str, _ch_idx: usize) -> usize {
+        0
+    }
+
+    fn delete_char_range(&mut self, _ch_range: Range<usize>) {}
+
+    fn type_id(&self) -> std::any::TypeId {
+        std::any::TypeId::of::<Self>()
+    }
+}

crates/epaint/src/text/fonts.rs

@@ -691,7 +691,7 @@ impl FontsView<'_> {
     ///
     /// The implementation uses memoization so repeated calls are cheap.
     #[inline]
-    pub fn layout_job(&mut self, job: LayoutJob) -> Arc<Galley> {
+    pub fn layout_job(&mut self, job: impl Into<Arc<LayoutJob>>) -> Arc<Galley> {
         let allow_split_paragraphs = true; // Optimization for editing text with many paragraphs.
         self.galley_cache.layout(
             self.fonts,
@@ -852,7 +852,7 @@ impl GalleyCache {
     fn layout_internal(
         &mut self,
         fonts: &mut FontsImpl,
-        mut job: LayoutJob,
+        mut job: Arc<LayoutJob>,
         pixels_per_point: f32,
         allow_split_paragraphs: bool,
     ) -> (u64, Arc<Galley>) {
@@ -878,7 +878,7 @@ impl GalleyCache {
             // * https://github.com/emilk/egui/issues/5084
             // * https://github.com/emilk/egui/issues/5163
 
-            job.wrap.max_width = job.wrap.max_width.round();
+            Arc::make_mut(&mut job).wrap.max_width = job.wrap.max_width.round();
         }
 
         let hash = crate::util::hash((&job, OrderedFloat(pixels_per_point))); // TODO(emilk): even faster hasher?
@@ -906,7 +906,6 @@ impl GalleyCache {
                 galley
             }
             std::collections::hash_map::Entry::Vacant(entry) => {
-                let job = Arc::new(job);
                 if allow_split_paragraphs && should_cache_each_paragraph_individually(&job) {
                     let (child_galleys, child_hashes) =
                         self.layout_each_paragraph_individually(fonts, &job, pixels_per_point);
@@ -946,10 +945,10 @@ impl GalleyCache {
         &mut self,
         fonts: &mut FontsImpl,
         pixels_per_point: f32,
-        job: LayoutJob,
+        job: impl Into<Arc<LayoutJob>>,
         allow_split_paragraphs: bool,
     ) -> Arc<Galley> {
-        self.layout_internal(fonts, job, pixels_per_point, allow_split_paragraphs)
+        self.layout_internal(fonts, job.into(), pixels_per_point, allow_split_paragraphs)
             .1
     }
 
@@ -1039,7 +1038,7 @@ impl GalleyCache {
 
             // TODO(emilk): we could lay out each paragraph in parallel to get a nice speedup on multicore machines.
             let (hash, galley) =
-                self.layout_internal(fonts, paragraph_job, pixels_per_point, false);
+                self.layout_internal(fonts, Arc::new(paragraph_job), pixels_per_point, false);
             child_hashes.push(hash);
 
             // This will prevent us from invalidating cache entries unnecessarily: