621 lines
20 KiB
Rust
621 lines
20 KiB
Rust
use super::*;
|
|
|
|
#[cfg(target_os = "macos")]
|
|
const MACOS_TRAY_ID: &str = "macos-tray";
|
|
|
|
#[cfg(target_os = "macos")]
|
|
#[derive(Default)]
|
|
pub(crate) struct MacosTrayClickState {
|
|
last_click: Option<Instant>,
|
|
sequence: u64,
|
|
}
|
|
|
|
#[cfg(target_os = "macos")]
|
|
pub(crate) fn set_macos_dock_visible(app_handle: &tauri::AppHandle, visible: bool) {
|
|
if let Err(error) = app_handle.set_dock_visibility(visible) {
|
|
eprintln!("更新 Dock 图标状态失败: {error}");
|
|
}
|
|
}
|
|
|
|
#[cfg(target_os = "macos")]
|
|
pub(crate) fn show_main_window_on_main_thread(app_handle: &tauri::AppHandle) {
|
|
let Some(window) = app_handle.get_webview_window("main") else {
|
|
return;
|
|
};
|
|
set_macos_dock_visible(app_handle, true);
|
|
if let Err(error) = window.show() {
|
|
eprintln!("显示主窗口失败: {error}");
|
|
set_macos_dock_visible(app_handle, false);
|
|
return;
|
|
}
|
|
if window.is_minimized().unwrap_or(false) {
|
|
if let Err(error) = window.unminimize() {
|
|
eprintln!("恢复主窗口失败: {error}");
|
|
}
|
|
}
|
|
if let Err(error) = window.set_focus() {
|
|
eprintln!("聚焦主窗口失败: {error}");
|
|
}
|
|
}
|
|
|
|
#[cfg(target_os = "macos")]
|
|
pub(crate) fn show_main_window(app_handle: &tauri::AppHandle) {
|
|
if MainThreadMarker::new().is_some() {
|
|
show_main_window_on_main_thread(app_handle);
|
|
return;
|
|
}
|
|
|
|
let app_handle = app_handle.clone();
|
|
if let Err(error) = app_handle.clone().run_on_main_thread(move || {
|
|
show_main_window_on_main_thread(&app_handle);
|
|
}) {
|
|
eprintln!("调度主窗口显示失败: {error}");
|
|
}
|
|
}
|
|
|
|
#[cfg(target_os = "macos")]
|
|
pub(crate) fn show_macos_tray_menu<R: tauri::Runtime>(tray: &TrayIcon<R>) {
|
|
let result = tray.with_inner_tray_icon(|tray_icon| {
|
|
let Some(status_item) = tray_icon.ns_status_item() else {
|
|
return;
|
|
};
|
|
let mtm = MainThreadMarker::new().expect("tray menu must be shown on the main thread");
|
|
if let Some(menu) = status_item.menu(mtm) {
|
|
#[allow(deprecated)]
|
|
status_item.popUpStatusItemMenu(&menu);
|
|
}
|
|
});
|
|
|
|
if let Err(error) = result {
|
|
eprintln!("显示托盘菜单失败: {error}");
|
|
}
|
|
}
|
|
|
|
#[cfg(target_os = "macos")]
|
|
pub(crate) fn setup_macos_tray(app: &mut tauri::App<tauri::Wry>) -> tauri::Result<()> {
|
|
let locale = app
|
|
.state::<GuiConfigState>()
|
|
.snapshot()
|
|
.map(|config| config.locale)
|
|
.unwrap_or_else(|_| "zh-CN".to_string());
|
|
let open_main_window = MenuItem::with_id(
|
|
app,
|
|
"open-main-window",
|
|
locale_text(&locale, "打开主界面", "Open Main Window"),
|
|
true,
|
|
None::<&str>,
|
|
)?;
|
|
let quit = MenuItem::with_id(
|
|
app,
|
|
"quit",
|
|
locale_text(&locale, "退出", "Quit"),
|
|
true,
|
|
None::<&str>,
|
|
)?;
|
|
let menu = Menu::with_items(app, &[&open_main_window, &quit])?;
|
|
let click_state = Arc::new(Mutex::new(MacosTrayClickState::default()));
|
|
let double_click_interval = Duration::from_secs_f64(NSEvent::doubleClickInterval());
|
|
|
|
TrayIconBuilder::with_id(MACOS_TRAY_ID)
|
|
.icon(
|
|
app.default_window_icon()
|
|
.cloned()
|
|
.expect("application icon is required for the tray"),
|
|
)
|
|
.menu(&menu)
|
|
.show_menu_on_left_click(false)
|
|
.on_menu_event(move |app_handle, event| match event.id().as_ref() {
|
|
"open-main-window" => show_main_window(app_handle),
|
|
"quit" => app_handle.exit(0),
|
|
_ => {}
|
|
})
|
|
.on_tray_icon_event(move |tray, event| {
|
|
if !matches!(
|
|
event,
|
|
TrayIconEvent::Click {
|
|
button: MouseButton::Left,
|
|
button_state: MouseButtonState::Up,
|
|
..
|
|
}
|
|
) {
|
|
return;
|
|
}
|
|
|
|
let now = Instant::now();
|
|
let Ok(mut state) = click_state.lock() else {
|
|
eprintln!("读取托盘点击状态失败");
|
|
return;
|
|
};
|
|
state.sequence += 1;
|
|
let sequence = state.sequence;
|
|
|
|
if state
|
|
.last_click
|
|
.is_some_and(|last_click| now.duration_since(last_click) <= double_click_interval)
|
|
{
|
|
state.last_click = None;
|
|
drop(state);
|
|
show_main_window(tray.app_handle());
|
|
return;
|
|
}
|
|
|
|
state.last_click = Some(now);
|
|
drop(state);
|
|
|
|
let app_handle = tray.app_handle().clone();
|
|
let click_state = Arc::clone(&click_state);
|
|
let tray_id = tray.id().clone();
|
|
thread::spawn(move || {
|
|
thread::sleep(double_click_interval);
|
|
let should_show_menu = match click_state.lock() {
|
|
Ok(mut state) if state.sequence == sequence => {
|
|
state.last_click = None;
|
|
true
|
|
}
|
|
Ok(_) => false,
|
|
Err(_) => {
|
|
eprintln!("读取托盘点击状态失败");
|
|
false
|
|
}
|
|
};
|
|
if !should_show_menu {
|
|
return;
|
|
}
|
|
|
|
if let Some(tray) = app_handle.tray_by_id(&tray_id) {
|
|
show_macos_tray_menu(&tray);
|
|
}
|
|
});
|
|
})
|
|
.build(app)?;
|
|
|
|
Ok(())
|
|
}
|
|
|
|
#[cfg(target_os = "windows")]
|
|
const WINDOWS_TRAY_ID: &str = "windows-tray";
|
|
#[cfg(target_os = "windows")]
|
|
const WINDOWS_TRAY_OPEN_MENU_ID: &str = "windows-tray-open-main-window";
|
|
#[cfg(target_os = "windows")]
|
|
const WINDOWS_TRAY_STATUS_MENU_ID: &str = "windows-tray-core-status";
|
|
#[cfg(target_os = "windows")]
|
|
const WINDOWS_TRAY_TOGGLE_CORE_MENU_ID: &str = "windows-tray-toggle-core";
|
|
#[cfg(target_os = "windows")]
|
|
const WINDOWS_TRAY_RESTART_CORE_MENU_ID: &str = "windows-tray-restart-core";
|
|
#[cfg(target_os = "windows")]
|
|
const WINDOWS_TRAY_QUIT_MENU_ID: &str = "windows-tray-quit";
|
|
|
|
#[cfg(target_os = "windows")]
|
|
#[derive(Clone, Copy)]
|
|
pub(crate) enum WindowsTrayCoreAction {
|
|
Toggle,
|
|
Restart,
|
|
}
|
|
|
|
#[cfg(target_os = "windows")]
|
|
pub(crate) struct WindowsTrayPresentation {
|
|
pub(crate) status_text: String,
|
|
pub(crate) toggle_text: String,
|
|
pub(crate) toggle_enabled: bool,
|
|
pub(crate) restart_enabled: bool,
|
|
pub(crate) tooltip: String,
|
|
}
|
|
|
|
#[cfg(target_os = "windows")]
|
|
pub(crate) fn windows_tray_presentation(
|
|
status: &CoreStatus,
|
|
busy: bool,
|
|
locale: &str,
|
|
) -> WindowsTrayPresentation {
|
|
let status_text = if busy {
|
|
locale_text(locale, "内核状态：处理中", "Core status: Working")
|
|
} else if !status.installed {
|
|
locale_text(locale, "内核状态：未安装", "Core status: Not installed")
|
|
} else if status.running {
|
|
locale_text(locale, "内核状态：运行中", "Core status: Running")
|
|
} else {
|
|
locale_text(locale, "内核状态：已停止", "Core status: Stopped")
|
|
};
|
|
let toggle_text = if busy {
|
|
locale_text(locale, "处理中...", "Working...")
|
|
} else if status.running {
|
|
locale_text(locale, "停止内核", "Stop Core")
|
|
} else {
|
|
locale_text(locale, "启动内核", "Start Core")
|
|
};
|
|
let tooltip = if busy {
|
|
locale_text(
|
|
locale,
|
|
"EasyCLIProxyAPI · 内核处理中",
|
|
"EasyCLIProxyAPI · Core working",
|
|
)
|
|
} else if !status.installed {
|
|
locale_text(
|
|
locale,
|
|
"EasyCLIProxyAPI · 内核未安装",
|
|
"EasyCLIProxyAPI · Core not installed",
|
|
)
|
|
} else if status.running {
|
|
locale_text(
|
|
locale,
|
|
"EasyCLIProxyAPI · 内核运行中",
|
|
"EasyCLIProxyAPI · Core running",
|
|
)
|
|
} else {
|
|
locale_text(
|
|
locale,
|
|
"EasyCLIProxyAPI · 内核已停止",
|
|
"EasyCLIProxyAPI · Core stopped",
|
|
)
|
|
};
|
|
|
|
WindowsTrayPresentation {
|
|
status_text: status_text.to_string(),
|
|
toggle_text: toggle_text.to_string(),
|
|
toggle_enabled: status.installed && !busy,
|
|
restart_enabled: status.installed && status.running && !busy,
|
|
tooltip: tooltip.to_string(),
|
|
}
|
|
}
|
|
|
|
#[cfg(target_os = "windows")]
|
|
pub(crate) struct WindowsTrayState {
|
|
open_main_window: MenuItem<tauri::Wry>,
|
|
status_item: MenuItem<tauri::Wry>,
|
|
toggle_core_item: MenuItem<tauri::Wry>,
|
|
restart_core_item: MenuItem<tauri::Wry>,
|
|
quit_item: MenuItem<tauri::Wry>,
|
|
locale: Mutex<String>,
|
|
busy: AtomicBool,
|
|
}
|
|
|
|
#[cfg(target_os = "windows")]
|
|
impl WindowsTrayState {
|
|
fn locale(&self) -> String {
|
|
self.locale
|
|
.lock()
|
|
.map(|locale| locale.clone())
|
|
.unwrap_or_else(|_| "zh-CN".to_string())
|
|
}
|
|
|
|
fn set_locale(&self, locale: &str) {
|
|
let normalized = normalize_app_locale(locale);
|
|
if let Ok(mut current) = self.locale.lock() {
|
|
*current = normalized.to_string();
|
|
}
|
|
let labels = [
|
|
(
|
|
&self.open_main_window,
|
|
locale_text(normalized, "打开主界面", "Open Main Window"),
|
|
),
|
|
(
|
|
&self.restart_core_item,
|
|
locale_text(normalized, "重启内核", "Restart Core"),
|
|
),
|
|
(&self.quit_item, locale_text(normalized, "退出", "Quit")),
|
|
];
|
|
for (item, label) in labels {
|
|
if let Err(error) = item.set_text(label) {
|
|
eprintln!("更新 Windows 托盘语言失败: {error}");
|
|
}
|
|
}
|
|
}
|
|
|
|
fn begin_action(&self) -> bool {
|
|
if self
|
|
.busy
|
|
.compare_exchange(false, true, Ordering::AcqRel, Ordering::Acquire)
|
|
.is_err()
|
|
{
|
|
return false;
|
|
}
|
|
|
|
let locale = self.locale();
|
|
if let Err(error) = self.status_item.set_text(locale_text(
|
|
&locale,
|
|
"内核状态：处理中",
|
|
"Core status: Working",
|
|
)) {
|
|
eprintln!("更新 Windows 托盘内核状态失败: {error}");
|
|
}
|
|
if let Err(error) =
|
|
self.toggle_core_item
|
|
.set_text(locale_text(&locale, "处理中...", "Working..."))
|
|
{
|
|
eprintln!("更新 Windows 托盘操作文本失败: {error}");
|
|
}
|
|
if let Err(error) = self.toggle_core_item.set_enabled(false) {
|
|
eprintln!("更新 Windows 托盘操作状态失败: {error}");
|
|
}
|
|
if let Err(error) = self.restart_core_item.set_enabled(false) {
|
|
eprintln!("更新 Windows 托盘重启状态失败: {error}");
|
|
}
|
|
true
|
|
}
|
|
|
|
fn finish_action(&self) {
|
|
self.busy.store(false, Ordering::Release);
|
|
}
|
|
|
|
fn update(&self, status: &CoreStatus) -> String {
|
|
let presentation =
|
|
windows_tray_presentation(status, self.busy.load(Ordering::Acquire), &self.locale());
|
|
if let Err(error) = self.status_item.set_text(presentation.status_text.clone()) {
|
|
eprintln!("更新 Windows 托盘内核状态失败: {error}");
|
|
}
|
|
if let Err(error) = self
|
|
.toggle_core_item
|
|
.set_text(presentation.toggle_text.clone())
|
|
{
|
|
eprintln!("更新 Windows 托盘操作文本失败: {error}");
|
|
}
|
|
if let Err(error) = self
|
|
.toggle_core_item
|
|
.set_enabled(presentation.toggle_enabled)
|
|
{
|
|
eprintln!("更新 Windows 托盘操作状态失败: {error}");
|
|
}
|
|
if let Err(error) = self
|
|
.restart_core_item
|
|
.set_enabled(presentation.restart_enabled)
|
|
{
|
|
eprintln!("更新 Windows 托盘重启状态失败: {error}");
|
|
}
|
|
presentation.tooltip
|
|
}
|
|
|
|
fn show_error(&self, error: &str) {
|
|
let mut summary = error.chars().take(48).collect::<String>();
|
|
if error.chars().count() > 48 {
|
|
summary.push('…');
|
|
}
|
|
let text = match normalize_app_locale(&self.locale()) {
|
|
"en" => format!("Operation failed: {summary}"),
|
|
"zh-TW" => format!("操作失敗：{summary}"),
|
|
"ja" => format!("操作に失敗しました：{summary}"),
|
|
_ => format!("操作失败：{summary}"),
|
|
};
|
|
if let Err(update_error) = self.status_item.set_text(text) {
|
|
eprintln!("更新 Windows 托盘错误状态失败: {update_error}");
|
|
}
|
|
}
|
|
}
|
|
|
|
#[cfg(target_os = "windows")]
|
|
pub(crate) fn show_windows_main_window(app_handle: &tauri::AppHandle) {
|
|
let Some(window) = app_handle.get_webview_window("main") else {
|
|
return;
|
|
};
|
|
if let Err(error) = window.show() {
|
|
eprintln!("显示主窗口失败: {error}");
|
|
return;
|
|
}
|
|
if window.is_minimized().unwrap_or(false) {
|
|
if let Err(error) = window.unminimize() {
|
|
eprintln!("恢复主窗口失败: {error}");
|
|
}
|
|
}
|
|
if let Err(error) = window.set_focus() {
|
|
eprintln!("聚焦主窗口失败: {error}");
|
|
}
|
|
}
|
|
|
|
#[cfg(target_os = "windows")]
|
|
pub(crate) fn update_windows_tray_status(app_handle: &tauri::AppHandle, status: &CoreStatus) {
|
|
let tooltip = app_handle
|
|
.try_state::<WindowsTrayState>()
|
|
.map(|tray_state| tray_state.update(status))
|
|
.unwrap_or_else(|| windows_tray_presentation(status, false, "zh-CN").tooltip);
|
|
|
|
if let Some(tray) = app_handle.tray_by_id(WINDOWS_TRAY_ID) {
|
|
if let Err(error) = tray.set_tooltip(Some(&tooltip)) {
|
|
eprintln!("更新 Windows 托盘提示失败: {error}");
|
|
}
|
|
}
|
|
}
|
|
|
|
#[cfg(target_os = "windows")]
|
|
pub(crate) fn update_windows_tray_locale(
|
|
app_handle: &tauri::AppHandle,
|
|
locale: &str,
|
|
status: &CoreStatus,
|
|
) {
|
|
if let Some(tray_state) = app_handle.try_state::<WindowsTrayState>() {
|
|
tray_state.set_locale(locale);
|
|
}
|
|
update_windows_tray_status(app_handle, status);
|
|
}
|
|
|
|
#[cfg(target_os = "windows")]
|
|
pub(crate) fn show_windows_tray_action_error(app_handle: &tauri::AppHandle, error: &str) {
|
|
eprintln!("Windows 托盘内核操作失败: {error}");
|
|
let locale = app_handle
|
|
.try_state::<WindowsTrayState>()
|
|
.map(|state| state.locale())
|
|
.unwrap_or_else(|| "zh-CN".to_string());
|
|
if let Some(tray_state) = app_handle.try_state::<WindowsTrayState>() {
|
|
tray_state.show_error(error);
|
|
}
|
|
if let Some(tray) = app_handle.tray_by_id(WINDOWS_TRAY_ID) {
|
|
if let Err(update_error) = tray.set_tooltip(Some(locale_text(
|
|
&locale,
|
|
"EasyCLIProxyAPI · 内核操作失败",
|
|
"EasyCLIProxyAPI · Core operation failed",
|
|
))) {
|
|
eprintln!("更新 Windows 托盘错误提示失败: {update_error}");
|
|
}
|
|
}
|
|
}
|
|
|
|
#[cfg(target_os = "windows")]
|
|
pub(crate) fn run_windows_tray_core_action(
|
|
app_handle: &tauri::AppHandle,
|
|
action: WindowsTrayCoreAction,
|
|
) {
|
|
let Some(tray_state) = app_handle.try_state::<WindowsTrayState>() else {
|
|
return;
|
|
};
|
|
if !tray_state.begin_action() {
|
|
return;
|
|
}
|
|
if let Some(tray) = app_handle.tray_by_id(WINDOWS_TRAY_ID) {
|
|
if let Err(error) = tray.set_tooltip(Some(locale_text(
|
|
&tray_state.locale(),
|
|
"EasyCLIProxyAPI · 内核处理中",
|
|
"EasyCLIProxyAPI · Core working",
|
|
))) {
|
|
eprintln!("更新 Windows 托盘处理中提示失败: {error}");
|
|
}
|
|
}
|
|
|
|
let app_handle = app_handle.clone();
|
|
tauri::async_runtime::spawn_blocking(move || {
|
|
let process_state = app_handle.state::<CoreProcessState>();
|
|
let gui_config_state = app_handle.state::<GuiConfigState>();
|
|
let result = (|| -> Result<CoreStatus, String> {
|
|
match action {
|
|
WindowsTrayCoreAction::Toggle => {
|
|
let config = gui_config_state.snapshot()?;
|
|
let status =
|
|
current_core_status(Some(process_state.inner()), Some(config.port))?;
|
|
if status.running {
|
|
stop_core_process_with_state(
|
|
process_state.inner(),
|
|
gui_config_state.inner(),
|
|
)
|
|
} else {
|
|
start_core_process_with_state(
|
|
process_state.inner(),
|
|
gui_config_state.inner(),
|
|
)
|
|
}
|
|
}
|
|
WindowsTrayCoreAction::Restart => {
|
|
restart_core_process_with_state(process_state.inner(), gui_config_state.inner())
|
|
}
|
|
}
|
|
})();
|
|
|
|
if let Some(tray_state) = app_handle.try_state::<WindowsTrayState>() {
|
|
tray_state.finish_action();
|
|
}
|
|
|
|
match result {
|
|
Ok(status) => emit_core_status(&app_handle, &status),
|
|
Err(error) => {
|
|
if let Ok(config) = gui_config_state.snapshot() {
|
|
if let Ok(status) =
|
|
current_core_status(Some(process_state.inner()), Some(config.port))
|
|
{
|
|
emit_core_status(&app_handle, &status);
|
|
}
|
|
}
|
|
show_windows_tray_action_error(&app_handle, &error);
|
|
}
|
|
}
|
|
});
|
|
}
|
|
|
|
#[cfg(target_os = "windows")]
|
|
pub(crate) fn setup_windows_tray(app: &mut tauri::App<tauri::Wry>) -> tauri::Result<()> {
|
|
let locale = app
|
|
.state::<GuiConfigState>()
|
|
.snapshot()
|
|
.map(|config| config.locale)
|
|
.unwrap_or_else(|_| "zh-CN".to_string());
|
|
let open_main_window = MenuItem::with_id(
|
|
app,
|
|
WINDOWS_TRAY_OPEN_MENU_ID,
|
|
locale_text(&locale, "打开主界面", "Open Main Window"),
|
|
true,
|
|
None::<&str>,
|
|
)?;
|
|
let status_item = MenuItem::with_id(
|
|
app,
|
|
WINDOWS_TRAY_STATUS_MENU_ID,
|
|
locale_text(&locale, "内核状态：正在检查", "Core status: Checking"),
|
|
false,
|
|
None::<&str>,
|
|
)?;
|
|
let toggle_core_item = MenuItem::with_id(
|
|
app,
|
|
WINDOWS_TRAY_TOGGLE_CORE_MENU_ID,
|
|
locale_text(&locale, "启动内核", "Start Core"),
|
|
false,
|
|
None::<&str>,
|
|
)?;
|
|
let restart_core_item = MenuItem::with_id(
|
|
app,
|
|
WINDOWS_TRAY_RESTART_CORE_MENU_ID,
|
|
locale_text(&locale, "重启内核", "Restart Core"),
|
|
false,
|
|
None::<&str>,
|
|
)?;
|
|
let quit = MenuItem::with_id(
|
|
app,
|
|
WINDOWS_TRAY_QUIT_MENU_ID,
|
|
locale_text(&locale, "退出", "Quit"),
|
|
true,
|
|
None::<&str>,
|
|
)?;
|
|
let separator_one = PredefinedMenuItem::separator(app)?;
|
|
let separator_two = PredefinedMenuItem::separator(app)?;
|
|
let menu = Menu::with_items(
|
|
app,
|
|
&[
|
|
&open_main_window,
|
|
&separator_one,
|
|
&status_item,
|
|
&toggle_core_item,
|
|
&restart_core_item,
|
|
&separator_two,
|
|
&quit,
|
|
],
|
|
)?;
|
|
|
|
TrayIconBuilder::with_id(WINDOWS_TRAY_ID)
|
|
.icon(
|
|
app.default_window_icon()
|
|
.cloned()
|
|
.expect("application icon is required for the tray"),
|
|
)
|
|
.tooltip("EasyCLIProxyAPI")
|
|
.menu(&menu)
|
|
.show_menu_on_left_click(false)
|
|
.on_menu_event(move |app_handle, event| match event.id().as_ref() {
|
|
WINDOWS_TRAY_OPEN_MENU_ID => show_windows_main_window(app_handle),
|
|
WINDOWS_TRAY_TOGGLE_CORE_MENU_ID => {
|
|
run_windows_tray_core_action(app_handle, WindowsTrayCoreAction::Toggle)
|
|
}
|
|
WINDOWS_TRAY_RESTART_CORE_MENU_ID => {
|
|
run_windows_tray_core_action(app_handle, WindowsTrayCoreAction::Restart)
|
|
}
|
|
WINDOWS_TRAY_QUIT_MENU_ID => app_handle.exit(0),
|
|
_ => {}
|
|
})
|
|
.on_tray_icon_event(move |tray, event| {
|
|
if matches!(
|
|
event,
|
|
TrayIconEvent::DoubleClick {
|
|
button: MouseButton::Left,
|
|
..
|
|
}
|
|
) {
|
|
show_windows_main_window(tray.app_handle());
|
|
}
|
|
})
|
|
.build(app)?;
|
|
|
|
let _ = app.manage(WindowsTrayState {
|
|
open_main_window,
|
|
status_item,
|
|
toggle_core_item,
|
|
restart_core_item,
|
|
quit_item: quit,
|
|
locale: Mutex::new(locale),
|
|
busy: AtomicBool::new(false),
|
|
});
|
|
|
|
Ok(())
|
|
}
|