migrate: 0.16.1 to 0.18.1 (thanks claude!)

src/foreign_toplevel_manager.rs

@@ -1,6 +1,6 @@
 use bevy::prelude::*;
 use smithay_client_toolkit::{
-    reexports::client::{event_created_child, Dispatch, QueueHandle},
+    reexports::client::{Dispatch, QueueHandle, event_created_child},
     registry::RegistryState,
 };
 use wayland_protocols_wlr::foreign_toplevel::v1::client::{
@@ -9,7 +9,7 @@ use wayland_protocols_wlr::foreign_toplevel::v1::client::{
 };
 
 use crate::WaylandState;
-#[derive(Debug, Copy, Clone, Event)]
+#[derive(Debug, Copy, Clone, Message)]
 pub enum ForeignToplevelEvent {
     MinimizeOthers,
 }
@@ -28,7 +28,7 @@ impl Plugin for ForeignToplevelManagerPlugin {
             info!("Foreign toplevel manager was bound!");
             app.insert_non_send_resource(foreign_top_level_manager);
             app.insert_non_send_resource(ForeignToplevels::default());
-            app.add_event::<ForeignToplevelEvent>();
+            app.add_message::<ForeignToplevelEvent>();
             app.add_systems(Update, foreign_top_level_event_handler);
         } else {
             let bind_error = foreign_top_level_manager.err().unwrap();
@@ -39,7 +39,7 @@ impl Plugin for ForeignToplevelManagerPlugin {
 
 fn foreign_top_level_event_handler(
     foreign_top_levels: NonSendMut<ForeignToplevels>,
-    mut events: EventReader<ForeignToplevelEvent>,
+    mut events: MessageReader<ForeignToplevelEvent>,
 ) {
     for event in events.read() {
         match event {

src/input_handler/keyboard.rs

@@ -409,9 +409,9 @@ impl KeyboardHandler for WaylandState {
         let active_window_entity = **self.world().resource::<ActiveWindow>();
         let keyboard_event =
             convert_keyboard_event(event, active_window_entity, ButtonState::Pressed);
-        self.world_mut().send_event(keyboard_event.clone());
+        self.world_mut().write_message(keyboard_event.clone());
         self.world_mut()
-            .send_event(WindowEvent::KeyboardInput(keyboard_event));
+            .write_message(WindowEvent::KeyboardInput(keyboard_event));
     }
 
     fn repeat_key(
@@ -426,9 +426,9 @@ impl KeyboardHandler for WaylandState {
         let mut keyboard_event =
             convert_keyboard_event(event, active_window_entity, ButtonState::Pressed);
         keyboard_event.repeat = true;
-        self.world_mut().send_event(keyboard_event.clone());
+        self.world_mut().write_message(keyboard_event.clone());
         self.world_mut()
-            .send_event(WindowEvent::KeyboardInput(keyboard_event));
+            .write_message(WindowEvent::KeyboardInput(keyboard_event));
     }
 
     fn release_key(
@@ -442,9 +442,9 @@ impl KeyboardHandler for WaylandState {
         let active_window_entity = **self.world().resource::<ActiveWindow>();
         let keyboard_event =
             convert_keyboard_event(event, active_window_entity, ButtonState::Released);
-        self.world_mut().send_event(keyboard_event.clone());
+        self.world_mut().write_message(keyboard_event.clone());
         self.world_mut()
-            .send_event(WindowEvent::KeyboardInput(keyboard_event));
+            .write_message(WindowEvent::KeyboardInput(keyboard_event));
     }
 
     fn update_modifiers(

src/input_handler/pointer.rs

@@ -101,26 +101,26 @@ impl PointerHandler for WaylandState {
             let window_event: WindowEvent = pointer_event;
             match window_event.clone() {
                 WindowEvent::CursorEntered(e) => {
-                    self.world_mut().send_event(e);
+                    self.world_mut().write_message(e);
                 }
                 WindowEvent::CursorLeft(e) => {
-                    self.world_mut().send_event(e);
+                    self.world_mut().write_message(e);
                 }
                 WindowEvent::CursorMoved(e) => {
-                    self.world_mut().send_event(e);
+                    self.world_mut().write_message(e);
                 }
                 WindowEvent::MouseButtonInput(e) => {
-                    self.world_mut().send_event(e);
+                    self.world_mut().write_message(e);
                 }
                 WindowEvent::MouseMotion(e) => {
-                    self.world_mut().send_event(e);
+                    self.world_mut().write_message(e);
                 }
                 WindowEvent::MouseWheel(e) => {
-                    self.world_mut().send_event(e);
+                    self.world_mut().write_message(e);
                 }
                 _ => {}
             }
-            self.world_mut().send_event::<WindowEvent>(window_event);
+            self.world_mut().write_message::<WindowEvent>(window_event);
         }
     }
 }

src/layer_shell.rs

@@ -11,7 +11,7 @@ use smithay_client_toolkit::{
 };
 
 use crate::{
-    surface_handler::{create_windows, SurfaceConfigured, WaylandSurfaces},
+    surface_handler::{SurfaceConfigured, SurfaceHandlerSystems, WaylandSurfaces},
     WaylandState,
 };
 
@@ -121,7 +121,10 @@ impl Default for LayerShellSettings {
 pub struct LayerShellPlugin;
 impl Plugin for LayerShellPlugin {
     fn build(&self, app: &mut App) {
-        app.add_systems(PreUpdate, assign_layer_shell_role.after(create_windows))
+        app.add_systems(
+            PreUpdate,
+            assign_layer_shell_role.after(SurfaceHandlerSystems::CreateWindows),
+        )
             .add_systems(Update, update_layer_shell_settings)
             .insert_non_send_resource(LayerShellWindows::default());
     }

src/lib.rs

@@ -8,9 +8,9 @@ use smithay_client_toolkit::{
     delegate_registry,
     output::OutputState,
     reexports::{
-        calloop::{self, channel::Sender, EventLoop},
+        calloop::{self, EventLoop, channel::Sender},
         calloop_wayland_source::WaylandSource,
-        client::{globals::registry_queue_init, Connection},
+        client::{Connection, globals::registry_queue_init},
     },
     registry::{ProvidesRegistryState, RegistryState},
     registry_handlers,
@@ -26,10 +26,9 @@ pub mod session_lock;
 mod surface_handler;
 
 pub mod prelude {
+    pub use crate::WaylandPlugin;
     pub use crate::input_region::InputRegion;
     pub use crate::layer_shell::{LayerShellSettings, LayerShellWindowSize};
-    pub use crate::session_lock::{SessionLockEvent, SessionLockWindow};
-    pub use crate::WaylandPlugin;
     pub use smithay_client_toolkit::shell::wlr_layer::{Anchor, KeyboardInteractivity, Layer};
 }
 

src/session_lock.rs

@@ -7,7 +7,7 @@ use smithay_client_toolkit::{
 };
 
 use crate::{
-    surface_handler::{create_windows, SurfaceConfigured, WaylandSurfaces},
+    surface_handler::{SurfaceConfigured, SurfaceHandlerSystems, WaylandSurfaces},
     WaylandState,
 };
 
@@ -30,7 +30,7 @@ impl SessionLockUnconfiguredWindow {
     }
 }
 
-#[derive(Clone, Copy, Event)]
+#[derive(Clone, Copy, Message)]
 pub enum SessionLockEvent {
     Lock,
     Unlock,
@@ -46,12 +46,12 @@ impl Plugin for SessionLockPlugin {
         app.insert_non_send_resource(session_lock_state);
         app.insert_non_send_resource(SessionLockWindows::default());
         app.insert_non_send_resource(SessionLockWrapper::default());
-        app.add_event::<SessionLockEvent>();
+        app.add_message::<SessionLockEvent>();
         app.add_systems(
             PreUpdate,
             (
-                session_lock_event_handler.before(create_windows),
-                configure_lock_surfaces.after(create_windows),
+                session_lock_event_handler.before(SurfaceHandlerSystems::CreateWindows),
+                configure_lock_surfaces.after(SurfaceHandlerSystems::CreateWindows),
             ),
         );
     }
@@ -61,7 +61,7 @@ impl Plugin for SessionLockPlugin {
 struct SessionLockWrapper(Option<SessionLock>);
 fn session_lock_event_handler(
     mut commands: Commands,
-    mut session_lock_event_reader: EventReader<SessionLockEvent>,
+    mut session_lock_event_reader: MessageReader<SessionLockEvent>,
     session_lock_state: NonSend<SessionLockState>,
     mut session_lock_wrapper: NonSendMut<SessionLockWrapper>,
     queue_handle: NonSend<QueueHandle<WaylandState>>,

src/surface_handler.rs

@@ -13,7 +13,7 @@ use smithay_client_toolkit::{
     compositor::{CompositorHandler, CompositorState},
     delegate_compositor,
     reexports::client::{
-        backend::ObjectId, protocol::wl_surface::WlSurface, Connection, Proxy, QueueHandle,
+        Connection, Proxy, QueueHandle, backend::ObjectId, protocol::wl_surface::WlSurface,
     },
 };
 
@@ -21,6 +21,12 @@ use crate::WaylandState;
 
 #[derive(Component)]
 pub struct SurfaceConfigured;
+
+#[derive(SystemSet, Debug, Clone, PartialEq, Eq, Hash)]
+pub enum SurfaceHandlerSystems {
+    CreateWindows,
+}
+
 pub struct SurfaceHandlerPlugin;
 impl Plugin for SurfaceHandlerPlugin {
     fn build(&self, app: &mut App) {
@@ -30,7 +36,10 @@ impl Plugin for SurfaceHandlerPlugin {
             CompositorState::bind(globals, queue_handle).expect("failed to bind compositor!"),
         );
         app.insert_non_send_resource(WaylandSurfaces::default());
-        app.add_systems(PreUpdate, create_windows);
+        app.add_systems(
+            PreUpdate,
+            create_windows.in_set(SurfaceHandlerSystems::CreateWindows),
+        );
     }
 }
 
@@ -173,7 +182,7 @@ pub fn create_windows(
     connection: NonSend<Connection>,
     queue_handle: NonSend<QueueHandle<WaylandState>>,
     bevy_windows: Query<(Entity, Option<&RawHandleWrapperHolder>), With<Window>>,
-    mut window_created_event: EventWriter<WindowCreated>,
+    mut window_created_event: MessageWriter<WindowCreated>,
 ) {
     for (entity, handle_holder) in &bevy_windows {
         if wayland_surfaces.get_window_wrapper(entity).is_some() {