Merge branch 'main' into callback-handles

crates/gpui2/src/elements/text.rs

@@ -1,68 +1,163 @@
 use crate::{
-    AnyElement, Bounds, Component, Element, ElementId, LayoutId, Pixels, SharedString, Size,
-    TextRun, WindowContext, WrappedLine,
+    Bounds, Element, ElementId, LayoutId, Pixels, RenderOnce, SharedString, Size, TextRun,
+    WindowContext, WrappedLine,
 };
+use anyhow::anyhow;
 use parking_lot::{Mutex, MutexGuard};
 use smallvec::SmallVec;
 use std::{cell::Cell, rc::Rc, sync::Arc};
 use util::ResultExt;
 
-pub struct Text {
+impl Element for &'static str {
+    type State = TextState;
+
+    fn layout(
+        &mut self,
+        _: Option<Self::State>,
+        cx: &mut WindowContext,
+    ) -> (LayoutId, Self::State) {
+        let mut state = TextState::default();
+        let layout_id = state.layout(SharedString::from(*self), None, cx);
+        (layout_id, state)
+    }
+
+    fn paint(self, bounds: Bounds<Pixels>, state: &mut TextState, cx: &mut WindowContext) {
+        state.paint(bounds, self, cx)
+    }
+}
+
+impl RenderOnce for &'static str {
+    type Element = Self;
+
+    fn element_id(&self) -> Option<ElementId> {
+        None
+    }
+
+    fn render_once(self) -> Self::Element {
+        self
+    }
+}
+
+impl Element for SharedString {
+    type State = TextState;
+
+    fn layout(
+        &mut self,
+        _: Option<Self::State>,
+        cx: &mut WindowContext,
+    ) -> (LayoutId, Self::State) {
+        let mut state = TextState::default();
+        let layout_id = state.layout(self.clone(), None, cx);
+        (layout_id, state)
+    }
+
+    fn paint(self, bounds: Bounds<Pixels>, state: &mut TextState, cx: &mut WindowContext) {
+        let text_str: &str = self.as_ref();
+        state.paint(bounds, text_str, cx)
+    }
+}
+
+impl RenderOnce for SharedString {
+    type Element = Self;
+
+    fn element_id(&self) -> Option<ElementId> {
+        None
+    }
+
+    fn render_once(self) -> Self::Element {
+        self
+    }
+}
+
+pub struct StyledText {
     text: SharedString,
     runs: Option<Vec<TextRun>>,
 }
 
-impl Text {
+impl StyledText {
     /// Renders text with runs of different styles.
     ///
     /// Callers are responsible for setting the correct style for each run.
     /// For text with a uniform style, you can usually avoid calling this constructor
     /// and just pass text directly.
-    pub fn styled(text: SharedString, runs: Vec<TextRun>) -> Self {
-        Text {
+    pub fn new(text: SharedString, runs: Vec<TextRun>) -> Self {
+        StyledText {
             text,
             runs: Some(runs),
         }
     }
 }
 
-impl Component for Text {
-    fn render(self) -> AnyElement {
-        AnyElement::new(self)
+impl Element for StyledText {
+    type State = TextState;
+
+    fn layout(
+        &mut self,
+        _: Option<Self::State>,
+        cx: &mut WindowContext,
+    ) -> (LayoutId, Self::State) {
+        let mut state = TextState::default();
+        let layout_id = state.layout(self.text.clone(), self.runs.take(), cx);
+        (layout_id, state)
+    }
+
+    fn paint(self, bounds: Bounds<Pixels>, state: &mut Self::State, cx: &mut WindowContext) {
+        state.paint(bounds, &self.text, cx)
     }
 }
 
-impl Element for Text {
-    type ElementState = TextState;
+impl RenderOnce for StyledText {
+    type Element = Self;
 
     fn element_id(&self) -> Option<crate::ElementId> {
         None
     }
 
+    fn render_once(self) -> Self::Element {
+        self
+    }
+}
+
+#[derive(Default, Clone)]
+pub struct TextState(Arc<Mutex<Option<TextStateInner>>>);
+
+struct TextStateInner {
+    lines: SmallVec<[WrappedLine; 1]>,
+    line_height: Pixels,
+    wrap_width: Option<Pixels>,
+    size: Option<Size<Pixels>>,
+}
+
+impl TextState {
+    fn lock(&self) -> MutexGuard<Option<TextStateInner>> {
+        self.0.lock()
+    }
+
     fn layout(
         &mut self,
-        element_state: Option<Self::ElementState>,
+        text: SharedString,
+        runs: Option<Vec<TextRun>>,
         cx: &mut WindowContext,
-    ) -> (LayoutId, Self::ElementState) {
-        let element_state = element_state.unwrap_or_default();
+    ) -> LayoutId {
         let text_system = cx.text_system().clone();
         let text_style = cx.text_style();
         let font_size = text_style.font_size.to_pixels(cx.rem_size());
         let line_height = text_style
             .line_height
             .to_pixels(font_size.into(), cx.rem_size());
-        let text = self.text.clone();
+        let text = SharedString::from(text);
 
         let rem_size = cx.rem_size();
 
-        let runs = if let Some(runs) = self.runs.take() {
+        let runs = if let Some(runs) = runs {
             runs
         } else {
             vec![text_style.to_run(text.len())]
         };
 
         let layout_id = cx.request_measured_layout(Default::default(), rem_size, {
-            let element_state = element_state.clone();
+            let element_state = self.clone();
+
             move |known_dimensions, available_space| {
                 let wrap_width = known_dimensions.width.or(match available_space.width {
                     crate::AvailableSpace::Definite(x) => Some(x),
@@ -113,19 +208,14 @@ impl Element for Text {
             }
         });
 
-        (layout_id, element_state)
+        layout_id
     }
 
-    fn paint(
-        &mut self,
-        bounds: Bounds<Pixels>,
-        element_state: &mut Self::ElementState,
-        cx: &mut WindowContext,
-    ) {
-        let element_state = element_state.lock();
+    fn paint(&mut self, bounds: Bounds<Pixels>, text: &str, cx: &mut WindowContext) {
+        let element_state = self.lock();
         let element_state = element_state
             .as_ref()
-            .ok_or_else(|| anyhow::anyhow!("measurement has not been performed on {}", &self.text))
+            .ok_or_else(|| anyhow!("measurement has not been performed on {}", text))
             .unwrap();
 
         let line_height = element_state.line_height;
@@ -137,25 +227,9 @@ impl Element for Text {
     }
 }
 
-#[derive(Default, Clone)]
-pub struct TextState(Arc<Mutex<Option<TextStateInner>>>);
-
-impl TextState {
-    fn lock(&self) -> MutexGuard<Option<TextStateInner>> {
-        self.0.lock()
-    }
-}
-
-struct TextStateInner {
-    lines: SmallVec<[WrappedLine; 1]>,
-    line_height: Pixels,
-    wrap_width: Option<Pixels>,
-    size: Option<Size<Pixels>>,
-}
-
 struct InteractiveText {
-    id: ElementId,
-    text: Text,
+    element_id: ElementId,
+    text: StyledText,
 }
 
 struct InteractiveTextState {
@@ -164,21 +238,17 @@ struct InteractiveTextState {
 }
 
 impl Element for InteractiveText {
-    type ElementState = InteractiveTextState;
-
-    fn element_id(&self) -> Option<ElementId> {
-        Some(self.id.clone())
-    }
+    type State = InteractiveTextState;
 
     fn layout(
         &mut self,
-        element_state: Option<Self::ElementState>,
+        state: Option<Self::State>,
         cx: &mut WindowContext,
-    ) -> (LayoutId, Self::ElementState) {
+    ) -> (LayoutId, Self::State) {
         if let Some(InteractiveTextState {
             text_state,
             clicked_range_ixs,
-        }) = element_state
+        }) = state
         {
             let (layout_id, text_state) = self.text.layout(Some(text_state), cx);
             let element_state = InteractiveTextState {
@@ -196,44 +266,19 @@ impl Element for InteractiveText {
         }
     }
 
-    fn paint(
-        &mut self,
-        bounds: Bounds<Pixels>,
-        element_state: &mut Self::ElementState,
-        cx: &mut WindowContext,
-    ) {
-        self.text.paint(bounds, &mut element_state.text_state, cx)
+    fn paint(self, bounds: Bounds<Pixels>, state: &mut Self::State, cx: &mut WindowContext) {
+        self.text.paint(bounds, &mut state.text_state, cx)
     }
 }
 
-impl Component for SharedString {
-    fn render(self) -> AnyElement {
-        Text {
-            text: self,
-            runs: None,
-        }
-        .render()
-    }
-}
+impl RenderOnce for InteractiveText {
+    type Element = Self;
 
-impl Component for &'static str {
-    fn render(self) -> AnyElement {
-        Text {
-            text: self.into(),
-            runs: None,
-        }
-        .render()
+    fn element_id(&self) -> Option<ElementId> {
+        Some(self.element_id.clone())
     }
-}
 
-// TODO: Figure out how to pass `String` to `child` without this.
-// This impl doesn't exist in the `gpui2` crate.
-impl Component for String {
-    fn render(self) -> AnyElement {
-        Text {
-            text: self.into(),
-            runs: None,
-        }
-        .render()
+    fn render_once(self) -> Self::Element {
+        self
     }
 }