Implement freeze functionality

libwayshot/src/dispatch.rs

@@ -1,20 +1,27 @@
 use std::{
+    collections::HashSet,
     process::exit,
     sync::atomic::{AtomicBool, Ordering},
 };
+use tracing::{debug, trace};
 use wayland_client::{
     delegate_noop,
     globals::GlobalListContents,
     protocol::{
-        wl_buffer::WlBuffer, wl_output, wl_output::WlOutput, wl_registry, wl_registry::WlRegistry,
-        wl_shm::WlShm, wl_shm_pool::WlShmPool,
+        wl_buffer::WlBuffer, wl_compositor::WlCompositor, wl_output, wl_output::WlOutput,
+        wl_registry, wl_registry::WlRegistry, wl_shm::WlShm, wl_shm_pool::WlShmPool,
+        wl_surface::WlSurface,
     },
     Connection, Dispatch, QueueHandle, WEnum,
     WEnum::Value,
 };
 use wayland_protocols::xdg::xdg_output::zv1::client::{
     zxdg_output_manager_v1::ZxdgOutputManagerV1, zxdg_output_v1, zxdg_output_v1::ZxdgOutputV1,
 };
+use wayland_protocols_wlr::layer_shell::v1::client::{
+    zwlr_layer_shell_v1::ZwlrLayerShellV1,
+    zwlr_layer_surface_v1::{self, ZwlrLayerSurfaceV1},
+};
 use wayland_protocols_wlr::screencopy::v1::client::{
     zwlr_screencopy_frame_v1, zwlr_screencopy_frame_v1::ZwlrScreencopyFrameV1,
     zwlr_screencopy_manager_v1::ZwlrScreencopyManagerV1,
@@ -25,6 +32,7 @@ use crate::{
     screencopy::FrameFormat,
 };
 
+#[derive(Debug)]
 pub struct OutputCaptureState {
     pub outputs: Vec<OutputInfo>,
 }
@@ -56,16 +64,9 @@ impl Dispatch<WlRegistry, ()> for OutputCaptureState {
                         name: "".to_string(),
                         description: String::new(),
                         transform: wl_output::Transform::Normal,
-                        dimensions: OutputPositioning {
-                            x: 0,
-                            y: 0,
-                            width: 0,
-                            height: 0,
-                        },
-                        mode: WlOutputMode {
-                            width: 0,
-                            height: 0,
-                        },
+                        scale: 1,
+                        dimensions: OutputPositioning::default(),
+                        mode: WlOutputMode::default(),
                     });
                 } else {
                     tracing::error!("Ignoring a wl_output with version < 4.");
@@ -106,7 +107,11 @@ impl Dispatch<WlOutput, ()> for OutputCaptureState {
             } => {
                 output.transform = transform;
             }
-            _ => (),
+            wl_output::Event::Scale { factor } => {
+                output.scale = factor;
+            }
+            wl_output::Event::Done => {}
+            _ => {}
         }
     }
 }
@@ -128,12 +133,10 @@ impl Dispatch<ZxdgOutputV1, usize> for OutputCaptureState {
             zxdg_output_v1::Event::LogicalPosition { x, y } => {
                 output_info.dimensions.x = x;
                 output_info.dimensions.y = y;
-                tracing::debug!("Logical position event fired!");
             }
             zxdg_output_v1::Event::LogicalSize { width, height } => {
                 output_info.dimensions.width = width;
                 output_info.dimensions.height = height;
-                tracing::debug!("Logical size event fired!");
             }
             _ => {}
         };
@@ -156,6 +159,7 @@ pub struct CaptureFrameState {
 }
 
 impl Dispatch<ZwlrScreencopyFrameV1, ()> for CaptureFrameState {
+    #[tracing::instrument(skip(frame), level = "trace")]
     fn event(
         frame: &mut Self,
         _: &ZwlrScreencopyFrameV1,
@@ -171,7 +175,6 @@ impl Dispatch<ZwlrScreencopyFrameV1, ()> for CaptureFrameState {
                 height,
                 stride,
             } => {
-                tracing::debug!("Received Buffer event");
                 if let Value(f) = format {
                     frame.formats.push(FrameFormat {
                         format: f,
@@ -184,30 +187,27 @@ impl Dispatch<ZwlrScreencopyFrameV1, ()> for CaptureFrameState {
                     exit(1);
                 }
             }
-            zwlr_screencopy_frame_v1::Event::Flags { .. } => {
-                tracing::debug!("Received Flags event");
-            }
             zwlr_screencopy_frame_v1::Event::Ready { .. } => {
                 // If the frame is successfully copied, a “flags” and a “ready” events are sent. Otherwise, a “failed” event is sent.
                 // This is useful when we call .copy on the frame object.
-                tracing::debug!("Received Ready event");
+                tracing::trace!("Received Ready event");
                 frame.state.replace(FrameState::Finished);
             }
             zwlr_screencopy_frame_v1::Event::Failed => {
-                tracing::debug!("Received Failed event");
+                tracing::trace!("Received Failed event");
                 frame.state.replace(FrameState::Failed);
             }
             zwlr_screencopy_frame_v1::Event::Damage { .. } => {
-                tracing::debug!("Received Damage event");
+                tracing::trace!("Received Damage event");
             }
             zwlr_screencopy_frame_v1::Event::LinuxDmabuf { .. } => {
-                tracing::debug!("Received LinuxDmaBuf event");
+                tracing::trace!("Received LinuxDmaBuf event");
             }
             zwlr_screencopy_frame_v1::Event::BufferDone => {
-                tracing::debug!("Received bufferdone event");
+                tracing::trace!("Received bufferdone event");
                 frame.buffer_done.store(true, Ordering::SeqCst);
             }
-            _ => unreachable!(),
+            _ => {}
         };
     }
 }
@@ -232,3 +232,70 @@ impl wayland_client::Dispatch<wl_registry::WlRegistry, GlobalListContents> for W
     ) {
     }
 }
+
+pub struct LayerShellState {
+    pub configured_outputs: HashSet<WlOutput>,
+}
+
+delegate_noop!(LayerShellState: ignore WlCompositor);
+// delegate_noop!(LayerShellState: ignore ZwlrLayerShellV1);
+// delegate_noop!(LayerShellState: ignore WlSurface);
+// delegate_noop!(LayerShellState: ignore ZwlrLayerSurfaceV1);
+delegate_noop!(LayerShellState: ignore WlShm);
+delegate_noop!(LayerShellState: ignore WlShmPool);
+delegate_noop!(LayerShellState: ignore WlBuffer);
+
+impl wayland_client::Dispatch<ZwlrLayerShellV1, ()> for LayerShellState {
+    fn event(
+        _state: &mut Self,
+        _proxy: &ZwlrLayerShellV1,
+        event: <ZwlrLayerShellV1 as wayland_client::Proxy>::Event,
+        _data: &(),
+        _conn: &Connection,
+        _qhandle: &QueueHandle<Self>,
+    ) {
+        match event {
+            _ => todo!(),
+        }
+    }
+}
+impl wayland_client::Dispatch<WlSurface, ()> for LayerShellState {
+    fn event(
+        _state: &mut Self,
+        _proxy: &WlSurface,
+        event: <WlSurface as wayland_client::Proxy>::Event,
+        _data: &(),
+        _conn: &Connection,
+        _qhandle: &QueueHandle<Self>,
+    ) {
+        debug!("WlSurface event: {:?}", event);
+    }
+}
+
+impl wayland_client::Dispatch<ZwlrLayerSurfaceV1, WlOutput> for LayerShellState {
+    fn event(
+        state: &mut Self,
+        proxy: &ZwlrLayerSurfaceV1,
+        event: <ZwlrLayerSurfaceV1 as wayland_client::Proxy>::Event,
+        data: &WlOutput,
+        _conn: &Connection,
+        _qhandle: &QueueHandle<Self>,
+    ) {
+        match event {
+            zwlr_layer_surface_v1::Event::Configure {
+                serial,
+                width: _,
+                height: _,
+            } => {
+                debug!("Acking configure");
+                state.configured_outputs.insert(data.clone());
+                proxy.ack_configure(serial);
+                trace!("Acked configure");
+            }
+            zwlr_layer_surface_v1::Event::Closed => {
+                debug!("Closed")
+            }
+            _ => {}
+        }
+    }
+}

libwayshot/src/error.rs

@@ -27,4 +27,6 @@ pub enum Error {
     NoSupportedBufferFormat,
     #[error("Cannot find required wayland protocol")]
     ProtocolNotFound(String),
+    #[error("error occurred in freeze callback")]
+    FreezeCallbackError,
 }