How to resize window dynamically when MousePassthrough set to true ？

[agkyunromb]

I'm adding an overlay to a game that's only meant to display information, and I want the overlay to follow the window and fully cover the game window.

However, I found that egui::ViewportCommand::InnerSize and ViewportCommand::OuterPosition seems to rely on mouse events. After I send ViewportCommand::MousePassthrough(enabled), I can no longer resize or repositon he window, nor can I disable mouse passthrough.

I wrote a simple example to confirm this behavior.

use eframe::egui;
use std::{sync::mpsc, time::Duration};
use winit::platform::windows::EventLoopBuilderExtWindows;

struct AppState {
    overlay_handle: Option<std::thread::JoinHandle<()>>,
    command_sender: mpsc::Sender<WindowCommand>,
}

#[derive(Debug)]
enum WindowCommand {
    SetSize([f32; 2]),
    SetPos([f32; 2]),
    SetMousePassthrough(bool),
    Exit,
}

fn main() {
    let (command_sender, command_receiver) = mpsc::channel();
    let (ui_sender, ui_receiver) = mpsc::channel();

    let app_state = AppState {
        overlay_handle: Some(std::thread::spawn(move || {
            let options = eframe::NativeOptions {
                event_loop_builder: Some(Box::new(|event_loop| {
                    event_loop.with_any_thread(true);
                })),
                viewport: eframe::egui::ViewportBuilder::default()
                    .with_transparent(true)
                    .with_decorations(false)
                    .with_position([100.0, 100.0])
                    .with_always_on_top()
                    .with_inner_size([400.0, 300.0])
                    .with_taskbar(false),
                ..Default::default()
            };

            let _ = eframe::run_native(
                "Window Control Test",
                options,
                Box::new(|_cc| Ok(Box::new(MyApp::new(command_receiver, ui_sender)))),
            );
        })),
        command_sender,
    };

    let mut passthrough_enabled = false;
    loop {
        println!("Menu:");
        println!(
            "1. Toggle Mouse Passthrough (current: {})",
            passthrough_enabled
        );
        println!("2. Resize Window");
        println!("3. RePositon Window");
        println!("4. Exit");

        let mut input = String::new();
        std::io::stdin().read_line(&mut input).unwrap();

        match input.trim() {
            "1" => {
                passthrough_enabled = !passthrough_enabled;
                app_state
                    .command_sender
                    .send(WindowCommand::SetMousePassthrough(passthrough_enabled))
                    .unwrap();
                println!("Mouse passthrough set to: {}", passthrough_enabled);
            }
            "2" => {
                println!("Enter new width and height (e.g. 500 400):");
                let mut size_input = String::new();
                std::io::stdin().read_line(&mut size_input).unwrap();
                let sizes: Vec<f32> = size_input
                    .split_whitespace()
                    .filter_map(|s| s.parse().ok())
                    .collect();

                if sizes.len() == 2 {
                    app_state
                        .command_sender
                        .send(WindowCommand::SetSize([sizes[0], sizes[1]]))
                        .unwrap();
                    println!("Resize command sent");
                } else {
                    println!("Invalid input");
                }
            }
            "3" => {
                println!("Enter new x and y (e.g. 500 400):");
                let mut size_input = String::new();
                std::io::stdin().read_line(&mut size_input).unwrap();
                let sizes: Vec<f32> = size_input
                    .split_whitespace()
                    .filter_map(|s| s.parse().ok())
                    .collect();

                if sizes.len() == 2 {
                    app_state
                        .command_sender
                        .send(WindowCommand::SetPos([sizes[0], sizes[1]]))
                        .unwrap();
                    println!("Resize command sent");
                } else {
                    println!("Invalid input");
                }
            }
            "4" => {
                app_state.command_sender.send(WindowCommand::Exit).unwrap();
                break;
            }
            _ => println!("Invalid option"),
        }

        if let Ok(msg) = ui_receiver.try_recv() {
            println!("UI Thread: {}", msg);
        }
    }

    if let Some(handle) = app_state.overlay_handle {
        let _ = handle.join();
    }
}

struct MyApp {
    command_receiver: mpsc::Receiver<WindowCommand>,
    ui_sender: mpsc::Sender<String>,
    current_pos: [f32; 2],
    current_size: [f32; 2],
    mouse_passthrough: bool,
}

impl MyApp {
    fn new(
        command_receiver: mpsc::Receiver<WindowCommand>,
        ui_sender: mpsc::Sender<String>,
    ) -> Self {
        Self {
            command_receiver,
            ui_sender,
            current_size: [400.0, 300.0],
            current_pos: [100.0, 100.0],
            mouse_passthrough: false,
        }
    }
}

impl eframe::App for MyApp {
    fn update(&mut self, ctx: &egui::Context, _frame: &mut eframe::Frame) {
        while let Ok(cmd) = self.command_receiver.try_recv() {
            match cmd {
                WindowCommand::SetSize(size) => {
                    self.current_size = size;

                    ctx.send_viewport_cmd(egui::ViewportCommand::InnerSize(egui::vec2(
                        size[0], size[1],
                    )));
                    self.ui_sender
                        .send(format!("Window resized to {}x{}", size[0], size[1]))
                        .unwrap();
                }
                WindowCommand::SetMousePassthrough(enabled) => {
                    self.mouse_passthrough = enabled;
                    ctx.send_viewport_cmd(egui::ViewportCommand::MousePassthrough(enabled));
                    self.ui_sender
                        .send(format!("Mouse passthrough set to {}", enabled))
                        .unwrap();
                }
                WindowCommand::Exit => {
                    ctx.send_viewport_cmd(egui::ViewportCommand::Close);
                }
                WindowCommand::SetPos(pos) => {
                    self.current_pos = pos;

                    ctx.send_viewport_cmd(egui::ViewportCommand::OuterPosition(egui::pos2(
                        pos[0], pos[1],
                    )));
                    self.ui_sender
                        .send(format!("Window positon set to {}x{}", pos[0], pos[1]))
                        .unwrap();
                }
            }
            ctx.request_repaint_after(Duration::from_millis(100));
        }

        egui::CentralPanel::default().show(ctx, |ui| {
            ui.heading("Window Control Test");
            ui.label("Control from main thread via commands");
            ui.separator();
            ui.label(format!(
                "Current size: {:.1}x{:.1}",
                self.current_size[0], self.current_size[1]
            ));
            ui.label(format!("Mouse passthrough: {}", self.mouse_passthrough));
            ui.separator();
            ui.label("Note: UI buttons won't work when mouse passthrough is enabled");
            ui.label("Use the console menu to control the window");
        });
    }
}