Remove dispatch_event from Element trait

crates/collab_ui/src/collab_titlebar_item.rs

@@ -526,18 +526,6 @@ impl Element for AvatarRibbon {
         cx.scene.push_path(path.build(self.color, None));
     }
 
-    fn dispatch_event(
-        &mut self,
-        _: &gpui::Event,
-        _: RectF,
-        _: RectF,
-        _: &mut Self::LayoutState,
-        _: &mut Self::PaintState,
-        _: &mut gpui::EventContext,
-    ) -> bool {
-        false
-    }
-
     fn rect_for_text_range(
         &self,
         _: Range<usize>,

crates/editor/src/element.rs

@@ -29,9 +29,9 @@ use gpui::{
     json::{self, ToJson},
     platform::CursorStyle,
     text_layout::{self, Line, RunStyle, TextLayoutCache},
-    AppContext, Axis, Border, CursorRegion, Element, ElementBox, Event, EventContext,
+    AppContext, Axis, Border, CursorRegion, Element, ElementBox, EventContext, LayoutContext,
-    LayoutContext, MouseButton, MouseButtonEvent, MouseMovedEvent, MouseRegion, MutableAppContext,
+    MouseButton, MouseButtonEvent, MouseMovedEvent, MouseRegion, MutableAppContext, PaintContext,
-    PaintContext, Quad, Scene, SizeConstraint, ViewContext, WeakViewHandle,
+    Quad, Scene, SizeConstraint, ViewContext, WeakViewHandle,
 };
 use json::json;
 use language::{Bias, DiagnosticSeverity, OffsetUtf16, Selection};
@@ -1878,18 +1878,6 @@ impl Element for EditorElement {
         cx.scene.pop_layer();
     }
 
-    fn dispatch_event(
-        &mut self,
-        _: &Event,
-        _: RectF,
-        _: RectF,
-        _: &mut LayoutState,
-        _: &mut (),
-        _: &mut EventContext,
-    ) -> bool {
-        false
-    }
-
     fn rect_for_text_range(
         &self,
         range_utf16: Range<usize>,

crates/gpui/examples/text.rs

@@ -101,18 +101,6 @@ impl gpui::Element for TextElement {
         line.paint(bounds.origin(), visible_bounds, bounds.height(), cx);
     }
 
-    fn dispatch_event(
-        &mut self,
-        _: &gpui::Event,
-        _: RectF,
-        _: RectF,
-        _: &mut Self::LayoutState,
-        _: &mut Self::PaintState,
-        _: &mut gpui::EventContext,
-    ) -> bool {
-        false
-    }
-
     fn rect_for_text_range(
         &self,
         _: Range<usize>,

crates/gpui/src/elements.rs

@@ -33,8 +33,8 @@ use crate::{
     },
     json,
     presenter::MeasurementContext,
-    Action, DebugContext, Event, EventContext, LayoutContext, PaintContext, RenderContext,
+    Action, DebugContext, EventContext, LayoutContext, PaintContext, RenderContext, SizeConstraint,
-    SizeConstraint, View,
+    View,
 };
 use core::panic;
 use json::ToJson;
@@ -50,7 +50,6 @@ use std::{
 trait AnyElement {
     fn layout(&mut self, constraint: SizeConstraint, cx: &mut LayoutContext) -> Vector2F;
     fn paint(&mut self, origin: Vector2F, visible_bounds: RectF, cx: &mut PaintContext);
-    fn dispatch_event(&mut self, event: &Event, cx: &mut EventContext) -> bool;
     fn rect_for_text_range(
         &self,
         range_utf16: Range<usize>,
@@ -80,16 +79,6 @@ pub trait Element {
         cx: &mut PaintContext,
     ) -> Self::PaintState;
 
-    fn dispatch_event(
-        &mut self,
-        event: &Event,
-        bounds: RectF,
-        visible_bounds: RectF,
-        layout: &mut Self::LayoutState,
-        paint: &mut Self::PaintState,
-        cx: &mut EventContext,
-    ) -> bool;
-
     fn rect_for_text_range(
         &self,
         range_utf16: Range<usize>,
@@ -303,22 +292,6 @@ impl<T: Element> AnyElement for Lifecycle<T> {
         }
     }
 
-    fn dispatch_event(&mut self, event: &Event, cx: &mut EventContext) -> bool {
-        if let Lifecycle::PostPaint {
-            element,
-            bounds,
-            visible_bounds,
-            layout,
-            paint,
-            ..
-        } = self
-        {
-            element.dispatch_event(event, *bounds, *visible_bounds, layout, paint, cx)
-        } else {
-            panic!("invalid element lifecycle state");
-        }
-    }
-
     fn rect_for_text_range(
         &self,
         range_utf16: Range<usize>,
@@ -433,10 +406,6 @@ impl ElementRc {
         self.element.borrow_mut().paint(origin, visible_bounds, cx);
     }
 
-    pub fn dispatch_event(&mut self, event: &Event, cx: &mut EventContext) -> bool {
-        self.element.borrow_mut().dispatch_event(event, cx)
-    }
-
     pub fn rect_for_text_range(
         &self,
         range_utf16: Range<usize>,

crates/gpui/src/elements/align.rs

@@ -2,8 +2,7 @@ use crate::{
     geometry::{rect::RectF, vector::Vector2F},
     json,
     presenter::MeasurementContext,
-    DebugContext, Element, ElementBox, Event, EventContext, LayoutContext, PaintContext,
+    DebugContext, Element, ElementBox, LayoutContext, PaintContext, SizeConstraint,
-    SizeConstraint,
 };
 use json::ToJson;
 
@@ -84,18 +83,6 @@ impl Element for Align {
         );
     }
 
-    fn dispatch_event(
-        &mut self,
-        event: &Event,
-        _: RectF,
-        _: RectF,
-        _: &mut Self::LayoutState,
-        _: &mut Self::PaintState,
-        cx: &mut EventContext,
-    ) -> bool {
-        self.child.dispatch_event(event, cx)
-    }
-
     fn rect_for_text_range(
         &self,
         range_utf16: std::ops::Range<usize>,

crates/gpui/src/elements/canvas.rs

@@ -56,18 +56,6 @@ where
         self.0(bounds, visible_bounds, cx)
     }
 
-    fn dispatch_event(
-        &mut self,
-        _: &crate::Event,
-        _: RectF,
-        _: RectF,
-        _: &mut Self::LayoutState,
-        _: &mut Self::PaintState,
-        _: &mut crate::EventContext,
-    ) -> bool {
-        false
-    }
-
     fn rect_for_text_range(
         &self,
         _: std::ops::Range<usize>,

crates/gpui/src/elements/constrained_box.rs

@@ -7,8 +7,7 @@ use crate::{
     geometry::{rect::RectF, vector::Vector2F},
     json,
     presenter::MeasurementContext,
-    DebugContext, Element, ElementBox, Event, EventContext, LayoutContext, PaintContext,
+    DebugContext, Element, ElementBox, LayoutContext, PaintContext, SizeConstraint,
-    SizeConstraint,
 };
 
 pub struct ConstrainedBox {
@@ -157,18 +156,6 @@ impl Element for ConstrainedBox {
         self.child.paint(bounds.origin(), visible_bounds, cx);
     }
 
-    fn dispatch_event(
-        &mut self,
-        event: &Event,
-        _: RectF,
-        _: RectF,
-        _: &mut Self::LayoutState,
-        _: &mut Self::PaintState,
-        cx: &mut EventContext,
-    ) -> bool {
-        self.child.dispatch_event(event, cx)
-    }
-
     fn rect_for_text_range(
         &self,
         range_utf16: Range<usize>,

crates/gpui/src/elements/container.rs

@@ -11,7 +11,7 @@ use crate::{
     platform::CursorStyle,
     presenter::MeasurementContext,
     scene::{self, Border, CursorRegion, Quad},
-    Element, ElementBox, Event, EventContext, LayoutContext, PaintContext, SizeConstraint,
+    Element, ElementBox, LayoutContext, PaintContext, SizeConstraint,
 };
 use serde::Deserialize;
 use serde_json::json;
@@ -285,18 +285,6 @@ impl Element for Container {
         }
     }
 
-    fn dispatch_event(
-        &mut self,
-        event: &Event,
-        _: RectF,
-        _: RectF,
-        _: &mut Self::LayoutState,
-        _: &mut Self::PaintState,
-        cx: &mut EventContext,
-    ) -> bool {
-        self.child.dispatch_event(event, cx)
-    }
-
     fn rect_for_text_range(
         &self,
         range_utf16: Range<usize>,

crates/gpui/src/elements/empty.rs

@@ -9,7 +9,7 @@ use crate::{
     presenter::MeasurementContext,
     DebugContext,
 };
-use crate::{Element, Event, EventContext, LayoutContext, PaintContext, SizeConstraint};
+use crate::{Element, LayoutContext, PaintContext, SizeConstraint};
 
 #[derive(Default)]
 pub struct Empty {
@@ -59,18 +59,6 @@ impl Element for Empty {
     ) -> Self::PaintState {
     }
 
-    fn dispatch_event(
-        &mut self,
-        _: &Event,
-        _: RectF,
-        _: RectF,
-        _: &mut Self::LayoutState,
-        _: &mut Self::PaintState,
-        _: &mut EventContext,
-    ) -> bool {
-        false
-    }
-
     fn rect_for_text_range(
         &self,
         _: Range<usize>,

crates/gpui/src/elements/expanded.rs

@@ -4,8 +4,7 @@ use crate::{
     geometry::{rect::RectF, vector::Vector2F},
     json,
     presenter::MeasurementContext,
-    DebugContext, Element, ElementBox, Event, EventContext, LayoutContext, PaintContext,
+    DebugContext, Element, ElementBox, LayoutContext, PaintContext, SizeConstraint,
-    SizeConstraint,
 };
 use serde_json::json;
 
@@ -66,18 +65,6 @@ impl Element for Expanded {
         self.child.paint(bounds.origin(), visible_bounds, cx);
     }
 
-    fn dispatch_event(
-        &mut self,
-        event: &Event,
-        _: RectF,
-        _: RectF,
-        _: &mut Self::LayoutState,
-        _: &mut Self::PaintState,
-        cx: &mut EventContext,
-    ) -> bool {
-        self.child.dispatch_event(event, cx)
-    }
-
     fn rect_for_text_range(
         &self,
         range_utf16: Range<usize>,

crates/gpui/src/elements/flex.rs

@@ -3,8 +3,8 @@ use std::{any::Any, cell::Cell, f32::INFINITY, ops::Range, rc::Rc};
 use crate::{
     json::{self, ToJson, Value},
     presenter::MeasurementContext,
-    Axis, DebugContext, Element, ElementBox, ElementStateHandle, Event, EventContext,
+    Axis, DebugContext, Element, ElementBox, ElementStateHandle, LayoutContext, PaintContext,
-    LayoutContext, PaintContext, RenderContext, SizeConstraint, Vector2FExt, View,
+    RenderContext, SizeConstraint, Vector2FExt, View,
 };
 use pathfinder_geometry::{
     rect::RectF,
@@ -318,23 +318,6 @@ impl Element for Flex {
         }
     }
 
-    fn dispatch_event(
-        &mut self,
-        event: &Event,
-        _: RectF,
-        _: RectF,
-        _: &mut Self::LayoutState,
-        _: &mut Self::PaintState,
-        cx: &mut EventContext,
-    ) -> bool {
-        let mut handled = false;
-        for child in &mut self.children {
-            handled = child.dispatch_event(event, cx) || handled;
-        }
-
-        handled
-    }
-
     fn rect_for_text_range(
         &self,
         range_utf16: Range<usize>,
@@ -420,18 +403,6 @@ impl Element for FlexItem {
         self.child.paint(bounds.origin(), visible_bounds, cx)
     }
 
-    fn dispatch_event(
-        &mut self,
-        event: &Event,
-        _: RectF,
-        _: RectF,
-        _: &mut Self::LayoutState,
-        _: &mut Self::PaintState,
-        cx: &mut EventContext,
-    ) -> bool {
-        self.child.dispatch_event(event, cx)
-    }
-
     fn rect_for_text_range(
         &self,
         range_utf16: Range<usize>,

crates/gpui/src/elements/hook.rs

@@ -4,8 +4,7 @@ use crate::{
     geometry::{rect::RectF, vector::Vector2F},
     json::json,
     presenter::MeasurementContext,
-    DebugContext, Element, ElementBox, Event, EventContext, LayoutContext, PaintContext,
+    DebugContext, Element, ElementBox, LayoutContext, PaintContext, SizeConstraint,
-    SizeConstraint,
 };
 
 pub struct Hook {
@@ -56,18 +55,6 @@ impl Element for Hook {
         self.child.paint(bounds.origin(), visible_bounds, cx);
     }
 
-    fn dispatch_event(
-        &mut self,
-        event: &Event,
-        _: RectF,
-        _: RectF,
-        _: &mut Self::LayoutState,
-        _: &mut Self::PaintState,
-        cx: &mut EventContext,
-    ) -> bool {
-        self.child.dispatch_event(event, cx)
-    }
-
     fn rect_for_text_range(
         &self,
         range_utf16: Range<usize>,

crates/gpui/src/elements/image.rs

@@ -6,8 +6,7 @@ use crate::{
     },
     json::{json, ToJson},
     presenter::MeasurementContext,
-    scene, Border, DebugContext, Element, Event, EventContext, ImageData, LayoutContext,
+    scene, Border, DebugContext, Element, ImageData, LayoutContext, PaintContext, SizeConstraint,
-    PaintContext, SizeConstraint,
 };
 use serde::Deserialize;
 use std::{ops::Range, sync::Arc};
@@ -81,18 +80,6 @@ impl Element for Image {
         });
     }
 
-    fn dispatch_event(
-        &mut self,
-        _: &Event,
-        _: RectF,
-        _: RectF,
-        _: &mut Self::LayoutState,
-        _: &mut Self::PaintState,
-        _: &mut EventContext,
-    ) -> bool {
-        false
-    }
-
     fn rect_for_text_range(
         &self,
         _: Range<usize>,

crates/gpui/src/elements/keystroke_label.rs

@@ -2,7 +2,7 @@ use crate::{
     elements::*,
     fonts::TextStyle,
     geometry::{rect::RectF, vector::Vector2F},
-    Action, ElementBox, Event, EventContext, LayoutContext, PaintContext, SizeConstraint,
+    Action, ElementBox, LayoutContext, PaintContext, SizeConstraint,
 };
 use serde_json::json;
 
@@ -64,18 +64,6 @@ impl Element for KeystrokeLabel {
         element.paint(bounds.origin(), visible_bounds, cx);
     }
 
-    fn dispatch_event(
-        &mut self,
-        event: &Event,
-        _: RectF,
-        _: RectF,
-        element: &mut ElementBox,
-        _: &mut (),
-        cx: &mut EventContext,
-    ) -> bool {
-        element.dispatch_event(event, cx)
-    }
-
     fn rect_for_text_range(
         &self,
         _: Range<usize>,

crates/gpui/src/elements/label.rs

@@ -9,7 +9,7 @@ use crate::{
     json::{ToJson, Value},
     presenter::MeasurementContext,
     text_layout::{Line, RunStyle},
-    DebugContext, Element, Event, EventContext, LayoutContext, PaintContext, SizeConstraint,
+    DebugContext, Element, LayoutContext, PaintContext, SizeConstraint,
 };
 use serde::Deserialize;
 use serde_json::json;
@@ -165,18 +165,6 @@ impl Element for Label {
         line.paint(bounds.origin(), visible_bounds, bounds.size().y(), cx)
     }
 
-    fn dispatch_event(
-        &mut self,
-        _: &Event,
-        _: RectF,
-        _: RectF,
-        _: &mut Self::LayoutState,
-        _: &mut Self::PaintState,
-        _: &mut EventContext,
-    ) -> bool {
-        false
-    }
-
     fn rect_for_text_range(
         &self,
         _: Range<usize>,

crates/gpui/src/elements/list.rs

@@ -5,7 +5,7 @@ use crate::{
     },
     json::json,
     presenter::MeasurementContext,
-    DebugContext, Element, ElementBox, ElementRc, Event, EventContext, LayoutContext, MouseRegion,
+    DebugContext, Element, ElementBox, ElementRc, EventContext, LayoutContext, MouseRegion,
     PaintContext, RenderContext, SizeConstraint, View, ViewContext,
 };
 use std::{cell::RefCell, collections::VecDeque, ops::Range, rc::Rc};
@@ -13,7 +13,6 @@ use sum_tree::{Bias, SumTree};
 
 pub struct List {
     state: ListState,
-    invalidated_elements: Vec<ElementRc>,
 }
 
 #[derive(Clone)]
@@ -82,10 +81,7 @@ struct Height(f32);
 
 impl List {
     pub fn new(state: ListState) -> Self {
-        Self {
+        Self { state }
-            state,
-            invalidated_elements: Default::default(),
-        }
     }
 }
 
@@ -289,50 +285,6 @@ impl Element for List {
         cx.scene.pop_layer();
     }
 
-    fn dispatch_event(
-        &mut self,
-        event: &Event,
-        bounds: RectF,
-        _: RectF,
-        scroll_top: &mut ListOffset,
-        _: &mut (),
-        cx: &mut EventContext,
-    ) -> bool {
-        let mut handled = false;
-
-        let mut state = self.state.0.borrow_mut();
-        let mut item_origin = bounds.origin() - vec2f(0., scroll_top.offset_in_item);
-        let mut cursor = state.items.cursor::<Count>();
-        let mut new_items = cursor.slice(&Count(scroll_top.item_ix), Bias::Right, &());
-        while let Some(item) = cursor.item() {
-            if item_origin.y() > bounds.max_y() {
-                break;
-            }
-
-            if let ListItem::Rendered(element) = item {
-                let prev_notify_count = cx.notify_count();
-                let mut element = element.clone();
-                handled = element.dispatch_event(event, cx) || handled;
-                item_origin.set_y(item_origin.y() + element.size().y());
-                if cx.notify_count() > prev_notify_count {
-                    new_items.push(ListItem::Unrendered, &());
-                    self.invalidated_elements.push(element);
-                } else {
-                    new_items.push(item.clone(), &());
-                }
-                cursor.next(&());
-            } else {
-                unreachable!();
-            }
-        }
-
-        new_items.push_tree(cursor.suffix(&()), &());
-        drop(cursor);
-        state.items = new_items;
-
-        handled
-    }
-
     fn rect_for_text_range(
         &self,
         range_utf16: Range<usize>,
@@ -964,18 +916,6 @@ mod tests {
             todo!()
         }
 
-        fn dispatch_event(
-            &mut self,
-            _: &Event,
-            _: RectF,
-            _: RectF,
-            _: &mut (),
-            _: &mut (),
-            _: &mut EventContext,
-        ) -> bool {
-            todo!()
-        }
-
         fn rect_for_text_range(
             &self,
             _: Range<usize>,

crates/gpui/src/elements/mouse_event_handler.rs

@@ -9,7 +9,7 @@ use crate::{
         CursorRegion, HandlerSet, MouseClick, MouseDown, MouseDownOut, MouseDrag, MouseHover,
         MouseMove, MouseScrollWheel, MouseUp, MouseUpOut,
     },
-    DebugContext, Element, ElementBox, Event, EventContext, LayoutContext, MeasurementContext,
+    DebugContext, Element, ElementBox, EventContext, LayoutContext, MeasurementContext,
     MouseButton, MouseRegion, MouseState, PaintContext, RenderContext, SizeConstraint, View,
 };
 use serde_json::json;
@@ -194,18 +194,6 @@ impl<Tag> Element for MouseEventHandler<Tag> {
         self.child.paint(bounds.origin(), visible_bounds, cx);
     }
 
-    fn dispatch_event(
-        &mut self,
-        event: &Event,
-        _: RectF,
-        _: RectF,
-        _: &mut Self::LayoutState,
-        _: &mut Self::PaintState,
-        cx: &mut EventContext,
-    ) -> bool {
-        self.child.dispatch_event(event, cx)
-    }
-
     fn rect_for_text_range(
         &self,
         range_utf16: Range<usize>,

crates/gpui/src/elements/overlay.rs

@@ -4,8 +4,8 @@ use crate::{
     geometry::{rect::RectF, vector::Vector2F},
     json::ToJson,
     presenter::MeasurementContext,
-    Axis, DebugContext, Element, ElementBox, Event, EventContext, LayoutContext, MouseRegion,
+    Axis, DebugContext, Element, ElementBox, LayoutContext, MouseRegion, PaintContext,
-    PaintContext, SizeConstraint,
+    SizeConstraint,
 };
 use serde_json::json;
 
@@ -225,18 +225,6 @@ impl Element for Overlay {
         cx.scene.pop_stacking_context();
     }
 
-    fn dispatch_event(
-        &mut self,
-        event: &Event,
-        _: RectF,
-        _: RectF,
-        _: &mut Self::LayoutState,
-        _: &mut Self::PaintState,
-        cx: &mut EventContext,
-    ) -> bool {
-        self.child.dispatch_event(event, cx)
-    }
-
     fn rect_for_text_range(
         &self,
         range_utf16: Range<usize>,

crates/gpui/src/elements/resizable.rs

@@ -187,18 +187,6 @@ impl Element for Resizable {
         self.child.paint(bounds.origin(), visible_bounds, cx);
     }
 
-    fn dispatch_event(
-        &mut self,
-        event: &crate::Event,
-        _bounds: pathfinder_geometry::rect::RectF,
-        _visible_bounds: pathfinder_geometry::rect::RectF,
-        _layout: &mut Self::LayoutState,
-        _paint: &mut Self::PaintState,
-        cx: &mut crate::EventContext,
-    ) -> bool {
-        self.child.dispatch_event(event, cx)
-    }
-
     fn rect_for_text_range(
         &self,
         range_utf16: std::ops::Range<usize>,

crates/gpui/src/elements/stack.rs

@@ -4,8 +4,7 @@ use crate::{
     geometry::{rect::RectF, vector::Vector2F},
     json::{self, json, ToJson},
     presenter::MeasurementContext,
-    DebugContext, Element, ElementBox, Event, EventContext, LayoutContext, PaintContext,
+    DebugContext, Element, ElementBox, LayoutContext, PaintContext, SizeConstraint,
-    SizeConstraint,
 };
 
 #[derive(Default)]
@@ -49,23 +48,6 @@ impl Element for Stack {
         }
     }
 
-    fn dispatch_event(
-        &mut self,
-        event: &Event,
-        _: RectF,
-        _: RectF,
-        _: &mut Self::LayoutState,
-        _: &mut Self::PaintState,
-        cx: &mut EventContext,
-    ) -> bool {
-        for child in self.children.iter_mut().rev() {
-            if child.dispatch_event(event, cx) {
-                return true;
-            }
-        }
-        false
-    }
-
     fn rect_for_text_range(
         &self,
         range_utf16: Range<usize>,

crates/gpui/src/elements/svg.rs

@@ -9,7 +9,7 @@ use crate::{
         vector::{vec2f, Vector2F},
     },
     presenter::MeasurementContext,
-    scene, DebugContext, Element, Event, EventContext, LayoutContext, PaintContext, SizeConstraint,
+    scene, DebugContext, Element, LayoutContext, PaintContext, SizeConstraint,
 };
 
 pub struct Svg {
@@ -73,18 +73,6 @@ impl Element for Svg {
         }
     }
 
-    fn dispatch_event(
-        &mut self,
-        _: &Event,
-        _: RectF,
-        _: RectF,
-        _: &mut Self::LayoutState,
-        _: &mut Self::PaintState,
-        _: &mut EventContext,
-    ) -> bool {
-        false
-    }
-
     fn rect_for_text_range(
         &self,
         _: Range<usize>,

crates/gpui/src/elements/text.rs

@@ -8,8 +8,7 @@ use crate::{
     json::{ToJson, Value},
     presenter::MeasurementContext,
     text_layout::{Line, RunStyle, ShapedBoundary},
-    DebugContext, Element, Event, EventContext, FontCache, LayoutContext, PaintContext,
+    DebugContext, Element, FontCache, LayoutContext, PaintContext, SizeConstraint, TextLayoutCache,
-    SizeConstraint, TextLayoutCache,
 };
 use log::warn;
 use serde_json::json;
@@ -178,18 +177,6 @@ impl Element for Text {
         }
     }
 
-    fn dispatch_event(
-        &mut self,
-        _: &Event,
-        _: RectF,
-        _: RectF,
-        _: &mut Self::LayoutState,
-        _: &mut Self::PaintState,
-        _: &mut EventContext,
-    ) -> bool {
-        false
-    }
-
     fn rect_for_text_range(
         &self,
         _: Range<usize>,

crates/gpui/src/elements/tooltip.rs

@@ -186,18 +186,6 @@ impl Element for Tooltip {
         }
     }
 
-    fn dispatch_event(
-        &mut self,
-        event: &crate::Event,
-        _: RectF,
-        _: RectF,
-        _: &mut Self::LayoutState,
-        _: &mut Self::PaintState,
-        cx: &mut crate::EventContext,
-    ) -> bool {
-        self.child.dispatch_event(event, cx)
-    }
-
     fn rect_for_text_range(
         &self,
         range: Range<usize>,

crates/gpui/src/elements/uniform_list.rs

@@ -1,4 +1,4 @@
-use super::{Element, Event, EventContext, LayoutContext, PaintContext, SizeConstraint};
+use super::{Element, EventContext, LayoutContext, PaintContext, SizeConstraint};
 use crate::{
     geometry::{
         rect::RectF,
@@ -324,23 +324,6 @@ impl Element for UniformList {
         cx.scene.pop_layer();
     }
 
-    fn dispatch_event(
-        &mut self,
-        event: &Event,
-        _: RectF,
-        _: RectF,
-        layout: &mut Self::LayoutState,
-        _: &mut Self::PaintState,
-        cx: &mut EventContext,
-    ) -> bool {
-        let mut handled = false;
-        for item in &mut layout.items {
-            handled = item.dispatch_event(event, cx) || handled;
-        }
-
-        handled
-    }
-
     fn rect_for_text_range(
         &self,
         range: Range<usize>,

crates/gpui/src/presenter.rs

@@ -228,7 +228,6 @@ impl Presenter {
         event_reused: bool,
         cx: &mut MutableAppContext,
     ) -> bool {
-        if let Some(root_view_id) = cx.root_view_id(self.window_id) {
         let mut mouse_events = SmallVec::<[_; 2]>::new();
         let mut notified_views: HashSet<usize> = Default::default();
 
@@ -239,9 +238,7 @@ impl Presenter {
         match &event {
             Event::KeyDown(e) => return cx.dispatch_key_down(self.window_id, e),
             Event::KeyUp(e) => return cx.dispatch_key_up(self.window_id, e),
-                Event::ModifiersChanged(e) => {
+            Event::ModifiersChanged(e) => return cx.dispatch_modifiers_changed(self.window_id, e),
-                    return cx.dispatch_modifiers_changed(self.window_id, e)
-                }
             Event::MouseDown(e) => {
                 // Click events are weird because they can be fired after a drag event.
                 // MDN says that browsers handle this by starting from 'the most
@@ -345,12 +342,10 @@ impl Presenter {
 
                 self.last_mouse_moved_event = Some(event.clone());
             }
-                Event::ScrollWheel(e) => {
+            Event::ScrollWheel(e) => mouse_events.push(MouseEvent::ScrollWheel(MouseScrollWheel {
-                    mouse_events.push(MouseEvent::ScrollWheel(MouseScrollWheel {
                 region: Default::default(),
                 platform_event: e.clone(),
-                    }))
+            })),
-                }
         }
 
         if let Some(position) = event.position() {
@@ -505,19 +500,11 @@ impl Presenter {
             }
         }
 
-            if !any_event_handled && !event_reused {
-                let mut event_cx = self.build_event_context(&mut notified_views, cx);
-                any_event_handled = event_cx.dispatch_event(root_view_id, &event);
-            }
-
         for view_id in notified_views {
             cx.notify_view(self.window_id, view_id);
         }
 
         any_event_handled
-        } else {
-            false
-        }
     }
 
     pub fn build_event_context<'a>(
@@ -526,7 +513,6 @@ impl Presenter {
         cx: &'a mut MutableAppContext,
     ) -> EventContext<'a> {
         EventContext {
-            rendered_views: &mut self.rendered_views,
             font_cache: &self.font_cache,
             text_layout_cache: &self.text_layout_cache,
             view_stack: Default::default(),
@@ -745,7 +731,6 @@ impl<'a> Deref for PaintContext<'a> {
 }
 
 pub struct EventContext<'a> {
-    rendered_views: &'a mut HashMap<usize, ElementBox>,
     pub font_cache: &'a FontCache,
     pub text_layout_cache: &'a TextLayoutCache,
     pub app: &'a mut MutableAppContext,
@@ -757,17 +742,6 @@ pub struct EventContext<'a> {
 }
 
 impl<'a> EventContext<'a> {
-    fn dispatch_event(&mut self, view_id: usize, event: &Event) -> bool {
-        if let Some(mut element) = self.rendered_views.remove(&view_id) {
-            let result =
-                self.with_current_view(view_id, |this| element.dispatch_event(event, this));
-            self.rendered_views.insert(view_id, element);
-            result
-        } else {
-            false
-        }
-    }
-
     fn with_current_view<F, T>(&mut self, view_id: usize, f: F) -> T
     where
         F: FnOnce(&mut Self) -> T,
@@ -1030,27 +1004,6 @@ impl Element for ChildView {
         }
     }
 
-    fn dispatch_event(
-        &mut self,
-        event: &Event,
-        _: RectF,
-        _: RectF,
-        view_is_valid: &mut Self::LayoutState,
-        _: &mut Self::PaintState,
-        cx: &mut EventContext,
-    ) -> bool {
-        if *view_is_valid {
-            cx.dispatch_event(self.view.id(), event)
-        } else {
-            log::error!(
-                "dispatch_event called on a ChildView element whose underlying view was dropped (view_id: {}, name: {:?})",
-                self.view.id(),
-                self.view_name
-            );
-            false
-        }
-    }
-
     fn rect_for_text_range(
         &self,
         range_utf16: Range<usize>,

crates/terminal/src/terminal_element.rs

@@ -798,18 +798,6 @@ impl Element for TerminalElement {
         });
     }
 
-    fn dispatch_event(
-        &mut self,
-        _: &gpui::Event,
-        _bounds: gpui::geometry::rect::RectF,
-        _visible_bounds: gpui::geometry::rect::RectF,
-        _layout: &mut Self::LayoutState,
-        _paint: &mut Self::PaintState,
-        _: &mut gpui::EventContext,
-    ) -> bool {
-        false
-    }
-
     fn metadata(&self) -> Option<&dyn std::any::Any> {
         None
     }