Add Window::on_present_notify to ack about drawing

That's a way to communicate to winit that you'll present to the window.
While it's a no-op for now, it'll be used to throttle drawing.

CHANGELOG.md

@@ -8,6 +8,7 @@ And please only add new entries to the top of this list, right below the `# Unre
 
 # Unreleased
 
+- Add `Window::pre_present_notify` to notify winit before presenting to the windowing system.
 - On Windows, added `WindowBuilderExtWindows::with_class_name` to customize the internal class name.
 - **Breaking:** Remove lifetime parameter from `Event` and `WindowEvent`.
 - **Breaking:** `ScaleFactorChanged` now contains a writer instead of a reference to update inner size.

examples/window.rs

@@ -33,6 +33,8 @@ fn main() -> Result<(), impl std::error::Error> {
                 window.request_redraw();
             }
             Event::RedrawRequested(_) => {
+                // Notify the windowing system that we'll be presenting to the window.
+                window.pre_present_notify();
                 fill::fill_window(&window);
             }
             _ => (),

src/platform_impl/android/mod.rs

@@ -813,6 +813,8 @@ impl Window {
         self.redraw_requester.request_redraw()
     }
 
+    pub fn pre_present_notify(&self) {}
+
     pub fn inner_position(&self) -> Result<PhysicalPosition<i32>, error::NotSupportedError> {
         Err(error::NotSupportedError::new())
     }

src/platform_impl/ios/window.rs

@@ -74,6 +74,8 @@ impl Inner {
         }
     }
 
+    pub fn pre_present_notify(&self) {}
+
     pub fn inner_position(&self) -> Result<PhysicalPosition<i32>, NotSupportedError> {
         unsafe {
             let safe_area = self.safe_area_screen_space();

src/platform_impl/linux/mod.rs

@@ -555,12 +555,7 @@ impl Window {
         }
     }
     pub fn request_user_attention(&self, request_type: Option<UserAttentionType>) {
-        match self {
+        x11_or_wayland!(match self; Window(w) => w.request_user_attention(request_type))
-            #[cfg(x11_platform)]
-            Window::X(ref w) => w.request_user_attention(request_type),
-            #[cfg(wayland_platform)]
-            Window::Wayland(ref w) => w.request_user_attention(request_type),
-        }
     }
 
     #[inline]
@@ -568,6 +563,11 @@ impl Window {
         x11_or_wayland!(match self; Window(w) => w.request_redraw())
     }
 
+    #[inline]
+    pub fn pre_present_notify(&self) {
+        x11_or_wayland!(match self; Window(w) => w.pre_present_notify())
+    }
+
     #[inline]
     pub fn current_monitor(&self) -> Option<MonitorHandle> {
         match self {

src/platform_impl/linux/wayland/window/mod.rs

@@ -293,6 +293,11 @@ impl Window {
         self.event_loop_awakener.ping();
     }
 
+    #[inline]
+    pub fn pre_present_notify(&self) {
+        // TODO
+    }
+
     #[inline]
     pub fn outer_size(&self) -> PhysicalSize<u32> {
         let window_state = self.window_state.lock().unwrap();

src/platform_impl/linux/x11/window.rs

@@ -1731,6 +1731,11 @@ impl UnownedWindow {
             .unwrap();
     }
 
+    #[inline]
+    pub fn pre_present_notify(&self) {
+        // TODO timer
+    }
+
     #[inline]
     pub fn raw_window_handle(&self) -> RawWindowHandle {
         let mut window_handle = XlibWindowHandle::empty();

src/platform_impl/macos/window.rs

@@ -569,6 +569,9 @@ impl WinitWindow {
         AppState::queue_redraw(RootWindowId(self.id()));
     }
 
+    #[inline]
+    pub fn pre_present_notify(&self) {}
+
     pub fn outer_position(&self) -> Result<PhysicalPosition<i32>, NotSupportedError> {
         let frame_rect = self.frame();
         let position = LogicalPosition::new(

src/platform_impl/orbital/window.rs

@@ -166,6 +166,9 @@ impl Window {
         }
     }
 
+    #[inline]
+    pub fn pre_present_notify(&self) {}
+
     #[inline]
     pub fn reset_dead_keys(&self) {
         // TODO?

src/platform_impl/web/window.rs

@@ -114,6 +114,8 @@ impl Window {
             .dispatch(|inner| (inner.register_redraw_request)());
     }
 
+    pub fn pre_present_notify(&self) {}
+
     pub fn outer_position(&self) -> Result<PhysicalPosition<i32>, NotSupportedError> {
         self.inner.queue(|inner| {
             Ok(inner

src/platform_impl/windows/window.rs

@@ -142,6 +142,9 @@ impl Window {
         }
     }
 
+    #[inline]
+    pub fn pre_present_notify(&self) {}
+
     #[inline]
     pub fn outer_position(&self) -> Result<PhysicalPosition<i32>, NotSupportedError> {
         util::WindowArea::Outer.get_rect(self.hwnd())

src/window.rs

@@ -548,6 +548,43 @@ impl Window {
         self.window.request_redraw()
     }
 
+    /// Notify the windowing system that you're before presenting to the window.
+    ///
+    /// You should call this event after you've done drawing operations, but before you submit
+    /// the buffer to the display or commit your drawings. Doing so will help winit to properly
+    /// schedule and do assumptions about its internal state. For example, it could properly
+    /// throttle [`Event::RedrawRequested`].
+    ///
+    /// ## Example
+    ///
+    /// This example illustrates how it looks with OpenGL, but it applies to other graphics
+    /// APIs and software rendering.
+    ///
+    /// ```no_run
+    /// # use winit::event_loop::EventLoop;
+    /// # use winit::window::Window;
+    /// # let mut event_loop = EventLoop::new();
+    /// # let window = Window::new(&event_loop).unwrap();
+    /// # fn swap_buffers() {}
+    /// // Do the actual drawing with OpenGL.
+    ///
+    /// // Notify winit that we're about to submit buffer to the windowing system.
+    /// window.pre_present_notify();
+    ///
+    /// // Sumbit buffer to the windowing system.
+    /// swap_buffers();
+    /// ```
+    ///
+    /// ## Platform-specific
+    ///
+    /// **Wayland:** - schedules a frame callback to throttle [`Event::RedrawRequested`].
+    ///
+    /// [`Event::RedrawRequested`]: crate::event::Event::RedrawRequested
+    #[inline]
+    pub fn pre_present_notify(&self) {
+        self.window.pre_present_notify();
+    }
+
     /// Reset the dead key state of the keyboard.
     ///
     /// This is useful when a dead key is bound to trigger an action. Then