X11 impl

Author: prokopyl

examples/open_window/src/main.rs

@@ -1,5 +1,6 @@
 use std::cell::{Cell, RefCell};
 use std::num::NonZeroU32;
+use std::thread;
 use std::time::Duration;
 
 use rtrb::{Consumer, RingBuffer};
@@ -8,8 +9,8 @@ use rtrb::{Consumer, RingBuffer};
 use baseview::copy_to_clipboard;
 use baseview::dpi::{LogicalSize, PhysicalPosition};
 use baseview::{
-    Event, EventStatus, HandlerError, MouseEvent, Window, WindowContext, WindowHandler,
-    WindowSettings, WindowSize,
+    Event, EventStatus, HandlerError, MouseEvent, Notification, Window, WindowContext,
+    WindowHandler, WindowSettings, WindowSize,
 };
 
 #[derive(Debug, Clone)]
@@ -46,6 +47,8 @@ impl WindowHandler for OpenWindowExample {
             return Ok(());
         }
 
+        eprintln!("Redraw!");
+
         let mut surface = self.surface.borrow_mut();
         let mut pixels = surface.buffer_mut()?;
         let size = self.window_context.size();
@@ -137,6 +140,14 @@ impl WindowHandler for OpenWindowExample {
 
         EventStatus::Captured
     }
+
+    fn notify(&self, notification: Notification) -> Result<(), HandlerError> {
+        if let Notification::Shown = notification {
+            self.damaged.set(true);
+        }
+
+        Ok(())
+    }
 }
 
 fn main() -> Result<(), baseview::Error> {
@@ -152,7 +163,7 @@ fn main() -> Result<(), baseview::Error> {
         }
     });
 
-    Window::create(window_open_options, |window| {
+    let w = Window::create(window_open_options, |window| {
         let ctx = softbuffer::Context::new(window.clone())?;
         let mut surface = softbuffer::Surface::new(&ctx, window.clone())?;
         let size = window.size().physical;
@@ -166,8 +177,11 @@ fn main() -> Result<(), baseview::Error> {
             is_cursor_inside: false.into(),
             damaged: true.into(),
         })
-    })?
-    .run_until_closed()?;
+    })?;
+
+    thread::sleep(Duration::from_secs(1));
+
+    w.run_until_closed()?;
 
     Ok(())
 }

src/context.rs

@@ -64,6 +64,15 @@ impl WindowContext {
         self.inner.size()
     }
 
+    /// Returns whether the window has been shown to the user.
+    ///
+    /// Note that this is distinct to whether the window is actually visible.
+    /// For instance, this will still return `true` if the window is minimized, or obscured by other
+    /// window.
+    pub fn is_shown(&self) -> bool {
+        self.inner.is_shown()
+    }
+
     /// Returns a new lightweight [`PlatformHandle`] to this window.
     ///
     /// It can be sent across threads to access the underlying platform window and display connection.

src/event.rs

@@ -164,3 +164,15 @@ pub enum EventStatus {
     /// result in [DropEffect]
     AcceptDrop(DropEffect),
 }
+
+/// A notification given to a [`WindowHandler`](crate::WindowHandler), via its
+/// [`notify`](crate::WindowHandler::notify) method.
+///
+/// These differ from [`Event`]s, in that the platform does not expect any kind of [`EventStatus`] as
+/// a result of handling (or not) a notification.
+#[non_exhaustive]
+#[derive(Debug, Clone, Copy, PartialEq, Eq)]
+pub enum Notification {
+    Shown,
+    Hidden,
+}

src/handler.rs

@@ -21,6 +21,24 @@ pub trait WindowHandler: 'static {
     /// previous size, but this is only a best-effort attempt since those operations can also fail.
     fn resized(&self, new_size: WindowSize) -> core::result::Result<(), HandlerError>;
     fn on_event(&self, event: Event) -> EventStatus;
+
+    /// Notifies the window handler about a given event.
+    ///
+    /// Unlike [`on_event`](Self::on_event), this method indicates that the platform does not need
+    /// any kind of return value from the [`WindowHandler`], and doesn't care whether the notification
+    /// has been processed in any way.
+    ///
+    /// # Errors
+    ///
+    /// If this operation fails, the failure reason will be logged, if the `tracing` feature is enabled.
+    /// Otherwise, the error is completely ignored.
+    ///
+    /// Implementations should be able to gracefully continue execution in case this method returns
+    /// an error.
+    fn notify(&self, notification: Notification) -> core::result::Result<(), HandlerError> {
+        let _ = notification;
+        Ok(())
+    }
 }
 
 type DynBuilderResult = core::result::Result<Box<dyn WindowHandler>, HandlerError>;

src/platform/x11/event_loop.rs

@@ -8,8 +8,8 @@ use crate::platform::x11::error::FatalError;
 use crate::platform::x11::window_thread::{
     HostCallback, WindowThreadRequest, WindowThreadResponseMessage,
 };
-use crate::warn;
 use crate::wrappers::xkbcommon::XkbcommonState;
+use crate::{warn, Notification};
 use crate::{Event, MouseButton, MouseEvent, ScrollDelta, WindowEvent, WindowHandler, WindowSize};
 use calloop::generic::Generic;
 use calloop::timer::{TimeoutAction, Timer};
@@ -319,6 +319,16 @@ impl EventLoop {
                 }
             }
 
+            XEvent::MapNotify(_) => {
+                self.window.is_mapped.set(true);
+                self.handle_notify(Notification::Shown);
+            }
+
+            XEvent::UnmapNotify(_) => {
+                self.window.is_mapped.set(false);
+                self.handle_notify(Notification::Hidden);
+            }
+
             XEvent::SelectionNotify(event) => {
                 if event.property == self.window.connection.atoms.XdndSelection {
                     self.drag_n_drop.handle_selection_notify_event(
@@ -425,6 +435,12 @@ impl EventLoop {
     fn handle_event(&mut self, event: Event) {
         self.handler.on_event(event);
     }
+
+    fn handle_notify(&self, notification: Notification) {
+        if let Err(e) = self.handler.notify(notification) {
+            crate::warn!("Failed to handle notification {:?}: {}", notification, e);
+        }
+    }
 }
 
 fn mouse_id(id: u8) -> MouseButton {

src/platform/x11/window_shared.rs

@@ -56,6 +56,7 @@ pub(crate) struct WindowInner {
     pub(crate) visual_id: Visualid,
 
     pub(crate) is_focused: Cell<bool>,
+    pub(crate) is_mapped: Cell<bool>,
     pub(crate) loop_signal: LoopSignal,
 
     pub(crate) main_thread_shared: Arc<WindowThreadShared>,
@@ -134,6 +135,7 @@ impl WindowInner {
             loop_signal: ev_loop.get_signal(),
 
             is_focused: false.into(),
+            is_mapped: false.into(),
             main_thread_shared: shared,
 
             #[cfg(feature = "opengl")]
@@ -265,4 +267,8 @@ impl WindowInner {
     pub fn size(&self) -> WindowSize {
         WindowSize::from_physical(self.window_size.get().cast(), self.scaling_factor.get())
     }
+
+    pub fn is_shown(&self) -> bool {
+        self.is_mapped.get()
+    }
 }