wip

Author: prokopyl

examples/open_parented/src/main.rs

@@ -1,4 +1,4 @@
-use baseview::dpi::LogicalSize;
+use baseview::dpi::{LogicalSize, PhysicalSize};
 use baseview::{
     Event, EventStatus, HandlerError, WindowContext, WindowHandle, WindowHandler,
     WindowOpenOptions, WindowSize,
@@ -10,7 +10,7 @@ struct ParentWindowHandler {
     surface: RefCell<softbuffer::Surface<WindowContext, WindowContext>>,
     damaged: Cell<bool>,
 
-    _child_window: Option<WindowHandle>,
+    child_window: WindowHandle,
 }
 
 impl ParentWindowHandler {
@@ -27,11 +27,7 @@ impl ParentWindowHandler {
 
         let child_window = baseview::create_window(window_open_options, ChildWindowHandler::new)?;
 
-        Ok(Self {
-            surface: surface.into(),
-            damaged: true.into(),
-            _child_window: Some(child_window),
-        })
+        Ok(Self { surface: surface.into(), damaged: true.into(), child_window })
     }
 }
 
@@ -58,6 +54,9 @@ impl WindowHandler for ParentWindowHandler {
             self.damaged.set(true);
         }
 
+        let child_size =
+            PhysicalSize::new(new_size.physical.width / 2, new_size.physical.height / 2);
+        self.child_window.resize(child_size.into())?;
         Ok(())
     }
 

src/platform/x11/event_loop.rs

@@ -3,6 +3,9 @@ use super::keyboard::{convert_key_press_event, convert_key_release_event, key_mo
 use super::*;
 use std::result::Result;
 
+use crate::platform::x11::window_thread::{
+    WindowThreadRequest, WindowThreadResponse, WindowThreadResponseMessage,
+};
 use crate::warn;
 use crate::wrappers::xkbcommon::XkbcommonState;
 use crate::{Event, MouseButton, MouseEvent, ScrollDelta, WindowEvent, WindowHandler, WindowSize};
@@ -11,6 +14,7 @@ use calloop::timer::{TimeoutAction, Timer};
 use calloop::{Interest, LoopSignal, Mode, PostAction};
 use dpi::{PhysicalPosition, PhysicalSize};
 use std::rc::Rc;
+use std::sync::mpsc;
 use std::time::{Duration, Instant};
 use x11rb::connection::Connection;
 use x11rb::errors::ConnectionError;
@@ -28,13 +32,17 @@ pub(crate) struct EventLoop {
     xkb_state: Option<XkbcommonState>,
 
     run_error: Option<Error>,
+
+    response_sender: mpsc::Sender<WindowThreadResponseMessage>,
 }
 
 const FRAME_INTERVAL: Duration = Duration::from_millis(15);
 
 impl EventLoop {
     pub fn new(
         window: Rc<WindowInner>, handler: Box<dyn WindowHandler>,
+        request_receiver: calloop::channel::Channel<WindowThreadRequest>,
+        response_sender: mpsc::Sender<WindowThreadResponseMessage>,
         inner: &mut calloop::EventLoop<'static, Self>,
     ) -> Result<Self, Error> {
         let loop_handle = inner.handle();
@@ -50,6 +58,10 @@ impl EventLoop {
             )
             .map_err(|e| e.error)?;
 
+        loop_handle
+            .insert_source(request_receiver, |e, _, l| l.handle_main_thread_request(e))
+            .map_err(|e| e.error)?;
+
         Ok(Self {
             loop_signal: inner.get_signal(),
             handler,
@@ -58,6 +70,7 @@ impl EventLoop {
             xkb_state: XkbcommonState::new(&window.connection),
             run_error: None,
             window,
+            response_sender,
         })
     }
 
@@ -73,21 +86,75 @@ impl EventLoop {
         }
 
         if let Some(size) = self.new_physical_size.take() {
-            let previous = self.window.window_size.replace(size);
+            let previous = self.window.store_size(size);
 
             let scale_factor = self.window.scaling_factor.get();
             if let Err(e) =
                 self.handler.resized(WindowSize::from_physical(size.cast(), scale_factor))
             {
                 warn!("Window Handler failed to resize: {}", e);
-                self.window.window_size.set(previous);
+                self.window.store_size(previous);
                 self.window.xcb_window.resize(previous.cast())?.check_warn();
             }
         }
 
         Ok(())
     }
 
+    fn handle_main_thread_request(&mut self, event: calloop::channel::Event<WindowThreadRequest>) {
+        match event {
+            calloop::channel::Event::Closed => {
+                // Closed channel means the sender, i.e. the Window Handle has been dropped.
+                // It should already stop this event loop on drop, but we'll take the hint.
+                self.stop_now();
+            }
+            calloop::channel::Event::Msg(req) => match self.handle_request(req) {
+                Ok(()) => self.send_response(Ok(WindowThreadResponse::Ok)),
+                Err(e) => self.send_response(Err(e.to_string())),
+            },
+        }
+    }
+
+    fn send_response(&mut self, response: WindowThreadResponseMessage) {
+        if let Err(e) = self.response_sender.send(response) {
+            warn!("Failed to send response back to main thread: {}", &e);
+            if let Err(e) = e.0 {
+                crate::error!("Request failed: {}", e)
+            }
+
+            self.stop_now();
+        }
+    }
+
+    fn stop_now(&self) {
+        self.loop_signal.stop();
+        self.loop_signal.wakeup();
+    }
+
+    fn handle_request(&mut self, req: WindowThreadRequest) -> Result<(), Error> {
+        match req {
+            WindowThreadRequest::Resize(new_size) => {
+                let scale_factor = self.window.scaling_factor.get();
+                let new_size = new_size.to_physical(scale_factor);
+
+                // Handle everything directly, so we can return a handler error immediately.
+                let previous = self.window.store_size(new_size);
+                self.window.xcb_window.resize(new_size.cast())?; // Will not call handler, as size is the same as above.
+
+                if let Err(e) =
+                    self.handler.resized(WindowSize::from_physical(new_size.cast(), scale_factor))
+                {
+                    warn!("Window Handler failed to resize: {}. Reverting to previous size", &e);
+                    self.window.store_size(previous);
+                    return Err(e.into());
+                }
+
+                Ok(())
+            }
+            _ => todo!(),
+        }
+    }
+
     fn handle_connection_event_ready(&mut self) -> Result<PostAction, ConnectionError> {
         self.drain_xcb_events()?;
 
@@ -97,7 +164,7 @@ impl EventLoop {
     fn handle_frame(&mut self, previous_deadline: Instant) -> TimeoutAction {
         if let Err(e) = self.handler.on_frame() {
             self.run_error = Some(e.into());
-            self.loop_signal.stop();
+            self.stop_now();
             return TimeoutAction::Drop;
         }
 
@@ -194,9 +261,7 @@ impl EventLoop {
             XEvent::ConfigureNotify(event) => {
                 let new_physical_size = PhysicalSize::new(event.width, event.height);
 
-                if self.new_physical_size.is_some()
-                    || new_physical_size != self.window.window_size.get()
-                {
+                if self.new_physical_size.is_some() || new_physical_size != self.window.get_size() {
                     self.new_physical_size = Some(new_physical_size);
                 }
             }

src/platform/x11/window_shared.rs

@@ -1,5 +1,6 @@
 use crate::platform::x11::event_loop::EventLoop;
 use crate::platform::x11::visual_info::WindowVisualConfig;
+use crate::platform::x11::window_thread::WindowThreadShared;
 use crate::platform::x11::xcb_window::XcbWindow;
 use crate::platform::*;
 use crate::{MouseCursor, WindowOpenOptions, WindowScalePolicy, WindowSize};
@@ -20,17 +21,20 @@ pub(crate) struct WindowInner {
     pub(crate) xcb_window: XcbWindow,
     pub(crate) connection: Rc<X11Connection>,
     pub(crate) scaling_factor: Cell<f64>,
-    pub(crate) window_size: Cell<PhysicalSize<u16>>,
+    window_size: Cell<PhysicalSize<u16>>,
     mouse_cursor: Cell<MouseCursor>,
     pub(crate) visual_id: Visualid,
 
     pub(crate) is_focused: Cell<bool>,
     pub(crate) loop_signal: LoopSignal,
+
+    main_thread_shared: Arc<WindowThreadShared>,
 }
 
 impl WindowInner {
     pub(crate) fn create(
         options: WindowOpenOptions, ev_loop: &calloop::EventLoop<'static, EventLoop>,
+        shared: Arc<WindowThreadShared>,
     ) -> Result<Rc<Self>> {
         // Connect to the X server
         let xcb_connection = X11Connection::new()?;
@@ -40,6 +44,7 @@ impl WindowInner {
             WindowScalePolicy::ScaleFactor(scale) => scale,
         };
 
+        shared.set_scaling_factor(scaling);
         let physical_size = options.size.to_physical(scaling);
 
         #[cfg(feature = "opengl")]
@@ -82,17 +87,17 @@ impl WindowInner {
             }
         };
 
-        let visual_id = visual_info.visual_id;
         Ok(Rc::new(Self {
             connection,
             xcb_window,
-            visual_id,
+            visual_id: visual_info.visual_id,
             window_size: physical_size.into(),
             scaling_factor: scaling.into(),
             mouse_cursor: MouseCursor::default().into(),
             loop_signal: ev_loop.get_signal(),
 
             is_focused: false.into(),
+            main_thread_shared: shared,
 
             #[cfg(feature = "opengl")]
             gl_context,
@@ -121,6 +126,16 @@ impl WindowInner {
         Ok(())
     }
 
+    pub fn store_size(&self, size: PhysicalSize<u16>) -> PhysicalSize<u16> {
+        let previous = self.window_size.replace(size);
+        self.main_thread_shared.set_size(size);
+        previous
+    }
+
+    pub fn get_size(&self) -> PhysicalSize<u16> {
+        self.window_size.get()
+    }
+
     pub fn request_close(&self) {
         self.loop_signal.stop();
         self.loop_signal.wakeup();
@@ -140,7 +155,7 @@ impl WindowInner {
     }
 
     pub fn resize(&self, size: Size) -> Result<()> {
-        let new_physical_size = size.to_physical::<u32>(self.scaling_factor.get());
+        let new_physical_size = size.to_physical(self.scaling_factor.get());
         self.xcb_window.resize(new_physical_size)?;
 
         // This will trigger a `ConfigureNotify` event which will in turn change `self.window_info`