winctx 0.0.20

A minimal window context for Rust on Windows.
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

use std::mem::MaybeUninit;
use std::ptr;

use tokio::sync::mpsc::UnboundedSender;
use windows_sys::Win32::Foundation::FALSE;
use windows_sys::Win32::UI::Shell as shellapi;
use windows_sys::Win32::UI::WindowsAndMessaging as winuser;
use windows_sys::Win32::UI::WindowsAndMessaging::{HMENU, MSG};

use crate::event::MouseButton;
use crate::event::MouseButtons;
use crate::event::MouseEvent;
use crate::AreaId;

use super::messages;
use super::WindowEvent;

/// Helper to manager clipboard polling state.
pub(super) struct MenuManager<'a> {
    events_tx: &'a UnboundedSender<WindowEvent>,
    menus: &'a [Option<(winuser::HMENU, MouseButtons)>],
}

impl<'a> MenuManager<'a> {
    pub(super) fn new(
        events_tx: &'a UnboundedSender<WindowEvent>,
        menus: &'a [Option<(winuser::HMENU, MouseButtons)>],
    ) -> Self {
        Self { events_tx, menus }
    }

    pub(super) unsafe fn dispatch(&mut self, msg: &MSG) -> bool {
        match msg.message {
            messages::ICON_ID => {
                let area_id = AreaId::new(msg.wParam as u32);

                match msg.lParam as u32 {
                    // Balloon clicked.
                    shellapi::NIN_BALLOONUSERCLICK => {
                        let event = MouseEvent {
                            buttons: MouseButtons::empty(),
                        };

                        _ = self
                            .events_tx
                            .send(WindowEvent::NotificationClicked(area_id, event));
                        return true;
                    }
                    // Balloon timed out.
                    shellapi::NIN_BALLOONTIMEOUT => {
                        _ = self
                            .events_tx
                            .send(WindowEvent::NotificationDismissed(area_id));
                        return true;
                    }
                    winuser::WM_LBUTTONUP | winuser::WM_RBUTTONUP => {
                        let button = match msg.lParam as u32 {
                            winuser::WM_LBUTTONUP => MouseButton::Left,
                            winuser::WM_RBUTTONUP => MouseButton::Right,
                            _ => return true,
                        };

                        _ = self.events_tx.send(WindowEvent::IconClicked(
                            area_id,
                            MouseEvent {
                                buttons: MouseButtons::from_iter([button]),
                            },
                        ));

                        let Some(Some((hmenu, open_menu))) = self.menus.get(area_id.id() as usize)
                        else {
                            return true;
                        };

                        if !open_menu.test(button) {
                            return true;
                        }

                        let mut p = MaybeUninit::zeroed();

                        if winuser::GetCursorPos(p.as_mut_ptr()) == FALSE {
                            return true;
                        }

                        let p = p.assume_init();

                        winuser::SetForegroundWindow(msg.hwnd);

                        winuser::TrackPopupMenu(
                            *hmenu,
                            0,
                            p.x,
                            p.y,
                            (winuser::TPM_BOTTOMALIGN | winuser::TPM_LEFTALIGN) as i32,
                            msg.hwnd,
                            ptr::null_mut(),
                        );

                        return true;
                    }
                    _ => (),
                }
            }
            winuser::WM_MENUCOMMAND => {
                let hmenu = msg.lParam as HMENU;

                let Some(area_id) = self
                    .menus
                    .iter()
                    .position(|el| el.as_ref().map(|(h, _)| *h) == Some(hmenu))
                else {
                    return true;
                };

                let event = MouseEvent {
                    buttons: MouseButtons::empty(),
                };

                _ = self.events_tx.send(WindowEvent::MenuItemClicked(
                    AreaId::new(area_id as u32),
                    msg.wParam as u32,
                    event,
                ));

                return true;
            }
            _ => {}
        }

        false
    }
}