Yehowshua/ZIm
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

Remove dispatch_event from Element trait

Browse source
This commit is contained in:
Nathan Sobo 2022-10-16 13:08:25 -06:00
parent d25c6b15a6
commit 12eab6551f
26 changed files with 288 additions and 736 deletions
Download patch file Download diff file Expand all files Collapse all files

12
crates/collab_ui/src/collab_titlebar_item.rs
View file

@ -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>,

18
crates/editor/src/element.rs
View file

@ -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,
LayoutContext, MouseButton, MouseButtonEvent, MouseMovedEvent, MouseRegion, MutableAppContext,
PaintContext, Quad, Scene, SizeConstraint, ViewContext, WeakViewHandle,
AppContext, Axis, Border, CursorRegion, Element, ElementBox, EventContext, LayoutContext,
MouseButton, MouseButtonEvent, MouseMovedEvent, MouseRegion, MutableAppContext, PaintContext,
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>,

12
crates/gpui/examples/text.rs
View file

@ -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>,

35
crates/gpui/src/elements.rs
View file

@ -33,8 +33,8 @@ use crate::{
},
json,
presenter::MeasurementContext,
Action, DebugContext, Event, EventContext, LayoutContext, PaintContext, RenderContext,
SizeConstraint, View,
Action, DebugContext, EventContext, LayoutContext, PaintContext, RenderContext, SizeConstraint,
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>,

15
crates/gpui/src/elements/align.rs
View file

@ -2,8 +2,7 @@ use crate::{
geometry::{rect::RectF, vector::Vector2F},
json,
presenter::MeasurementContext,
DebugContext, Element, ElementBox, Event, EventContext, LayoutContext, PaintContext,
SizeConstraint,
DebugContext, Element, ElementBox, LayoutContext, PaintContext, 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>,

12
crates/gpui/src/elements/canvas.rs
View file

@ -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>,

15
crates/gpui/src/elements/constrained_box.rs
View file

@ -7,8 +7,7 @@ use crate::{
geometry::{rect::RectF, vector::Vector2F},
json,
presenter::MeasurementContext,
DebugContext, Element, ElementBox, Event, EventContext, LayoutContext, PaintContext,
SizeConstraint,
DebugContext, Element, ElementBox, LayoutContext, PaintContext, 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>,

14
crates/gpui/src/elements/container.rs
View file

@ -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>,

14
crates/gpui/src/elements/empty.rs
View file

@ -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>,

15
crates/gpui/src/elements/expanded.rs
View file

@ -4,8 +4,7 @@ use crate::{
geometry::{rect::RectF, vector::Vector2F},
json,
presenter::MeasurementContext,
DebugContext, Element, ElementBox, Event, EventContext, LayoutContext, PaintContext,
SizeConstraint,
DebugContext, Element, ElementBox, LayoutContext, PaintContext, 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>,

33
crates/gpui/src/elements/flex.rs
View file

@ -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,
LayoutContext, PaintContext, RenderContext, SizeConstraint, Vector2FExt, View,
Axis, DebugContext, Element, ElementBox, ElementStateHandle, LayoutContext, PaintContext,
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>,

15
crates/gpui/src/elements/hook.rs
View file

@ -4,8 +4,7 @@ use crate::{
geometry::{rect::RectF, vector::Vector2F},
json::json,
presenter::MeasurementContext,
DebugContext, Element, ElementBox, Event, EventContext, LayoutContext, PaintContext,
SizeConstraint,
DebugContext, Element, ElementBox, LayoutContext, PaintContext, 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>,

15
crates/gpui/src/elements/image.rs
View file

@ -6,8 +6,7 @@ use crate::{
},
json::{json, ToJson},
presenter::MeasurementContext,
scene, Border, DebugContext, Element, Event, EventContext, ImageData, LayoutContext,
PaintContext, SizeConstraint,
scene, Border, DebugContext, Element, ImageData, LayoutContext, 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>,

14
crates/gpui/src/elements/keystroke_label.rs
View file

@ -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>,

14
crates/gpui/src/elements/label.rs
View file

@ -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>,

64
crates/gpui/src/elements/list.rs
View file

@ -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 {
state,
invalidated_elements: Default::default(),
}
Self { state }
}
}
@ -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>,

14
crates/gpui/src/elements/mouse_event_handler.rs
View file

@ -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>,

16
crates/gpui/src/elements/overlay.rs
View file

@ -4,8 +4,8 @@ use crate::{
geometry::{rect::RectF, vector::Vector2F},
json::ToJson,
presenter::MeasurementContext,
Axis, DebugContext, Element, ElementBox, Event, EventContext, LayoutContext, MouseRegion,
PaintContext, SizeConstraint,
Axis, DebugContext, Element, ElementBox, LayoutContext, MouseRegion, PaintContext,
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>,

12
crates/gpui/src/elements/resizable.rs
View file

@ -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>,

20
crates/gpui/src/elements/stack.rs
View file

@ -4,8 +4,7 @@ use crate::{
geometry::{rect::RectF, vector::Vector2F},
json::{self, json, ToJson},
presenter::MeasurementContext,
DebugContext, Element, ElementBox, Event, EventContext, LayoutContext, PaintContext,
SizeConstraint,
DebugContext, Element, ElementBox, LayoutContext, PaintContext, 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>,

14
crates/gpui/src/elements/svg.rs
View file

@ -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>,

15
crates/gpui/src/elements/text.rs
View file

@ -8,8 +8,7 @@ use crate::{
json::{ToJson, Value},
presenter::MeasurementContext,
text_layout::{Line, RunStyle, ShapedBoundary},
DebugContext, Element, Event, EventContext, FontCache, LayoutContext, PaintContext,
SizeConstraint, TextLayoutCache,
DebugContext, Element, FontCache, LayoutContext, PaintContext, 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>,

12
crates/gpui/src/elements/tooltip.rs
View file

@ -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>,

19
crates/gpui/src/elements/uniform_list.rs
View file

@ -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>,

53
crates/gpui/src/presenter.rs
View file

@ -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) => {
return cx.dispatch_modifiers_changed(self.window_id, e)
}
Event::ModifiersChanged(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) => {
mouse_events.push(MouseEvent::ScrollWheel(MouseScrollWheel {
Event::ScrollWheel(e) => 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>,

12
crates/terminal/src/terminal_element.rs
View file

@ -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
}