diff --git a/src/platform_impl/linux/wayland/event_loop/mod.rs b/src/platform_impl/linux/wayland/event_loop/mod.rs
index c615550783..e153d02726 100644
--- a/src/platform_impl/linux/wayland/event_loop/mod.rs
+++ b/src/platform_impl/linux/wayland/event_loop/mod.rs
@@ -375,7 +375,7 @@ impl EventLoop {
         });
         for event in buffer_sink.drain() {
             match event {
-                Event::WindowEvent { window_id, event } => {
+                Event::SurfaceEvent { window_id, event } => {
                     app.window_event(&self.active_event_loop, window_id, event)
                 },
                 Event::DeviceEvent { device_id, event } => {
@@ -391,7 +391,7 @@ impl EventLoop {
         });
         for event in buffer_sink.drain() {
             match event {
-                Event::WindowEvent { window_id, event } => {
+                Event::SurfaceEvent { window_id, event } => {
                     app.window_event(&self.active_event_loop, window_id, event)
                 },
                 Event::DeviceEvent { device_id, event } => {
diff --git a/src/platform_impl/linux/wayland/event_loop/sink.rs b/src/platform_impl/linux/wayland/event_loop/sink.rs
index 8f988afc02..d530fda1a5 100644
--- a/src/platform_impl/linux/wayland/event_loop/sink.rs
+++ b/src/platform_impl/linux/wayland/event_loop/sink.rs
@@ -32,7 +32,7 @@ impl EventSink {
     /// Add new window event to a queue.
     #[inline]
     pub fn push_window_event(&mut self, event: SurfaceEvent, window_id: SurfaceId) {
-        self.window_events.push(Event::WindowEvent { event, window_id });
+        self.window_events.push(Event::SurfaceEvent { event, window_id });
     }
 
     #[inline]
diff --git a/src/platform_impl/linux/x11/event_processor.rs b/src/platform_impl/linux/x11/event_processor.rs
index 9adbe07df3..fc1d557378 100644
--- a/src/platform_impl/linux/x11/event_processor.rs
+++ b/src/platform_impl/linux/x11/event_processor.rs
@@ -119,7 +119,7 @@ impl EventProcessor {
                 _ => continue,
             };
 
-            callback(&self.target, Event::WindowEvent { window_id, event });
+            callback(&self.target, Event::SurfaceEvent { window_id, event });
         }
     }
 
@@ -371,7 +371,7 @@ impl EventProcessor {
         let window_id = mkwid(window);
 
         if xev.data.get_long(0) as xproto::Atom == self.target.wm_delete_window {
-            let event = Event::WindowEvent { window_id, event: SurfaceEvent::CloseRequested };
+            let event = Event::SurfaceEvent { window_id, event: SurfaceEvent::CloseRequested };
             callback(&self.target, event);
             return;
         }
@@ -521,7 +521,7 @@ impl EventProcessor {
             let (source_window, state) = if let Some(source_window) = self.dnd.source_window {
                 if let Some(Ok(ref path_list)) = self.dnd.result {
                     for path in path_list {
-                        let event = Event::WindowEvent {
+                        let event = Event::SurfaceEvent {
                             window_id,
                             event: SurfaceEvent::DroppedFile(path.clone()),
                         };
@@ -548,7 +548,7 @@ impl EventProcessor {
 
         if xev.message_type == atoms[XdndLeave] as c_ulong {
             self.dnd.reset();
-            let event = Event::WindowEvent { window_id, event: SurfaceEvent::HoveredFileCancelled };
+            let event = Event::SurfaceEvent { window_id, event: SurfaceEvent::HoveredFileCancelled };
             callback(&self.target, event);
         }
     }
@@ -575,7 +575,7 @@ impl EventProcessor {
             let parse_result = self.dnd.parse_data(&mut data);
             if let Ok(ref path_list) = parse_result {
                 for path in path_list {
-                    let event = Event::WindowEvent {
+                    let event = Event::SurfaceEvent {
                         window_id,
                         event: SurfaceEvent::HoveredFile(path.clone()),
                     };
@@ -659,7 +659,7 @@ impl EventProcessor {
             if moved {
                 callback(
                     &self.target,
-                    Event::WindowEvent { window_id, event: SurfaceEvent::Moved(outer.into()) },
+                    Event::SurfaceEvent { window_id, event: SurfaceEvent::Moved(outer.into()) },
                 );
             }
             outer
@@ -708,7 +708,7 @@ impl EventProcessor {
                 let surface_size = Arc::new(Mutex::new(new_surface_size));
                 callback(
                     &self.target,
-                    Event::WindowEvent {
+                    Event::SurfaceEvent {
                         window_id,
                         event: SurfaceEvent::ScaleFactorChanged {
                             scale_factor: new_scale_factor,
@@ -769,7 +769,7 @@ impl EventProcessor {
         if resized {
             callback(
                 &self.target,
-                Event::WindowEvent {
+                Event::SurfaceEvent {
                     window_id,
                     event: SurfaceEvent::SurfaceResized(new_surface_size.into()),
                 },
@@ -803,7 +803,7 @@ impl EventProcessor {
         // window, given that we can't rely on `CreateNotify`, due to it being not
         // sent.
         let focus = self.with_window(window, |window| window.has_focus()).unwrap_or_default();
-        let event = Event::WindowEvent { window_id, event: SurfaceEvent::Focused(focus) };
+        let event = Event::SurfaceEvent { window_id, event: SurfaceEvent::Focused(focus) };
 
         callback(&self.target, event);
     }
@@ -827,7 +827,7 @@ impl EventProcessor {
                 .expect("Failed to destroy input context");
         }
 
-        callback(&self.target, Event::WindowEvent { window_id, event: SurfaceEvent::Destroyed });
+        callback(&self.target, Event::SurfaceEvent { window_id, event: SurfaceEvent::Destroyed });
     }
 
     fn property_notify<F>(&mut self, xev: &XPropertyEvent, mut callback: F)
@@ -850,7 +850,7 @@ impl EventProcessor {
     {
         let xwindow = xev.window as xproto::Window;
 
-        let event = Event::WindowEvent {
+        let event = Event::SurfaceEvent {
             window_id: mkwid(xwindow),
             event: SurfaceEvent::Occluded(xev.state == xlib::VisibilityFullyObscured),
         };
@@ -871,7 +871,7 @@ impl EventProcessor {
             let window = xev.window as xproto::Window;
             let window_id = mkwid(window);
 
-            let event = Event::WindowEvent { window_id, event: SurfaceEvent::RedrawRequested };
+            let event = Event::SurfaceEvent { window_id, event: SurfaceEvent::RedrawRequested };
 
             callback(&self.target, event);
         }
@@ -951,7 +951,7 @@ impl EventProcessor {
 
             if let Some(mut key_processor) = self.xkb_context.key_context() {
                 let event = key_processor.process_key_event(keycode, state, repeat);
-                let event = Event::WindowEvent {
+                let event = Event::SurfaceEvent {
                     window_id,
                     event: SurfaceEvent::KeyboardInput {
                         device_id: None,
@@ -975,14 +975,14 @@ impl EventProcessor {
         {
             let written = self.target.xconn.lookup_utf8(ic, xev);
             if !written.is_empty() {
-                let event = Event::WindowEvent {
+                let event = Event::SurfaceEvent {
                     window_id,
                     event: SurfaceEvent::Ime(Ime::Preedit(String::new(), None)),
                 };
                 callback(&self.target, event);
 
                 let event =
-                    Event::WindowEvent { window_id, event: SurfaceEvent::Ime(Ime::Commit(written)) };
+                    Event::SurfaceEvent { window_id, event: SurfaceEvent::Ime(Ime::Commit(written)) };
 
                 self.is_composing = false;
                 callback(&self.target, event);
@@ -1017,7 +1017,7 @@ impl EventProcessor {
         let mods: ModifiersState = xkb_state.modifiers().into();
 
         let event =
-            Event::WindowEvent { window_id, event: SurfaceEvent::ModifiersChanged(mods.into()) };
+            Event::SurfaceEvent { window_id, event: SurfaceEvent::ModifiersChanged(mods.into()) };
 
         callback(&self.target, event);
     }
@@ -1096,7 +1096,7 @@ impl EventProcessor {
             },
         };
 
-        let event = Event::WindowEvent { window_id, event };
+        let event = Event::SurfaceEvent { window_id, event };
         callback(&self.target, event);
     }
 
@@ -1120,7 +1120,7 @@ impl EventProcessor {
         if cursor_moved == Some(true) {
             let position = PhysicalPosition::new(event.event_x, event.event_y);
 
-            let event = Event::WindowEvent {
+            let event = Event::SurfaceEvent {
                 window_id,
                 event: SurfaceEvent::PointerMoved {
                     device_id,
@@ -1166,7 +1166,7 @@ impl EventProcessor {
                 };
 
                 let event = SurfaceEvent::MouseWheel { device_id, delta, phase: TouchPhase::Moved };
-                events.push(Event::WindowEvent { window_id, event });
+                events.push(Event::SurfaceEvent { window_id, event });
             }
 
             value = unsafe { value.offset(1) };
@@ -1209,7 +1209,7 @@ impl EventProcessor {
             let device_id = Some(device_id);
             let position = PhysicalPosition::new(event.event_x, event.event_y);
 
-            let event = Event::WindowEvent {
+            let event = Event::SurfaceEvent {
                 window_id,
                 event: SurfaceEvent::PointerEntered {
                     device_id,
@@ -1233,7 +1233,7 @@ impl EventProcessor {
         // Leave, FocusIn, and FocusOut can be received by a window that's already
         // been destroyed, which the user presumably doesn't want to deal with.
         if self.window_exists(window) {
-            let event = Event::WindowEvent {
+            let event = Event::SurfaceEvent {
                 window_id: mkwid(window),
                 event: SurfaceEvent::PointerLeft {
                     device_id: Some(mkdid(event.deviceid as xinput::DeviceId)),
@@ -1273,7 +1273,7 @@ impl EventProcessor {
             window.shared_state_lock().has_focus = true;
         }
 
-        let event = Event::WindowEvent { window_id, event: SurfaceEvent::Focused(true) };
+        let event = Event::SurfaceEvent { window_id, event: SurfaceEvent::Focused(true) };
         callback(&self.target, event);
 
         // Issue key press events for all pressed keys
@@ -1295,7 +1295,7 @@ impl EventProcessor {
             .get(&mkdid(xev.deviceid as xinput::DeviceId))
             .map(|device| mkdid(device.attachment as xinput::DeviceId));
 
-        let event = Event::WindowEvent {
+        let event = Event::SurfaceEvent {
             window_id,
             event: SurfaceEvent::PointerMoved { device_id, position, source: PointerSource::Mouse },
         };
@@ -1348,7 +1348,7 @@ impl EventProcessor {
                 window.shared_state_lock().has_focus = false;
             }
 
-            let event = Event::WindowEvent { window_id, event: SurfaceEvent::Focused(false) };
+            let event = Event::SurfaceEvent { window_id, event: SurfaceEvent::Focused(false) };
             callback(&self.target, event)
         }
     }
@@ -1369,7 +1369,7 @@ impl EventProcessor {
             // Mouse cursor position changes when touch events are received.
             // Only the first concurrently active touch ID moves the mouse cursor.
             if is_first_touch(&mut self.first_touch, &mut self.num_touch, id, phase) {
-                let event = Event::WindowEvent {
+                let event = Event::SurfaceEvent {
                     window_id,
                     event: SurfaceEvent::PointerMoved {
                         device_id: None,
@@ -1385,7 +1385,7 @@ impl EventProcessor {
 
             match phase {
                 xinput2::XI_TouchBegin => {
-                    let event = Event::WindowEvent {
+                    let event = Event::SurfaceEvent {
                         window_id,
                         event: SurfaceEvent::PointerEntered {
                             device_id,
@@ -1394,7 +1394,7 @@ impl EventProcessor {
                         },
                     };
                     callback(&self.target, event);
-                    let event = Event::WindowEvent {
+                    let event = Event::SurfaceEvent {
                         window_id,
                         event: SurfaceEvent::PointerButton {
                             device_id,
@@ -1406,7 +1406,7 @@ impl EventProcessor {
                     callback(&self.target, event);
                 },
                 xinput2::XI_TouchUpdate => {
-                    let event = Event::WindowEvent {
+                    let event = Event::SurfaceEvent {
                         window_id,
                         event: SurfaceEvent::PointerMoved {
                             device_id,
@@ -1417,7 +1417,7 @@ impl EventProcessor {
                     callback(&self.target, event);
                 },
                 xinput2::XI_TouchEnd => {
-                    let event = Event::WindowEvent {
+                    let event = Event::SurfaceEvent {
                         window_id,
                         event: SurfaceEvent::PointerButton {
                             device_id,
@@ -1427,7 +1427,7 @@ impl EventProcessor {
                         },
                     };
                     callback(&self.target, event);
-                    let event = Event::WindowEvent {
+                    let event = Event::SurfaceEvent {
                         window_id,
                         event: SurfaceEvent::PointerLeft {
                             device_id,
@@ -1777,7 +1777,7 @@ impl EventProcessor {
         // NOTE: Always update the modifiers to account for case when they've changed
         // and forced was `true`.
         if self.modifiers.replace(modifiers) != modifiers || force {
-            let event = Event::WindowEvent {
+            let event = Event::SurfaceEvent {
                 window_id,
                 event: SurfaceEvent::ModifiersChanged(self.modifiers.get().into()),
             };
@@ -1814,7 +1814,7 @@ impl EventProcessor {
 
         for keycode in target.xconn.query_keymap().into_iter().filter(|k| *k >= KEYCODE_OFFSET) {
             let event = key_processor.process_key_event(keycode as u32, state, false);
-            let event = Event::WindowEvent {
+            let event = Event::SurfaceEvent {
                 window_id,
                 event: SurfaceEvent::KeyboardInput { device_id: None, event, is_synthetic: true },
             };
diff --git a/src/platform_impl/linux/x11/mod.rs b/src/platform_impl/linux/x11/mod.rs
index a1d2099cc7..61609eb0e0 100644
--- a/src/platform_impl/linux/x11/mod.rs
+++ b/src/platform_impl/linux/x11/mod.rs
@@ -574,12 +574,12 @@ impl EventLoop {
         while unsafe { self.event_processor.poll_one_event(xev.as_mut_ptr()) } {
             let mut xev = unsafe { xev.assume_init() };
             self.event_processor.process_event(&mut xev, |window_target, event: Event| {
-                if let Event::WindowEvent { window_id, event: SurfaceEvent::RedrawRequested } = event
+                if let Event::SurfaceEvent { window_id, event: SurfaceEvent::RedrawRequested } = event
                 {
                     window_target.redraw_sender.send(window_id);
                 } else {
                     match event {
-                        Event::WindowEvent { window_id, event } => {
+                        Event::SurfaceEvent { window_id, event } => {
                             app.window_event(window_target, window_id, event)
                         },
                         Event::DeviceEvent { device_id, event } => {
diff --git a/src/platform_impl/linux/x11/window.rs b/src/platform_impl/linux/x11/window.rs
index e22fb2a4d4..d5bb7ca213 100644
--- a/src/platform_impl/linux/x11/window.rs
+++ b/src/platform_impl/linux/x11/window.rs
@@ -1232,7 +1232,7 @@ impl UnownedWindow {
 
             let old_surface_size = PhysicalSize::new(width, height);
             let surface_size = Arc::new(Mutex::new(PhysicalSize::new(new_width, new_height)));
-            callback(Event::WindowEvent {
+            callback(Event::SurfaceEvent {
                 window_id: self.id(),
                 event: SurfaceEvent::ScaleFactorChanged {
                     scale_factor: new_monitor.scale_factor,
diff --git a/src/platform_impl/web/event_loop/mod.rs b/src/platform_impl/web/event_loop/mod.rs
index 9c13266814..306427b511 100644
--- a/src/platform_impl/web/event_loop/mod.rs
+++ b/src/platform_impl/web/event_loop/mod.rs
@@ -90,7 +90,7 @@ impl EventLoop {
 fn handle_event<A: ApplicationHandler>(app: &mut A, target: &ActiveEventLoop, event: Event) {
     match event {
         Event::NewEvents(cause) => app.new_events(target, cause),
-        Event::WindowEvent { window_id, event } => app.window_event(target, window_id, event),
+        Event::SurfaceEvent { window_id, event } => app.window_event(target, window_id, event),
         Event::DeviceEvent { device_id, event } => app.device_event(target, device_id, event),
         Event::UserWakeUp => app.proxy_wake_up(target),
         Event::Suspended => app.suspended(target),
diff --git a/src/platform_impl/web/event_loop/runner.rs b/src/platform_impl/web/event_loop/runner.rs
index 8709a0e5c1..fdf0bdff9d 100644
--- a/src/platform_impl/web/event_loop/runner.rs
+++ b/src/platform_impl/web/event_loop/runner.rs
@@ -421,7 +421,7 @@ impl Shared {
                             if let (false, Some(true) | None) | (true, Some(true)) =
                                 (is_visible, canvas.is_intersecting.get())
                             {
-                                runner.send_event(Event::WindowEvent {
+                                runner.send_event(Event::SurfaceEvent {
                                     window_id: *id,
                                     event: SurfaceEvent::Occluded(!is_visible),
                                 });
@@ -566,7 +566,7 @@ impl Shared {
     fn process_destroy_pending_windows(&self) {
         while let Some(id) = self.0.destroy_pending.borrow_mut().pop_front() {
             self.0.all_canvases.borrow_mut().retain(|&(item_id, ..)| item_id != id);
-            self.handle_event(Event::WindowEvent {
+            self.handle_event(Event::SurfaceEvent {
                 window_id: id,
                 event: crate::event::SurfaceEvent::Destroyed,
             });
@@ -587,7 +587,7 @@ impl Shared {
         // Collect all of the redraw events to avoid double-locking the RefCell
         let redraw_events: Vec<SurfaceId> = self.0.redraw_pending.borrow_mut().drain().collect();
         for window_id in redraw_events {
-            self.handle_event(Event::WindowEvent {
+            self.handle_event(Event::SurfaceEvent {
                 window_id,
                 event: SurfaceEvent::RedrawRequested,
             });
diff --git a/src/platform_impl/web/event_loop/window_target.rs b/src/platform_impl/web/event_loop/window_target.rs
index 46d4df8c52..c799e9d13c 100644
--- a/src/platform_impl/web/event_loop/window_target.rs
+++ b/src/platform_impl/web/event_loop/window_target.rs
@@ -83,13 +83,13 @@ impl ActiveEventLoop {
 
             let clear_modifiers = (!modifiers.get().is_empty()).then(|| {
                 modifiers.set(ModifiersState::empty());
-                Event::WindowEvent {
+                Event::SurfaceEvent {
                     window_id,
                     event: SurfaceEvent::ModifiersChanged(ModifiersState::empty().into()),
                 }
             });
 
-            runner.send_events(clear_modifiers.into_iter().chain(iter::once(Event::WindowEvent {
+            runner.send_events(clear_modifiers.into_iter().chain(iter::once(Event::SurfaceEvent {
                 window_id,
                 event: SurfaceEvent::Focused(false),
             })));
@@ -99,7 +99,7 @@ impl ActiveEventLoop {
         let has_focus = canvas.has_focus.clone();
         canvas.on_focus(move || {
             if !has_focus.replace(true) {
-                runner.send_event(Event::WindowEvent {
+                runner.send_event(Event::SurfaceEvent {
                     window_id,
                     event: SurfaceEvent::Focused(true),
                 });
@@ -120,7 +120,7 @@ impl ActiveEventLoop {
         if focused {
             canvas.has_focus.set(true);
             self.runner
-                .send_event(Event::WindowEvent { window_id, event: SurfaceEvent::Focused(true) })
+                .send_event(Event::SurfaceEvent { window_id, event: SurfaceEvent::Focused(true) })
         }
 
         let runner = self.runner.clone();
@@ -129,14 +129,14 @@ impl ActiveEventLoop {
             move |physical_key, logical_key, text, location, repeat, active_modifiers| {
                 let modifiers_changed = (modifiers.get() != active_modifiers).then(|| {
                     modifiers.set(active_modifiers);
-                    Event::WindowEvent {
+                    Event::SurfaceEvent {
                         window_id,
                         event: SurfaceEvent::ModifiersChanged(active_modifiers.into()),
                     }
                 });
 
                 runner.send_events(
-                    iter::once(Event::WindowEvent {
+                    iter::once(Event::SurfaceEvent {
                         window_id,
                         event: SurfaceEvent::KeyboardInput {
                             device_id: None,
@@ -163,14 +163,14 @@ impl ActiveEventLoop {
             move |physical_key, logical_key, text, location, repeat, active_modifiers| {
                 let modifiers_changed = (modifiers.get() != active_modifiers).then(|| {
                     modifiers.set(active_modifiers);
-                    Event::WindowEvent {
+                    Event::SurfaceEvent {
                         window_id,
                         event: SurfaceEvent::ModifiersChanged(active_modifiers.into()),
                     }
                 });
 
                 runner.send_events(
-                    iter::once(Event::WindowEvent {
+                    iter::once(Event::SurfaceEvent {
                         window_id,
                         event: SurfaceEvent::KeyboardInput {
                             device_id: None,
@@ -200,13 +200,13 @@ impl ActiveEventLoop {
             move |active_modifiers, device_id, position, kind| {
                 let focus = (has_focus.get() && modifiers.get() != active_modifiers).then(|| {
                     modifiers.set(active_modifiers);
-                    Event::WindowEvent {
+                    Event::SurfaceEvent {
                         window_id,
                         event: SurfaceEvent::ModifiersChanged(active_modifiers.into()),
                     }
                 });
 
-                runner.send_events(focus.into_iter().chain(iter::once(Event::WindowEvent {
+                runner.send_events(focus.into_iter().chain(iter::once(Event::SurfaceEvent {
                     window_id,
                     event: SurfaceEvent::PointerLeft { device_id, position: Some(position), kind },
                 })))
@@ -221,13 +221,13 @@ impl ActiveEventLoop {
             move |active_modifiers, device_id, position, kind| {
                 let focus = (has_focus.get() && modifiers.get() != active_modifiers).then(|| {
                     modifiers.set(active_modifiers);
-                    Event::WindowEvent {
+                    Event::SurfaceEvent {
                         window_id,
                         event: SurfaceEvent::ModifiersChanged(active_modifiers.into()),
                     }
                 });
 
-                runner.send_events(focus.into_iter().chain(iter::once(Event::WindowEvent {
+                runner.send_events(focus.into_iter().chain(iter::once(Event::SurfaceEvent {
                     window_id,
                     event: SurfaceEvent::PointerEntered { device_id, position, kind },
                 })))
@@ -245,13 +245,13 @@ impl ActiveEventLoop {
                         let modifiers = (has_focus.get() && modifiers.get() != active_modifiers)
                             .then(|| {
                                 modifiers.set(active_modifiers);
-                                Event::WindowEvent {
+                                Event::SurfaceEvent {
                                     window_id,
                                     event: SurfaceEvent::ModifiersChanged(active_modifiers.into()),
                                 }
                             });
 
-                        modifiers.into_iter().chain(iter::once(Event::WindowEvent {
+                        modifiers.into_iter().chain(iter::once(Event::SurfaceEvent {
                             window_id,
                             event: SurfaceEvent::PointerMoved { device_id, position, source },
                         }))
@@ -267,13 +267,13 @@ impl ActiveEventLoop {
                     let modifiers =
                         (has_focus.get() && modifiers.get() != active_modifiers).then(|| {
                             modifiers.set(active_modifiers);
-                            Event::WindowEvent {
+                            Event::SurfaceEvent {
                                 window_id,
                                 event: SurfaceEvent::ModifiersChanged(active_modifiers.into()),
                             }
                         });
 
-                    runner.send_events(modifiers.into_iter().chain([Event::WindowEvent {
+                    runner.send_events(modifiers.into_iter().chain([Event::SurfaceEvent {
                         window_id,
                         event: SurfaceEvent::PointerButton { device_id, state, position, button },
                     }]));
@@ -288,13 +288,13 @@ impl ActiveEventLoop {
             move |active_modifiers, device_id, position, button| {
                 let modifiers = (modifiers.get() != active_modifiers).then(|| {
                     modifiers.set(active_modifiers);
-                    Event::WindowEvent {
+                    Event::SurfaceEvent {
                         window_id,
                         event: SurfaceEvent::ModifiersChanged(active_modifiers.into()),
                     }
                 });
 
-                runner.send_events(modifiers.into_iter().chain(iter::once(Event::WindowEvent {
+                runner.send_events(modifiers.into_iter().chain(iter::once(Event::SurfaceEvent {
                     window_id,
                     event: SurfaceEvent::PointerButton {
                         device_id,
@@ -315,13 +315,13 @@ impl ActiveEventLoop {
                 let modifiers =
                     (has_focus.get() && modifiers.get() != active_modifiers).then(|| {
                         modifiers.set(active_modifiers);
-                        Event::WindowEvent {
+                        Event::SurfaceEvent {
                             window_id,
                             event: SurfaceEvent::ModifiersChanged(active_modifiers.into()),
                         }
                     });
 
-                runner.send_events(modifiers.into_iter().chain(iter::once(Event::WindowEvent {
+                runner.send_events(modifiers.into_iter().chain(iter::once(Event::SurfaceEvent {
                     window_id,
                     event: SurfaceEvent::PointerButton {
                         device_id,
@@ -339,14 +339,14 @@ impl ActiveEventLoop {
             let modifiers_changed =
                 (has_focus.get() && modifiers.get() != active_modifiers).then(|| {
                     modifiers.set(active_modifiers);
-                    Event::WindowEvent {
+                    Event::SurfaceEvent {
                         window_id,
                         event: SurfaceEvent::ModifiersChanged(active_modifiers.into()),
                     }
                 });
 
             runner.send_events(modifiers_changed.into_iter().chain(iter::once(
-                Event::WindowEvent {
+                Event::SurfaceEvent {
                     window_id,
                     event: SurfaceEvent::MouseWheel {
                         device_id: None,
@@ -360,7 +360,7 @@ impl ActiveEventLoop {
         let runner = self.runner.clone();
         canvas.on_dark_mode(move |is_dark_mode| {
             let theme = if is_dark_mode { Theme::Dark } else { Theme::Light };
-            runner.send_event(Event::WindowEvent {
+            runner.send_event(Event::SurfaceEvent {
                 window_id,
                 event: SurfaceEvent::ThemeChanged(theme),
             });
@@ -387,7 +387,7 @@ impl ActiveEventLoop {
                     canvas.set_current_size(new_size);
                     if canvas.old_size() != new_size {
                         canvas.set_old_size(new_size);
-                        runner.send_event(Event::WindowEvent {
+                        runner.send_event(Event::SurfaceEvent {
                             window_id,
                             event: SurfaceEvent::SurfaceResized(new_size),
                         });
@@ -403,7 +403,7 @@ impl ActiveEventLoop {
             if backend::is_visible(runner.document())
                 && !(is_intersecting && canvas_clone.is_intersecting.get().is_none())
             {
-                runner.send_event(Event::WindowEvent {
+                runner.send_event(Event::SurfaceEvent {
                     window_id,
                     event: SurfaceEvent::Occluded(!is_intersecting),
                 });
diff --git a/src/platform_impl/web/web_sys/canvas.rs b/src/platform_impl/web/web_sys/canvas.rs
index 3fedb945a8..80c36bfccf 100644
--- a/src/platform_impl/web/web_sys/canvas.rs
+++ b/src/platform_impl/web/web_sys/canvas.rs
@@ -488,7 +488,7 @@ impl Canvas {
         self.set_current_size(current_size);
         let new_size = {
             let new_size = Arc::new(Mutex::new(current_size));
-            event_handler(crate::event::Event::WindowEvent {
+            event_handler(crate::event::Event::SurfaceEvent {
                 window_id: self.id,
                 event: crate::event::SurfaceEvent::ScaleFactorChanged {
                     scale_factor: scale,
@@ -516,7 +516,7 @@ impl Canvas {
         } else if self.old_size() != new_size {
             // Then we at least send a resized event.
             self.set_old_size(new_size);
-            runner.send_event(crate::event::Event::WindowEvent {
+            runner.send_event(crate::event::Event::SurfaceEvent {
                 window_id: self.id,
                 event: crate::event::SurfaceEvent::SurfaceResized(new_size),
             })