wip

Author: prokopyl

Cargo.toml

@@ -37,6 +37,7 @@ opengl = [
 keyboard-types = { version = "0.8.3" }
 raw-window-handle = "0.6.2"
 dpi = "0.1.2"
+tracing = { version = "0.1", optional = true }
 
 [target.'cfg(target_os="linux")'.dependencies]
 x11rb = { version = "0.13.2", features = ["cursor", "resource_manager", "allow-unsafe-code", "dl-libxcb"], default-features = false }

examples/open_parented/src/main.rs

@@ -1,6 +1,7 @@
 use baseview::dpi::LogicalSize;
 use baseview::{
-    Event, EventStatus, WindowContext, WindowHandle, WindowHandler, WindowOpenOptions, WindowSize,
+    Event, EventStatus, HandlerError, WindowContext, WindowHandle, WindowHandler,
+    WindowOpenOptions, WindowSize,
 };
 use std::cell::{Cell, RefCell};
 use std::num::NonZeroU32;
@@ -13,22 +14,25 @@ struct ParentWindowHandler {
 }
 
 impl ParentWindowHandler {
-    pub fn new(window: WindowContext) -> Self {
-        let ctx = softbuffer::Context::new(window.clone()).unwrap();
-        let mut surface = softbuffer::Surface::new(&ctx, window.clone()).unwrap();
+    pub fn new(window: WindowContext) -> Result<Self, HandlerError> {
+        let ctx = softbuffer::Context::new(window.clone())?;
+        let mut surface = softbuffer::Surface::new(&ctx, window.clone())?;
         let size = window.size().physical;
         surface
-            .resize(NonZeroU32::new(size.width).unwrap(), NonZeroU32::new(size.height).unwrap())
-            .unwrap();
+            .resize(NonZeroU32::new(size.width).unwrap(), NonZeroU32::new(size.height).unwrap())?;
 
         let window_open_options = WindowOpenOptions::new()
             .with_size(LogicalSize::new(256, 256))
             .with_parent(&window)
             .with_title("baseview child");
 
-        let child_window = baseview::create_window(window_open_options, ChildWindowHandler::new);
+        let child_window = baseview::create_window(window_open_options, ChildWindowHandler::new)?;
 
-        Self { surface: surface.into(), damaged: true.into(), _child_window: Some(child_window) }
+        Ok(Self {
+            surface: surface.into(),
+            damaged: true.into(),
+            _child_window: Some(child_window),
+        })
     }
 }
 
@@ -72,15 +76,14 @@ struct ChildWindowHandler {
 }
 
 impl ChildWindowHandler {
-    pub fn new(window: WindowContext) -> Self {
-        let ctx = softbuffer::Context::new(window.clone()).unwrap();
-        let mut surface = softbuffer::Surface::new(&ctx, window.clone()).unwrap();
+    pub fn new(window: WindowContext) -> Result<Self, HandlerError> {
+        let ctx = softbuffer::Context::new(window.clone())?;
+        let mut surface = softbuffer::Surface::new(&ctx, window.clone())?;
         let size = window.size().physical;
         surface
-            .resize(NonZeroU32::new(size.width).unwrap(), NonZeroU32::new(size.height).unwrap())
-            .unwrap();
+            .resize(NonZeroU32::new(size.width).unwrap(), NonZeroU32::new(size.height).unwrap())?;
 
-        Self { surface: surface.into(), damaged: true.into() }
+        Ok(Self { surface: surface.into(), damaged: true.into() })
     }
 }
 
@@ -121,5 +124,7 @@ impl WindowHandler for ChildWindowHandler {
 fn main() {
     let window_open_options = WindowOpenOptions::new().with_size(LogicalSize::new(512.0, 512.0));
 
-    baseview::create_window(window_open_options, ParentWindowHandler::new).run_until_closed();
+    baseview::create_window(window_open_options, ParentWindowHandler::new)
+        .unwrap()
+        .run_until_closed();
 }

examples/open_window/src/main.rs

@@ -155,15 +155,16 @@ fn main() {
             .resize(NonZeroU32::new(size.width).unwrap(), NonZeroU32::new(size.height).unwrap())
             .unwrap();
 
-        OpenWindowExample {
+        Ok(OpenWindowExample {
             window_context: window,
             surface: surface.into(),
             rx: rx.into(),
             mouse_pos: PhysicalPosition::new(0., 0.).into(),
             is_cursor_inside: false.into(),
             damaged: true.into(),
-        }
+        })
     })
+    .unwrap()
     .run_until_closed();
 }
 

examples/render_femtovg/src/main.rs

@@ -1,7 +1,8 @@
 use baseview::dpi::{LogicalSize, PhysicalPosition};
 use baseview::gl::{GlConfig, GlContext};
 use baseview::{
-    Event, EventStatus, MouseEvent, WindowContext, WindowHandler, WindowOpenOptions, WindowSize,
+    Event, EventStatus, HandlerError, MouseEvent, WindowContext, WindowHandler, WindowOpenOptions,
+    WindowSize,
 };
 use femtovg::renderer::OpenGl;
 use femtovg::{Canvas, Color};
@@ -17,28 +18,27 @@ struct FemtovgExample {
 }
 
 impl FemtovgExample {
-    fn new(window_context: WindowContext) -> Self {
+    fn new(window_context: WindowContext) -> Result<Self, HandlerError> {
         let gl_context = window_context.gl_context().unwrap();
         unsafe { gl_context.make_current() };
 
         let renderer = unsafe {
             OpenGl::new_from_function(|s| gl_context.get_proc_address(&CString::new(s).unwrap()))
-        }
-        .unwrap();
+        }?;
 
-        let mut canvas = Canvas::new(renderer).unwrap();
+        let mut canvas = Canvas::new(renderer)?;
         let size = window_context.size();
 
         canvas.set_size(size.physical.width, size.physical.height, size.scale_factor as f32);
 
         unsafe { gl_context.make_not_current() };
-        Self {
+        Ok(Self {
             gl_context,
             window_context,
             canvas: canvas.into(),
             damaged: true.into(),
             current_mouse_position: Cell::new(PhysicalPosition::default()),
-        }
+        })
     }
 }
 
@@ -119,7 +119,7 @@ fn main() {
         .with_size(LogicalSize::new(512, 512))
         .with_gl_config(GlConfig { alpha_bits: 8, ..GlConfig::default() });
 
-    baseview::create_window(window_open_options, FemtovgExample::new).run_until_closed();
+    baseview::create_window(window_open_options, FemtovgExample::new).unwrap().run_until_closed();
 }
 
 fn log_event(event: &Event) {

examples/render_wgpu/src/main.rs

@@ -1,5 +1,7 @@
 use baseview::dpi::{LogicalSize, PhysicalSize};
-use baseview::{Event, EventStatus, WindowContext, WindowHandler, WindowOpenOptions, WindowSize};
+use baseview::{
+    Event, EventStatus, HandlerError, WindowContext, WindowHandler, WindowOpenOptions, WindowSize,
+};
 
 use log::LevelFilter;
 use std::cell::RefCell;
@@ -16,12 +18,12 @@ struct WgpuExample {
 }
 
 impl WgpuExample {
-    async fn new(context: WindowContext) -> Self {
+    async fn new(context: WindowContext) -> Result<Self, HandlerError> {
         let instance = wgpu::Instance::new(wgpu::InstanceDescriptor::new_with_display_handle(
             Box::new(context.platform_handle()),
         ));
 
-        let surface = instance.create_surface(context.platform_handle()).unwrap();
+        let surface = instance.create_surface(context.platform_handle())?;
 
         let adapter = instance
             .request_adapter(&wgpu::RequestAdapterOptions {
@@ -31,8 +33,7 @@ impl WgpuExample {
                 compatible_surface: Some(&surface),
                 ..Default::default()
             })
-            .await
-            .expect("Failed to find an appropriate adapter");
+            .await?;
 
         // Create the logical device and command queue
         let (device, queue) = adapter
@@ -44,8 +45,7 @@ impl WgpuExample {
                 memory_hints: wgpu::MemoryHints::MemoryUsage,
                 ..Default::default()
             })
-            .await
-            .expect("Failed to create device");
+            .await?;
 
         const SHADER: &str = "
             const VERTS = array(
@@ -116,7 +116,7 @@ impl WgpuExample {
         let surface_config = surface.get_default_config(&adapter, width, height).unwrap();
         surface.configure(&device, &surface_config);
 
-        Self {
+        Ok(Self {
             window_context: context,
 
             instance,
@@ -125,7 +125,7 @@ impl WgpuExample {
             queue,
             surface: surface.into(),
             surface_config: surface_config.into(),
-        }
+        })
     }
 }
 
@@ -209,6 +209,7 @@ fn main() {
         .with_size(LogicalSize::new(512, 512));
 
     baseview::create_window(window_open_options, |c| pollster::block_on(WgpuExample::new(c)))
+        .unwrap()
         .run_until_closed();
 }
 

src/error.rs

@@ -0,0 +1,62 @@
+use std::fmt::{Debug, Display, Formatter};
+
+pub type Result<T> = std::result::Result<T, Error>;
+
+pub struct Error {
+    inner: crate::platform::Error,
+}
+
+impl From<crate::platform::Error> for Error {
+    fn from(inner: crate::platform::Error) -> Error {
+        Error { inner }
+    }
+}
+
+impl Debug for Error {
+    #[inline]
+    fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
+        Debug::fmt(&self.inner, f)
+    }
+}
+
+impl Display for Error {
+    fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
+        Display::fmt(&self.inner, f)
+    }
+}
+
+impl std::error::Error for Error {}
+
+pub struct HandlerError {
+    inner: Box<dyn std::error::Error + 'static>,
+}
+
+impl HandlerError {
+    #[inline]
+    pub fn cause(&self) -> &(dyn std::error::Error + 'static) {
+        self.inner.as_ref()
+    }
+
+    #[inline]
+    pub fn into_inner(self) -> Box<dyn std::error::Error + 'static> {
+        self.inner
+    }
+}
+
+impl Debug for HandlerError {
+    fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
+        Debug::fmt(&self.inner, f)
+    }
+}
+
+impl Display for HandlerError {
+    fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
+        Display::fmt(&self.inner, f)
+    }
+}
+
+impl<E: std::error::Error + 'static> From<E> for HandlerError {
+    fn from(value: E) -> Self {
+        Self { inner: Box::new(value) }
+    }
+}

src/gl.rs

@@ -1,4 +1,3 @@
-use crate::platform::gl::*;
 use std::ffi::{c_void, CStr};
 use std::marker::PhantomData;
 
@@ -43,13 +42,6 @@ pub enum Profile {
     Core,
 }
 
-#[derive(Debug)]
-#[non_exhaustive]
-pub enum GlError {
-    VersionNotSupported,
-    CreationFailed(CreationFailedError),
-}
-
 #[derive(Clone)]
 pub struct GlContext {
     inner: crate::platform::gl::GlContext,

src/handler.rs

@@ -1,24 +1,30 @@
 use super::*;
+use crate::platform::Result;
 
 pub trait WindowHandler: 'static {
     fn on_frame(&self);
     fn resized(&self, new_size: WindowSize);
     fn on_event(&self, event: Event) -> EventStatus;
 }
 
+type DynBuilderResult = core::result::Result<Box<dyn WindowHandler>, HandlerError>;
+
 #[allow(unused)]
 pub struct WindowHandlerBuilder {
-    inner: Box<dyn FnOnce(WindowContext) -> Box<dyn WindowHandler> + Send + 'static>,
+    inner: Box<dyn FnOnce(WindowContext) -> DynBuilderResult + Send + 'static>,
 }
 
 impl WindowHandlerBuilder {
     pub fn new<H: WindowHandler>(
-        f: impl FnOnce(WindowContext) -> H + Send + 'static,
+        f: impl FnOnce(WindowContext) -> core::result::Result<H, HandlerError> + Send + 'static,
     ) -> WindowHandlerBuilder {
-        Self { inner: Box::new(|c| Box::new(f(c))) }
+        Self { inner: Box::new(|c| Ok(Box::new(f(c)?))) }
     }
 
-    pub fn build(self, ctx: WindowContext) -> Box<dyn WindowHandler> {
-        (self.inner)(ctx)
+    pub fn build(self, ctx: WindowContext) -> Result<Box<dyn WindowHandler>> {
+        match (self.inner)(ctx) {
+            Ok(handle) => Ok(handle),
+            Err(e) => Err(platform::Error::Handler(e)),
+        }
     }
 }

src/lib.rs

@@ -1,9 +1,11 @@
 mod clipboard;
 mod context;
+mod error;
 mod event;
 mod handler;
 mod keyboard;
 mod mouse_cursor;
+mod tracing;
 mod window;
 mod window_open_options;
 
@@ -15,10 +17,13 @@ pub mod gl;
 pub use clipboard::*;
 pub use context::{PlatformHandle, WindowContext};
 pub use dpi;
+pub use error::*;
 pub use event::*;
 pub use handler::WindowHandler;
 pub use mouse_cursor::MouseCursor;
 pub use window::*;
 pub use window_open_options::*;
 
+pub(crate) use tracing::*;
+
 pub(crate) mod wrappers;

src/platform/macos/error.rs

@@ -0,0 +1,19 @@
+use crate::HandlerError;
+use std::fmt::Display;
+
+#[derive(Debug)]
+pub enum Error {
+    Handler(HandlerError),
+    #[cfg(feature = "opengl")]
+    GlError(super::gl::GlError),
+}
+
+impl Display for Error {
+    fn fmt(&self, fmt: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
+        match self {
+            #[cfg(feature = "opengl")]
+            Error::GlError(e) => e.fmt(fmt),
+            Error::Handler(e) => e.fmt(fmt),
+        }
+    }
+}