Implement Destroyed

Author: prokopyl

src/context.rs

@@ -50,7 +50,7 @@ impl WindowContext {
     /// The given `size` can either be in [physical](dpi::PhysicalSize) or
     /// [logical](dpi::LogicalSize) pixels.
     pub fn resize(&self, size: impl Into<Size>) -> Result<(), Error> {
-        self.inner.resize(size.into())?;
+        self.inner.resize_later(size.into())?;
         Ok(())
     }
 

src/platform/win/window.rs

@@ -23,6 +23,7 @@ pub(crate) const BV_WINDOW_MUST_CLOSE: u32 = WM_USER + 1;
 use super::drop_target::DropTarget;
 use super::*;
 use crate::handler::WindowHandlerBuilder;
+use crate::host::Host;
 use crate::platform::win::window_state::{WindowSharedState, WindowState};
 use crate::platform::Error;
 use crate::wrappers::win32::cursor::SystemCursor;
@@ -112,6 +113,11 @@ impl WindowHandle {
             Err(Error::ResizeFailed)
         }
     }
+
+    #[inline]
+    pub fn handle_main_thread_callback(&self) {
+        // No-op
+    }
 }
 
 impl Drop for WindowHandle {
@@ -128,6 +134,7 @@ pub struct BaseviewWindow {
     initial_size: Size,
 
     handler_builder: Cell<Option<WindowHandlerBuilder>>,
+    host: Host,
 
     // Things not directly used, but kept so their Drop impl runs when the window is destroyed
     _keyboard_hook: Cell<Option<hook::KeyboardHookHandle>>,
@@ -198,7 +205,7 @@ impl WindowImpl for BaseviewWindow {
     unsafe fn handle_message(
         &self, window: HWnd, msg: u32, wparam: WPARAM, lparam: LPARAM,
     ) -> Option<LRESULT> {
-        unsafe { wnd_proc_inner(window, msg, wparam, lparam, &self.window_state) }
+        unsafe { wnd_proc_inner(window, msg, wparam, lparam, &self) }
     }
 
     fn before_destroy(&self, window: HWnd) {
@@ -209,8 +216,9 @@ impl WindowImpl for BaseviewWindow {
 /// Our custom `wnd_proc` handler. If the result contains a value, then this is returned after
 /// handling any deferred tasks. otherwise the default window procedure is invoked.
 unsafe fn wnd_proc_inner(
-    window: HWnd, msg: u32, wparam: WPARAM, lparam: LPARAM, window_state: &WindowState,
+    window: HWnd, msg: u32, wparam: WPARAM, lparam: LPARAM, window_bv: &BaseviewWindow,
 ) -> Option<LRESULT> {
+    let window_state = &window_bv.window_state;
     match msg {
         WM_MOUSEMOVE => {
             if window_state.mouse_was_outside_window.get() {
@@ -465,7 +473,7 @@ unsafe fn wnd_proc_inner(
 
 impl WindowHandle {
     pub fn create_window(
-        options: WindowOpenOptions, build: WindowHandlerBuilder,
+        options: WindowOpenOptions, build: WindowHandlerBuilder, host: Host,
     ) -> Result<WindowHandle> {
         let extended_user_32 = ExtendedUser32::load()?;
         let title = HSTRING::from(options.title);
@@ -495,6 +503,7 @@ impl WindowHandle {
                     initial_size: options.size,
                     handler_builder: Cell::new(Some(build)),
                     shared_state,
+                    host,
 
                     _drop_target: None.into(),
                     _keyboard_hook: None.into(),

src/platform/x11/error.rs

@@ -4,13 +4,40 @@ use crate::platform::x11::xcb_connection::GetPropertyError;
 use crate::warn;
 use crate::wrappers::xlib::{DisplayOpenFailedError, InitThreadsFailedError};
 use crate::HandlerError;
+use std::fmt::{Display, Formatter};
 use std::sync::mpsc::RecvError;
 use x11_dl::error::OpenError;
 use x11rb::connection::RequestConnection;
 use x11rb::cookie::{Cookie, VoidCookie};
 use x11rb::errors::{ConnectError, ConnectionError, ReplyError, ReplyOrIdError};
 use x11rb::x11_utils::{TryParse, X11Error};
 
+#[derive(Debug)]
+pub enum FatalError {
+    Connection(ConnectionError),
+    SendMainThread,
+    ReceiveMainThread,
+}
+
+impl Display for FatalError {
+    fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
+        match self {
+            FatalError::Connection(e) => e.fmt(f),
+            // TODO: better errors
+            FatalError::SendMainThread => f.write_str("SendMainThread"),
+            FatalError::ReceiveMainThread => f.write_str("ReceiveMainThread"),
+        }
+    }
+}
+
+impl std::error::Error for FatalError {}
+
+impl From<ConnectionError> for FatalError {
+    fn from(err: ConnectionError) -> FatalError {
+        FatalError::Connection(err)
+    }
+}
+
 #[derive(Debug)]
 pub enum Error {
     CreationFailed(String),
@@ -35,7 +62,7 @@ pub enum Error {
     Gl(super::gl::CreationFailedError),
 }
 
-impl std::fmt::Display for Error {
+impl Display for Error {
     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
         match self {
             Error::Io(e) => e.fmt(f),

src/platform/x11/event_loop.rs

@@ -4,6 +4,7 @@ use super::*;
 use std::result::Result;
 
 use crate::host::HostMainThreadCaller;
+use crate::platform::x11::error::FatalError;
 use crate::platform::x11::window_thread::{
     HostCallback, WindowThreadRequest, WindowThreadResponse, WindowThreadResponseMessage,
 };
@@ -16,11 +17,36 @@ use calloop::{Interest, LoopSignal, Mode, PostAction};
 use dpi::{PhysicalPosition, PhysicalSize};
 use std::rc::Rc;
 use std::sync::mpsc;
+use std::sync::mpsc::Receiver;
 use std::time::{Duration, Instant};
 use x11rb::connection::Connection;
 use x11rb::errors::ConnectionError;
 use x11rb::protocol::Event as XEvent;
 
+pub struct MainThreadCaller {
+    sender: mpsc::Sender<HostCallback>,
+    caller: Box<dyn HostMainThreadCaller>,
+}
+
+impl MainThreadCaller {
+    pub(crate) fn new(
+        main_thread: Option<Box<dyn HostMainThreadCaller>>,
+    ) -> (Option<Self>, Option<Receiver<HostCallback>>) {
+        let Some(main_thread) = main_thread else {
+            return (None, None);
+        };
+
+        let (sender, receiver) = mpsc::channel();
+        (Some(Self { sender, caller: main_thread }), Some(receiver))
+    }
+
+    pub fn send(&mut self, msg: HostCallback) -> Result<(), FatalError> {
+        self.sender.send(msg).map_err(|_| FatalError::SendMainThread)?;
+        self.caller.call_main_thread();
+        Ok(())
+    }
+}
+
 pub(crate) struct EventLoop {
     handler: Box<dyn WindowHandler>,
     window: Rc<WindowInner>,
@@ -35,8 +61,7 @@ pub(crate) struct EventLoop {
     run_error: Option<Error>,
 
     response_sender: mpsc::Sender<WindowThreadResponseMessage>,
-    callback_sender: mpsc::Sender<HostCallback>,
-    main_thread_caller: Option<Box<dyn HostMainThreadCaller>>,
+    main_thread: Option<MainThreadCaller>,
 }
 
 const FRAME_INTERVAL: Duration = Duration::from_millis(15);
@@ -46,9 +71,7 @@ impl EventLoop {
         window: Rc<WindowInner>, handler: Box<dyn WindowHandler>,
         request_receiver: calloop::channel::Channel<WindowThreadRequest>,
         response_sender: mpsc::Sender<WindowThreadResponseMessage>,
-        callback_sender: mpsc::Sender<HostCallback>,
-        main_thread_caller: Option<Box<dyn HostMainThreadCaller>>,
-        inner: &mut calloop::EventLoop<'static, Self>,
+        main_thread: Option<MainThreadCaller>, inner: &mut calloop::EventLoop<'static, Self>,
     ) -> Result<Self, Error> {
         let loop_handle = inner.handle();
 
@@ -74,16 +97,15 @@ impl EventLoop {
             drag_n_drop: DragNDropState::NoCurrentSession,
             xkb_state: XkbcommonState::new(&window.connection),
             run_error: None,
-            callback_sender,
-            main_thread_caller,
+            main_thread,
 
             window,
             response_sender,
         })
     }
 
     #[inline]
-    fn drain_xcb_events(&mut self) -> Result<(), ConnectionError> {
+    fn drain_xcb_events(&mut self) -> Result<(), FatalError> {
         // the X server has a tendency to send spurious/extraneous configure notify events when a
         // window is resized, and we need to batch those together and just send one resize event
         // when they've all been coalesced.
@@ -93,28 +115,31 @@ impl EventLoop {
             self.handle_xcb_event(event)?;
         }
 
-        if let Some(size) = self.new_physical_size.take() {
-            let previous = self.window.store_size(size);
-
-            let scale_factor = self.window.scaling_factor.get();
-            let new_size = WindowSize::from_physical(size.cast(), scale_factor);
-
-            if let Err(e) = self.handler.resized(new_size) {
-                warn!("Window Handler failed to resize: {}", e);
-                self.window.store_size(previous);
-                self.window.xcb_window.resize(previous.cast())?.check_warn();
-            } else {
-                // TODO: only if this wansn't the result of a host request
-                // TODO: do not allocate channel if no host callback is present
-                if let Some(main_thread) = self.main_thread_caller.as_mut() {
-                    self.callback_sender
-                        .send(HostCallback::Resized {
-                            new_size,
-                            previous: WindowSize::from_physical(previous.cast(), scale_factor),
-                        })
-                        .unwrap(); // TODO: unwrap
-                    main_thread.call_main_thread();
-                }
+        self.handle_coalesced_resize_events()
+    }
+
+    fn handle_coalesced_resize_events(&mut self) -> Result<(), FatalError> {
+        let Some(new_size) = self.new_physical_size.take() else { return Ok(()) };
+        let previous = self.window.store_size(new_size);
+
+        if previous == new_size {
+            return Ok(());
+        };
+
+        let scale_factor = self.window.scaling_factor.get();
+        let new_size = WindowSize::from_physical(new_size.cast(), scale_factor);
+
+        if let Err(e) = self.handler.resized(new_size) {
+            warn!("Window Handler failed to resize: {}", e);
+            self.window.store_size(previous);
+            self.window.xcb_window.resize(previous.cast())?.check_warn();
+        } else {
+            // TODO: only if this wansn't the result of a host request
+            if let Some(host) = self.main_thread.as_mut() {
+                host.send(HostCallback::Resized {
+                    new_size,
+                    previous: WindowSize::from_physical(previous.cast(), scale_factor),
+                })?;
             }
         }
 
@@ -177,7 +202,7 @@ impl EventLoop {
         }
     }
 
-    fn handle_connection_event_ready(&mut self) -> Result<PostAction, ConnectionError> {
+    fn handle_connection_event_ready(&mut self) -> Result<PostAction, FatalError> {
         self.drain_xcb_events()?;
 
         Ok(PostAction::Continue)
@@ -214,6 +239,15 @@ impl EventLoop {
 
         self.handle_event(Event::Window(WindowEvent::WillClose));
 
+        // If the event loop doesn't stop because the host asked it to, then we should notify it
+        if !self.window.main_thread_shared.is_stop_host_requested() {
+            if let Some(main_thread) = self.main_thread.as_mut() {
+                if let Err(e) = main_thread.send(HostCallback::Destroyed) {
+                    warn!("Could not notify host that X11 thread is stopping: {}", e)
+                }
+            }
+        }
+
         if let Some(err) = self.run_error {
             return Err(err);
         };

src/platform/x11/window_shared.rs

@@ -61,7 +61,7 @@ pub(crate) struct WindowInner {
     pub(crate) is_focused: Cell<bool>,
     pub(crate) loop_signal: LoopSignal,
 
-    main_thread_shared: Arc<WindowThreadShared>,
+    pub(crate) main_thread_shared: Arc<WindowThreadShared>,
 }
 
 impl WindowInner {
@@ -186,7 +186,7 @@ impl WindowInner {
         Ok(())
     }
 
-    pub fn resize(&self, size: Size) -> Result<()> {
+    pub fn resize_later(&self, size: Size) -> Result<()> {
         let new_physical_size = size.to_physical(self.scaling_factor.get());
         self.xcb_window.resize(new_physical_size)?.check()?;
 
@@ -211,10 +211,12 @@ impl WindowInner {
             warn!("Window Handler failed to resize: {}. Reverting to previous size", &e);
             self.store_size(previous);
             return Err(e.into());
-        } else {
-            self.xcb_window.resize(new_size.cast())?.check()?; // Will not call handler, as size is the same as above.
         }
 
+        self.xcb_window.resize(new_size.cast())?.check()?; // Will not call handler, as size is the same as above.
+
+        // These come from the Host, no need to notify it about the new size
+
         Ok(())
     }