wiard 0.8.1

Window handling library for Windows in Rust
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
140
141
142
143
144

use crate::*;
use windows::Win32::Foundation::{LPARAM, POINT, WPARAM};
use windows::Win32::Graphics::Gdi::{ClientToScreen, ScreenToClient};
use windows::Win32::System::{Ole::MK_ALT, SystemServices::*};
use windows::Win32::UI::WindowsAndMessaging::GetCursorPos;
use bitflags::bitflags;

#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Debug, Hash)]
#[repr(u32)]
enum MouseStateVirtualKey {
    Ctrl = 0x1,
    Shift = 0x2,
}

#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
pub struct MouseStateVirtualKeys(u32);

impl MouseStateVirtualKeys {
    #[inline]
    pub fn contains(&self, key: VirtualKey) -> bool {
        if key == VirtualKey::Ctrl {
            self.0 & MouseStateVirtualKey::Ctrl as u32 != 0
        } else if key == VirtualKey::Shift {
            self.0 & MouseStateVirtualKey::Shift as u32 != 0
        } else {
            false
        }
    }

    #[inline]
    pub fn to_vec(&self) -> Vec<VirtualKey> {
        let mut v = vec![];
        if self.0 & MouseStateVirtualKey::Ctrl as u32 != 0 {
            v.push(VirtualKey::Ctrl);
        }
        if self.0 & MouseStateVirtualKey::Shift as u32 != 0 {
            v.push(VirtualKey::Shift);
        }
        v
    }
}

impl From<WPARAM> for MouseStateVirtualKeys {
    #[inline]
    fn from(value: WPARAM) -> Self {
        let value = loword(value.0 as i32) as u32;
        let mut ret = 0;
        if value & MK_CONTROL.0 != 0 {
            ret |= MouseStateVirtualKey::Ctrl as u32;
        }
        if value & MK_SHIFT.0 != 0 {
            ret |= MouseStateVirtualKey::Shift as u32;
        }
        Self(ret)
    }
}

impl std::fmt::Debug for MouseStateVirtualKeys {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let v = self.to_vec();
        write!(f, "{v:?}")
    }
}

impl std::fmt::Display for MouseStateVirtualKeys {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let v = self.to_vec();
        write!(f, "{v:?}")
    }
}

#[derive(Clone, Debug)]
pub struct MouseState {
    pub position: PhysicalPosition<i32>,
    pub buttons: MouseButtons,
    pub keys: MouseStateVirtualKeys,
}

impl MouseState {
    pub(crate) fn from_params(wparam: WPARAM, lparam: LPARAM) -> Self {
        Self {
            position: lparam_to_point(lparam),
            buttons: wparam.into(),
            keys: wparam.into(),
        }
    }
}

/// This value is a multiple of wheel value.
pub const WHEEL_DELTA: i32 = windows::Win32::UI::WindowsAndMessaging::WHEEL_DELTA as i32;

#[inline]
pub fn get_cursor_pos() -> ScreenPosition<i32> {
    unsafe {
        let mut pt = POINT::default();
        let _ = GetCursorPos(&mut pt);
        ScreenPosition::new(pt.x, pt.y)
    }
}

#[inline]
pub fn client_to_screen(window: &impl IsWindow, src: PhysicalPosition<i32>) -> ScreenPosition<i32> {
    unsafe {
        let mut pt = POINT { x: src.x, y: src.y };
        let _ = ClientToScreen(window.window_handle().as_hwnd(), &mut pt);
        ScreenPosition::new(pt.x, pt.y)
    }
}

#[inline]
pub fn screen_to_client(window: &impl IsWindow, src: ScreenPosition<i32>) -> PhysicalPosition<i32> {
    unsafe {
        let mut pt = POINT { x: src.x, y: src.y };
        let _ = ScreenToClient(window.window_handle().as_hwnd(), &mut pt);
        PhysicalPosition::new(pt.x, pt.y)
    }
}

bitflags! {
    #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Debug, Hash)]
    pub struct ModifierKey: u32 {
        const CONTROL = MK_CONTROL.0;
        const SHIFT = MK_SHIFT.0;
        const ALT = MK_ALT;
        const LBUTTON = MK_LBUTTON.0;
        const RBUTTON = MK_RBUTTON.0;
        const MBUTTON = MK_MBUTTON.0;
        const XBUTTON1 = MK_XBUTTON1.0;
        const XBUTTON2 = MK_XBUTTON2.0;
    }
}

impl ModifierKey {
    #[inline]
    pub const fn as_raw(&self) -> MODIFIERKEYS_FLAGS {
        MODIFIERKEYS_FLAGS(self.bits())
    }
}

impl From<MODIFIERKEYS_FLAGS> for ModifierKey {
    fn from(value: MODIFIERKEYS_FLAGS) -> Self {
        Self::from_bits_retain(value.0)
    }
}