How to intercept closing the window, but keep it visible?

[jsprog]

With tauri, I can intercept CloseRequested, and display a confirmation dialog inside the same window while keeping it visible.

    .on_window_event(|window, event| match event {
        tauri::WindowEvent::CloseRequested { api, .. } => {
            api.prevent_close(); // prevent non-confirmed closed (Ctrl+F4 or window's close button)
            window.emit("CloseRequested", ()).unwrap(); // emit the event to webview, and from there, display a confirmation dialog
        }
        _ => ()
    })

But when using dioxus, I'm forced to choose between hiding the window WindowCloseBehaviour::WindowHides or destroying the window WindowCloseBehaviour::WindowCloses.

    // .with_exits_when_last_window_closes(false)
    .with_close_behaviour(WindowCloseBehaviour::WindowHides)
    .with_custom_event_handler(move |evt, event_loop_window_target| {
        if let Event::WindowEvent { event: WindowEvent::CloseRequested, .. } = evt {
        // panics outside of dioxus runtime, and I can't get a handle to window here
        dioxus::desktop::window().set_visible(true); 

My goals:

• I hope that dioxus adds the support for keeping the window visible on CloseRequested.
• As a temporary fix, I need to restore the visibility of the window

[apoorva-01]

Short version: dioxus doesn't have a prevent_close like tauri's api.prevent_close(). WindowCloseBehaviour only has the two variants you found (WindowHides / WindowCloses), and the maintainer confirmed there's no API to cancel the default close (#2988).

You can still fake it though. Keep WindowHides so the X doesn't destroy the window, catch the close event yourself, and immediately re-show the window so it stays up while your confirm dialog runs:

use dioxus_desktop::{use_window, use_wry_event_handler};
use dioxus_desktop::tao::event::{Event, WindowEvent};

let window = use_window();

use_wry_event_handler(move |event, _| {
    if let Event::WindowEvent { event: WindowEvent::CloseRequested, .. } = event {
        // WindowHides already kept it alive, pull it back into view
        window.set_visible(true);
        // then trigger your in-app confirm dialog (flip a signal, etc.)
    }
});

use_window() gives you a DesktopService that derefs to the tao Window, so set_visible, set_close_behavior and close are all right there. When the user actually confirms, call window.close() (or flip to WindowCloses first).

One honest caveat: it hides-then-reshows in the same tick, so depending on the platform you can get a tiny flicker. That's the cost of there being no real cancel hook today. If you want the clean version, worth a +1 on #2988 so it stays on their radar.

[jsprog]

Thank you. The problem with restoring visibility using window.set_visible(true) is that the state for position and size is lost when the window hide. The only way to restore window's state is to synchronize it at runtime, because you can't access it from a custom handler before it hides. Dioxus takes ownership of tauri's event loop; making it not accessible for custom handlers

The Desktop app I'm writing use the close event to navigate back in the app tree until I reach the root view. Instead of coding my app, I spent more time wrestling with dioxus and writing code at various locations in order to restore window's state and I can't prevent it from blinking.

I completely gave up on dioxus after building a Portal and having a hard time adding popover menus and dialogs; I moved to pure tauri + sveltekit

use std::sync::Mutex;
use futures::channel::mpsc;

pub static COMMAND_RECEIVER: Mutex<Option<mpsc::UnboundedReceiver<Command>>> = Mutex::new(None);

    let (tx, rx) = futures::channel::mpsc::unbounded::<Command>();
    COMMAND_RECEIVER.lock().unwrap().replace(rx);

    .with_custom_event_handler(move |evt, _evl_window_target| {
        if let Event::WindowEvent { event: WindowEvent::CloseRequested, .. } = evt {
            // window is not accessible here. send a notification message through a channel
            let _r = tx.unbounded_send(Command::CloseRequested).unwrap();
        }
    })

#[component]
fn Layout() -> Element {
    let nav = use_navigator();

    use_coroutine(move |_: UnboundedReceiver<()>| async move {

        let command_receiver = {
            crate::COMMAND_RECEIVER
                .lock().unwrap()
                .take()
        };

        if let Some(mut command_receiver) = command_receiver {
        while let Ok(command) = command_receiver.recv().await {
            use crate::Command;
            match command {
                Command::CloseRequested => {

With all my respect to the team behind dioxus, I suppose that the support for tauri is not a priority and instead they have plans for replacing it with Blitz