src/app.rs

@@ -130,19 +130,23 @@ impl ApplicationHandler<UserEvent> for Application {
             return;
         };
         let viewport_id = viewport.id();
-        match &event {
+        let mut queue_redraw = false;
+        let mut inactive_viewports = HashSet::new();
+        let (consumed, action) = viewport.on_window_event(&event);
+        if !consumed {
+            match event {
                 WindowEvent::KeyboardInput { event, .. } => {
-                self.controllers.handle_key_event(event);
+                    if !viewport.app.handle_key_event(&event) {
-                viewport.app.handle_key_event(event);
+                        self.controllers.handle_key_event(&event);
+                    }
                 }
                 WindowEvent::Focused(new_focused) => {
                     self.focused = new_focused.then_some(viewport_id);
                 }
                 _ => {}
             }
-        let mut queue_redraw = false;
+        }
-        let mut inactive_viewports = HashSet::new();
+        match action {
-        match viewport.on_window_event(event) {
             Some(Action::Redraw) => {
                 for viewport in self.viewports.values_mut() {
                     match viewport.redraw(event_loop) {
@@ -194,15 +198,16 @@ impl ApplicationHandler<UserEvent> for Application {
     fn user_event(&mut self, event_loop: &ActiveEventLoop, event: UserEvent) {
         match event {
             UserEvent::GamepadEvent(event) => {
-                self.controllers.handle_gamepad_event(&event);
+                if let Some(viewport) = self
-                let Some(viewport) = self
                     .focused
                     .as_ref()
                     .and_then(|id| self.viewports.get_mut(id))
-                else {
+                {
+                    if viewport.app.handle_gamepad_event(&event) {
                         return;
-                };
+                    }
-                viewport.app.handle_gamepad_event(&event);
+                }
+                self.controllers.handle_gamepad_event(&event);
             }
             UserEvent::OpenAbout => {
                 let about = AboutWindow;
@@ -388,8 +393,8 @@ impl Viewport {
         self.app.viewport_id()
     }
 
-    pub fn on_window_event(&mut self, event: WindowEvent) -> Option<Action> {
+    pub fn on_window_event(&mut self, event: &WindowEvent) -> (bool, Option<Action>) {
-        let response = self.state.on_window_event(&self.window, &event);
+        let response = self.state.on_window_event(&self.window, event);
         egui_winit::update_viewport_info(
             &mut self.info,
             self.state.egui_ctx(),
@@ -397,22 +402,22 @@ impl Viewport {
             false,
         );
 
-        match event {
+        let action = match event {
             WindowEvent::RedrawRequested => Some(Action::Redraw),
             WindowEvent::CloseRequested => Some(Action::Close),
             WindowEvent::Resized(size) => {
-                let (Some(width), Some(height)) =
+                if let (Some(width), Some(height)) =
                     (NonZero::new(size.width), NonZero::new(size.height))
-                else {
+                {
-                    return None;
-                };
                     self.painter
                         .on_window_resized(ViewportId::ROOT, width, height);
+                }
                 None
             }
             _ if response.repaint => Some(Action::Redraw),
             _ => None,
-        }
+        };
+        (response.consumed, action)
     }
 
     fn redraw(&mut self, event_loop: &ActiveEventLoop) -> Option<Action> {

src/window.rs

@@ -28,10 +28,12 @@ pub trait AppWindow {
         let _ = render_state;
     }
     fn on_destroy(&mut self) {}
-    fn handle_key_event(&mut self, event: &KeyEvent) {
+    fn handle_key_event(&mut self, event: &KeyEvent) -> bool {
         let _ = event;
+        false
     }
-    fn handle_gamepad_event(&mut self, event: &gilrs::Event) {
+    fn handle_gamepad_event(&mut self, event: &gilrs::Event) -> bool {
         let _ = event;
+        false
     }
 }

src/window/input.rs

@@ -198,58 +198,63 @@ impl AppWindow for InputWindow {
         });
     }
 
-    fn handle_key_event(&mut self, event: &winit::event::KeyEvent) {
+    fn handle_key_event(&mut self, event: &winit::event::KeyEvent) -> bool {
         if !event.state.is_pressed() {
-            return;
+            return false;
         }
         let sim_id = match self.active_tab {
             InputTab::Player1 => SimId::Player1,
             InputTab::Player2 => SimId::Player2,
             _ => {
-                return;
+                return false;
             }
         };
         let Some(vb) = self.now_binding.take() else {
-            return;
+            return false;
         };
         let mut mappings = self.mappings.for_sim(sim_id).write().unwrap();
         mappings.add_keyboard_mapping(vb, event.physical_key);
         drop(mappings);
         self.mappings.save();
+        true
     }
 
-    fn handle_gamepad_event(&mut self, event: &gilrs::Event) {
+    fn handle_gamepad_event(&mut self, event: &gilrs::Event) -> bool {
         let InputTab::RebindGamepad(gamepad_id) = self.active_tab else {
-            return;
+            return false;
         };
         if gamepad_id != event.id {
-            return;
+            return false;
         }
         let Some(mappings) = self.mappings.for_gamepad(gamepad_id) else {
-            return;
+            return false;
         };
         let Some(vb) = self.now_binding else {
-            return;
+            return false;
         };
         match event.event {
             EventType::ButtonPressed(_, code) => {
                 let mut mapping = mappings.write().unwrap();
                 mapping.add_button_mapping(vb, code);
                 self.now_binding.take();
+                true
             }
             EventType::AxisChanged(_, value, code) => {
                 if value < -0.75 {
                     let mut mapping = mappings.write().unwrap();
                     mapping.add_axis_neg_mapping(vb, code);
                     self.now_binding.take();
-                }
+                    true
-                if value > 0.75 {
+                } else if value > 0.75 {
                     let mut mapping = mappings.write().unwrap();
                     mapping.add_axis_pos_mapping(vb, code);
                     self.now_binding.take();
+                    true
+                } else {
+                    false
                 }
             }
-            _ => {}
+            _ => false,
         }
     }
 }