Remove initialize method from Element trait

crates/editor2/src/element.rs

@@ -2398,21 +2398,14 @@ impl Element<Editor> for EditorElement {
         Some(self.editor_id.into())
     }
 
-    fn initialize(
+    fn layout(
         &mut self,
         editor: &mut Editor,
         element_state: Option<Self::ElementState>,
         cx: &mut gpui::ViewContext<Editor>,
-    ) -> Self::ElementState {
+    ) -> (gpui::LayoutId, Self::ElementState) {
         editor.style = Some(self.style.clone()); // Long-term, we'd like to eliminate this.
-    }
 
-    fn layout(
-        &mut self,
-        editor: &mut Editor,
-        element_state: &mut Self::ElementState,
-        cx: &mut gpui::ViewContext<Editor>,
-    ) -> gpui::LayoutId {
         let rem_size = cx.rem_size();
         let mut style = Style::default();
         style.size.width = relative(1.).into();
@@ -2421,7 +2414,8 @@ impl Element<Editor> for EditorElement {
             EditorMode::AutoHeight { .. } => todo!(),
             EditorMode::Full => relative(1.).into(),
         };
-        cx.request_layout(&style, None)
+        let layout_id = cx.request_layout(&style, None);
+        (layout_id, ())
     }
 
     fn paint(

crates/gpui2/src/element.rs

@@ -244,7 +244,7 @@ where
 
     fn draw(
         &mut self,
-        mut origin: Point<Pixels>,
+        origin: Point<Pixels>,
         available_space: Size<AvailableSpace>,
         view_state: &mut V,
         cx: &mut ViewContext<V>,

crates/gpui2/src/elements/uniform_list.rs

@@ -108,62 +108,54 @@ impl<V: 'static> Element<V> for UniformList<V> {
         Some(self.id.clone())
     }
 
-    fn initialize(
+    fn layout(
         &mut self,
         view_state: &mut V,
         element_state: Option<Self::ElementState>,
         cx: &mut ViewContext<V>,
-    ) -> Self::ElementState {
-        if let Some(mut element_state) = element_state {
-            element_state.interactive = self
-                .interactivity
-                .initialize(Some(element_state.interactive), cx);
-            element_state
-        } else {
-            let item_size = self.measure_item(view_state, None, cx);
-            UniformListState {
-                interactive: self.interactivity.initialize(None, cx),
-                item_size,
-            }
-        }
-    }
-
-    fn layout(
-        &mut self,
-        _view_state: &mut V,
-        element_state: Option<Self::ElementState>,
-        cx: &mut ViewContext<V>,
     ) -> (LayoutId, Self::ElementState) {
         let max_items = self.item_count;
-        let item_size = element_state.item_size;
         let rem_size = cx.rem_size();
+        let item_size = element_state
+            .as_ref()
+            .map(|s| s.item_size)
+            .unwrap_or_else(|| self.measure_item(view_state, None, cx));
 
-        self.interactivity
+        let (layout_id, interactive) =
-            .layout(&mut element_state.interactive, cx, |style, cx| {
+            self.interactivity
-                cx.request_measured_layout(
+                .layout(element_state.map(|s| s.interactive), cx, |style, cx| {
-                    style,
+                    cx.request_measured_layout(
-                    rem_size,
+                        style,
-                    move |known_dimensions: Size<Option<Pixels>>,
+                        rem_size,
-                          available_space: Size<AvailableSpace>| {
+                        move |known_dimensions: Size<Option<Pixels>>,
-                        let desired_height = item_size.height * max_items;
+                              available_space: Size<AvailableSpace>| {
-                        let width = known_dimensions
+                            let desired_height = item_size.height * max_items;
-                            .width
+                            let width =
-                            .unwrap_or(match available_space.width {
+                                known_dimensions
-                                AvailableSpace::Definite(x) => x,
+                                    .width
+                                    .unwrap_or(match available_space.width {
+                                        AvailableSpace::Definite(x) => x,
+                                        AvailableSpace::MinContent | AvailableSpace::MaxContent => {
+                                            item_size.width
+                                        }
+                                    });
+                            let height = match available_space.height {
+                                AvailableSpace::Definite(x) => desired_height.min(x),
                                 AvailableSpace::MinContent | AvailableSpace::MaxContent => {
-                                    item_size.width
+                                    desired_height
                                 }
-                            });
+                            };
-                        let height = match available_space.height {
+                            size(width, height)
-                            AvailableSpace::Definite(x) => desired_height.min(x),
+                        },
-                            AvailableSpace::MinContent | AvailableSpace::MaxContent => {
+                    )
-                                desired_height
+                });
-                            }
+
-                        };
+        let element_state = UniformListState {
-                        size(width, height)
+            interactive,
-                    },
+            item_size,
-                )
+        };
-            })
+
+        (layout_id, element_state)
     }
 
     fn paint(

crates/gpui2/src/view.rs

@@ -225,10 +225,10 @@ impl<ParentViewState: 'static> Element<ParentViewState> for AnyView {
     fn layout(
         &mut self,
         _view_state: &mut ParentViewState,
-        rendered_element: Option<Self::ElementState>,
+        _element_state: Option<Self::ElementState>,
         cx: &mut ViewContext<ParentViewState>,
     ) -> (LayoutId, Self::ElementState) {
-        (self.layout)(self, rendered_element, cx)
+        (self.layout)(self, cx)
     }
 
     fn paint(

crates/gpui2/src/window.rs

@@ -1076,26 +1076,22 @@ impl<'a> WindowContext<'a> {
 
         self.with_z_index(0, |cx| {
             let available_space = cx.window.viewport_size.map(Into::into);
-            root_view.draw(available_space, cx);
+            root_view.draw(Point::zero(), available_space, cx);
         });
 
         if let Some(active_drag) = self.app.active_drag.take() {
             self.with_z_index(1, |cx| {
                 let offset = cx.mouse_position() - active_drag.cursor_offset;
-                cx.with_element_offset(offset, |cx| {
+                let available_space = size(AvailableSpace::MinContent, AvailableSpace::MinContent);
-                    let available_space =
+                active_drag.view.draw(offset, available_space, cx);
-                        size(AvailableSpace::MinContent, AvailableSpace::MinContent);
+                cx.active_drag = Some(active_drag);
-                    active_drag.view.draw(available_space, cx);
-                    cx.active_drag = Some(active_drag);
-                });
             });
         } else if let Some(active_tooltip) = self.app.active_tooltip.take() {
             self.with_z_index(1, |cx| {
-                cx.with_element_offset(active_tooltip.cursor_offset, |cx| {
+                let available_space = size(AvailableSpace::MinContent, AvailableSpace::MinContent);
-                    let available_space =
+                active_tooltip
-                        size(AvailableSpace::MinContent, AvailableSpace::MinContent);
+                    .view
-                    active_tooltip.view.draw(available_space, cx);
+                    .draw(active_tooltip.cursor_offset, available_space, cx);
-                });
             });
         }