Implement Debug for Context, Surface and Buffer (#268)

* Implement Debug for all types

* Make Debug impls not output pixel data

Author: madsmtm

CHANGELOG.md

@@ -5,6 +5,7 @@
 - Make `Context` cloneable.
 - Added `Buffer::width()` and `Buffer::height()` getters.
 - Added support for `wasm64-*` targets.
+- `Context`, `Surface` and `Buffer` now implement `Debug`.
 
 # 0.4.6
 

src/backend_dispatch.rs

@@ -3,6 +3,7 @@
 use crate::{backend_interface::*, backends, InitError, Rect, SoftBufferError};
 
 use raw_window_handle::{HasDisplayHandle, HasWindowHandle};
+use std::fmt;
 use std::num::NonZeroU32;
 
 /// A macro for creating the enum used to statically dispatch to the platform-specific implementation.
@@ -54,6 +55,17 @@ macro_rules! make_dispatch {
             }
         }
 
+        impl<D: fmt::Debug> fmt::Debug for ContextDispatch<D> {
+            fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+                match self {
+                    $(
+                        $(#[$attr])*
+                        Self::$name(inner) => inner.fmt(f),
+                    )*
+                }
+            }
+        }
+
         #[allow(clippy::large_enum_variant)] // it's boxed anyways
         pub(crate) enum SurfaceDispatch<$dgen, $wgen> {
             $(
@@ -115,6 +127,17 @@ macro_rules! make_dispatch {
             }
         }
 
+        impl<D: fmt::Debug, W: fmt::Debug> fmt::Debug for SurfaceDispatch<D, W> {
+            fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+                match self {
+                    $(
+                        $(#[$attr])*
+                        Self::$name(inner) => inner.fmt(f),
+                    )*
+                }
+            }
+        }
+
         pub(crate) enum BufferDispatch<'a, $dgen, $wgen> {
             $(
                 $(#[$attr])*
@@ -190,6 +213,17 @@ macro_rules! make_dispatch {
                 }
             }
         }
+
+        impl<D: fmt::Debug, W: fmt::Debug> fmt::Debug for BufferDispatch<'_, D, W> {
+            fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+                match self {
+                    $(
+                        $(#[$attr])*
+                        Self::$name(inner) => inner.fmt(f),
+                    )*
+                }
+            }
+        }
     };
 }
 

src/backends/android.rs

@@ -12,9 +12,10 @@ use raw_window_handle::AndroidNdkWindowHandle;
 use raw_window_handle::{HasDisplayHandle, HasWindowHandle, RawWindowHandle};
 
 use crate::error::InitError;
-use crate::{BufferInterface, Rect, SoftBufferError, SurfaceInterface};
+use crate::{util, BufferInterface, Rect, SoftBufferError, SurfaceInterface};
 
 /// The handle to a window for software buffering.
+#[derive(Debug)]
 pub struct AndroidImpl<D, W> {
     native_window: NativeWindow,
     window: W,
@@ -102,7 +103,7 @@ impl<D: HasDisplayHandle, W: HasWindowHandle> SurfaceInterface<D, W> for Android
 
         Ok(BufferImpl {
             native_window_buffer,
-            buffer,
+            buffer: util::PixelBuffer(buffer),
             marker: PhantomData,
         })
     }
@@ -113,9 +114,10 @@ impl<D: HasDisplayHandle, W: HasWindowHandle> SurfaceInterface<D, W> for Android
     }
 }
 
+#[derive(Debug)]
 pub struct BufferImpl<'a, D: ?Sized, W> {
     native_window_buffer: NativeWindowBufferLockGuard<'a>,
-    buffer: Vec<u32>,
+    buffer: util::PixelBuffer,
     marker: PhantomData<(&'a D, &'a W)>,
 }
 

src/backends/cg.rs

@@ -1,7 +1,7 @@
 //! Softbuffer implementation using CoreGraphics.
 use crate::backend_interface::*;
 use crate::error::InitError;
-use crate::{Rect, SoftBufferError};
+use crate::{util, Rect, SoftBufferError};
 use objc2::rc::Retained;
 use objc2::runtime::{AnyObject, Bool};
 use objc2::{define_class, msg_send, AllocAnyThread, DefinedClass, MainThreadMarker, Message};
@@ -29,6 +29,7 @@ define_class!(
     #[unsafe(super(NSObject))]
     #[name = "SoftbufferObserver"]
     #[ivars = SendCALayer]
+    #[derive(Debug)]
     struct Observer;
 
     /// NSKeyValueObserving
@@ -93,6 +94,7 @@ impl Observer {
     }
 }
 
+#[derive(Debug)]
 pub struct CGImpl<D, W> {
     /// Our layer.
     layer: SendCALayer,
@@ -258,15 +260,16 @@ impl<D: HasDisplayHandle, W: HasWindowHandle> SurfaceInterface<D, W> for CGImpl<
 
     fn buffer_mut(&mut self) -> Result<BufferImpl<'_, D, W>, SoftBufferError> {
         Ok(BufferImpl {
-            buffer: vec![0; self.width * self.height].into(),
+            buffer: util::PixelBuffer(vec![0; self.width * self.height]),
             imp: self,
         })
     }
 }
 
+#[derive(Debug)]
 pub struct BufferImpl<'a, D, W> {
     imp: &'a mut CGImpl<D, W>,
-    buffer: Box<[u32]>,
+    buffer: util::PixelBuffer,
 }
 
 impl<D: HasDisplayHandle, W: HasWindowHandle> BufferInterface for BufferImpl<'_, D, W> {
@@ -306,7 +309,7 @@ impl<D: HasDisplayHandle, W: HasWindowHandle> BufferInterface for BufferImpl<'_,
 
         let data_provider = {
             let len = self.buffer.len() * size_of::<u32>();
-            let buffer: *mut [u32] = Box::into_raw(self.buffer);
+            let buffer: *mut [u32] = Box::into_raw(self.buffer.0.into_boxed_slice());
             // Convert slice pointer to thin pointer.
             let data_ptr = buffer.cast::<c_void>();
 
@@ -363,6 +366,7 @@ impl<D: HasDisplayHandle, W: HasWindowHandle> BufferInterface for BufferImpl<'_,
     }
 }
 
+#[derive(Debug)]
 struct SendCALayer(Retained<CALayer>);
 
 // SAFETY: CALayer is dubiously thread safe, like most things in Core Animation.

src/backends/kms.rs

@@ -12,6 +12,7 @@ use drm::Device;
 use raw_window_handle::{HasDisplayHandle, HasWindowHandle, RawDisplayHandle, RawWindowHandle};
 
 use std::collections::HashSet;
+use std::fmt;
 use std::marker::PhantomData;
 use std::num::NonZeroU32;
 use std::os::unix::io::{AsFd, BorrowedFd};
@@ -118,6 +119,13 @@ pub(crate) struct BufferImpl<'a, D: ?Sized, W: ?Sized> {
     _window: PhantomData<&'a mut W>,
 }
 
+impl<D: ?Sized + fmt::Debug, W: ?Sized + fmt::Debug> fmt::Debug for BufferImpl<'_, D, W> {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        // FIXME: Derive instead once `DumbMapping` impls `Debug`.
+        f.debug_struct("BufferImpl").finish_non_exhaustive()
+    }
+}
+
 /// The combined frame buffer and dumb buffer.
 #[derive(Debug)]
 struct SharedBuffer {

src/backends/orbital.rs

@@ -3,8 +3,9 @@ use raw_window_handle::{HasDisplayHandle, HasWindowHandle, OrbitalWindowHandle,
 use std::{cmp, marker::PhantomData, num::NonZeroU32, slice, str};
 
 use crate::backend_interface::*;
-use crate::{Rect, SoftBufferError};
+use crate::{util, Rect, SoftBufferError};
 
+#[derive(Debug)]
 struct OrbitalMap {
     address: usize,
     size: usize,
@@ -55,6 +56,7 @@ impl Drop for OrbitalMap {
     }
 }
 
+#[derive(Debug)]
 pub struct OrbitalImpl<D, W> {
     handle: ThreadSafeWindowHandle,
     width: u32,
@@ -64,6 +66,7 @@ pub struct OrbitalImpl<D, W> {
     _display: PhantomData<D>,
 }
 
+#[derive(Debug)]
 struct ThreadSafeWindowHandle(OrbitalWindowHandle);
 unsafe impl Send for ThreadSafeWindowHandle {}
 unsafe impl Sync for ThreadSafeWindowHandle {}
@@ -174,17 +177,23 @@ impl<D: HasDisplayHandle, W: HasWindowHandle> SurfaceInterface<D, W> for Orbital
                     .expect("failed to map orbital window"),
             )
         } else {
-            Pixels::Buffer(vec![0; self.width as usize * self.height as usize])
+            Pixels::Buffer(util::PixelBuffer(vec![
+                0;
+                self.width as usize
+                    * self.height as usize
+            ]))
         };
         Ok(BufferImpl { imp: self, pixels })
     }
 }
 
+#[derive(Debug)]
 enum Pixels {
     Mapping(OrbitalMap),
-    Buffer(Vec<u32>),
+    Buffer(util::PixelBuffer),
 }
 
+#[derive(Debug)]
 pub struct BufferImpl<'a, D, W> {
     imp: &'a mut OrbitalImpl<D, W>,
     pixels: Pixels,

src/backends/wayland/buffer.rs

@@ -67,6 +67,7 @@ unsafe fn map_file(file: &File) -> MmapMut {
     unsafe { MmapMut::map_mut(file.as_raw_fd()).expect("Failed to map shared memory") }
 }
 
+#[derive(Debug)]
 pub(super) struct WaylandBuffer {
     qh: QueueHandle<State>,
     tempfile: File,

src/backends/wayland/mod.rs

@@ -20,6 +20,7 @@ use buffer::WaylandBuffer;
 
 struct State;
 
+#[derive(Debug)]
 pub struct WaylandDisplayImpl<D: ?Sized> {
     conn: Option<Connection>,
     event_queue: Mutex<EventQueue<State>>,
@@ -74,6 +75,7 @@ impl<D: ?Sized> Drop for WaylandDisplayImpl<D> {
     }
 }
 
+#[derive(Debug)]
 pub struct WaylandImpl<D: ?Sized, W: ?Sized> {
     display: Arc<WaylandDisplayImpl<D>>,
     surface: Option<wl_surface::WlSurface>,
@@ -261,6 +263,7 @@ impl<D: ?Sized, W: ?Sized> Drop for WaylandImpl<D, W> {
     }
 }
 
+#[derive(Debug)]
 pub struct BufferImpl<'a, D: ?Sized, W> {
     stack: util::BorrowStack<'a, WaylandImpl<D, W>, [u32]>,
     width: i32,

src/backends/web.rs

@@ -18,7 +18,7 @@ use std::num::NonZeroU32;
 /// Display implementation for the web platform.
 ///
 /// This just caches the document to prevent having to query it every time.
-#[derive(Clone)]
+#[derive(Clone, Debug)]
 pub struct WebDisplayImpl<D> {
     document: web_sys::Document,
     _display: D,
@@ -43,12 +43,13 @@ impl<D: HasDisplayHandle> ContextInterface<D> for WebDisplayImpl<D> {
     }
 }
 
+#[derive(Debug)]
 pub struct WebImpl<D, W> {
     /// The handle and context to the canvas that we're drawing to.
     canvas: Canvas,
 
     /// The buffer that we're drawing to.
-    buffer: Vec<u32>,
+    buffer: util::PixelBuffer,
 
     /// Buffer has been presented.
     buffer_presented: bool,
@@ -65,6 +66,7 @@ pub struct WebImpl<D, W> {
 
 /// Holding canvas and context for [`HtmlCanvasElement`] or [`OffscreenCanvas`],
 /// since they have different types.
+#[derive(Debug)]
 enum Canvas {
     Canvas {
         canvas: HtmlCanvasElement,
@@ -82,7 +84,7 @@ impl<D: HasDisplayHandle, W: HasWindowHandle> WebImpl<D, W> {
 
         Ok(Self {
             canvas: Canvas::Canvas { canvas, ctx },
-            buffer: Vec::new(),
+            buffer: util::PixelBuffer(Vec::new()),
             buffer_presented: false,
             size: None,
             window_handle: window,
@@ -98,7 +100,7 @@ impl<D: HasDisplayHandle, W: HasWindowHandle> WebImpl<D, W> {
 
         Ok(Self {
             canvas: Canvas::OffscreenCanvas { canvas, ctx },
-            buffer: Vec::new(),
+            buffer: util::PixelBuffer(Vec::new()),
             buffer_presented: false,
             size: None,
             window_handle: window,
@@ -373,6 +375,7 @@ impl Canvas {
     }
 }
 
+#[derive(Debug)]
 pub struct BufferImpl<'a, D, W> {
     imp: &'a mut WebImpl<D, W>,
 }

src/backends/win32.rs

@@ -25,6 +25,7 @@ const ZERO_QUAD: Gdi::RGBQUAD = Gdi::RGBQUAD {
     rgbReserved: 0,
 };
 
+#[derive(Debug)]
 struct Buffer {
     dc: Gdi::HDC,
     bitmap: Gdi::HBITMAP,
@@ -135,6 +136,7 @@ impl Buffer {
 }
 
 /// The handle to a window for software buffering.
+#[derive(Debug)]
 pub struct Win32Impl<D: ?Sized, W> {
     /// The window handle.
     window: OnlyUsedFromOrigin<HWND>,
@@ -281,6 +283,7 @@ impl<D: HasDisplayHandle, W: HasWindowHandle> SurfaceInterface<D, W> for Win32Im
     }
 }
 
+#[derive(Debug)]
 pub struct BufferImpl<'a, D, W>(&'a mut Win32Impl<D, W>);
 
 impl<D: HasDisplayHandle, W: HasWindowHandle> BufferInterface for BufferImpl<'_, D, W> {
@@ -468,6 +471,7 @@ impl Command {
     }
 }
 
+#[derive(Debug)]
 struct OnlyUsedFromOrigin<T>(T);
 unsafe impl<T> Send for OnlyUsedFromOrigin<T> {}