385 lines
14 KiB
Rust
Executable File
385 lines
14 KiB
Rust
Executable File
use crate::{
|
|
config::Config,
|
|
core::handle,
|
|
feat, logging, logging_error,
|
|
module::lightweight::entry_lightweight_mode,
|
|
process::AsyncHandler,
|
|
utils::{logging::Type, resolve},
|
|
};
|
|
use anyhow::{bail, Result};
|
|
use once_cell::sync::OnceCell;
|
|
use parking_lot::Mutex;
|
|
use std::{collections::HashMap, sync::Arc};
|
|
use tauri::Manager;
|
|
use tauri_plugin_global_shortcut::{Code, GlobalShortcutExt, ShortcutState};
|
|
|
|
pub struct Hotkey {
|
|
current: Arc<Mutex<Vec<String>>>, // 保存当前的热键设置
|
|
}
|
|
|
|
impl Hotkey {
|
|
pub fn global() -> &'static Hotkey {
|
|
static HOTKEY: OnceCell<Hotkey> = OnceCell::new();
|
|
|
|
HOTKEY.get_or_init(|| Hotkey {
|
|
current: Arc::new(Mutex::new(Vec::new())),
|
|
})
|
|
}
|
|
|
|
pub fn init(&self) -> Result<()> {
|
|
let verge = Config::verge();
|
|
let enable_global_hotkey = verge.latest().enable_global_hotkey.unwrap_or(true);
|
|
|
|
logging!(
|
|
debug,
|
|
Type::Hotkey,
|
|
true,
|
|
"Initializing global hotkeys: {}",
|
|
enable_global_hotkey
|
|
);
|
|
|
|
// 如果全局热键被禁用，则不注册热键
|
|
if !enable_global_hotkey {
|
|
return Ok(());
|
|
}
|
|
|
|
if let Some(hotkeys) = verge.latest().hotkeys.as_ref() {
|
|
logging!(
|
|
debug,
|
|
Type::Hotkey,
|
|
true,
|
|
"Has {} hotkeys need to register",
|
|
hotkeys.len()
|
|
);
|
|
|
|
for hotkey in hotkeys.iter() {
|
|
let mut iter = hotkey.split(',');
|
|
let func = iter.next();
|
|
let key = iter.next();
|
|
|
|
match (key, func) {
|
|
(Some(key), Some(func)) => {
|
|
logging!(
|
|
debug,
|
|
Type::Hotkey,
|
|
true,
|
|
"Registering hotkey: {} -> {}",
|
|
key,
|
|
func
|
|
);
|
|
if let Err(e) = self.register(key, func) {
|
|
logging!(
|
|
error,
|
|
Type::Hotkey,
|
|
true,
|
|
"Failed to register hotkey {} -> {}: {:?}",
|
|
key,
|
|
func,
|
|
e
|
|
);
|
|
} else {
|
|
logging!(
|
|
debug,
|
|
Type::Hotkey,
|
|
"Successfully registered hotkey {} -> {}",
|
|
key,
|
|
func
|
|
);
|
|
}
|
|
}
|
|
_ => {
|
|
let key = key.unwrap_or("None");
|
|
let func = func.unwrap_or("None");
|
|
logging!(
|
|
error,
|
|
Type::Hotkey,
|
|
true,
|
|
"Invalid hotkey configuration: `{}`:`{}`",
|
|
key,
|
|
func
|
|
);
|
|
}
|
|
}
|
|
}
|
|
self.current.lock().clone_from(hotkeys);
|
|
} else {
|
|
logging!(debug, Type::Hotkey, "No hotkeys configured");
|
|
}
|
|
|
|
Ok(())
|
|
}
|
|
|
|
pub fn reset(&self) -> Result<()> {
|
|
let app_handle = handle::Handle::global().app_handle().unwrap();
|
|
let manager = app_handle.global_shortcut();
|
|
manager.unregister_all()?;
|
|
Ok(())
|
|
}
|
|
|
|
pub fn register(&self, hotkey: &str, func: &str) -> Result<()> {
|
|
let app_handle = handle::Handle::global().app_handle().unwrap();
|
|
let manager = app_handle.global_shortcut();
|
|
|
|
logging!(
|
|
debug,
|
|
Type::Hotkey,
|
|
"Attempting to register hotkey: {} for function: {}",
|
|
hotkey,
|
|
func
|
|
);
|
|
|
|
if manager.is_registered(hotkey) {
|
|
logging!(
|
|
debug,
|
|
Type::Hotkey,
|
|
"Hotkey {} was already registered, unregistering first",
|
|
hotkey
|
|
);
|
|
manager.unregister(hotkey)?;
|
|
}
|
|
|
|
let f = match func.trim() {
|
|
"open_or_close_dashboard" => {
|
|
logging!(
|
|
debug,
|
|
Type::Hotkey,
|
|
"Registering open_or_close_dashboard function"
|
|
);
|
|
|| {
|
|
logging!(
|
|
debug,
|
|
Type::Hotkey,
|
|
true,
|
|
"=== Hotkey Dashboard Window Operation Start ==="
|
|
);
|
|
|
|
// 检查是否在轻量模式下，如果是，需要同步处理
|
|
if crate::module::lightweight::is_in_lightweight_mode() {
|
|
logging!(
|
|
info,
|
|
Type::Hotkey,
|
|
true,
|
|
"In lightweight mode, calling open_or_close_dashboard directly"
|
|
);
|
|
crate::feat::open_or_close_dashboard();
|
|
} else {
|
|
AsyncHandler::spawn(move || async move {
|
|
logging!(
|
|
debug,
|
|
Type::Hotkey,
|
|
true,
|
|
"Toggle dashboard window visibility (async)"
|
|
);
|
|
|
|
// 检查窗口是否存在
|
|
if let Some(window) = handle::Handle::global().get_window() {
|
|
// 如果窗口可见，则隐藏
|
|
match window.is_visible() {
|
|
Ok(visible) => {
|
|
if visible {
|
|
logging!(
|
|
info,
|
|
Type::Window,
|
|
true,
|
|
"Window is visible, hiding it"
|
|
);
|
|
let _ = window.hide();
|
|
} else {
|
|
// 如果窗口不可见，则显示
|
|
logging!(
|
|
info,
|
|
Type::Window,
|
|
true,
|
|
"Window is hidden, showing it"
|
|
);
|
|
if window.is_minimized().unwrap_or(false) {
|
|
let _ = window.unminimize();
|
|
}
|
|
let _ = window.show();
|
|
let _ = window.set_focus();
|
|
}
|
|
}
|
|
Err(e) => {
|
|
logging!(
|
|
warn,
|
|
Type::Window,
|
|
true,
|
|
"Failed to check window visibility: {}",
|
|
e
|
|
);
|
|
let _ = window.show();
|
|
let _ = window.set_focus();
|
|
}
|
|
}
|
|
} else {
|
|
// 如果窗口不存在，创建一个新窗口
|
|
logging!(
|
|
info,
|
|
Type::Window,
|
|
true,
|
|
"Window does not exist, creating a new one"
|
|
);
|
|
resolve::create_window(true);
|
|
}
|
|
});
|
|
}
|
|
|
|
logging!(
|
|
debug,
|
|
Type::Hotkey,
|
|
"=== Hotkey Dashboard Window Operation End ==="
|
|
);
|
|
}
|
|
}
|
|
"clash_mode_rule" => || feat::change_clash_mode("rule".into()),
|
|
"clash_mode_global" => || feat::change_clash_mode("global".into()),
|
|
"clash_mode_direct" => || feat::change_clash_mode("direct".into()),
|
|
"toggle_system_proxy" => || feat::toggle_system_proxy(),
|
|
"toggle_tun_mode" => || feat::toggle_tun_mode(None),
|
|
"entry_lightweight_mode" => || entry_lightweight_mode(),
|
|
"quit" => || feat::quit(),
|
|
#[cfg(target_os = "macos")]
|
|
"hide" => || feat::hide(),
|
|
|
|
_ => {
|
|
logging!(error, Type::Hotkey, "Invalid function: {}", func);
|
|
bail!("invalid function \"{func}\"");
|
|
}
|
|
};
|
|
|
|
let is_quit = func.trim() == "quit";
|
|
|
|
let _ = manager.on_shortcut(hotkey, move |app_handle, hotkey, event| {
|
|
if event.state == ShortcutState::Pressed {
|
|
logging!(debug, Type::Hotkey, "Hotkey pressed: {:?}", hotkey);
|
|
|
|
if hotkey.key == Code::KeyQ && is_quit {
|
|
if let Some(window) = app_handle.get_webview_window("main") {
|
|
if window.is_focused().unwrap_or(false) {
|
|
logging!(debug, Type::Hotkey, "Executing quit function");
|
|
f();
|
|
}
|
|
}
|
|
} else {
|
|
// 直接执行函数，不做任何状态检查
|
|
logging!(debug, Type::Hotkey, "Executing function directly");
|
|
|
|
// 获取全局热键状态
|
|
let is_enable_global_hotkey = Config::verge()
|
|
.latest()
|
|
.enable_global_hotkey
|
|
.unwrap_or(true);
|
|
|
|
if is_enable_global_hotkey {
|
|
f();
|
|
} else if let Some(window) = app_handle.get_webview_window("main") {
|
|
// 非轻量模式且未启用全局热键时，只在窗口可见且有焦点的情况下响应热键
|
|
let is_visible = window.is_visible().unwrap_or(false);
|
|
let is_focused = window.is_focused().unwrap_or(false);
|
|
|
|
if is_focused && is_visible {
|
|
f();
|
|
}
|
|
}
|
|
}
|
|
}
|
|
});
|
|
|
|
logging!(
|
|
debug,
|
|
Type::Hotkey,
|
|
"Successfully registered hotkey {} for {}",
|
|
hotkey,
|
|
func
|
|
);
|
|
Ok(())
|
|
}
|
|
|
|
pub fn unregister(&self, hotkey: &str) -> Result<()> {
|
|
let app_handle = handle::Handle::global().app_handle().unwrap();
|
|
let manager = app_handle.global_shortcut();
|
|
manager.unregister(hotkey)?;
|
|
logging!(debug, Type::Hotkey, "Unregister hotkey {}", hotkey);
|
|
Ok(())
|
|
}
|
|
|
|
pub fn update(&self, new_hotkeys: Vec<String>) -> Result<()> {
|
|
let mut current = self.current.lock();
|
|
let old_map = Self::get_map_from_vec(¤t);
|
|
let new_map = Self::get_map_from_vec(&new_hotkeys);
|
|
|
|
let (del, add) = Self::get_diff(old_map, new_map);
|
|
|
|
del.iter().for_each(|key| {
|
|
let _ = self.unregister(key);
|
|
});
|
|
|
|
add.iter().for_each(|(key, func)| {
|
|
logging_error!(Type::Hotkey, self.register(key, func));
|
|
});
|
|
|
|
*current = new_hotkeys;
|
|
Ok(())
|
|
}
|
|
|
|
fn get_map_from_vec(hotkeys: &[String]) -> HashMap<&str, &str> {
|
|
let mut map = HashMap::new();
|
|
|
|
hotkeys.iter().for_each(|hotkey| {
|
|
let mut iter = hotkey.split(',');
|
|
let func = iter.next();
|
|
let key = iter.next();
|
|
|
|
if func.is_some() && key.is_some() {
|
|
let func = func.unwrap().trim();
|
|
let key = key.unwrap().trim();
|
|
map.insert(key, func);
|
|
}
|
|
});
|
|
map
|
|
}
|
|
|
|
fn get_diff<'a>(
|
|
old_map: HashMap<&'a str, &'a str>,
|
|
new_map: HashMap<&'a str, &'a str>,
|
|
) -> (Vec<&'a str>, Vec<(&'a str, &'a str)>) {
|
|
let mut del_list = vec![];
|
|
let mut add_list = vec![];
|
|
|
|
old_map.iter().for_each(|(&key, func)| {
|
|
match new_map.get(key) {
|
|
Some(new_func) => {
|
|
if new_func != func {
|
|
del_list.push(key);
|
|
add_list.push((key, *new_func));
|
|
}
|
|
}
|
|
None => del_list.push(key),
|
|
};
|
|
});
|
|
|
|
new_map.iter().for_each(|(&key, &func)| {
|
|
if !old_map.contains_key(key) {
|
|
add_list.push((key, func));
|
|
}
|
|
});
|
|
|
|
(del_list, add_list)
|
|
}
|
|
}
|
|
|
|
impl Drop for Hotkey {
|
|
fn drop(&mut self) {
|
|
let app_handle = handle::Handle::global().app_handle().unwrap();
|
|
if let Err(e) = app_handle.global_shortcut().unregister_all() {
|
|
logging!(
|
|
error,
|
|
Type::Hotkey,
|
|
true,
|
|
"Error unregistering all hotkeys: {:?}",
|
|
e
|
|
);
|
|
}
|
|
}
|
|
}
|