Use destructuring and descriptive names.

Author: xorgy

Cargo.lock

@@ -55,8 +55,8 @@ parley = { git = "https://github.com/linebender/parley", rev = "587b7634ae8601c1
 peniko = "0.4.0"
 winit = "0.30.10"
 tracing = { version = "0.1.41", default-features = false }
-ui-events = { git = "https://github.com/endoli/ui-events", rev = "6382e63" }
-ui-events-winit = { git = "https://github.com/endoli/ui-events", rev = "6382e63" }
+ui-events = { git = "https://github.com/endoli/ui-events", rev = "08c942c" }
+ui-events-winit = { git = "https://github.com/endoli/ui-events", rev = "08c942c" }
 smallvec = "1.15.0"
 hashbrown = "0.15.3"
 dpi = "0.1.2"

Cargo.toml

@@ -17,8 +17,8 @@ use vello::peniko::Color;
 use crate::core::keyboard::{Key, NamedKey};
 use crate::core::{
     AccessCtx, AccessEvent, BoxConstraints, ChildrenIds, EventCtx, LayoutCtx, NewWidget, PaintCtx,
-    PointerEvent, PropertiesMut, PropertiesRef, RegisterCtx, TextEvent, Update, UpdateCtx, Widget,
-    WidgetId, WidgetMut, WidgetPod,
+    PointerButtonEvent, PointerEvent, PropertiesMut, PropertiesRef, RegisterCtx, TextEvent, Update,
+    UpdateCtx, Widget, WidgetId, WidgetMut, WidgetPod,
 };
 use crate::properties::{
     ActiveBackground, Background, BorderColor, BorderWidth, BoxShadow, CornerRadius,
@@ -118,9 +118,9 @@ impl Widget for Button {
                 ctx.request_paint_only();
                 trace!("Button {:?} pressed", ctx.widget_id());
             }
-            PointerEvent::Up(b) => {
+            PointerEvent::Up(PointerButtonEvent { button, .. }) => {
                 if ctx.is_active() && ctx.is_hovered() {
-                    ctx.submit_action::<Self::Action>(ButtonPress { button: b.button });
+                    ctx.submit_action::<Self::Action>(ButtonPress { button: *button });
                     trace!("Button {:?} released", ctx.widget_id());
                 }
                 // Changes in pointer capture impact appearance, but not accessibility node

masonry/src/widgets/button.rs

@@ -11,8 +11,9 @@ use vello::kurbo::{Point, Rect, Size, Vec2};
 
 use crate::core::{
     AccessCtx, AccessEvent, Axis, BoxConstraints, ChildrenIds, ComposeCtx, EventCtx, FromDynWidget,
-    LayoutCtx, NewWidget, NoAction, PaintCtx, PointerEvent, PropertiesMut, PropertiesRef,
-    RegisterCtx, ScrollDelta, TextEvent, Update, UpdateCtx, Widget, WidgetId, WidgetMut, WidgetPod,
+    LayoutCtx, NewWidget, NoAction, PaintCtx, PointerEvent, PointerScrollEvent, PropertiesMut,
+    PropertiesRef, RegisterCtx, ScrollDelta, TextEvent, Update, UpdateCtx, Widget, WidgetId,
+    WidgetMut, WidgetPod,
 };
 use crate::widgets::ScrollBar;
 
@@ -270,10 +271,10 @@ impl<W: Widget + FromDynWidget + ?Sized> Widget for Portal<W> {
         let content_size = self.content_size;
 
         match *event {
-            PointerEvent::Scroll(ref s) => {
+            PointerEvent::Scroll(PointerScrollEvent { delta, .. }) => {
                 // TODO - Remove reference to scale factor.
                 // See https://github.com/linebender/xilem/issues/1264
-                let delta = match s.delta {
+                let delta = match delta {
                     ScrollDelta::PixelDelta(PhysicalPosition::<f64> { x, y }) => -Vec2 { x, y },
                     ScrollDelta::LineDelta(x, y) => {
                         -Vec2 {

masonry/src/widgets/portal.rs

@@ -8,8 +8,8 @@ use vello::kurbo::{Point, Rect, Size};
 
 use crate::core::{
     AccessCtx, AccessEvent, AllowRawMut, Axis, BoxConstraints, ChildrenIds, EventCtx, LayoutCtx,
-    NoAction, PaintCtx, PointerEvent, PropertiesMut, PropertiesRef, RegisterCtx, TextEvent, Update,
-    UpdateCtx, Widget, WidgetId, WidgetMut,
+    NoAction, PaintCtx, PointerButtonEvent, PointerEvent, PointerUpdate, PropertiesMut,
+    PropertiesRef, RegisterCtx, TextEvent, Update, UpdateCtx, Widget, WidgetId, WidgetMut,
 };
 use crate::theme;
 use crate::util::{fill_color, include_screenshot, stroke};
@@ -129,12 +129,12 @@ impl Widget for ScrollBar {
         event: &PointerEvent,
     ) {
         match event {
-            PointerEvent::Down(b) => {
+            PointerEvent::Down(PointerButtonEvent { state, .. }) => {
                 ctx.capture_pointer();
 
                 let cursor_min_length = theme::SCROLLBAR_MIN_SIZE;
                 let cursor_rect = self.get_cursor_rect(ctx.size(), cursor_min_length);
-                let mouse_pos = ctx.local_position(b.state.position);
+                let mouse_pos = ctx.local_position(state.position);
                 if cursor_rect.contains(mouse_pos) {
                     let (z0, z1) = self.axis.major_span(cursor_rect);
                     let mouse_major = self.axis.major_pos(mouse_pos);
@@ -147,14 +147,14 @@ impl Widget for ScrollBar {
                 };
                 ctx.request_render();
             }
-            PointerEvent::Move(u) => {
+            PointerEvent::Move(PointerUpdate { current, .. }) => {
                 if let Some(grab_anchor) = self.grab_anchor {
                     let cursor_min_length = theme::SCROLLBAR_MIN_SIZE;
                     self.cursor_progress = self.progress_from_mouse_pos(
                         ctx.size(),
                         cursor_min_length,
                         grab_anchor,
-                        ctx.local_position(u.current.position),
+                        ctx.local_position(current.position),
                     );
                     self.moved = true;
                 }

masonry/src/widgets/scroll_bar.rs

@@ -10,8 +10,9 @@ use vello::kurbo::{Line, Point, Rect, Size};
 
 use crate::core::{
     AccessCtx, AccessEvent, Axis, BoxConstraints, ChildrenIds, CursorIcon, EventCtx, FromDynWidget,
-    LayoutCtx, NewWidget, NoAction, PaintCtx, PointerEvent, PropertiesMut, PropertiesRef, QueryCtx,
-    RegisterCtx, TextEvent, Widget, WidgetId, WidgetMut, WidgetPod,
+    LayoutCtx, NewWidget, NoAction, PaintCtx, PointerButtonEvent, PointerEvent, PointerUpdate,
+    PropertiesMut, PropertiesRef, QueryCtx, RegisterCtx, TextEvent, Widget, WidgetId, WidgetMut,
+    WidgetPod,
 };
 use crate::peniko::Color;
 use crate::properties::types::{AsUnit, Length};
@@ -395,8 +396,8 @@ where
     ) {
         if self.draggable {
             match event {
-                PointerEvent::Down(b) => {
-                    let pos = ctx.local_position(b.state.position);
+                PointerEvent::Down(PointerButtonEvent { state, .. }) => {
+                    let pos = ctx.local_position(state.position);
                     if self.bar_hit_test(ctx.size(), pos) {
                         ctx.set_handled();
                         ctx.capture_pointer();
@@ -407,9 +408,9 @@ where
                         } - self.bar_position(ctx.size());
                     }
                 }
-                PointerEvent::Move(u) => {
+                PointerEvent::Move(PointerUpdate { current, .. }) => {
                     if ctx.is_active() {
-                        let pos = ctx.local_position(u.current.position);
+                        let pos = ctx.local_position(current.position);
                         // If widget has pointer capture, assume always it's hovered
                         let effective_pos = match self.split_axis {
                             Axis::Horizontal => Point {

masonry/src/widgets/split.rs

@@ -15,9 +15,9 @@ use vello::peniko::Fill;
 use crate::core::keyboard::{Key, KeyState, NamedKey};
 use crate::core::{
     AccessCtx, AccessEvent, BoxConstraints, BrushIndex, ChildrenIds, CursorIcon, EventCtx, Ime,
-    LayoutCtx, PaintCtx, PointerButton, PointerEvent, PropertiesMut, PropertiesRef, QueryCtx,
-    RegisterCtx, StyleProperty, TextEvent, Update, UpdateCtx, Widget, WidgetId, WidgetMut,
-    render_text,
+    LayoutCtx, PaintCtx, PointerButton, PointerButtonEvent, PointerEvent, PointerUpdate,
+    PropertiesMut, PropertiesRef, QueryCtx, RegisterCtx, StyleProperty, TextEvent, Update,
+    UpdateCtx, Widget, WidgetId, WidgetMut, render_text,
 };
 use crate::properties::{ContentColor, DisabledContentColor};
 use crate::theme::default_text_styles;
@@ -424,34 +424,36 @@ impl<const EDITABLE: bool> Widget for TextArea<EDITABLE> {
         _props: &mut PropertiesMut<'_>,
         event: &PointerEvent,
     ) {
-        if self.editor.is_composing() {
+        if ctx.is_disabled() || self.editor.is_composing() {
             return;
         }
 
         match event {
-            PointerEvent::Down(b) => {
-                if matches!(b.button, None | Some(PointerButton::Primary)) {
-                    let cursor_pos = ctx.local_position(b.state.position);
-                    let (fctx, lctx) = ctx.text_contexts();
-                    let mut drv = self.editor.driver(fctx, lctx);
-                    match b.state.count {
-                        2 => drv.select_word_at_point(cursor_pos.x as f32, cursor_pos.y as f32),
-                        3 => drv.select_line_at_point(cursor_pos.x as f32, cursor_pos.y as f32),
-                        _ => drv.move_to_point(cursor_pos.x as f32, cursor_pos.y as f32),
-                    }
-                    let new_generation = self.editor.generation();
-                    if new_generation != self.rendered_generation {
-                        ctx.request_render();
-                        ctx.set_ime_area(self.ime_area());
-                        self.rendered_generation = new_generation;
-                    }
-                    ctx.request_focus();
-                    ctx.capture_pointer();
+            PointerEvent::Down(PointerButtonEvent {
+                button: None | Some(PointerButton::Primary),
+                state,
+                ..
+            }) => {
+                let cursor_pos = ctx.local_position(state.position);
+                let (fctx, lctx) = ctx.text_contexts();
+                let mut drv = self.editor.driver(fctx, lctx);
+                match state.count {
+                    2 => drv.select_word_at_point(cursor_pos.x as f32, cursor_pos.y as f32),
+                    3 => drv.select_line_at_point(cursor_pos.x as f32, cursor_pos.y as f32),
+                    _ => drv.move_to_point(cursor_pos.x as f32, cursor_pos.y as f32),
+                }
+                let new_generation = self.editor.generation();
+                if new_generation != self.rendered_generation {
+                    ctx.request_render();
+                    ctx.set_ime_area(self.ime_area());
+                    self.rendered_generation = new_generation;
                 }
+                ctx.request_focus();
+                ctx.capture_pointer();
             }
-            PointerEvent::Move(u) => {
+            PointerEvent::Move(PointerUpdate { current, .. }) => {
                 if ctx.is_active() {
-                    let cursor_pos = ctx.local_position(u.current.position);
+                    let cursor_pos = ctx.local_position(current.position);
                     let (fctx, lctx) = ctx.text_contexts();
                     self.editor
                         .driver(fctx, lctx)

masonry/src/widgets/text_area.rs

@@ -10,9 +10,9 @@ use vello::kurbo::{Point, Size, Vec2};
 
 use crate::core::keyboard::{Key, KeyState, NamedKey};
 use crate::core::{
-    AccessCtx, AccessEvent, BoxConstraints, ChildrenIds, ComposeCtx, EventCtx, LayoutCtx,
-    NewWidget, PaintCtx, PointerEvent, PropertiesMut, PropertiesRef, RegisterCtx, ScrollDelta,
-    TextEvent, Update, UpdateCtx, Widget, WidgetMut, WidgetPod,
+    AccessCtx, AccessEvent, BoxConstraints, ChildrenIds, ComposeCtx, EventCtx, KeyboardEvent,
+    LayoutCtx, NewWidget, PaintCtx, PointerEvent, PointerScrollEvent, PropertiesMut, PropertiesRef,
+    RegisterCtx, ScrollDelta, TextEvent, Update, UpdateCtx, Widget, WidgetMut, WidgetPod,
 };
 use crate::util::debug_panic;
 
@@ -524,10 +524,10 @@ impl Widget for VirtualScroll {
         event: &PointerEvent,
     ) {
         match event {
-            PointerEvent::Scroll(s) => {
+            PointerEvent::Scroll(PointerScrollEvent { delta, .. }) => {
                 // TODO - Remove reference to scale factor.
                 // See https://github.com/linebender/xilem/issues/1264
-                let delta = match s.delta {
+                let delta = match delta {
                     ScrollDelta::PixelDelta(p) => -p.to_logical::<f64>(ctx.get_scale_factor()).y,
                     ScrollDelta::LineDelta(_, y) => -y as f64 * ctx.get_scale_factor() * 120.,
                     _ => 0.0,
@@ -545,23 +545,33 @@ impl Widget for VirtualScroll {
         _props: &mut PropertiesMut<'_>,
         event: &TextEvent,
     ) {
-        match event {
-            TextEvent::Keyboard(key_event) => {
-                // To get to this state, you currently need to press "tab" to focus this widget in the example.
-                if matches!(key_event.state, KeyState::Down) {
-                    // We use an unreasonably large delta (logical pixels) here to allow testing that the case where the
-                    // scrolling "jumps" the area is handled correctly.
-                    // In future, this manual testing would be achieved through use of a scrollbar.
-                    let delta = 20000.;
-                    if matches!(key_event.key, Key::Named(NamedKey::PageDown)) {
-                        self.scroll_offset_from_anchor += delta;
-                        self.event_post_scroll(ctx);
-                    }
-                    if matches!(key_event.key, Key::Named(NamedKey::PageUp)) {
-                        self.scroll_offset_from_anchor -= delta;
-                        self.event_post_scroll(ctx);
-                    }
-                }
+        // We use an unreasonably large delta (logical pixels) here to allow testing that the case
+        // where the scrolling "jumps" the area is handled correctly.
+        // In future, this manual testing would be achieved through use of a scrollbar.
+        const DELTA: f64 = 20000.;
+
+        // To get to this state, you currently need to press "tab" to focus this widget in the
+        // example.
+        let TextEvent::Keyboard(keyboard_event) = event else {
+            return;
+        };
+
+        match keyboard_event {
+            KeyboardEvent {
+                state: KeyState::Down,
+                key: Key::Named(NamedKey::PageDown),
+                ..
+            } => {
+                self.scroll_offset_from_anchor += DELTA;
+                self.event_post_scroll(ctx);
+            }
+            KeyboardEvent {
+                state: KeyState::Down,
+                key: Key::Named(NamedKey::PageUp),
+                ..
+            } => {
+                self.scroll_offset_from_anchor -= DELTA;
+                self.event_post_scroll(ctx);
             }
             _ => {}
         }

masonry/src/widgets/virtual_scroll.rs

@@ -42,8 +42,8 @@ pub use widget_tag::WidgetTag;
 
 pub use ui_events::keyboard::{KeyboardEvent, Modifiers};
 pub use ui_events::pointer::{
-    PointerButton, PointerButtonEvent, PointerEvent, PointerId, PointerInfo, PointerScrollEvent,
-    PointerState, PointerType, PointerUpdate,
+    PointerButton, PointerButtonEvent, PointerEvent, PointerGesture, PointerGestureEvent,
+    PointerId, PointerInfo, PointerScrollEvent, PointerState, PointerType, PointerUpdate,
 };
 pub use ui_events::{ScrollDelta, keyboard, pointer};
 

masonry_core/src/core/mod.rs

@@ -6,8 +6,9 @@ use tracing::{debug, info_span, trace};
 use crate::app::{RenderRoot, RenderRootSignal};
 use crate::core::keyboard::{Key, KeyState, NamedKey};
 use crate::core::{
-    AccessEvent, EventCtx, Handled, Ime, PointerButtonEvent, PointerEvent, PointerInfo,
-    PointerScrollEvent, PointerType, PointerUpdate, PropertiesMut, TextEvent, Widget, WidgetId,
+    AccessEvent, EventCtx, Handled, Ime, PointerButtonEvent, PointerEvent, PointerGestureEvent,
+    PointerInfo, PointerScrollEvent, PointerType, PointerUpdate, PropertiesMut, TextEvent, Widget,
+    WidgetId,
 };
 use crate::debug_panic;
 use crate::dpi::{LogicalPosition, PhysicalPosition};
@@ -53,6 +54,7 @@ fn pointer_event_short_name(e: &PointerEvent) -> &'static str {
         PointerEvent::Leave(..) => "Leave",
         PointerEvent::Cancel(..) => "Cancel",
         PointerEvent::Scroll(..) => "Scroll",
+        PointerEvent::Gesture(..) => "Gesture",
     }
 }
 
@@ -62,7 +64,8 @@ fn try_event_position(event: &PointerEvent) -> Option<PhysicalPosition<f64>> {
         PointerEvent::Down(PointerButtonEvent { state, .. })
         | PointerEvent::Up(PointerButtonEvent { state, .. })
         | PointerEvent::Move(PointerUpdate { current: state, .. })
-        | PointerEvent::Scroll(PointerScrollEvent { state, .. }) => Some(state.position),
+        | PointerEvent::Scroll(PointerScrollEvent { state, .. })
+        | PointerEvent::Gesture(PointerGestureEvent { state, .. }) => Some(state.position),
         _ => None,
     }
 }