Files
GlobalProtect-openconnect/crates/gpapi/src/utils/window.rs
T
2026-10-09 18:21:44 +08:00

193 lines
5.0 KiB
Rust

use tauri::WebviewWindow;
#[cfg(any(target_os = "linux", target_os = "freebsd", target_os = "openbsd"))]
#[derive(Clone, Copy, Debug, Eq, PartialEq)]
pub enum WindowTypeHint {
Dialog,
Utility,
}
#[cfg(any(target_os = "linux", target_os = "freebsd", target_os = "openbsd"))]
pub fn is_screen_composited() -> bool {
gtk::gdk::Screen::default().is_some_and(|screen| screen.is_composited())
}
#[cfg(any(target_os = "linux", target_os = "freebsd", target_os = "openbsd"))]
pub fn set_window_type_hint(window: &WebviewWindow, hint: WindowTypeHint) -> anyhow::Result<()> {
use gtk::{gdk, traits::GtkWindowExt};
let hint = match hint {
WindowTypeHint::Dialog => gdk::WindowTypeHint::Dialog,
WindowTypeHint::Utility => gdk::WindowTypeHint::Utility,
};
window.gtk_window()?.set_type_hint(hint);
Ok(())
}
/// Returns the frame-to-content height difference for a standard titled macOS window.
/// This is nonzero only on macOS.
pub fn get_title_bar_height() -> f64 {
#[cfg(target_os = "macos")]
{
macos_title_bar_height(os_info::get().version())
}
#[cfg(not(target_os = "macos"))]
{
0.0
}
}
#[cfg(target_os = "macos")]
fn macos_title_bar_height(version: &os_info::Version) -> f64 {
if version.ge(&os_info::Version::from_string("26.0.0")) {
32.0
} else {
28.0
}
}
pub trait WindowExt {
fn raise(&self) -> anyhow::Result<()>;
}
impl WindowExt for WebviewWindow {
#[cfg(target_os = "macos")]
fn raise(&self) -> anyhow::Result<()> {
self.show()?;
self.set_focus()?;
Ok(())
}
#[cfg(target_os = "windows")]
fn raise(&self) -> anyhow::Result<()> {
self.show()?;
Ok(())
}
#[cfg(not(any(target_os = "macos", target_os = "windows")))]
fn raise(&self) -> anyhow::Result<()> {
unix::raise_window(self)
}
}
#[cfg(test)]
mod tests {
use super::*;
#[cfg(target_os = "macos")]
#[test]
fn uses_the_current_macos_title_bar_height() {
assert_eq!(macos_title_bar_height(&os_info::Version::from_string("25.9.0")), 28.0);
assert_eq!(macos_title_bar_height(&os_info::Version::from_string("26.0.0")), 32.0);
}
#[cfg(not(target_os = "macos"))]
#[test]
fn native_title_bar_height_is_zero_without_a_native_macos_title_bar() {
assert_eq!(get_title_bar_height(), 0.0);
}
}
#[cfg(not(any(target_os = "macos", target_os = "windows")))]
mod unix {
use std::{process::ExitStatus, time::Duration};
use anyhow::bail;
use gtk::{
EventBox,
glib::{self, Cast},
traits::{EventBoxExt, GtkWindowExt, WidgetExt},
};
use log::info;
use tauri::WebviewWindow;
use tokio::process::Command;
/// Wrapper to mark a non-Send closure as Send for dispatch to the GTK main thread.
///
/// SAFETY: The caller must ensure the closure is only executed on the GTK main
/// thread. This is guaranteed by `glib::MainContext::default().invoke()`.
struct SendFn(Box<dyn FnOnce()>);
unsafe impl Send for SendFn {}
impl SendFn {
fn invoke(self) {
(self.0)();
}
}
pub fn raise_window(win: &WebviewWindow) -> anyhow::Result<()> {
let is_wayland = std::env::var("XDG_SESSION_TYPE").unwrap_or_default() == "wayland";
if is_wayland {
let gtk_win = win.gtk_window()?;
// GTK operations must run on the main thread. When this function is called
// from a background thread (e.g., rspc handler on a tokio worker), calling
// GTK widget methods directly causes crashes in GTK's CSS subsystem
// (gtk_css_value_inherit_free assertion failure). Dispatch to the main
// thread via glib::MainContext to ensure thread safety.
let send_fn = SendFn(Box::new(move || {
if let Some(header) = gtk_win.titlebar() {
let _ = header.downcast::<EventBox>().map(|event_box| {
event_box.set_above_child(false);
});
}
gtk_win.hide();
gtk_win.show_all();
}));
glib::MainContext::default().invoke(move || send_fn.invoke());
} else {
if !win.is_visible()? {
win.show()?;
}
let title = win.title()?;
tokio::spawn(async move {
if let Err(err) = wmctrl_raise_window(&title).await {
info!("Window not raised: {}", err);
}
});
}
// Calling window.show() on window object will cause the menu to be shown.
// We need to hide it again.
win.hide_menu()?;
Ok(())
}
async fn wmctrl_raise_window(title: &str) -> anyhow::Result<()> {
let mut counter = 0;
loop {
if let Ok(exit_status) = wmctrl_try_raise_window(title).await {
if exit_status.success() {
info!("Window raised after {} attempts", counter + 1);
return Ok(());
}
}
if counter >= 10 {
bail!("Failed to raise window: {}", title)
}
counter += 1;
tokio::time::sleep(Duration::from_millis(100)).await;
}
}
async fn wmctrl_try_raise_window(title: &str) -> anyhow::Result<ExitStatus> {
let exit_status = Command::new("wmctrl")
.arg("-F")
.arg("-a")
.arg(title)
.spawn()?
.wait()
.await?;
Ok(exit_status)
}
}