wayland/x11: Make ControlFlow::Exit sticky

felixrabe · Apr 18, 2019 · 7933209 · 7933209
1 parent 8355a75
commit 7933209
Show file tree

Hide file tree

Showing 2 changed files with 88 additions and 13 deletions.
diff --git a/src/platform_impl/linux/wayland/event_loop.rs b/src/platform_impl/linux/wayland/event_loop.rs
@@ -204,23 +204,63 @@ impl<T: 'static> EventLoop<T> {
             // empty buffer of events
             {
                 let mut guard = sink.lock().unwrap();
-                guard.empty_with(|evt| callback(evt, &self.window_target, &mut control_flow));
+                guard.empty_with(|evt| {
+                    // make ControlFlow::Exit sticky by providing a dummy
+                    // control flow reference if it is already Exit.
+                    let mut dummy = ControlFlow::Exit;
+                    let cf = if control_flow == ControlFlow::Exit {
+                        &mut dummy
+                    } else {
+                        &mut control_flow
+                    };
+                    // user callback
+                    callback(evt, &self.window_target, cf)
+                });
             }
             // empty user events
             {
                 let mut guard = user_events.borrow_mut();
                 for evt in guard.drain(..) {
-                    callback(::event::Event::UserEvent(evt), &self.window_target, &mut control_flow);
+                    // make ControlFlow::Exit sticky by providing a dummy
+                    // control flow reference if it is already Exit.
+                    let mut dummy = ControlFlow::Exit;
+                    let cf = if control_flow == ControlFlow::Exit {
+                        &mut dummy
+                    } else {
+                        &mut control_flow
+                    };
+                    // user callback
+                    callback(::event::Event::UserEvent(evt), &self.window_target, cf);
                 }
             }
-
-            callback(::event::Event::EventsCleared, &self.window_target, &mut control_flow);
-
-            // fo a second run of post-dispatch-triggers, to handle user-generated "request-redraw"
+            // send Events cleared
+            {
+                // make ControlFlow::Exit sticky
+                let mut dummy = ControlFlow::Exit;
+                let cf = if control_flow == ControlFlow::Exit {
+                    &mut dummy
+                } else {
+                    &mut control_flow
+                };
+                // user callback
+                callback(::event::Event::EventsCleared, &self.window_target, cf);
+            }
+            // do a second run of post-dispatch-triggers, to handle user-generated "request-redraw"
             self.post_dispatch_triggers();
             {
                 let mut guard = sink.lock().unwrap();
-                guard.empty_with(|evt| callback(evt, &self.window_target, &mut control_flow));
+                guard.empty_with(|evt| {
+                    // make ControlFlow::Exit sticky by providing a dummy
+                    // control flow reference if it is already Exit.
+                    let mut dummy = ControlFlow::Exit;
+                    let cf = if control_flow == ControlFlow::Exit {
+                        &mut dummy
+                    } else {
+                        &mut control_flow
+                    };
+                    // user callback
+                    callback(evt, &self.window_target, cf)
+                });
             }
 
             // send pending events to the server

diff --git a/src/platform_impl/linux/x11/mod.rs b/src/platform_impl/linux/x11/mod.rs
@@ -232,29 +232,64 @@ impl<T: 'static> EventLoop<T> {
             {
                 let mut guard = self.pending_events.borrow_mut();
                 for evt in guard.drain(..) {
-                    callback(evt, &self.target, &mut control_flow);
+                    // make ControlFlow::Exit sticky by providing a dummy
+                    // control flow reference if it is already Exit.
+                    let mut dummy = ControlFlow::Exit;
+                    let cf = if control_flow == ControlFlow::Exit {
+                        &mut dummy
+                    } else {
+                        &mut control_flow
+                    };
+                    // user callback
+                    callback(evt, &self.target, cf);
                 }
             }
             // Empty the user event buffer
             {
                 let mut guard = self.pending_user_events.borrow_mut();
                 for evt in guard.drain(..) {
-                    callback(::event::Event::UserEvent(evt), &self.target, &mut control_flow);
+                    // make ControlFlow::Exit sticky
+                    let mut dummy = ControlFlow::Exit;
+                    let cf = if control_flow == ControlFlow::Exit {
+                        &mut dummy
+                    } else {
+                        &mut control_flow
+                    };
+                    // user callback
+                    callback(::event::Event::UserEvent(evt), &self.target, cf);
                 }
             }
-
-            callback(::event::Event::EventsCleared, &self.target, &mut control_flow);
-            // Empty th redraw requests
+            // send Events cleared
+            {
+                // make ControlFlow::Exit sticky
+                let mut dummy = ControlFlow::Exit;
+                let cf = if control_flow == ControlFlow::Exit {
+                    &mut dummy
+                } else {
+                    &mut control_flow
+                };
+                // user callback
+                callback(::event::Event::EventsCleared, &self.target, cf);
+            }
+            // Empty the redraw requests
             {
                 let mut guard = wt.pending_redraws.lock().unwrap();
                 for wid in guard.drain(..) {
+                    // make ControlFlow::Exit sticky
+                    let mut dummy = ControlFlow::Exit;
+                    let cf = if control_flow == ControlFlow::Exit {
+                        &mut dummy
+                    } else {
+                        &mut control_flow
+                    };
+                    // user callback
                     callback(
                         Event::WindowEvent {
                             window_id: ::window::WindowId(super::WindowId::X(wid)),
                             event: WindowEvent::RedrawRequested
                         },
                         &self.target,
-                        &mut control_flow
+                        cf
                     );
                 }
             }