Show a preview of the desktop

Author: radiantly

Cargo.lock

@@ -12,6 +12,7 @@ egui_extras = "0.32.0"
 image = { version = "0.25.6", default-features = false, features = ["ico"]}
 wgpu = { version = "25.0.0", default-features = true }
 windows = { version = "0.61.3", features = ["Win32_UI_WindowsAndMessaging" , "Win32_Graphics_Dwm", "Win32_System_Console"] }
+windows-capture = "1.5.0"
 
 [build-dependencies]
 winresource = "0.1.23"

injector/Cargo.toml

@@ -1,12 +1,54 @@
 use crate::injector::{self, WindowInfo};
 use eframe::{
     Renderer,
-    egui::{self, IconData},
+    egui::{self, ColorImage, IconData},
 };
 use image::{GenericImageView, ImageFormat, ImageReader};
 use std::sync::{Arc, Mutex};
 use std::thread;
 use std::{io::Cursor, mem};
+use windows_capture::capture::{Context, GraphicsCaptureApiHandler};
+use windows_capture::frame::Frame;
+use windows_capture::monitor::Monitor;
+use windows_capture::settings::{
+    ColorFormat, CursorCaptureSettings, DirtyRegionSettings, DrawBorderSettings,
+    MinimumUpdateIntervalSettings, SecondaryWindowSettings, Settings,
+};
+
+struct ScreenCapture {
+    capture_sender: crossbeam_channel::Sender<ColorImage>,
+}
+
+impl GraphicsCaptureApiHandler for ScreenCapture {
+    type Flags = crossbeam_channel::Sender<ColorImage>;
+
+    type Error = Box<dyn std::error::Error + Send + Sync>;
+
+    fn new(ctx: Context<Self::Flags>) -> Result<Self, Self::Error> {
+        Ok(ScreenCapture {
+            capture_sender: ctx.flags,
+        })
+    }
+
+    fn on_frame_arrived(
+        &mut self,
+        frame: &mut Frame,
+        _capture_control: windows_capture::graphics_capture_api::InternalCaptureControl,
+    ) -> Result<(), Self::Error> {
+        let width = frame.width();
+        let height = frame.height();
+        if let Ok(mut buffer) = frame.buffer() {
+            if let Ok(no_pad_buffer) = buffer.as_nopadding_buffer() {
+                let img = ColorImage::from_rgba_unmultiplied(
+                    [width as usize, height as usize],
+                    &no_pad_buffer,
+                );
+                let _ = self.capture_sender.try_send(img);
+            }
+        }
+        Ok(())
+    }
+}
 
 #[derive(Debug)]
 enum WorkerEvents {
@@ -15,11 +57,12 @@ enum WorkerEvents {
     SHOW(u32, u32, bool),
 }
 
-#[derive(Debug)]
 struct Gui {
     windows: Arc<Mutex<Vec<WindowInfo>>>,
-    sender: crossbeam_channel::Sender<WorkerEvents>,
-    hide_taskbar_icons: bool,
+    event_sender: crossbeam_channel::Sender<WorkerEvents>,
+    capture_receiver: crossbeam_channel::Receiver<ColorImage>,
+    hide_from_taskbar: bool,
+    capture_tex: Option<egui::TextureHandle>,
 }
 
 impl Gui {
@@ -50,10 +93,39 @@ impl Gui {
             }
         });
 
+        let (capture_sender, capture_receiver) = crossbeam_channel::bounded(1);
+
+        thread::spawn(move || {
+            let primary_monitor = Monitor::primary().expect("There is no primary monitor");
+
+            let settings = Settings::new(
+                // Item to capture
+                primary_monitor,
+                // Capture cursor settings
+                CursorCaptureSettings::Default,
+                // Draw border settings
+                DrawBorderSettings::Default,
+                // Secondary window settings, if you want to include secondary windows in the capture
+                SecondaryWindowSettings::Default,
+                // Minimum update interval, if you want to change the frame rate limit (default is 60 FPS or 16.67 ms)
+                MinimumUpdateIntervalSettings::Default,
+                // Dirty region settings,
+                DirtyRegionSettings::Default,
+                // The desired color format for the captured frame.
+                ColorFormat::Rgba8,
+                // Additional flags for the capture settings that will be passed to the user-defined `new` function.
+                capture_sender,
+            );
+
+            ScreenCapture::start(settings).expect("screen capture failed");
+        });
+
         Gui {
             windows,
-            sender,
-            hide_taskbar_icons: false,
+            event_sender: sender,
+            capture_receiver,
+            hide_from_taskbar: false,
+            capture_tex: None,
         }
     }
 }
@@ -67,17 +139,39 @@ impl eframe::App for Gui {
                 // `focused` is a bool: true=gained focus, false=lost focus
                 if focused {
                     println!("focused");
-                    self.sender.send(WorkerEvents::UPDATE).unwrap();
+                    self.event_sender.send(WorkerEvents::UPDATE).unwrap();
                 } else {
                     println!("unfocused");
                 }
             }
         }
         egui::CentralPanel::default().show(ctx, |ui| {
-            ui.heading("Hide applications");
-            ui.add_space(4.0);
-
             egui::ScrollArea::vertical().show(ui, |ui| {
+                ui.heading("Desktop Preview");
+                ui.add_space(4.0);
+
+                if let Ok(img) = self.capture_receiver.try_recv() {
+                    if let Some(texture_handle) = &mut self.capture_tex {
+                        texture_handle.set(img, egui::TextureOptions::default());
+                    } else {
+                        self.capture_tex = Some(ctx.load_texture(
+                            "screen_capture",
+                            img,
+                            egui::TextureOptions::LINEAR, // or NEAREST if you want crisp pixels
+                        ));
+                    }
+                }
+
+                if let Some(tex) = &self.capture_tex {
+                    // Show at native size:
+                    ui.add(egui::Image::from_texture(tex).shrink_to_fit());
+                    // or force a size (e.g. scale to 512x512):
+                    // ui.image((tex.id(), egui::vec2(512.0, 512.0)));
+                }
+                ui.add_space(8.0);
+
+                ui.heading("Hide applications");
+                ui.add_space(4.0);
                 for window_info in self.windows.lock().unwrap().iter_mut() {
                     ui.style_mut().wrap_mode = Some(egui::TextWrapMode::Truncate); // elide with "…"
                     let checkbox_response =
@@ -87,24 +181,21 @@ impl eframe::App for Gui {
                             WorkerEvents::HIDE(
                                 window_info.pid,
                                 window_info.hwnd,
-                                !self.hide_taskbar_icons,
+                                self.hide_from_taskbar,
                             )
                         } else {
                             WorkerEvents::SHOW(
                                 window_info.pid,
                                 window_info.hwnd,
-                                !self.hide_taskbar_icons,
+                                self.hide_from_taskbar,
                             )
                         };
-                        self.sender.send(event).unwrap();
+                        self.event_sender.send(event).unwrap();
                     }
                 }
                 ui.add_space(10.0);
                 ui.collapsing("Advanced settings", |ui| {
-                    ui.checkbox(
-                        &mut self.hide_taskbar_icons,
-                        "Hide from Alt+Tab and Taskbar",
-                    )
+                    ui.checkbox(&mut self.hide_from_taskbar, "Hide from Alt+Tab and Taskbar")
                 });
             });
         });

injector/src/gui.rs

@@ -114,7 +114,7 @@ pub fn set_window_props(
     target_process: OwnedProcess,
     hwnds: &[u32],
     hide: bool,
-    show_on_taskbar: bool,
+    hide_from_taskbar: bool,
 ) {
     let syringe = Syringe::for_process(target_process);
 
@@ -125,23 +125,22 @@ pub fn set_window_props(
 
     let remote_proc2 = inject_and_get_remote_proc::<extern "system" fn(HWND, bool) -> bool>(
         &syringe,
-        "ShowOnTaskBar",
+        "HideFromTaskbar",
     );
 
     for hwnd in hwnds {
         remote_proc
             .call(HWND(hwnd.clone() as *mut _), hide)
             .unwrap();
 
-        if !show_on_taskbar {
-            remote_proc2
-                .call(HWND(hwnd.clone() as *mut _), !hide)
-                .unwrap();
-        }
+        // TODO: only call this method if we have changed it before
+        remote_proc2
+            .call(HWND(hwnd.clone() as *mut _), hide && hide_from_taskbar)
+            .unwrap();
     }
 }
 
-pub fn set_window_props_with_pid(pid: u32, hwnd: u32, hide: bool, show_on_taskbar: bool) {
+pub fn set_window_props_with_pid(pid: u32, hwnd: u32, hide: bool, hide_from_taskbar: bool) {
     let target_process = OwnedProcess::from_pid(pid).unwrap();
-    set_window_props(target_process, &[hwnd], hide, show_on_taskbar);
+    set_window_props(target_process, &[hwnd], hide, hide_from_taskbar);
 }

injector/src/injector.rs

@@ -18,17 +18,17 @@ pub extern "system" fn SetWindowVisibility(hwnd: HWND, hide: bool) -> bool {
 }
 
 #[unsafe(no_mangle)]
-pub extern "system" fn ShowOnTaskBar(hwnd: HWND, show: bool) -> bool {
+pub extern "system" fn HideFromTaskbar(hwnd: HWND, hide: bool) -> bool {
     let mut style = unsafe { GetWindowLongW(hwnd, GWL_EXSTYLE) };
     if style == 0 {
         return false;
     }
-    if show {
-        style |= WS_EX_APPWINDOW.0 as i32;
-        style &= (!WS_EX_TOOLWINDOW.0) as i32;
-    } else {
+    if hide {
         style |= WS_EX_TOOLWINDOW.0 as i32;
         style &= (!WS_EX_APPWINDOW.0) as i32;
+    } else {
+        style |= WS_EX_APPWINDOW.0 as i32;
+        style &= (!WS_EX_TOOLWINDOW.0) as i32;
     }
     unsafe { SetWindowLongW(hwnd, GWL_EXSTYLE, style) };
     true