How to minimize an eframe app to the tray?

[Absolucy]

I want to make an eframe app that can be minimized to the tray - the window can fully disappear at some point. How would I go about doing this?

[Gremious]

2 ish years too late but it was a pain to figure out, so here's my newfound knowledge for those that come after:

egui/eframe doesn't support that even now, years later as far as I can see.

Using the egui::viewport commands also doesn't work - #3655. I think it's because egui doesn't update once the window is not interactable e.g. invisible/minimized.

It also doesn't allow for running eframe on an existing event loop - #2875. This means you can't have your own loop where you actually honest to god close the window and re-create it every time to "minimize to tray". I really do wish it exposed native or something.

But aftrer like 2 days of screwing around, this is the simplest solution I found. This is for Windows, however, you can very likely substitute platform specific code here in much the same way:

eframe::run_native(
// --snip--
	Box::new(|cc| {
		let winit::raw_window_handle::RawWindowHandle::Win32(handle) = cc.window_handle().unwrap().as_raw() else {
			panic!("Unsupported platform");
		};

		let context = cc.egui_ctx.clone();

		// tray-icon crate
		// https://docs.rs/tray-icon/0.12.0/tray_icon/struct.TrayIconEvent.html#method.set_event_handler
		TrayIconEvent::set_event_handler(Some(move |event: TrayIconEvent| {
			println!("TrayIconEvent: {:?}", event);
			if event.click_type != tray_icon::ClickType::Double {
				return;
			}

			// Just a static Mutex<bool>
			let mut visible = VISIBLE.lock().unwrap();

			if *visible {
				let window_handle = windows::Win32::Foundation::HWND(handle.hwnd.into());
				let hide = windows::Win32::UI::WindowsAndMessaging::SW_HIDE;
				unsafe {
					windows::Win32::UI::WindowsAndMessaging::ShowWindow(window_handle, hide);
				}
				*visible = false;
			} else {
				let window_handle = windows::Win32::Foundation::HWND(handle.hwnd.into());
				// You can show the window in all sorts of ways:
				// https://learn.microsoft.com/en-gb/windows/win32/api/winuser/nf-winuser-showwindow
				let show = windows::Win32::UI::WindowsAndMessaging::SW_SHOWDEFAULT;
				unsafe {
					windows::Win32::UI::WindowsAndMessaging::ShowWindow(window_handle, show);
				}
				*visible = true;
			}
		}
	));

	Box::new(...)
}),

[gembleman]

use eframe::egui;
use std::sync::Mutex;
use tray_icon::{Icon, MouseButtonState, TrayIconBuilder, TrayIconEvent};
use windows::Win32::Foundation::HWND;
use windows::Win32::UI::WindowsAndMessaging::{ShowWindow, SW_HIDE, SW_SHOWDEFAULT};
use winit::raw_window_handle::{HasWindowHandle, RawWindowHandle};

static VISIBLE: Mutex<bool> = Mutex::new(true);

fn main() -> Result<(), Box<dyn std::error::Error>> {
    let mut icon_data: Vec<u8> = Vec::with_capacity(16 * 16 * 4);
    for _ in 0..256 {
        // all red
        icon_data.extend_from_slice(&[255, 0, 0, 255]);
    }
    let icon = Icon::from_rgba(icon_data, 16, 16)?;
    let _tray_icon = TrayIconBuilder::new()
        .with_icon(icon)
        .with_tooltip("My App")
        .build()?;

    let options = eframe::NativeOptions {
        viewport: egui::ViewportBuilder::default().with_inner_size([320.0, 240.0]),
        ..Default::default()
    };

    let _ = eframe::run_native(
        "My egui App",
        options,
        Box::new(|cc| {
            let RawWindowHandle::Win32(handle) = cc.window_handle().unwrap().as_raw() else {
                panic!("Unsupported platform");
            };

            // let context = cc.egui_ctx.clone();

            TrayIconEvent::set_event_handler(Some(move |event: TrayIconEvent| {
                // println!("TrayIconEvent: {:?}", event);

                match event {
                    TrayIconEvent::Click {
                        button_state: MouseButtonState::Down,
                        ..
                    } => {
                        let mut visible = VISIBLE.lock().unwrap();

                        if *visible {
                            let window_handle = HWND(handle.hwnd.into());
                            unsafe {
                                ShowWindow(window_handle, SW_HIDE);
                            }
                            *visible = false;
                        } else {
                            let window_handle = HWND(handle.hwnd.into());
                            unsafe {
                                ShowWindow(window_handle, SW_SHOWDEFAULT);
                            }
                            *visible = true;
                        }

                        // context.request_repaint();
                    }
                    _ => return,
                }
            }));

            Box::new(MyApp::default())
        }),
    );
    Ok(())
}

struct MyApp {
    // Your app state here
}

impl Default for MyApp {
    fn default() -> Self {
        Self {
            // Initialize your app state here
        }
    }
}

impl eframe::App for MyApp {
    fn update(&mut self, ctx: &egui::Context, _frame: &mut eframe::Frame) {
        egui::CentralPanel::default().show(ctx, |ui| {
            ui.heading("Hello World!");
        });
    }
}

Cargo.toml

[dependencies]
eframe = "0.27.2"
tray-icon = "0.14.3"
windows = { version = "0.52.0", features = [
    "Win32_Foundation",
    "Win32_UI_WindowsAndMessaging",
] }
winit = "0.29.15"

This is a simple example that works on Windows as of 2024.06.27.
Before seeing this answer, I was in a state of near-resignation.
Thank you! @Gremious

[aurexav]

Perhaps you could submit a pull request to include this in the examples.

[rustbasic]

I tried modifying it as follows so that it can be used in the latest version, such as egui 0.28.1.

// Windows Tray Icon Example
use eframe::egui;
use std::sync::Mutex;
use tray_icon::{Icon, MouseButtonState, TrayIconBuilder, TrayIconEvent};
use windows::Win32::Foundation::HWND;
use windows::Win32::UI::WindowsAndMessaging::{ShowWindow, SW_HIDE, SW_SHOWDEFAULT};
use winit::raw_window_handle::{HasWindowHandle, RawWindowHandle, Win32WindowHandle};

static VISIBLE: Mutex<bool> = Mutex::new(true);

fn main() -> Result<(), Box<dyn std::error::Error>> {
    let mut icon_data: Vec<u8> = Vec::with_capacity(16 * 16 * 4);
    for _ in 0..256 {
        // all red
        icon_data.extend_from_slice(&[255, 0, 0, 255]);
    }
    let icon = Icon::from_rgba(icon_data, 16, 16)?;
    let _tray_icon = TrayIconBuilder::new()
        .with_icon(icon)
        .with_tooltip("My App")
        .build()?;

    let options = eframe::NativeOptions {
        viewport: egui::ViewportBuilder::default().with_inner_size([320.0, 240.0]),
        ..Default::default()
    };

    let _ = eframe::run_native(
        "My egui App",
        options,
        Box::new(|cc| {
            let RawWindowHandle::Win32(mut handle) = cc.window_handle().unwrap().as_raw() else {
                panic!("Unsupported platform");
            };

            // let context = cc.egui_ctx.clone();

            TrayIconEvent::set_event_handler(Some(move |event: TrayIconEvent| {
                // println!("TrayIconEvent: {:?}", event);

                match event {
                    TrayIconEvent::Click {
                        button_state: MouseButtonState::Down,
                        ..
                    } => {
                        let mut visible = VISIBLE.lock().unwrap();

                        if *visible {
                            let window_handle = handle_to_hwnd(handle);
                            unsafe {
                                let _ = ShowWindow(window_handle, SW_HIDE);
                            }
                            *visible = false;
                        } else {
                            let window_handle = handle_to_hwnd(handle);
                            unsafe {
                                let _ = ShowWindow(window_handle, SW_SHOWDEFAULT);
                            }
                            *visible = true;
                        }
                    }
                    _ => return,
                }
            }));

            Ok(Box::new(MyApp::default()))
        }),
    );
    Ok(())
}

pub fn handle_to_hwnd(handle: Win32WindowHandle) -> windows::Win32::Foundation::HWND {
    let hwnd_isize: isize = handle.hwnd.into();
    let hwnd = hwnd_isize as *mut core::ffi::c_void;

    HWND(hwnd)
}

struct MyApp {
    // Your app state here
}

impl Default for MyApp {
    fn default() -> Self {
        Self {
            // Initialize your app state here
        }
    }
}

impl eframe::App for MyApp {
    fn update(&mut self, ctx: &egui::Context, _frame: &mut eframe::Frame) {
        let visible = VISIBLE.lock().unwrap();

        if *visible {
            egui::CentralPanel::default().show(ctx, |ui| {
                ui.heading("Hello World!");
            });
        }

        // ctx.request_repaint();
    }
}

[tbellembois]

Can somebody provide a sample code for Linux ?
Thanks