mouse_through.rs for windows下透明窗体鼠标穿透

[cgisky1980]

mouse_through.rs

use core::time::Duration;
use png::Decoder;
use serde::Serialize;
use std::error::Error;
use std::sync::mpsc;
use std::{
    io::Cursor,
    sync::{Arc, Mutex, Condvar},
    thread,
};
use tauri::{webview::WebviewWindow, Manager, WindowEvent};
use windows::Win32::Foundation::{POINT, HINSTANCE, WPARAM, LPARAM, LRESULT};
use windows::Win32::UI::WindowsAndMessaging::{
    GetCursorPos, SetWindowsHookExW, UnhookWindowsHookEx, CallNextHookEx, HHOOK, HC_ACTION,
    MSG, WM_LBUTTONDOWN, WM_LBUTTONUP, WH_MOUSE_LL, MSLLHOOKSTRUCT,GetMessageA, TranslateMessage, DispatchMessageA,
    GetForegroundWindow, GetWindowTextW
};
use lazy_static::lazy_static;

lazy_static! {
    static ref PAUSE_STATE: (Arc<Mutex<bool>>, Arc<Condvar>) = {
        let mutex = Arc::new(Mutex::new(false));
        let condvar = Arc::new(Condvar::new());
        (mutex, condvar)
    };
}

/**
 * Decode PNG data
 */
pub fn decode_png(data: &[u8]) -> Result<(Vec<u8>, u32, u32), png::DecodingError> {
    let decoder = Decoder::new(Cursor::new(data));
    let mut reader = decoder.read_info()?;

    let mut img_data = vec![0; reader.output_buffer_size()];
    let info = reader.next_frame(&mut img_data)?;

    Ok((img_data, info.width, info.height))
}

/**
 * Get pixel color at x and y coordinates, the bitmap is RGBA8888 format.
 */
pub fn get_pixel_color(bitmap: &[u8], width: u32, x: u32, y: u32) -> Option<(u8, u8, u8, u8)> {
    let index = ((y * width + x) as usize) * 4; // Each pixel has 4 bytes (RGBA)
    if index + 3 < bitmap.len() {
        Some((
            bitmap[index],
            bitmap[index + 1],
            bitmap[index + 2],
            bitmap[index + 3],
        ))
    } else {
        None
    }
}

/**
 * Capture window preview, synchronous, resource-intensive
 */
fn capture_preview(window: &WebviewWindow) -> Result<Vec<u8>, String> {
    if !window.is_visible().map_err(|x| x.to_string())? {
        return Err("Window is not visible".into());
    }
    let (tx, rx) = mpsc::channel();
    let tx1 = tx.clone();
    let tx2 = tx.clone();
    let main_win = window.app_handle().get_webview_window("main").unwrap();
    let _ = main_win.with_webview(move |webview| {
        #[cfg(windows)]
        unsafe {
            use webview2_com::CapturePreviewCompletedHandler;
            use webview2_com::Microsoft::Web::WebView2::Win32::{
                ICoreWebView2_15, COREWEBVIEW2_CAPTURE_PREVIEW_IMAGE_FORMAT_PNG,
            };
            use windows::core::Interface;
            use windows::Win32::UI::Shell::SHCreateMemStream;
            let stream1 = match SHCreateMemStream(None) {
                Some(stream) => stream,
                None => {
                    let _ = tx.send(Err("Unable to create image stream".to_string()));
                    return;
                }
           
 };
            let stream2 = match stream1.Clone() {
                Ok(stream) => stream,
                Err(error) => {
                    let _ = tx.send(Err(error.to_string()));
                    return;
                }
            };

            let handler = CapturePreviewCompletedHandler::create(Box::new(move |result| {
                if let Err(err) = result {
                    tx1.send(Err(err.to_string())).unwrap();
                    return Err(err.into());
                }

                let mut data: Vec<u8> = Vec::new();
                let mut buffer: [u8; 4096] = [0; 4096];

                loop {
                    let mut bytes_read: u32 = 0;

                    let result = stream2.Read(
                        buffer.as_mut_ptr() as *mut ::core::ffi::c_void,
                        buffer.len() as u32,
                        Some(&mut bytes_read),
                    );

                    if result.is_err() {
                        let _ = tx.send(Err(result.message().to_string()));
                        return Ok(());
                    }

                    if bytes_read == 0 {
                        break;
                    }

                    data.extend_from_slice(&buffer[..bytes_read as usize]);
                }

                tx1.send(Ok(data)).unwrap();
                return Ok(());
            }));

            let result = webview
                .controller()
                .CoreWebView2()
                .unwrap()
                .cast::<ICoreWebView2_15>()
                .unwrap()
                .CapturePreview(
                    COREWEBVIEW2_CAPTURE_PREVIEW_IMAGE_FORMAT_PNG,
                    &stream1,
                    &handler,
                );

            if let Err(err) = result {
                tx2.send(Err(err.to_string())).unwrap();
            }
      
  }
        #[cfg(all(target_os = "linux", not(windows)))]
        unsafe {
            tx.send(Err("Unsupported platform: Linux".to_string()))
                .unwrap();
        }

        #[cfg(all(target_os = "macos", not(windows)))]
        unsafe {
            tx.send(Err("Unsupported platform: macOS".to_string()))
                .unwrap();
        }
    });

    match rx.recv() {
        Ok(data) => data,
        Err(err) => Err(err.to_string()),
    }
}

#[derive(Serialize, Debug, Clone)]
pub struct Point2D {
    pub x: i32,
    pub y: i32,
}

/// Get current cursor position
pub fn get_cursor_position() -> Result<Point2D, String> {
    #[cfg(windows)]
    unsafe {
        let mut pos = POINT { x: 0, y: 0 };
        let _ = GetCursorPos(&mut pos);
        return Ok(Point2D { x: pos.x, y: pos.y });
    }

    #[cfg(all(target_os = "linux", not(windows)))]
    unsafe {
        return Err("Unsupported platform: Linux".to_string());
    }

    #[cfg(all(target_os = "macos", not(windows)))]
    unsafe {
        return Err("Unsupported platform: macOS".to_string());
    }
}

/// Check if the cursor is on the given window, return bool and relative position.
pub fn is_mouse_on_window(window: Arc<WebviewWindow>) -> Result<(bool, Point2D), Box<dyn Error>> {
    if let Ok(true) = window.is_visible() {
        let cur_pos = get_cursor_position()?;

        let win_pos = window.inner_position()?;

        let win_size = window.inner_size()?;

        let pix_pos: Point2D = Point2D {
            x: cur_pos.x - win_pos.x,
            y: cur_pos.y - win_pos.y,
        };

        if (pix_pos.x > 0 && pix_pos.x < win_size.width as i32)
            && (pix_pos.y > 0 && pix_pos.y < win_size.height as i32)
        {
            return Ok((true, pix_pos));
        }
    }

    return Ok((false, Point2D { x: 0, y: 0 }));
}

/// Switch ignore cursor events based on alpha.
pub fn use_mouse_through(window1: Arc<WebviewWindow>) {
    let window2 = window1.clone();

    let kill_signal1 = Arc::new(Mutex::new(false));
    let kill_signal2 = kill_signal1.clone();
    let kill_signal3 = kill_signal1.clone();
    let kill_signal4 = kill_signal1.clone(); 

    let buffer1: Arc<Mutex<(Vec<u8>, u32, u32)>> = Arc::new(Mutex::new((Vec::new(), 0, 0)));
    let buffer2 = buffer1.clone();

    // 窗口事件处理
    window1.clone().on_window_event(move |event| match event {
        WindowEvent::Destroyed => {
            println!("[use_mouse_through] 窗口销毁，设置终止信号");
            *kill_signal1.lock().unwrap() = true;
            // 唤醒所有等待线程
            PAUSE_STATE.1.notify_all();
        }
        _ => {}
    });

    // Capture preview thread
    thread::spawn(move || loop {
        if *kill_signal2.lock().unwrap() {
            println!("[use_mouse_through] Thread break of capture preview.");
            break;
        }

        // 使用条件变量等待暂停状态解除
        let (lock, cvar) = &*PAUSE_STATE;
        let mut paused = lock.lock().unwrap();
        while *paused {
            paused = cvar.wait(paused).unwrap();
        }
        drop(paused);

        match is_mouse_on_window(window1.clone()) {
            Ok((true, _)) => {
                if let Ok(png_data) = capture_preview(&window1) {
                    if let Ok((bitmap, width, height)) = decode_png(&png_data) {
                        let mut buffer = buffer1.lock().unwrap();
                        buffer.0.clear();
                        buffer.0.extend_from_slice(&bitmap);
                        buffer.1 = width;
                        buffer.2 = height;
                    }
                }
            }
            Ok((false, _)) => {}
            Err(_) => break,
        }

        thread::sleep(Duration::from_millis(500));
    });

    // Switch ignore cursor events thread
    let mut previous_alpha = false;
    thread::spawn(move || loop {
        if *kill_signal3.lock().unwrap() {
            println!("[use_mouse_through] Thread break of switch ignore cursor events.");
            break;
        }
        use windows::Win32::System::Threading::{
            GetCurrentThread, SetThreadPriority, THREAD_PRIORITY_ABOVE_NORMAL,
        };
        unsafe {
            let current_thread = GetCurrentThread();
            // 设置线程的优先级
            SetThreadPriority(current_thread, THREAD_PRIORITY_ABOVE_NORMAL).unwrap();
        }

        match is_mouse_on_window(window2.clone()) {
            Ok((true, pix_pos)) => {
                let buffer = buffer2.lock().unwrap();

                if let Some(color) =
                    get_pixel_color(&buffer.0, buffer.1, pix_pos.x as u32, pix_pos.y as u32)
                {
                    if previous_alpha != (color.3 == 0) {
                        let _ = window2.set_ignore_cursor_events(color.3 == 0);
                        // Send mouse position to the WebView
                        // let script = format!("handleMouseMove({}, {})", pix_pos.x, pix_pos.y);
                        // if let Err(e) = window2.eval(&script) {
                        //    eprintln!("Failed to send mouse position to WebView: {}", e);
                        //}
                        previous_alpha = color.3 == 0;
                    }
                }
            }
            Ok((false, _)) => {}
            Err(_) => break,
        }

        thread::sleep(Duration::from_millis(16));
    });

    // 设置全局鼠标钩子

        // 在独立线程中运行消息循环
        thread::spawn(move || {
            unsafe {
                match SetWindowsHookExW(WH_MOUSE_LL, Some(mouse_hook_proc), HINSTANCE::default(), 0) {
                    Ok(hook) => {
                        let mut msg: MSG = std::mem::zeroed();
                        while GetMessageA(&mut msg, None, 0, 0).as_bool() {
                            let _ = TranslateMessage(&msg);
                            DispatchMessageA(&msg);
                        
                            // 检查终止信号
                            if *kill_signal4.lock().unwrap() {
                                let _ = UnhookWindowsHookEx(hook);
                                break;
                            }
                        }
                    }
                    Err(e) => {
                        eprintln!("Failed to install hook: {}", e);
                        return;
                    }
                }
            }
        });
    
}

// 鼠标钩子回调函数
unsafe extern "system" fn mouse_hook_proc(code: i32, wparam: WPARAM, lparam: LPARAM) -> LRESULT {
    if code == HC_ACTION as i32 {
        let mouse_struct: &MSLLHOOKSTRUCT = &*(lparam.0 as *const MSLLHOOKSTRUCT);
        match wparam.0 {
            x if x == WM_LBUTTONDOWN as usize => {
                println!("Mouse left button down at ({}, {})", mouse_struct.pt.x, mouse_struct.pt.y);
                // 设置暂停状态
                let (lock, cvar) = &*PAUSE_STATE;
                let mut paused = lock.lock().unwrap();
                *paused = true;
                cvar.notify_all();
                // 打印当前窗口的标题
                let hwnd = GetForegroundWindow();
                let mut title = [0u16; 256];
                GetWindowTextW(hwnd, &mut title);
                println!("Current window title: {}", String::from_utf16_lossy(&title));
            }
            x if x == WM_LBUTTONUP as usize => {
                println!("Mouse left button up at ({}, {})", mouse_struct.pt.x, mouse_struct.pt.y);
                // 解除暂停状态
                let (lock, cvar) = &*PAUSE_STATE;
                {
                    let mut paused = lock.lock().unwrap();
                    *paused = false;
                } // 显式释放锁
                cvar.notify_all();
            }
            _ => {}
        }
    }
    CallNextHookEx(HHOOK::default(), code, wparam, lparam)
}

[cgisky1980]

mod mouse_through;
use crate::mouse_through::*;

...
...
    tauri::Builder::default()
        .invoke_handler(tauri::generate_handler![])
        .setup(|app| {
            let main_window = app.get_webview_window("main").unwrap();
            let main_window_arc = Arc::new(main_window);
            use_mouse_through(main_window_arc);
            Ok(())
        })

[cgisky1980]

use core::time::Duration;
use png::Decoder;
use serde::Serialize;
use std::error::Error;
use std::sync::mpsc;
use std::{
    io::Cursor,
    sync::{Arc, Mutex, Condvar},
    thread,
};
use tauri::{webview::WebviewWindow, Manager, WindowEvent};
use windows::Win32::Foundation::{POINT, HINSTANCE, WPARAM, LPARAM, LRESULT};
use windows::Win32::UI::WindowsAndMessaging::{
    GetCursorPos, SetWindowsHookExW, UnhookWindowsHookEx, CallNextHookEx, HHOOK, HC_ACTION,
    MSG, WM_LBUTTONDOWN, WM_LBUTTONUP, WH_MOUSE_LL, MSLLHOOKSTRUCT,GetMessageA, TranslateMessage, DispatchMessageA,
    GetForegroundWindow, GetWindowTextW
};
use lazy_static::lazy_static;

lazy_static! {
    static ref PAUSE_STATE: (Arc<Mutex<bool>>, Arc<Condvar>) = {
        let mutex = Arc::new(Mutex::new(false));
        let condvar = Arc::new(Condvar::new());
        (mutex, condvar)
    };
}

/**
 * Decode PNG data
 */
pub fn decode_png(data: &[u8]) -> Result<(Vec<u8>, u32, u32), png::DecodingError> {
    let decoder = Decoder::new(Cursor::new(data));
    let mut reader = decoder.read_info()?;

    let mut img_data = vec![0; reader.output_buffer_size()];
    let info = reader.next_frame(&mut img_data)?;

    Ok((img_data, info.width, info.height))
}

/**
 * Get pixel color at x and y coordinates, the bitmap is RGBA8888 format.
 */
pub fn get_pixel_color(bitmap: &[u8], width: u32, x: u32, y: u32) -> Option<(u8, u8, u8, u8)> {
    let index = ((y * width + x) as usize) * 4; // Each pixel has 4 bytes (RGBA)
    if index + 3 < bitmap.len() {
        Some((
            bitmap[index],
            bitmap[index + 1],
            bitmap[index + 2],
            bitmap[index + 3],
        ))
    } else {
        None
    }
}

/**
 * Capture window preview, synchronous, resource-intensive
 */
fn capture_preview(window: &WebviewWindow) -> Result<Vec<u8>, String> {
    if !window.is_visible().map_err(|x| x.to_string())? {
        return Err("Window is not visible".into());
    }

    let (tx, rx) = mpsc::channel();
    let tx1 = tx.clone();
    let tx2 = tx.clone();
    let main_win = window.app_handle().get_webview_window("main").unwrap();
    let _ = main_win.with_webview(move |webview| {
        #[cfg(windows)]
        unsafe {
            use webview2_com::CapturePreviewCompletedHandler;
            use webview2_com::Microsoft::Web::WebView2::Win32::{
                ICoreWebView2_15, COREWEBVIEW2_CAPTURE_PREVIEW_IMAGE_FORMAT_PNG,
            };
            use windows::core::Interface;
            use windows::Win32::UI::Shell::SHCreateMemStream;

            let stream1 = match SHCreateMemStream(None) {
                Some(stream) => stream,
                None => {
                    let _ = tx.send(Err("Unable to create image stream".to_string()));
                    return;
                }
            };

            let stream2 = match stream1.Clone() {
                Ok(stream) => stream,
                Err(error) => {
                    let _ = tx.send(Err(error.to_string()));
                    return;
                }
            };

            let handler = CapturePreviewCompletedHandler::create(Box::new(move |result| {
                if let Err(err) = result {
                    tx1.send(Err(err.to_string())).unwrap();
                    return Err(err.into());
                }

                let mut data: Vec<u8> = Vec::new();
                let mut buffer: [u8; 4096] = [0; 4096];

                loop {
                    let mut bytes_read: u32 = 0;

                    let result = stream2.Read(
                        buffer.as_mut_ptr() as *mut ::core::ffi::c_void,
                        buffer.len() as u32,
                        Some(&mut bytes_read),
                    );

                    if result.is_err() {
                        let _ = tx.send(Err(result.message().to_string()));
                        return Ok(());
                    }

                    if bytes_read == 0 {
                        break;
                    }

                    data.extend_from_slice(&buffer[..bytes_read as usize]);
                }

                tx1.send(Ok(data)).unwrap();
                return Ok(());
            }));

            let result = webview
                .controller()
                .CoreWebView2()
                .unwrap()
                .cast::<ICoreWebView2_15>()
                .unwrap()
                .CapturePreview(
                    COREWEBVIEW2_CAPTURE_PREVIEW_IMAGE_FORMAT_PNG,
                    &stream1,
                    &handler,
                );

            if let Err(err) = result {
                tx2.send(Err(err.to_string())).unwrap();
            }
        }

        #[cfg(all(target_os = "linux", not(windows)))]
        unsafe {
            tx.send(Err("Unsupported platform: Linux".to_string()))
                .unwrap();
        }

        #[cfg(all(target_os = "macos", not(windows)))]
        unsafe {
            tx.send(Err("Unsupported platform: macOS".to_string()))
                .unwrap();
        }
    });

    match rx.recv() {
        Ok(data) => data,
        Err(err) => Err(err.to_string()),
    }
}

#[derive(Serialize, Debug, Clone)]
pub struct Point2D {
    pub x: i32,
    pub y: i32,
}

/// Get current cursor position
pub fn get_cursor_position() -> Result<Point2D, String> {
    #[cfg(windows)]
    unsafe {
        let mut pos = POINT { x: 0, y: 0 };
        let _ = GetCursorPos(&mut pos);
        return Ok(Point2D { x: pos.x, y: pos.y });
    }

    #[cfg(all(target_os = "linux", not(windows)))]
    unsafe {
        return Err("Unsupported platform: Linux".to_string());
    }

    #[cfg(all(target_os = "macos", not(windows)))]
    unsafe {
        return Err("Unsupported platform: macOS".to_string());
    }
}

/// Check if the cursor is on the given window, return bool and relative position.
pub fn is_mouse_on_window(window: Arc<WebviewWindow>) -> Result<(bool, Point2D), Box<dyn Error>> {
    if let Ok(true) = window.is_visible() {
        let cur_pos = get_cursor_position()?;

        let win_pos = window.inner_position()?;

        let win_size = window.inner_size()?;

        let pix_pos: Point2D = Point2D {
            x: cur_pos.x - win_pos.x,
            y: cur_pos.y - win_pos.y,
        };

        if (pix_pos.x > 0 && pix_pos.x < win_size.width as i32)
            && (pix_pos.y > 0 && pix_pos.y < win_size.height as i32)
        {
            return Ok((true, pix_pos));
        }
    }

    return Ok((false, Point2D { x: 0, y: 0 }));
}

/// Switch ignore cursor events based on alpha.
pub fn use_mouse_through(window1: Arc<WebviewWindow>) {
    let window2 = window1.clone();

    let kill_signal1 = Arc::new(Mutex::new(false));
    let kill_signal2 = kill_signal1.clone();
    let kill_signal3 = kill_signal1.clone();
    let kill_signal4 = kill_signal1.clone(); 

    let buffer1: Arc<Mutex<(Vec<u8>, u32, u32)>> = Arc::new(Mutex::new((Vec::new(), 0, 0)));
    let buffer2 = buffer1.clone();

    // 窗口事件处理
    window1.clone().on_window_event(move |event| match event {
        WindowEvent::Destroyed => {
            println!("[use_mouse_through] 窗口销毁，设置终止信号");
            *kill_signal1.lock().unwrap() = true;
            // 唤醒所有等待线程
            PAUSE_STATE.1.notify_all();
        }
        _ => {}
    });

    // Capture preview thread
    thread::spawn(move || loop {
        if *kill_signal2.lock().unwrap() {
            println!("[use_mouse_through] Thread break of capture preview.");
            break;
        }

        // 使用条件变量等待暂停状态解除
        let (lock, cvar) = &*PAUSE_STATE;
        let mut paused = lock.lock().unwrap();
        while *paused {
            paused = cvar.wait(paused).unwrap();
        }
        drop(paused);

        match is_mouse_on_window(window1.clone()) {
            Ok((true, _)) => {
                if let Ok(png_data) = capture_preview(&window1) {
                    if let Ok((bitmap, width, height)) = decode_png(&png_data) {
                        let mut buffer = buffer1.lock().unwrap();
                        buffer.0.clear();
                        buffer.0.extend_from_slice(&bitmap);
                        buffer.1 = width;
                        buffer.2 = height;
                    }
                }
            }
            Ok((false, _)) => {}
            Err(_) => break,
        }

        thread::sleep(Duration::from_millis(500));
    });

    // Switch ignore cursor events thread
    let mut previous_alpha = false;
    thread::spawn(move || loop {
        if *kill_signal3.lock().unwrap() {
            println!("[use_mouse_through] Thread break of switch ignore cursor events.");
            break;
        }
        use windows::Win32::System::Threading::{
            GetCurrentThread, SetThreadPriority, THREAD_PRIORITY_ABOVE_NORMAL,
        };
        unsafe {
            let current_thread = GetCurrentThread();
            // 设置线程的优先级
            SetThreadPriority(current_thread, THREAD_PRIORITY_ABOVE_NORMAL).unwrap();
        }

        match is_mouse_on_window(window2.clone()) {
            Ok((true, pix_pos)) => {
                let buffer = buffer2.lock().unwrap();

                if let Some(color) =
                    get_pixel_color(&buffer.0, buffer.1, pix_pos.x as u32, pix_pos.y as u32)
                {
                    if previous_alpha != (color.3 == 0) {
                        let _ = window2.set_ignore_cursor_events(color.3 == 0);
                        // Send mouse position to the WebView
                        // let script = format!("handleMouseMove({}, {})", pix_pos.x, pix_pos.y);
                        // if let Err(e) = window2.eval(&script) {
                        //    eprintln!("Failed to send mouse position to WebView: {}", e);
                        //}
                        previous_alpha = color.3 == 0;
                    }
                }
            }
            Ok((false, _)) => {}
            Err(_) => break,
        }

        thread::sleep(Duration::from_millis(16));
    });

    // 设置全局鼠标钩子

        // 在独立线程中运行消息循环
        thread::spawn(move || {
            unsafe {
                match SetWindowsHookExW(WH_MOUSE_LL, Some(mouse_hook_proc), Some(HINSTANCE::default()), 0) {
                    Ok(hook) => {
                        let mut msg: MSG = std::mem::zeroed();
                        while GetMessageA(&mut msg, None, 0, 0).as_bool() {
                            let _ = TranslateMessage(&msg);
                            DispatchMessageA(&msg);
                        
                            // 检查终止信号
                            if *kill_signal4.lock().unwrap() {
                                let _ = UnhookWindowsHookEx(hook);
                                break;
                            }
                        }
                    }
                    Err(e) => {
                        eprintln!("Failed to install hook: {}", e);
                        return;
                    }
                }
            }
        });
    
}

// 鼠标钩子回调函数
unsafe extern "system" fn mouse_hook_proc(code: i32, wparam: WPARAM, lparam: LPARAM) -> LRESULT {
    if code == HC_ACTION as i32 {
        let mouse_struct: &MSLLHOOKSTRUCT = &*(lparam.0 as *const MSLLHOOKSTRUCT);
        match wparam.0 {
            x if x == WM_LBUTTONDOWN as usize => {
                println!("Mouse left button down at ({}, {})", mouse_struct.pt.x, mouse_struct.pt.y);
                // 设置暂停状态
                let (lock, cvar) = &*PAUSE_STATE;
                let mut paused = lock.lock().unwrap();
                *paused = true;
                cvar.notify_all();
                // 打印当前窗口的标题
                let hwnd = GetForegroundWindow();
                let mut title = [0u16; 256];
                GetWindowTextW(hwnd, &mut title);
                println!("Current window title: {}", String::from_utf16_lossy(&title));
            }
            x if x == WM_LBUTTONUP as usize => {
                println!("Mouse left button up at ({}, {})", mouse_struct.pt.x, mouse_struct.pt.y);
                // 解除暂停状态
                let (lock, cvar) = &*PAUSE_STATE;
                {
                    let mut paused = lock.lock().unwrap();
                    *paused = false;
                } // 显式释放锁
                cvar.notify_all();
            }
            _ => {}
        }
    }
    CallNextHookEx(Some(HHOOK::default()), code, wparam, lparam)
}

update for
[dependencies.windows]
version = "0.60.0"