diff --git a/src/changelog/unreleased.md b/src/changelog/unreleased.md index 9eefbbd3d6..23654f4b97 100644 --- a/src/changelog/unreleased.md +++ b/src/changelog/unreleased.md @@ -163,6 +163,7 @@ changelog entry. - On X11, use bottom-right corner for IME hotspot in `Window::set_ime_cursor_area`. - On macOS and iOS, no longer emit `ScaleFactorChanged` upon window creation. - On macOS, no longer emit `Focused` upon window creation. +- On iOS, emit more events immediately, instead of queuing them. ### Removed diff --git a/src/platform_impl/apple/event_handler.rs b/src/platform_impl/apple/event_handler.rs index 37765d760c..a68d4bb8e6 100644 --- a/src/platform_impl/apple/event_handler.rs +++ b/src/platform_impl/apple/event_handler.rs @@ -106,7 +106,6 @@ impl EventHandler { self.inner.try_borrow().is_err() } - #[cfg(target_os = "macos")] pub(crate) fn ready(&self) -> bool { matches!(self.inner.try_borrow().as_deref(), Ok(Some(_))) } diff --git a/src/platform_impl/apple/uikit/app_state.rs b/src/platform_impl/apple/uikit/app_state.rs index c90629e235..420504bf85 100644 --- a/src/platform_impl/apple/uikit/app_state.rs +++ b/src/platform_impl/apple/uikit/app_state.rs @@ -27,8 +27,9 @@ use super::window::WinitUIWindow; use super::{ActiveEventLoop, EventLoopProxy}; use crate::application::ApplicationHandler; use crate::dpi::PhysicalSize; -use crate::event::{Event, StartCause, SurfaceSizeWriter, WindowEvent}; +use crate::event::{StartCause, SurfaceSizeWriter, WindowEvent}; use crate::event_loop::ControlFlow; +use crate::window::WindowId; macro_rules! bug { ($($msg:tt)*) => { @@ -67,25 +68,9 @@ fn get_handler(mtm: MainThreadMarker) -> &'static EventHandler { GLOBAL.get(mtm).get_or_init(EventHandler::new) } -fn handle_event(mtm: MainThreadMarker, event: Event) { - let event_loop = &ActiveEventLoop { mtm }; - get_handler(mtm).handle(|app| match event { - Event::NewEvents(cause) => app.new_events(event_loop, cause), - Event::WindowEvent { window_id, event } => app.window_event(event_loop, window_id, event), - Event::DeviceEvent { device_id, event } => app.device_event(event_loop, device_id, event), - Event::UserWakeUp => app.proxy_wake_up(event_loop), - Event::Suspended => app.suspended(event_loop), - Event::Resumed => app.resumed(event_loop), - Event::CreateSurfaces => app.can_create_surfaces(event_loop), - Event::AboutToWait => app.about_to_wait(event_loop), - Event::LoopExiting => app.exiting(event_loop), - Event::MemoryWarning => app.memory_warning(event_loop), - }) -} - #[derive(Debug)] pub(crate) enum EventWrapper { - StaticEvent(Event), + Window { window_id: WindowId, event: WindowEvent }, ScaleFactorChanged(ScaleFactorChanged), } @@ -96,14 +81,9 @@ pub struct ScaleFactorChanged { pub(super) scale_factor: f64, } -enum UserCallbackTransitionResult<'a> { - Success { active_control_flow: ControlFlow, processing_redraws: bool }, - ReentrancyPrevented { queued_events: &'a mut Vec }, -} - -impl Event { +impl EventWrapper { fn is_redraw(&self) -> bool { - matches!(self, Event::WindowEvent { event: WindowEvent::RedrawRequested, .. }) + matches!(self, Self::Window { event: WindowEvent::RedrawRequested, .. }) } } @@ -112,18 +92,12 @@ impl Event { #[must_use = "dropping `AppStateImpl` without inspecting it is probably a bug"] enum AppStateImpl { Initial { - queued_events: Vec, queued_gpu_redraws: HashSet>, }, ProcessingEvents { queued_gpu_redraws: HashSet>, active_control_flow: ControlFlow, }, - // special state to deal with reentrancy and prevent mutable aliasing. - InUserCallback { - queued_events: Vec, - queued_gpu_redraws: HashSet>, - }, ProcessingRedraws { active_control_flow: ControlFlow, }, @@ -140,6 +114,7 @@ pub(crate) struct AppState { control_flow: ControlFlow, waker: EventLoopWaker, event_loop_proxy: Arc, + queued_events: Vec, } impl AppState { @@ -158,13 +133,11 @@ impl AppState { fn init_guard(guard: &mut RefMut<'static, Option>) { let waker = EventLoopWaker::new(unsafe { CFRunLoopGetMain() }); **guard = Some(AppState { - app_state: Some(AppStateImpl::Initial { - queued_events: Vec::new(), - queued_gpu_redraws: HashSet::new(), - }), + app_state: Some(AppStateImpl::Initial { queued_gpu_redraws: HashSet::new() }), control_flow: ControlFlow::default(), waker, event_loop_proxy: Arc::new(EventLoopProxy::new()), + queued_events: Vec::new(), }); } init_guard(&mut guard); @@ -217,48 +190,34 @@ impl AppState { matches!(self.state(), AppStateImpl::Terminated) } - fn did_finish_launching_transition(&mut self) -> Vec { - let (events, queued_gpu_redraws) = match self.take_state() { - AppStateImpl::Initial { queued_events, queued_gpu_redraws } => { - (queued_events, queued_gpu_redraws) - }, + fn did_finish_launching_transition(&mut self) { + let queued_gpu_redraws = match self.take_state() { + AppStateImpl::Initial { queued_gpu_redraws } => queued_gpu_redraws, s => bug!("unexpected state {:?}", s), }; self.set_state(AppStateImpl::ProcessingEvents { active_control_flow: self.control_flow, queued_gpu_redraws, }); - events } - fn wakeup_transition(&mut self) -> Option { + fn wakeup_transition(&mut self) -> Option { // before `AppState::did_finish_launching` is called, pretend there is no running // event loop. if !self.has_launched() || self.has_terminated() { return None; } - let event = match (self.control_flow, self.take_state()) { - (ControlFlow::Poll, AppStateImpl::PollFinished) => { - EventWrapper::StaticEvent(Event::NewEvents(StartCause::Poll)) - }, + let start_cause = match (self.control_flow, self.take_state()) { + (ControlFlow::Poll, AppStateImpl::PollFinished) => StartCause::Poll, (ControlFlow::Wait, AppStateImpl::Waiting { start }) => { - EventWrapper::StaticEvent(Event::NewEvents(StartCause::WaitCancelled { - start, - requested_resume: None, - })) + StartCause::WaitCancelled { start, requested_resume: None } }, (ControlFlow::WaitUntil(requested_resume), AppStateImpl::Waiting { start }) => { if Instant::now() >= requested_resume { - EventWrapper::StaticEvent(Event::NewEvents(StartCause::ResumeTimeReached { - start, - requested_resume, - })) + StartCause::ResumeTimeReached { start, requested_resume } } else { - EventWrapper::StaticEvent(Event::NewEvents(StartCause::WaitCancelled { - start, - requested_resume: Some(requested_resume), - })) + StartCause::WaitCancelled { start, requested_resume: Some(requested_resume) } } }, s => bug!("`EventHandler` unexpectedly woke up {:?}", s), @@ -268,55 +227,7 @@ impl AppState { queued_gpu_redraws: Default::default(), active_control_flow: self.control_flow, }); - Some(event) - } - - fn try_user_callback_transition(&mut self) -> UserCallbackTransitionResult<'_> { - // If we're not able to process an event due to recursion or `Init` not having been sent out - // yet, then queue the events up. - match self.state_mut() { - &mut AppStateImpl::Initial { ref mut queued_events, .. } - | &mut AppStateImpl::InUserCallback { ref mut queued_events, .. } => { - // A lifetime cast: early returns are not currently handled well with NLL, but - // polonius handles them well. This transmute is a safe workaround. - return unsafe { - mem::transmute::< - UserCallbackTransitionResult<'_>, - UserCallbackTransitionResult<'_>, - >(UserCallbackTransitionResult::ReentrancyPrevented { - queued_events, - }) - }; - }, - - &mut AppStateImpl::ProcessingEvents { .. } - | &mut AppStateImpl::ProcessingRedraws { .. } => {}, - - s @ &mut AppStateImpl::PollFinished { .. } - | s @ &mut AppStateImpl::Waiting { .. } - | s @ &mut AppStateImpl::Terminated => { - bug!("unexpected attempted to process an event {:?}", s) - }, - } - - let (queued_gpu_redraws, active_control_flow, processing_redraws) = match self.take_state() - { - AppStateImpl::Initial { .. } | AppStateImpl::InUserCallback { .. } => unreachable!(), - AppStateImpl::ProcessingEvents { queued_gpu_redraws, active_control_flow } => { - (queued_gpu_redraws, active_control_flow, false) - }, - AppStateImpl::ProcessingRedraws { active_control_flow } => { - (Default::default(), active_control_flow, true) - }, - AppStateImpl::PollFinished { .. } - | AppStateImpl::Waiting { .. } - | AppStateImpl::Terminated => unreachable!(), - }; - self.set_state(AppStateImpl::InUserCallback { - queued_events: Vec::new(), - queued_gpu_redraws, - }); - UserCallbackTransitionResult::Success { active_control_flow, processing_redraws } + Some(start_cause) } fn main_events_cleared_transition(&mut self) -> HashSet> { @@ -372,7 +283,7 @@ impl AppState { fn terminated_transition(&mut self) { match self.replace_state(AppStateImpl::Terminated) { AppStateImpl::ProcessingEvents { .. } => {}, - s => bug!("`LoopExiting` happened while not processing events {:?}", s), + s => bug!("terminated while not processing events {:?}", s), } } @@ -393,8 +304,7 @@ pub(crate) fn queue_gl_or_metal_redraw(mtm: MainThreadMarker, window: Retained { + | &mut AppStateImpl::ProcessingEvents { ref mut queued_gpu_redraws, .. } => { let _ = queued_gpu_redraws.insert(window); }, s @ &mut AppStateImpl::ProcessingRedraws { .. } @@ -418,27 +328,24 @@ pub fn did_finish_launching(mtm: MainThreadMarker) { // have to drop RefMut because the window setup code below can trigger new events drop(this); - let events = AppState::get_mut(mtm).did_finish_launching_transition(); + AppState::get_mut(mtm).did_finish_launching_transition(); - let events = [ - EventWrapper::StaticEvent(Event::NewEvents(StartCause::Init)), - EventWrapper::StaticEvent(Event::CreateSurfaces), - ] - .into_iter() - .chain(events); - handle_nonuser_events(mtm, events); + get_handler(mtm).handle(|app| app.new_events(&ActiveEventLoop { mtm }, StartCause::Init)); + get_handler(mtm).handle(|app| app.can_create_surfaces(&ActiveEventLoop { mtm })); + handle_nonuser_events(mtm, []); } // AppState::did_finish_launching handles the special transition `Init` pub fn handle_wakeup_transition(mtm: MainThreadMarker) { let mut this = AppState::get_mut(mtm); - let wakeup_event = match this.wakeup_transition() { + let cause = match this.wakeup_transition() { None => return, - Some(wakeup_event) => wakeup_event, + Some(cause) => cause, }; drop(this); - handle_nonuser_event(mtm, wakeup_event) + get_handler(mtm).handle(|app| app.new_events(&ActiveEventLoop { mtm }, cause)); + handle_nonuser_events(mtm, []); } pub(crate) fn handle_nonuser_event(mtm: MainThreadMarker, event: EventWrapper) { @@ -454,132 +361,75 @@ pub(crate) fn handle_nonuser_events>( return; } - let (active_control_flow, processing_redraws) = match this.try_user_callback_transition() { - UserCallbackTransitionResult::ReentrancyPrevented { queued_events } => { - queued_events.extend(events); - return; - }, - UserCallbackTransitionResult::Success { active_control_flow, processing_redraws } => { - (active_control_flow, processing_redraws) - }, - }; + if !get_handler(mtm).ready() { + // Prevent re-entrancy; queue the events up for once we're done handling the event instead. + this.queued_events.extend(events); + return; + } + + let processing_redraws = matches!(this.state(), AppStateImpl::ProcessingRedraws { .. }); drop(this); - for wrapper in events { - match wrapper { - EventWrapper::StaticEvent(event) => { - if !processing_redraws && event.is_redraw() { - tracing::info!("processing `RedrawRequested` during the main event loop"); - } else if processing_redraws && !event.is_redraw() { - tracing::warn!( - "processing non `RedrawRequested` event after the main event loop: {:#?}", - event - ); - } - handle_event(mtm, event) - }, - EventWrapper::ScaleFactorChanged(event) => handle_hidpi_proxy(mtm, event), + for event in events { + if !processing_redraws && event.is_redraw() { + tracing::info!("processing `RedrawRequested` during the main event loop"); + } else if processing_redraws && !event.is_redraw() { + tracing::warn!( + "processing non `RedrawRequested` event after the main event loop: {:#?}", + event + ); } + handle_wrapped_event(mtm, event) } loop { let mut this = AppState::get_mut(mtm); - let queued_events = match this.state_mut() { - &mut AppStateImpl::InUserCallback { ref mut queued_events, queued_gpu_redraws: _ } => { - mem::take(queued_events) - }, - s => bug!("unexpected state {:?}", s), - }; + let queued_events = mem::take(&mut this.queued_events); if queued_events.is_empty() { - let queued_gpu_redraws = match this.take_state() { - AppStateImpl::InUserCallback { queued_events: _, queued_gpu_redraws } => { - queued_gpu_redraws - }, - _ => unreachable!(), - }; - this.app_state = Some(if processing_redraws { - bug_assert!( - queued_gpu_redraws.is_empty(), - "redraw queued while processing redraws" - ); - AppStateImpl::ProcessingRedraws { active_control_flow } - } else { - AppStateImpl::ProcessingEvents { queued_gpu_redraws, active_control_flow } - }); break; } drop(this); - for wrapper in queued_events { - match wrapper { - EventWrapper::StaticEvent(event) => { - if !processing_redraws && event.is_redraw() { - tracing::info!("processing `RedrawRequested` during the main event loop"); - } else if processing_redraws && !event.is_redraw() { - tracing::warn!( - "processing non-`RedrawRequested` event after the main event loop: \ - {:#?}", - event - ); - } - handle_event(mtm, event) - }, - EventWrapper::ScaleFactorChanged(event) => handle_hidpi_proxy(mtm, event), + for event in queued_events { + if !processing_redraws && event.is_redraw() { + tracing::info!("processing `RedrawRequested` during the main event loop"); + } else if processing_redraws && !event.is_redraw() { + tracing::warn!( + "processing non-`RedrawRequested` event after the main event loop: {:#?}", + event + ); } + handle_wrapped_event(mtm, event); } } } fn handle_user_events(mtm: MainThreadMarker) { - let mut this = AppState::get_mut(mtm); - let (active_control_flow, processing_redraws) = match this.try_user_callback_transition() { - UserCallbackTransitionResult::ReentrancyPrevented { .. } => { - bug!("unexpected attempted to process an event") - }, - UserCallbackTransitionResult::Success { active_control_flow, processing_redraws } => { - (active_control_flow, processing_redraws) - }, - }; - if processing_redraws { + let this = AppState::get_mut(mtm); + if matches!(this.state(), AppStateImpl::ProcessingRedraws { .. }) { bug!("user events attempted to be sent out while `ProcessingRedraws`"); } let event_loop_proxy = this.event_loop_proxy().clone(); drop(this); if event_loop_proxy.wake_up.swap(false, Ordering::Relaxed) { - handle_event(mtm, Event::UserWakeUp); + get_handler(mtm).handle(|app| app.proxy_wake_up(&ActiveEventLoop { mtm })); } loop { let mut this = AppState::get_mut(mtm); - let queued_events = match this.state_mut() { - &mut AppStateImpl::InUserCallback { ref mut queued_events, queued_gpu_redraws: _ } => { - mem::take(queued_events) - }, - s => bug!("unexpected state {:?}", s), - }; + let queued_events = mem::take(&mut this.queued_events); if queued_events.is_empty() { - let queued_gpu_redraws = match this.take_state() { - AppStateImpl::InUserCallback { queued_events: _, queued_gpu_redraws } => { - queued_gpu_redraws - }, - _ => unreachable!(), - }; - this.app_state = - Some(AppStateImpl::ProcessingEvents { queued_gpu_redraws, active_control_flow }); break; } drop(this); - for wrapper in queued_events { - match wrapper { - EventWrapper::StaticEvent(event) => handle_event(mtm, event), - EventWrapper::ScaleFactorChanged(event) => handle_hidpi_proxy(mtm, event), - } + for event in queued_events { + handle_wrapped_event(mtm, event); } if event_loop_proxy.wake_up.swap(false, Ordering::Relaxed) { - handle_event(mtm, Event::UserWakeUp); + get_handler(mtm).handle(|app| app.proxy_wake_up(&ActiveEventLoop { mtm })); } } } @@ -597,10 +447,10 @@ pub(crate) fn send_occluded_event_for_all_windows(application: &UIApplication, o let ptr: *const WinitUIWindow = ptr.cast(); &*ptr }; - events.push(EventWrapper::StaticEvent(Event::WindowEvent { + events.push(EventWrapper::Window { window_id: window.id(), event: WindowEvent::Occluded(occluded), - })); + }); } } handle_nonuser_events(mtm, events); @@ -623,23 +473,37 @@ pub fn handle_main_events_cleared(mtm: MainThreadMarker) { let redraw_events: Vec = this .main_events_cleared_transition() .into_iter() - .map(|window| { - EventWrapper::StaticEvent(Event::WindowEvent { - window_id: window.id(), - event: WindowEvent::RedrawRequested, - }) + .map(|window| EventWrapper::Window { + window_id: window.id(), + event: WindowEvent::RedrawRequested, }) .collect(); drop(this); handle_nonuser_events(mtm, redraw_events); - handle_nonuser_event(mtm, EventWrapper::StaticEvent(Event::AboutToWait)); + get_handler(mtm).handle(|app| app.about_to_wait(&ActiveEventLoop { mtm })); + handle_nonuser_events(mtm, []); } pub fn handle_events_cleared(mtm: MainThreadMarker) { AppState::get_mut(mtm).events_cleared_transition(); } +pub(crate) fn handle_resumed(mtm: MainThreadMarker) { + get_handler(mtm).handle(|app| app.resumed(&ActiveEventLoop { mtm })); + handle_nonuser_events(mtm, []); +} + +pub(crate) fn handle_suspended(mtm: MainThreadMarker) { + get_handler(mtm).handle(|app| app.suspended(&ActiveEventLoop { mtm })); + handle_nonuser_events(mtm, []); +} + +pub(crate) fn handle_memory_warning(mtm: MainThreadMarker) { + get_handler(mtm).handle(|app| app.memory_warning(&ActiveEventLoop { mtm })); + handle_nonuser_events(mtm, []); +} + pub(crate) fn terminated(application: &UIApplication) { let mtm = MainThreadMarker::from(application); @@ -653,10 +517,10 @@ pub(crate) fn terminated(application: &UIApplication) { let ptr: *const WinitUIWindow = ptr.cast(); &*ptr }; - events.push(EventWrapper::StaticEvent(Event::WindowEvent { + events.push(EventWrapper::Window { window_id: window.id(), event: WindowEvent::Destroyed, - })); + }); } } handle_nonuser_events(mtm, events); @@ -665,20 +529,26 @@ pub(crate) fn terminated(application: &UIApplication) { this.terminated_transition(); drop(this); - handle_event(mtm, Event::LoopExiting) + get_handler(mtm).handle(|app| app.exiting(&ActiveEventLoop { mtm })); +} + +fn handle_wrapped_event(mtm: MainThreadMarker, event: EventWrapper) { + match event { + EventWrapper::Window { window_id, event } => get_handler(mtm) + .handle(|app| app.window_event(&ActiveEventLoop { mtm }, window_id, event)), + EventWrapper::ScaleFactorChanged(event) => handle_hidpi_proxy(mtm, event), + } } fn handle_hidpi_proxy(mtm: MainThreadMarker, event: ScaleFactorChanged) { let ScaleFactorChanged { suggested_size, scale_factor, window } = event; let new_surface_size = Arc::new(Mutex::new(suggested_size)); - let event = Event::WindowEvent { - window_id: window.id(), - event: WindowEvent::ScaleFactorChanged { + get_handler(mtm).handle(|app| { + app.window_event(&ActiveEventLoop { mtm }, window.id(), WindowEvent::ScaleFactorChanged { scale_factor, surface_size_writer: SurfaceSizeWriter::new(Arc::downgrade(&new_surface_size)), - }, - }; - handle_event(mtm, event); + }); + }); let (view, screen_frame) = get_view_and_screen_frame(&window); let physical_size = *new_surface_size.lock().unwrap(); drop(new_surface_size); diff --git a/src/platform_impl/apple/uikit/event_loop.rs b/src/platform_impl/apple/uikit/event_loop.rs index 4f93a61d90..ba7377ce66 100644 --- a/src/platform_impl/apple/uikit/event_loop.rs +++ b/src/platform_impl/apple/uikit/event_loop.rs @@ -23,11 +23,10 @@ use objc2_ui_kit::{ use rwh_06::HasDisplayHandle; use super::super::notification_center::create_observer; -use super::app_state::{send_occluded_event_for_all_windows, AppState, EventWrapper}; +use super::app_state::{send_occluded_event_for_all_windows, AppState}; use super::{app_state, monitor, MonitorHandle}; use crate::application::ApplicationHandler; use crate::error::{EventLoopError, NotSupportedError, RequestError}; -use crate::event::Event; use crate::event_loop::{ ActiveEventLoop as RootActiveEventLoop, ControlFlow, DeviceEvents, EventLoopProxy as CoreEventLoopProxy, EventLoopProxyProvider, @@ -174,17 +173,13 @@ impl EventLoop { ¢er, // `applicationDidBecomeActive:` unsafe { UIApplicationDidBecomeActiveNotification }, - move |_| { - app_state::handle_nonuser_event(mtm, EventWrapper::StaticEvent(Event::Resumed)); - }, + move |_| app_state::handle_resumed(mtm), ); let _will_resign_active_observer = create_observer( ¢er, // `applicationWillResignActive:` unsafe { UIApplicationWillResignActiveNotification }, - move |_| { - app_state::handle_nonuser_event(mtm, EventWrapper::StaticEvent(Event::Suspended)); - }, + move |_| app_state::handle_suspended(mtm), ); let _will_enter_foreground_observer = create_observer( ¢er, @@ -231,12 +226,7 @@ impl EventLoop { ¢er, // `applicationDidReceiveMemoryWarning:` unsafe { UIApplicationDidReceiveMemoryWarningNotification }, - move |_| { - app_state::handle_nonuser_event( - mtm, - EventWrapper::StaticEvent(Event::MemoryWarning), - ); - }, + move |_| app_state::handle_memory_warning(mtm), ); Ok(EventLoop { diff --git a/src/platform_impl/apple/uikit/view.rs b/src/platform_impl/apple/uikit/view.rs index 64ee71570a..9330a9cc5c 100644 --- a/src/platform_impl/apple/uikit/view.rs +++ b/src/platform_impl/apple/uikit/view.rs @@ -17,8 +17,8 @@ use super::app_state::{self, EventWrapper}; use super::window::WinitUIWindow; use crate::dpi::PhysicalPosition; use crate::event::{ - ButtonSource, ElementState, Event, FingerId, Force, KeyEvent, PointerKind, PointerSource, - TouchPhase, WindowEvent, + ButtonSource, ElementState, FingerId, Force, KeyEvent, PointerKind, PointerSource, TouchPhase, + WindowEvent, }; use crate::keyboard::{Key, KeyCode, KeyLocation, NamedKey, NativeKeyCode, PhysicalKey}; use crate::platform_impl::KeyEventExtra; @@ -60,10 +60,10 @@ declare_class!( let window = self.window().unwrap(); app_state::handle_nonuser_event( mtm, - EventWrapper::StaticEvent(Event::WindowEvent { + EventWrapper::Window { window_id: window.id(), event: WindowEvent::RedrawRequested, - }), + }, ); let _: () = unsafe { msg_send![super(self), drawRect: rect] }; } @@ -84,10 +84,10 @@ declare_class!( let window = self.window().unwrap(); app_state::handle_nonuser_event( mtm, - EventWrapper::StaticEvent(Event::WindowEvent { + EventWrapper::Window { window_id: window.id(), event: WindowEvent::SurfaceResized(size), - }), + }, ); } @@ -131,12 +131,11 @@ declare_class!( suggested_size: size.to_physical(scale_factor), }, )) - .chain(std::iter::once(EventWrapper::StaticEvent( - Event::WindowEvent { + .chain(std::iter::once(EventWrapper::Window { window_id, event: WindowEvent::SurfaceResized(size.to_physical(scale_factor)), }, - ))), + )), ); } @@ -192,14 +191,14 @@ declare_class!( state => panic!("unexpected recognizer state: {state:?}"), }; - let gesture_event = EventWrapper::StaticEvent(Event::WindowEvent { + let gesture_event = EventWrapper::Window { window_id: window.id(), event: WindowEvent::PinchGesture { device_id: None, delta: delta as f64, phase, }, - }); + }; let mtm = MainThreadMarker::new().unwrap(); app_state::handle_nonuser_event(mtm, gesture_event); @@ -210,12 +209,12 @@ declare_class!( let window = self.window().unwrap(); if recognizer.state() == UIGestureRecognizerState::Ended { - let gesture_event = EventWrapper::StaticEvent(Event::WindowEvent { + let gesture_event = EventWrapper::Window { window_id: window.id(), event: WindowEvent::DoubleTapGesture { device_id: None, }, - }); + }; let mtm = MainThreadMarker::new().unwrap(); app_state::handle_nonuser_event(mtm, gesture_event); @@ -252,14 +251,14 @@ declare_class!( }; // Make delta negative to match macos, convert to degrees - let gesture_event = EventWrapper::StaticEvent(Event::WindowEvent { + let gesture_event = EventWrapper::Window { window_id: window.id(), event: WindowEvent::RotationGesture { device_id: None, delta: -delta.to_degrees() as _, phase, }, - }); + }; let mtm = MainThreadMarker::new().unwrap(); app_state::handle_nonuser_event(mtm, gesture_event); @@ -303,14 +302,14 @@ declare_class!( }; - let gesture_event = EventWrapper::StaticEvent(Event::WindowEvent { + let gesture_event = EventWrapper::Window { window_id: window.id(), event: WindowEvent::PanGesture { device_id: None, delta: PhysicalPosition::new(dx as _, dy as _), phase, }, - }); + }; let mtm = MainThreadMarker::new().unwrap(); app_state::handle_nonuser_event(mtm, gesture_event); @@ -538,7 +537,7 @@ impl WinitView { } }; - touch_events.push(EventWrapper::StaticEvent(Event::WindowEvent { + touch_events.push(EventWrapper::Window { window_id, event: WindowEvent::PointerEntered { device_id: None, @@ -550,8 +549,8 @@ impl WinitView { PointerKind::Touch(finger_id) }, }, - })); - touch_events.push(EventWrapper::StaticEvent(Event::WindowEvent { + }); + touch_events.push(EventWrapper::Window { window_id, event: WindowEvent::PointerButton { device_id: None, @@ -564,7 +563,7 @@ impl WinitView { ButtonSource::Touch { finger_id, force } }, }, - })); + }); }, UITouchPhase::Moved => { let (primary, source) = if let UITouchType::Pencil = touch_type { @@ -576,7 +575,7 @@ impl WinitView { }) }; - touch_events.push(EventWrapper::StaticEvent(Event::WindowEvent { + touch_events.push(EventWrapper::Window { window_id, event: WindowEvent::PointerMoved { device_id: None, @@ -584,7 +583,7 @@ impl WinitView { position, source, }, - })); + }); }, // 2 is UITouchPhase::Stationary and is not expected here UITouchPhase::Ended | UITouchPhase::Cancelled => { @@ -600,7 +599,7 @@ impl WinitView { }; if let UITouchPhase::Ended = phase { - touch_events.push(EventWrapper::StaticEvent(Event::WindowEvent { + touch_events.push(EventWrapper::Window { window_id, event: WindowEvent::PointerButton { device_id: None, @@ -613,10 +612,10 @@ impl WinitView { ButtonSource::Touch { finger_id, force } }, }, - })); + }); } - touch_events.push(EventWrapper::StaticEvent(Event::WindowEvent { + touch_events.push(EventWrapper::Window { window_id, event: WindowEvent::PointerLeft { device_id: None, @@ -628,7 +627,7 @@ impl WinitView { PointerKind::Touch(finger_id) }, }, - })); + }); }, _ => panic!("unexpected touch phase: {phase:?}"), } @@ -647,29 +646,25 @@ impl WinitView { text.to_string().chars().flat_map(|c| { let text = smol_str::SmolStr::from_iter([c]); // Emit both press and release events - [ElementState::Pressed, ElementState::Released].map(|state| { - EventWrapper::StaticEvent(Event::WindowEvent { - window_id, - event: WindowEvent::KeyboardInput { - event: KeyEvent { - text: if state == ElementState::Pressed { - Some(text.clone()) - } else { - None - }, - state, - location: KeyLocation::Standard, - repeat: false, - logical_key: Key::Character(text.clone()), - physical_key: PhysicalKey::Unidentified( - NativeKeyCode::Unidentified, - ), - platform_specific: KeyEventExtra {}, + [ElementState::Pressed, ElementState::Released].map(|state| EventWrapper::Window { + window_id, + event: WindowEvent::KeyboardInput { + device_id: None, + event: KeyEvent { + text: if state == ElementState::Pressed { + Some(text.clone()) + } else { + None }, - is_synthetic: false, - device_id: None, + state, + location: KeyLocation::Standard, + repeat: false, + logical_key: Key::Character(text.clone()), + physical_key: PhysicalKey::Unidentified(NativeKeyCode::Unidentified), + platform_specific: KeyEventExtra {}, }, - }) + is_synthetic: false, + }, }) }), ); @@ -681,23 +676,21 @@ impl WinitView { let mtm = MainThreadMarker::new().unwrap(); app_state::handle_nonuser_events( mtm, - [ElementState::Pressed, ElementState::Released].map(|state| { - EventWrapper::StaticEvent(Event::WindowEvent { - window_id, - event: WindowEvent::KeyboardInput { - device_id: None, - event: KeyEvent { - state, - logical_key: Key::Named(NamedKey::Backspace), - physical_key: PhysicalKey::Code(KeyCode::Backspace), - platform_specific: KeyEventExtra {}, - repeat: false, - location: KeyLocation::Standard, - text: None, - }, - is_synthetic: false, + [ElementState::Pressed, ElementState::Released].map(|state| EventWrapper::Window { + window_id, + event: WindowEvent::KeyboardInput { + device_id: None, + event: KeyEvent { + state, + logical_key: Key::Named(NamedKey::Backspace), + physical_key: PhysicalKey::Code(KeyCode::Backspace), + platform_specific: KeyEventExtra {}, + repeat: false, + location: KeyLocation::Standard, + text: None, }, - }) + is_synthetic: false, + }, }), ); } diff --git a/src/platform_impl/apple/uikit/window.rs b/src/platform_impl/apple/uikit/window.rs index 1764e00b8f..fcbe2cf3ba 100644 --- a/src/platform_impl/apple/uikit/window.rs +++ b/src/platform_impl/apple/uikit/window.rs @@ -23,7 +23,7 @@ use crate::dpi::{ Position, Size, }; use crate::error::{NotSupportedError, RequestError}; -use crate::event::{Event, WindowEvent}; +use crate::event::WindowEvent; use crate::icon::Icon; use crate::monitor::MonitorHandle as CoreMonitorHandle; use crate::platform::ios::{ScreenEdge, StatusBarStyle, ValidOrientations}; @@ -51,10 +51,10 @@ declare_class!( let mtm = MainThreadMarker::new().unwrap(); app_state::handle_nonuser_event( mtm, - EventWrapper::StaticEvent(Event::WindowEvent { + EventWrapper::Window { window_id: self.id(), event: WindowEvent::Focused(true), - }), + }, ); let _: () = unsafe { msg_send![super(self), becomeKeyWindow] }; } @@ -64,10 +64,10 @@ declare_class!( let mtm = MainThreadMarker::new().unwrap(); app_state::handle_nonuser_event( mtm, - EventWrapper::StaticEvent(Event::WindowEvent { + EventWrapper::Window { window_id: self.id(), event: WindowEvent::Focused(false), - }), + }, ); let _: () = unsafe { msg_send![super(self), resignKeyWindow] }; }