Merge pull request #49 from devmobasa/zoom-improvements

Zoom improvements

Author: devmobasa

packaging/wayscriber.service

@@ -2,13 +2,18 @@
 Description=Wayscriber - Screen annotation tool for Wayland
 Documentation=https://wayscriber.com
 PartOf=graphical-session.target
+After=graphical-session.target
+Wants=graphical-session.target
 
 [Service]
 Type=simple
+ExecStartPre=/bin/sh -c '[ -n "$WAYLAND_DISPLAY" ] && [ -S "$XDG_RUNTIME_DIR/$WAYLAND_DISPLAY" ]'
 ExecStart=/usr/bin/wayscriber --daemon
 Restart=on-failure
 RestartSec=5
-# Ensure Wayland environment is available
+RestartPreventExitStatus=75
+SuccessExitStatus=75
+# Ensure consistent PATH for helper tools
 Environment="PATH=/usr/local/bin:/usr/bin:/bin"
 
 [Install]

src/backend/wayland/backend.rs

@@ -35,12 +35,12 @@ use std::{
 };
 #[cfg(tablet)]
 const TABLET_MANAGER_MAX_VERSION: u32 = 2;
-use wayland_client::{Connection, globals::registry_queue_init};
+use wayland_client::{Connection, backend::WaylandError, globals::registry_queue_init};
 #[cfg(tablet)]
 use wayland_protocols::wp::tablet::zv2::client::zwp_tablet_manager_v2::ZwpTabletManagerV2;
 use wayland_protocols_wlr::screencopy::v1::client::zwlr_screencopy_manager_v1::ZwlrScreencopyManagerV1;
 
-use super::state::WaylandState;
+use super::state::{OverlaySuppression, WaylandState};
 use crate::{
     RESUME_SESSION_ENV,
     capture::{CaptureManager, CaptureOutcome},
@@ -641,12 +641,8 @@ impl WaylandBackend {
             }
 
             // Apply any completed portal fallback captures without blocking.
-            state
-                .frozen
-                .poll_portal_capture(&mut state.surface, &mut state.input_state);
-            state
-                .zoom
-                .poll_portal_capture(&mut state.surface, &mut state.input_state);
+            state.frozen.poll_portal_capture(&mut state.input_state);
+            state.zoom.poll_portal_capture(&mut state.input_state);
 
             if tray_action_flag
                 .as_ref()
@@ -656,9 +652,46 @@ impl WaylandBackend {
                 process_tray_action(&mut state);
             }
 
-            // Dispatch all pending events (blocking) but check should_exit after each batch
-            match event_queue.blocking_dispatch(&mut state) {
-                Ok(_) => {
+            let capture_active = state.capture.is_in_progress()
+                || state.frozen.is_in_progress()
+                || state.zoom.is_in_progress()
+                || state.overlay_suppressed();
+
+            let mut dispatch_error: Option<anyhow::Error> = None;
+            if capture_active {
+                if let Err(e) = event_queue.dispatch_pending(&mut state) {
+                    dispatch_error = Some(anyhow::anyhow!("Wayland event queue error: {}", e));
+                }
+
+                if dispatch_error.is_none()
+                    && let Err(e) = event_queue.flush()
+                {
+                    dispatch_error = Some(anyhow::anyhow!("Wayland flush error: {}", e));
+                }
+
+                if dispatch_error.is_none()
+                    && let Some(guard) = event_queue.prepare_read()
+                {
+                    match guard.read() {
+                        Ok(_) => {
+                            if let Err(e) = event_queue.dispatch_pending(&mut state) {
+                                dispatch_error =
+                                    Some(anyhow::anyhow!("Wayland event queue error: {}", e));
+                            }
+                        }
+                        Err(WaylandError::Io(err))
+                            if err.kind() == std::io::ErrorKind::WouldBlock => {}
+                        Err(err) => {
+                            dispatch_error = Some(anyhow::anyhow!("Wayland read error: {}", err));
+                        }
+                    }
+                }
+            } else if let Err(e) = event_queue.blocking_dispatch(&mut state) {
+                dispatch_error = Some(anyhow::anyhow!("Wayland event queue error: {}", e));
+            }
+
+            match dispatch_error {
+                None => {
                     // Check immediately after dispatch returns
                     if state.input_state.should_exit {
                         info!("Exit requested after dispatch, breaking event loop");
@@ -679,13 +712,20 @@ impl WaylandBackend {
                         state.input_state.needs_redraw = true;
                     }
                 }
-                Err(e) => {
+                Some(e) => {
                     warn!("Event queue error: {}", e);
-                    loop_error = Some(anyhow::anyhow!("Wayland event queue error: {}", e));
+                    loop_error = Some(e);
                     break;
                 }
             }
 
+            if capture_active {
+                let _ = conn.flush();
+                std::thread::sleep(std::time::Duration::from_millis(10));
+            }
+
+            state.apply_capture_completion();
+
             if state.input_state.take_pending_frozen_toggle() {
                 if !state.frozen_enabled() {
                     warn!(
@@ -702,24 +742,20 @@ impl WaylandBackend {
                     } else {
                         log::info!("Frozen mode: using screencopy fast path");
                     }
-                    if let Err(err) = state.frozen.start_capture(
-                        &state.shm,
-                        &mut state.surface,
-                        &qh,
-                        use_fallback,
-                        &mut state.input_state,
-                        &state.tokio_handle,
-                    ) {
+                    state.enter_overlay_suppression(OverlaySuppression::Frozen);
+                    if let Err(err) = state
+                        .frozen
+                        .start_capture(use_fallback, &state.tokio_handle)
+                    {
                         warn!("Frozen capture failed to start: {}", err);
-                        state
-                            .frozen
-                            .cancel(&mut state.surface, &mut state.input_state);
+                        state.exit_overlay_suppression(OverlaySuppression::Frozen);
+                        state.frozen.cancel(&mut state.input_state);
                     }
                 }
             }
 
             if let Some(action) = state.input_state.take_pending_zoom_action() {
-                state.handle_zoom_action(action, &qh);
+                state.handle_zoom_action(action);
             }
 
             // Check for completed capture operations

src/backend/wayland/capture.rs

@@ -1,19 +1,13 @@
-//! Capture controller for managing overlay visibility and capture state.
+//! Capture controller for managing screenshot capture state.
 //!
-//! Keeps the overlay hide/show logic alongside the CaptureManager so the
-//! main Wayland loop only coordinates events instead of tracking flags.
+//! Keeps the capture manager and in-progress flag together so the main
+//! Wayland loop can coordinate capture requests and results.
 
 use crate::capture::CaptureManager;
-use log::{debug, info, warn};
-use smithay_client_toolkit::shell::WaylandSurface;
-
-use super::surface::SurfaceState;
-
-/// Tracks capture manager state along with overlay visibility flags.
+/// Tracks capture manager state and in-progress flag.
 pub struct CaptureState {
     manager: CaptureManager,
     in_progress: bool,
-    overlay_hidden: bool,
 }
 
 impl CaptureState {
@@ -22,7 +16,6 @@ impl CaptureState {
         Self {
             manager,
             in_progress: false,
-            overlay_hidden: false,
         }
     }
 
@@ -45,65 +38,4 @@ impl CaptureState {
     pub fn clear_in_progress(&mut self) {
         self.in_progress = false;
     }
-
-    /// Returns whether the overlay is currently hidden.
-    pub fn is_overlay_hidden(&self) -> bool {
-        self.overlay_hidden
-    }
-
-    /// Hides the overlay before capture.
-    ///
-    /// Returns `true` if the overlay was hidden, `false` if it was already hidden.
-    pub fn hide_overlay(&mut self, surface: &mut SurfaceState) -> bool {
-        if self.overlay_hidden {
-            warn!("Overlay already hidden for capture");
-            return false;
-        }
-
-        info!("Hiding overlay for screenshot capture");
-        let mut hidden = false;
-        if let Some(layer_surface) = surface.layer_surface_mut() {
-            layer_surface.set_size(0, 0);
-            let wl_surface = layer_surface.wl_surface();
-            wl_surface.commit();
-            hidden = true;
-        } else if surface.is_xdg_window() {
-            if let Some(wl_surface) = surface.wl_surface() {
-                // Detach the buffer to unmap the xdg window during capture.
-                wl_surface.attach(None, 0, 0);
-                wl_surface.commit();
-                hidden = true;
-            } else {
-                warn!("xdg-shell surface missing wl_surface; cannot hide overlay");
-            }
-        }
-
-        self.overlay_hidden = hidden;
-        hidden
-    }
-
-    /// Restores the overlay after capture.
-    ///
-    /// Returns `true` if the overlay was restored, `false` if it wasn't hidden.
-    pub fn show_overlay(&mut self, surface: &mut SurfaceState) -> bool {
-        if !self.overlay_hidden {
-            warn!("Overlay was not hidden, nothing to restore");
-            return false;
-        }
-
-        info!("Restoring overlay after screenshot capture");
-
-        let width = surface.width();
-        let height = surface.height();
-        if let Some(layer_surface) = surface.layer_surface_mut() {
-            layer_surface.set_size(width, height);
-            let wl_surface = layer_surface.wl_surface();
-            wl_surface.commit();
-        } else if surface.is_xdg_window() {
-            debug!("xdg-shell overlay will be restored on next render");
-        }
-
-        self.overlay_hidden = false;
-        true
-    }
 }