wip

Author: prokopyl

Cargo.toml

@@ -99,3 +99,6 @@ missing-safety-doc = "allow"
 
 [package.metadata.docs.rs]
 all-features = true
+
+[workspace.dependencies]
+tracing-subscriber = "0.3.23"

examples/render_femtovg/Cargo.toml

@@ -5,5 +5,6 @@ edition = "2021"
 publish = false
 
 [dependencies]
-baseview = { path = "../..", features = ["opengl"] }
+baseview = { path = "../..", features = ["opengl", "tracing"] }
 femtovg = "0.25.1"
+tracing-subscriber = { workspace = true }

examples/render_femtovg/src/main.rs

@@ -116,6 +116,8 @@ impl WindowHandler for FemtovgExample {
 }
 
 fn main() -> Result<(), baseview::Error> {
+    tracing_subscriber::fmt::init();
+
     let window_open_options = WindowOpenOptions::new()
         .with_title("Femtovg on Baseview")
         .with_size(LogicalSize::new(512, 512))

src/lib.rs

@@ -25,6 +25,6 @@ pub use window::*;
 pub use window_open_options::*;
 
 #[allow(unused)]
-pub(crate) use tracing::warn;
+pub(crate) use tracing::*;
 
 pub(crate) mod wrappers;

src/platform/x11/error.rs

@@ -105,6 +105,12 @@ impl From<calloop::Error> for Error {
     }
 }
 
+impl From<RecvError> for Error {
+    fn from(value: RecvError) -> Self {
+        Self::Channel(value)
+    }
+}
+
 #[cfg(feature = "opengl")]
 impl From<crate::wrappers::xlib::XLibError> for Error {
     fn from(value: crate::wrappers::xlib::XLibError) -> Self {

src/platform/x11/event_loop.rs

@@ -4,7 +4,6 @@ use super::*;
 use std::result::Result;
 
 use crate::warn;
-use crate::wrappers::connection_poller::{ConnectionPoller, PollStatus};
 use crate::wrappers::xkbcommon::XkbcommonState;
 use crate::{Event, MouseButton, MouseEvent, ScrollDelta, WindowEvent, WindowHandler, WindowSize};
 use calloop::generic::Generic;
@@ -37,20 +36,20 @@ impl EventLoop {
     pub fn new(
         window: Rc<WindowInner>, handler: Box<dyn WindowHandler>,
         inner: &mut calloop::EventLoop<'static, Self>,
-    ) -> Self {
+    ) -> Result<Self, Error> {
         let loop_handle = inner.handle();
         let frame_timer = loop_handle
             .insert_source(Timer::from_duration(FRAME_INTERVAL), |i, _, e| e.handle_frame(i))
-            .unwrap();
+            .map_err(|e| e.error)?;
 
         loop_handle
             .insert_source(
                 Generic::new_with_error(window.connection.conn.clone(), Interest::READ, Mode::Edge),
                 |_, _, e| e.handle_connection_event_ready(),
             )
-            .unwrap();
+            .map_err(|e| e.error)?;
 
-        Self {
+        Ok(Self {
             loop_handle,
             loop_signal: inner.get_signal(),
             handler,
@@ -59,7 +58,7 @@ impl EventLoop {
             drag_n_drop: DragNDropState::NoCurrentSession,
             xkb_state: XkbcommonState::new(&window.connection),
             window,
-        }
+        })
     }
 
     pub fn window_id(&self) -> NonZeroU32 {
@@ -139,8 +138,8 @@ impl EventLoop {
         }
     }
 
-    pub fn run(&mut self, mut inner: calloop::EventLoop<Self>) -> Result<(), Error> {
-        inner.run(None, self, Self::handle_idle)?;
+    pub fn run(mut self, mut inner: calloop::EventLoop<Self>) -> Result<(), Error> {
+        inner.run(None, &mut self, Self::handle_idle)?;
 
         Ok(())
     }

src/platform/x11/window.rs

@@ -1,101 +1,6 @@
-use std::cell::Cell;
-use std::num::NonZero;
-use std::sync::atomic::{AtomicBool, Ordering};
-use std::sync::mpsc;
-use std::sync::Arc;
-use std::thread::{self, JoinHandle};
+use crate::platform::x11::window_thread::WindowThreadHandle;
 
-use crate::handler::WindowHandlerBuilder;
-use crate::platform::Result;
-use crate::*;
-
-pub struct WindowHandle {
-    window_id: Option<NonZero<x11rb::protocol::xproto::Window>>,
-    event_loop_handle: Cell<Option<JoinHandle<()>>>,
-    close_requested: Arc<AtomicBool>,
-    is_open: Arc<AtomicBool>,
-}
-
-impl WindowHandle {
-    pub fn create_window(
-        options: WindowOpenOptions, handler: WindowHandlerBuilder,
-    ) -> Result<WindowHandle> {
-        let (tx, rx) = mpsc::sync_channel::<WindowOpenResult>(1);
-        let (parent_handle, mut window_handle) = ParentHandle::new();
-
-        let join_handle =
-            thread::spawn(move || match create_window(options, handler, Some(parent_handle)) {
-                Ok(ev_loop) => {
-                    tx.send(Ok(ev_loop.window_id())).unwrap();
-                    ev_loop.run().unwrap();
-                }
-                Err(e) => {
-                    tx.send(Err(format!("{}", e))).unwrap();
-                }
-            });
-
-        let id = match rx.recv() {
-            Ok(Ok(id)) => id,
-            Err(e) => return Err(super::Error::Channel(e)),
-            Ok(Err(s)) => return Err(super::error::Error::CreationFailed(s)),
-        };
-
-        window_handle.window_id = Some(id);
-        window_handle.event_loop_handle = Some(join_handle).into();
-        Ok(window_handle)
-    }
-
-    pub fn run_until_closed(self) {
-        let Some(thread) = self.event_loop_handle.take() else { return };
-
-        thread.join().unwrap_or_else(|err| {
-            eprintln!("Window thread panicked: {:#?}", err);
-        });
-    }
-
-    pub fn is_open(&self) -> bool {
-        self.is_open.load(Ordering::Relaxed)
-    }
-}
-
-impl Drop for WindowHandle {
-    fn drop(&mut self) {
-        self.close_requested.store(true, Ordering::Relaxed);
-        if let Some(event_loop) = self.event_loop_handle.take() {
-            let _ = event_loop.join();
-        }
-    }
-}
-
-pub(crate) struct ParentHandle {
-    close_requested: Arc<AtomicBool>,
-    is_open: Arc<AtomicBool>,
-}
-
-impl ParentHandle {
-    pub fn new() -> (Self, WindowHandle) {
-        let close_requested = Arc::new(AtomicBool::new(false));
-        let is_open = Arc::new(AtomicBool::new(true));
-        let handle = WindowHandle {
-            window_id: None,
-            event_loop_handle: None.into(),
-            close_requested: Arc::clone(&close_requested),
-            is_open: Arc::clone(&is_open),
-        };
-
-        (Self { close_requested, is_open }, handle)
-    }
-
-    pub fn parent_did_drop(&self) -> bool {
-        self.close_requested.load(Ordering::Relaxed)
-    }
-}
-
-impl Drop for ParentHandle {
-    fn drop(&mut self) {
-        self.is_open.store(false, Ordering::Relaxed);
-    }
-}
+pub type WindowHandle = WindowThreadHandle;
 
 pub fn copy_to_clipboard(_data: &str) {
     todo!()

src/platform/x11/window_thread.rs

@@ -0,0 +1,130 @@
+use super::*;
+use crate::handler::WindowHandlerBuilder;
+use crate::platform::x11::event_loop::EventLoop;
+use crate::platform::x11::window_shared::WindowInner;
+use crate::{WindowContext, WindowOpenOptions};
+use calloop::LoopSignal;
+use std::cell::Cell;
+use std::num::NonZeroU32;
+use std::panic::resume_unwind;
+use std::rc::Rc;
+use std::sync::mpsc;
+use std::thread;
+use std::thread::JoinHandle;
+use std::time::Duration;
+
+pub struct WindowThreadHandle {
+    window_id: NonZeroU32,
+    event_loop_handle: Cell<Option<JoinHandle<()>>>,
+}
+
+impl WindowThreadHandle {
+    pub fn create_window(
+        options: WindowOpenOptions, handler: WindowHandlerBuilder,
+    ) -> Result<Self> {
+        let (tx, rx) = result_channel();
+
+        let join_handle = thread::spawn(move || {
+            let thread = match WindowThread::create(options, handler) {
+                Err(e) => return tx.send_error(e),
+                Ok(thread) => thread,
+            };
+
+            if tx.send_success(&thread) {
+                thread.run()
+            }
+        });
+
+        thread::sleep(Duration::from_millis(2000));
+
+        rx.receive(join_handle)
+    }
+
+    pub fn run_until_closed(self) {
+        let Some(thread) = self.event_loop_handle.take() else { return };
+
+        if let Err(panic) = thread.join() {
+            resume_unwind(panic);
+        }
+    }
+
+    pub fn is_open(&self) -> bool {
+        todo!()
+    }
+}
+
+impl Drop for WindowThreadHandle {
+    fn drop(&mut self) {
+        // TODO: stop event loop
+        if let Some(event_loop) = self.event_loop_handle.take() {
+            let _ = event_loop.join();
+        }
+    }
+}
+
+enum WindowOpenResult {
+    Success { window_id: NonZeroU32, loop_signal: LoopSignal },
+    Error(String),
+}
+
+struct WindowThread {
+    event_loop: EventLoop,
+    ev_loop: calloop::EventLoop<'static, EventLoop>,
+}
+
+impl WindowThread {
+    pub fn create(options: WindowOpenOptions, handler: WindowHandlerBuilder) -> Result<Self> {
+        let mut ev_loop = calloop::EventLoop::try_new()?;
+        let inner = WindowInner::create(options)?;
+        let handler = handler.build(WindowContext::new(Rc::clone(&inner)))?;
+        let event_loop = EventLoop::new(inner, handler, &mut ev_loop)?;
+
+        Ok(Self { event_loop, ev_loop })
+    }
+
+    pub fn run(self) {
+        self.event_loop.run(self.ev_loop).unwrap();
+    }
+}
+
+fn result_channel() -> (WindowResultSender, WindowResultReceiver) {
+    let (tx, rx) = mpsc::sync_channel::<WindowOpenResult>(1);
+    (WindowResultSender(tx), WindowResultReceiver(rx))
+}
+
+struct WindowResultSender(mpsc::SyncSender<WindowOpenResult>);
+impl WindowResultSender {
+    pub fn send_error(self, error: Error) {
+        if let Err(err) = self.0.send(WindowOpenResult::Error(format!("{}", error))) {
+            crate::error!("Window creation failed: {}", error);
+            crate::warn!("Failed to send error to main thread: {err}");
+        }
+    }
+
+    pub fn send_success(self, thread: &WindowThread) -> bool {
+        let msg = WindowOpenResult::Success {
+            loop_signal: thread.ev_loop.get_signal(),
+            window_id: thread.event_loop.window_id(),
+        };
+
+        if let Err(err) = self.0.send(msg) {
+            crate::error!("Failed to send created window to main thread: {}. Aborting.", err);
+            return false;
+        }
+
+        true
+    }
+}
+
+struct WindowResultReceiver(mpsc::Receiver<WindowOpenResult>);
+impl WindowResultReceiver {
+    pub fn receive(self, join_handle: JoinHandle<()>) -> Result<WindowThreadHandle> {
+        let result = self.0.recv()?;
+        match result {
+            WindowOpenResult::Error(e) => Err(Error::CreationFailed(e)),
+            WindowOpenResult::Success { window_id, loop_signal } => {
+                Ok(WindowThreadHandle { event_loop_handle: Some(join_handle).into(), window_id })
+            }
+        }
+    }
+}

src/tracing.rs

@@ -1,5 +1,5 @@
 #[cfg(feature = "tracing")]
-pub use tracing::*;
+pub use tracing::{error, warn};
 
 #[cfg(not(feature = "tracing"))]
 mod tracing_impl {
@@ -13,6 +13,7 @@ mod tracing_impl {
     }
 
     pub(crate) use __warn as warn;
+    pub(crate) use __warn as error;
 }
 
 #[cfg(not(feature = "tracing"))]