rdesktop-core 0.1.0

Core abstractions for rdesktop - a dual-engine Rust desktop framework
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139

//! Platform-specific window attributes for deep desktop scenarios.
//!
//! Provides [`apply_window_attributes`], called right after a tao window is
//! built. It realizes the `Wallpaper`/`Overlay` window kinds and click-through
//! requested in [`crate::config::WindowConfig`].
//!
//! - **Click-through**: the window ignores pointer input, which falls through
//!   to whatever is behind it. Required for wallpaper; optional for overlays.
//! - **Desktop layer**: the window is reparented beneath the desktop icons
//!   (Windows: `WorkerW`; macOS: `kCGDesktopWindowLevel`) so it behaves like
//!   a Wallpaper-Engine-style background.

use crate::config::{WindowConfig, WindowKind};
use tao::window::Window;

/// Apply `config.kind` / `config.click_through` to a freshly built window.
pub fn apply_window_attributes(window: &Window, config: &WindowConfig) {
    let click_through = config.click_through || config.kind == WindowKind::Wallpaper;
    let is_wallpaper = config.kind == WindowKind::Wallpaper;

    #[cfg(target_os = "windows")]
    windows::apply(window, click_through, is_wallpaper);
    #[cfg(target_os = "macos")]
    macos::apply(window, click_through, is_wallpaper);
    #[cfg(not(any(target_os = "windows", target_os = "macos")))]
    {
        let _ = (window, click_through, is_wallpaper);
        tracing::debug!("click-through / wallpaper layer not implemented on this platform");
    }
}

#[cfg(target_os = "windows")]
mod windows {
    use std::ptr;

    use tao::platform::windows::WindowExtWindows;
    use tao::window::Window;
    use windows_sys::Win32::Foundation::{BOOL, HWND, LPARAM};
    use windows_sys::Win32::UI::WindowsAndMessaging::{
        EnumWindows, FindWindowExW, FindWindowW, GetWindowLongPtrW, SendMessageTimeoutW, SetParent,
        SetWindowLongPtrW, SetWindowPos, GWL_EXSTYLE, HWND_BOTTOM, SMTO_ABORTIFHUNG,
        SWP_NOACTIVATE, SWP_NOMOVE, SWP_NOSIZE, WS_EX_LAYERED, WS_EX_TRANSPARENT,
    };

    pub(crate) fn apply(window: &Window, click_through: bool, is_wallpaper: bool) {
        let hwnd = window.hwnd() as HWND;
        if hwnd == 0 {
            return;
        }
        unsafe {
            if click_through {
                let ex = GetWindowLongPtrW(hwnd, GWL_EXSTYLE);
                let new_ex = ex | (WS_EX_LAYERED as isize) | (WS_EX_TRANSPARENT as isize);
                SetWindowLongPtrW(hwnd, GWL_EXSTYLE, new_ex);
            }
            if is_wallpaper {
                if let Some(worker) = find_desktop_workerw() {
                    SetParent(hwnd, worker);
                }
                SetWindowPos(
                    hwnd,
                    HWND_BOTTOM,
                    0,
                    0,
                    0,
                    0,
                    SWP_NOMOVE | SWP_NOSIZE | SWP_NOACTIVATE,
                );
            }
        }
    }

    /// Locate the desktop `WorkerW` window (the host behind the desktop icons)
    /// by asking Explorer to (re)create it and then finding the sibling
    /// `WorkerW` that does not own `SHELLDLL_DefView`.
    unsafe fn find_desktop_workerw() -> Option<HWND> {
        let progman = FindWindowW(windows_sys::w!("Progman"), ptr::null::<u16>());
        if progman == 0 {
            return None;
        }
        // Prompt Explorer to create a dedicated wallpaper WorkerW host.
        SendMessageTimeoutW(
            progman,
            0x52C,
            0,
            0,
            SMTO_ABORTIFHUNG,
            1000,
            ptr::null_mut::<usize>(),
        );
        let mut worker: HWND = 0;
        EnumWindows(Some(enum_proc), &mut worker as *mut _ as LPARAM);
        if worker == 0 {
            None
        } else {
            Some(worker)
        }
    }

    extern "system" fn enum_proc(hwnd: HWND, lparam: LPARAM) -> BOOL {
        unsafe {
            let defview = FindWindowExW(
                hwnd,
                0,
                windows_sys::w!("SHELLDLL_DefView"),
                ptr::null::<u16>(),
            );
            if defview != 0 {
                let pworker = &mut *(lparam as *mut HWND);
                *pworker = FindWindowExW(0, hwnd, windows_sys::w!("WorkerW"), ptr::null::<u16>());
            }
            windows_sys::Win32::Foundation::TRUE
        }
    }
}

#[cfg(target_os = "macos")]
mod macos {
    use core_graphics::window::{CGWindowLevelForKey, CGWindowLevelKey};
    use objc::{msg_send, runtime::Object};
    use tao::platform::macos::WindowExtMacOS;
    use tao::window::Window;

    pub(crate) fn apply(window: &Window, click_through: bool, is_wallpaper: bool) {
        let ns_win = window.ns_window() as *mut Object;
        if ns_win.is_null() {
            return;
        }
        unsafe {
            let _: () = msg_send![ns_win, setIgnoresMouseEvents: click_through || is_wallpaper];
            if is_wallpaper {
                let level: i64 =
                    CGWindowLevelForKey(CGWindowLevelKey::kCGDesktopWindowLevelKey) as i64;
                let _: () = msg_send![ns_win, setLevel: level];
                let _: () = msg_send![ns_win, orderBack: ns_win];
            }
        }
    }
}