1 #![allow(unused_variables, non_upper_case_globals, non_snake_case, unused_unsafe, non_camel_case_types, dead_code, clippy::all)]
2 #[derive(:: std :: cmp :: PartialEq, :: std :: cmp :: Eq, :: std :: marker :: Copy, :: std :: clone :: Clone, :: std :: default :: Default, :: std :: fmt :: Debug)]
3 #[repr(transparent)]
4 pub struct ACTIVATE_KEYBOARD_LAYOUT_FLAGS(pub u32);
5 pub const KLF_REORDER: ACTIVATE_KEYBOARD_LAYOUT_FLAGS = ACTIVATE_KEYBOARD_LAYOUT_FLAGS(8u32);
6 pub const KLF_RESET: ACTIVATE_KEYBOARD_LAYOUT_FLAGS = ACTIVATE_KEYBOARD_LAYOUT_FLAGS(1073741824u32);
7 pub const KLF_SETFORPROCESS: ACTIVATE_KEYBOARD_LAYOUT_FLAGS = ACTIVATE_KEYBOARD_LAYOUT_FLAGS(256u32);
8 pub const KLF_SHIFTLOCK: ACTIVATE_KEYBOARD_LAYOUT_FLAGS = ACTIVATE_KEYBOARD_LAYOUT_FLAGS(65536u32);
9 pub const KLF_ACTIVATE: ACTIVATE_KEYBOARD_LAYOUT_FLAGS = ACTIVATE_KEYBOARD_LAYOUT_FLAGS(1u32);
10 pub const KLF_NOTELLSHELL: ACTIVATE_KEYBOARD_LAYOUT_FLAGS = ACTIVATE_KEYBOARD_LAYOUT_FLAGS(128u32);
11 pub const KLF_REPLACELANG: ACTIVATE_KEYBOARD_LAYOUT_FLAGS = ACTIVATE_KEYBOARD_LAYOUT_FLAGS(16u32);
12 pub const KLF_SUBSTITUTE_OK: ACTIVATE_KEYBOARD_LAYOUT_FLAGS = ACTIVATE_KEYBOARD_LAYOUT_FLAGS(2u32);
13 impl ::std::convert::From<u32> for ACTIVATE_KEYBOARD_LAYOUT_FLAGS {
from(value: u32) -> Self14 fn from(value: u32) -> Self {
15 Self(value)
16 }
17 }
18 unsafe impl ::windows::runtime::Abi for ACTIVATE_KEYBOARD_LAYOUT_FLAGS {
19 type Abi = Self;
20 type DefaultType = Self;
21 }
22 impl ::std::ops::BitOr for ACTIVATE_KEYBOARD_LAYOUT_FLAGS {
23 type Output = Self;
bitor(self, rhs: Self) -> Self24 fn bitor(self, rhs: Self) -> Self {
25 Self(self.0 | rhs.0)
26 }
27 }
28 impl ::std::ops::BitAnd for ACTIVATE_KEYBOARD_LAYOUT_FLAGS {
29 type Output = Self;
bitand(self, rhs: Self) -> Self30 fn bitand(self, rhs: Self) -> Self {
31 Self(self.0 & rhs.0)
32 }
33 }
34 impl ::std::ops::BitOrAssign for ACTIVATE_KEYBOARD_LAYOUT_FLAGS {
bitor_assign(&mut self, rhs: Self)35 fn bitor_assign(&mut self, rhs: Self) {
36 self.0.bitor_assign(rhs.0)
37 }
38 }
39 impl ::std::ops::BitAndAssign for ACTIVATE_KEYBOARD_LAYOUT_FLAGS {
bitand_assign(&mut self, rhs: Self)40 fn bitand_assign(&mut self, rhs: Self) {
41 self.0.bitand_assign(rhs.0)
42 }
43 }
44 impl ::std::ops::Not for ACTIVATE_KEYBOARD_LAYOUT_FLAGS {
45 type Output = Self;
not(self) -> Self46 fn not(self) -> Self {
47 Self(self.0.not())
48 }
49 }
50 pub const ACUTE: u32 = 769u32;
51 pub const AX_KBD_DESKTOP_TYPE: u32 = 1u32;
52 #[cfg(feature = "Win32_UI_TextServices")]
53 #[inline]
ActivateKeyboardLayout<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::TextServices::HKL>>(hkl: Param0, flags: ACTIVATE_KEYBOARD_LAYOUT_FLAGS) -> super::super::TextServices::HKL54 pub unsafe fn ActivateKeyboardLayout<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::TextServices::HKL>>(hkl: Param0, flags: ACTIVATE_KEYBOARD_LAYOUT_FLAGS) -> super::super::TextServices::HKL {
55 #[cfg(windows)]
56 {
57 #[link(name = "windows")]
58 extern "system" {
59 fn ActivateKeyboardLayout(hkl: super::super::TextServices::HKL, flags: ACTIVATE_KEYBOARD_LAYOUT_FLAGS) -> super::super::TextServices::HKL;
60 }
61 ::std::mem::transmute(ActivateKeyboardLayout(hkl.into_param().abi(), ::std::mem::transmute(flags)))
62 }
63 #[cfg(not(windows))]
64 unimplemented!("Unsupported target OS");
65 }
66 pub const BREVE: u32 = 774u32;
67 #[cfg(feature = "Win32_Foundation")]
68 #[inline]
BlockInput<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::super::Foundation::BOOL>>(fblockit: Param0) -> super::super::super::Foundation::BOOL69 pub unsafe fn BlockInput<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::super::Foundation::BOOL>>(fblockit: Param0) -> super::super::super::Foundation::BOOL {
70 #[cfg(windows)]
71 {
72 #[link(name = "windows")]
73 extern "system" {
74 fn BlockInput(fblockit: super::super::super::Foundation::BOOL) -> super::super::super::Foundation::BOOL;
75 }
76 ::std::mem::transmute(BlockInput(fblockit.into_param().abi()))
77 }
78 #[cfg(not(windows))]
79 unimplemented!("Unsupported target OS");
80 }
81 pub const CAPLOK: u32 = 1u32;
82 pub const CAPLOKALTGR: u32 = 4u32;
83 pub const CEDILLA: u32 = 807u32;
84 pub const CIRCUMFLEX: u32 = 770u32;
85 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
86 #[repr(C)]
87 pub struct DEADKEY {
88 pub dwBoth: u32,
89 pub wchComposed: u16,
90 pub uFlags: u16,
91 }
92 impl DEADKEY {}
93 impl ::std::default::Default for DEADKEY {
default() -> Self94 fn default() -> Self {
95 unsafe { ::std::mem::zeroed() }
96 }
97 }
98 impl ::std::fmt::Debug for DEADKEY {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result99 fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
100 fmt.debug_struct("DEADKEY").field("dwBoth", &self.dwBoth).field("wchComposed", &self.wchComposed).field("uFlags", &self.uFlags).finish()
101 }
102 }
103 impl ::std::cmp::PartialEq for DEADKEY {
eq(&self, other: &Self) -> bool104 fn eq(&self, other: &Self) -> bool {
105 self.dwBoth == other.dwBoth && self.wchComposed == other.wchComposed && self.uFlags == other.uFlags
106 }
107 }
108 impl ::std::cmp::Eq for DEADKEY {}
109 unsafe impl ::windows::runtime::Abi for DEADKEY {
110 type Abi = Self;
111 type DefaultType = Self;
112 }
113 pub const DEC_KBD_ANSI_LAYOUT_TYPE: u32 = 1u32;
114 pub const DEC_KBD_JIS_LAYOUT_TYPE: u32 = 2u32;
115 pub const DIARESIS: u32 = 776u32;
116 pub const DIARESIS_TONOS: u32 = 901u32;
117 pub const DKF_DEAD: u32 = 1u32;
118 pub const DONTCARE_BIT: u32 = 33554432u32;
119 pub const DOT_ABOVE: u32 = 775u32;
120 pub const DOUBLE_ACUTE: u32 = 779u32;
121 #[cfg(feature = "Win32_Foundation")]
122 #[inline]
DragDetect<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::super::Foundation::HWND>, Param1: ::windows::runtime::IntoParam<'a, super::super::super::Foundation::POINT>>(hwnd: Param0, pt: Param1) -> super::super::super::Foundation::BOOL123 pub unsafe fn DragDetect<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::super::Foundation::HWND>, Param1: ::windows::runtime::IntoParam<'a, super::super::super::Foundation::POINT>>(hwnd: Param0, pt: Param1) -> super::super::super::Foundation::BOOL {
124 #[cfg(windows)]
125 {
126 #[link(name = "windows")]
127 extern "system" {
128 fn DragDetect(hwnd: super::super::super::Foundation::HWND, pt: super::super::super::Foundation::POINT) -> super::super::super::Foundation::BOOL;
129 }
130 ::std::mem::transmute(DragDetect(hwnd.into_param().abi(), pt.into_param().abi()))
131 }
132 #[cfg(not(windows))]
133 unimplemented!("Unsupported target OS");
134 }
135 pub const EXTENDED_BIT: u32 = 16777216u32;
136 #[cfg(feature = "Win32_Foundation")]
137 #[inline]
EnableWindow<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::super::Foundation::HWND>, Param1: ::windows::runtime::IntoParam<'a, super::super::super::Foundation::BOOL>>(hwnd: Param0, benable: Param1) -> super::super::super::Foundation::BOOL138 pub unsafe fn EnableWindow<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::super::Foundation::HWND>, Param1: ::windows::runtime::IntoParam<'a, super::super::super::Foundation::BOOL>>(hwnd: Param0, benable: Param1) -> super::super::super::Foundation::BOOL {
139 #[cfg(windows)]
140 {
141 #[link(name = "windows")]
142 extern "system" {
143 fn EnableWindow(hwnd: super::super::super::Foundation::HWND, benable: super::super::super::Foundation::BOOL) -> super::super::super::Foundation::BOOL;
144 }
145 ::std::mem::transmute(EnableWindow(hwnd.into_param().abi(), benable.into_param().abi()))
146 }
147 #[cfg(not(windows))]
148 unimplemented!("Unsupported target OS");
149 }
150 pub const FAKE_KEYSTROKE: u32 = 33554432u32;
151 pub const FMR_KBD_JIS_TYPE: u32 = 0u32;
152 pub const FMR_KBD_OASYS_TYPE: u32 = 1u32;
153 pub const FMV_KBD_OASYS_TYPE: u32 = 2u32;
154 #[derive(:: std :: cmp :: PartialEq, :: std :: cmp :: Eq, :: std :: marker :: Copy, :: std :: clone :: Clone, :: std :: default :: Default, :: std :: fmt :: Debug)]
155 #[repr(transparent)]
156 pub struct GET_MOUSE_MOVE_POINTS_EX_RESOLUTION(pub u32);
157 pub const GMMP_USE_DISPLAY_POINTS: GET_MOUSE_MOVE_POINTS_EX_RESOLUTION = GET_MOUSE_MOVE_POINTS_EX_RESOLUTION(1u32);
158 pub const GMMP_USE_HIGH_RESOLUTION_POINTS: GET_MOUSE_MOVE_POINTS_EX_RESOLUTION = GET_MOUSE_MOVE_POINTS_EX_RESOLUTION(2u32);
159 impl ::std::convert::From<u32> for GET_MOUSE_MOVE_POINTS_EX_RESOLUTION {
from(value: u32) -> Self160 fn from(value: u32) -> Self {
161 Self(value)
162 }
163 }
164 unsafe impl ::windows::runtime::Abi for GET_MOUSE_MOVE_POINTS_EX_RESOLUTION {
165 type Abi = Self;
166 type DefaultType = Self;
167 }
168 impl ::std::ops::BitOr for GET_MOUSE_MOVE_POINTS_EX_RESOLUTION {
169 type Output = Self;
bitor(self, rhs: Self) -> Self170 fn bitor(self, rhs: Self) -> Self {
171 Self(self.0 | rhs.0)
172 }
173 }
174 impl ::std::ops::BitAnd for GET_MOUSE_MOVE_POINTS_EX_RESOLUTION {
175 type Output = Self;
bitand(self, rhs: Self) -> Self176 fn bitand(self, rhs: Self) -> Self {
177 Self(self.0 & rhs.0)
178 }
179 }
180 impl ::std::ops::BitOrAssign for GET_MOUSE_MOVE_POINTS_EX_RESOLUTION {
bitor_assign(&mut self, rhs: Self)181 fn bitor_assign(&mut self, rhs: Self) {
182 self.0.bitor_assign(rhs.0)
183 }
184 }
185 impl ::std::ops::BitAndAssign for GET_MOUSE_MOVE_POINTS_EX_RESOLUTION {
bitand_assign(&mut self, rhs: Self)186 fn bitand_assign(&mut self, rhs: Self) {
187 self.0.bitand_assign(rhs.0)
188 }
189 }
190 impl ::std::ops::Not for GET_MOUSE_MOVE_POINTS_EX_RESOLUTION {
191 type Output = Self;
not(self) -> Self192 fn not(self) -> Self {
193 Self(self.0.not())
194 }
195 }
196 pub const GRAVE: u32 = 768u32;
197 pub const GRPSELTAP: u32 = 128u32;
198 #[cfg(feature = "Win32_Foundation")]
199 #[inline]
GetActiveWindow() -> super::super::super::Foundation::HWND200 pub unsafe fn GetActiveWindow() -> super::super::super::Foundation::HWND {
201 #[cfg(windows)]
202 {
203 #[link(name = "windows")]
204 extern "system" {
205 fn GetActiveWindow() -> super::super::super::Foundation::HWND;
206 }
207 ::std::mem::transmute(GetActiveWindow())
208 }
209 #[cfg(not(windows))]
210 unimplemented!("Unsupported target OS");
211 }
212 #[inline]
GetAsyncKeyState(vkey: i32) -> i16213 pub unsafe fn GetAsyncKeyState(vkey: i32) -> i16 {
214 #[cfg(windows)]
215 {
216 #[link(name = "windows")]
217 extern "system" {
218 fn GetAsyncKeyState(vkey: i32) -> i16;
219 }
220 ::std::mem::transmute(GetAsyncKeyState(::std::mem::transmute(vkey)))
221 }
222 #[cfg(not(windows))]
223 unimplemented!("Unsupported target OS");
224 }
225 #[cfg(feature = "Win32_Foundation")]
226 #[inline]
GetCapture() -> super::super::super::Foundation::HWND227 pub unsafe fn GetCapture() -> super::super::super::Foundation::HWND {
228 #[cfg(windows)]
229 {
230 #[link(name = "windows")]
231 extern "system" {
232 fn GetCapture() -> super::super::super::Foundation::HWND;
233 }
234 ::std::mem::transmute(GetCapture())
235 }
236 #[cfg(not(windows))]
237 unimplemented!("Unsupported target OS");
238 }
239 #[inline]
GetDoubleClickTime() -> u32240 pub unsafe fn GetDoubleClickTime() -> u32 {
241 #[cfg(windows)]
242 {
243 #[link(name = "windows")]
244 extern "system" {
245 fn GetDoubleClickTime() -> u32;
246 }
247 ::std::mem::transmute(GetDoubleClickTime())
248 }
249 #[cfg(not(windows))]
250 unimplemented!("Unsupported target OS");
251 }
252 #[cfg(feature = "Win32_Foundation")]
253 #[inline]
GetFocus() -> super::super::super::Foundation::HWND254 pub unsafe fn GetFocus() -> super::super::super::Foundation::HWND {
255 #[cfg(windows)]
256 {
257 #[link(name = "windows")]
258 extern "system" {
259 fn GetFocus() -> super::super::super::Foundation::HWND;
260 }
261 ::std::mem::transmute(GetFocus())
262 }
263 #[cfg(not(windows))]
264 unimplemented!("Unsupported target OS");
265 }
266 #[inline]
GetKBCodePage() -> u32267 pub unsafe fn GetKBCodePage() -> u32 {
268 #[cfg(windows)]
269 {
270 #[link(name = "windows")]
271 extern "system" {
272 fn GetKBCodePage() -> u32;
273 }
274 ::std::mem::transmute(GetKBCodePage())
275 }
276 #[cfg(not(windows))]
277 unimplemented!("Unsupported target OS");
278 }
279 #[cfg(feature = "Win32_Foundation")]
280 #[inline]
GetKeyNameTextA(lparam: i32, lpstring: super::super::super::Foundation::PSTR, cchsize: i32) -> i32281 pub unsafe fn GetKeyNameTextA(lparam: i32, lpstring: super::super::super::Foundation::PSTR, cchsize: i32) -> i32 {
282 #[cfg(windows)]
283 {
284 #[link(name = "windows")]
285 extern "system" {
286 fn GetKeyNameTextA(lparam: i32, lpstring: super::super::super::Foundation::PSTR, cchsize: i32) -> i32;
287 }
288 ::std::mem::transmute(GetKeyNameTextA(::std::mem::transmute(lparam), ::std::mem::transmute(lpstring), ::std::mem::transmute(cchsize)))
289 }
290 #[cfg(not(windows))]
291 unimplemented!("Unsupported target OS");
292 }
293 #[cfg(feature = "Win32_Foundation")]
294 #[inline]
GetKeyNameTextW(lparam: i32, lpstring: super::super::super::Foundation::PWSTR, cchsize: i32) -> i32295 pub unsafe fn GetKeyNameTextW(lparam: i32, lpstring: super::super::super::Foundation::PWSTR, cchsize: i32) -> i32 {
296 #[cfg(windows)]
297 {
298 #[link(name = "windows")]
299 extern "system" {
300 fn GetKeyNameTextW(lparam: i32, lpstring: super::super::super::Foundation::PWSTR, cchsize: i32) -> i32;
301 }
302 ::std::mem::transmute(GetKeyNameTextW(::std::mem::transmute(lparam), ::std::mem::transmute(lpstring), ::std::mem::transmute(cchsize)))
303 }
304 #[cfg(not(windows))]
305 unimplemented!("Unsupported target OS");
306 }
307 #[inline]
GetKeyState(nvirtkey: i32) -> i16308 pub unsafe fn GetKeyState(nvirtkey: i32) -> i16 {
309 #[cfg(windows)]
310 {
311 #[link(name = "windows")]
312 extern "system" {
313 fn GetKeyState(nvirtkey: i32) -> i16;
314 }
315 ::std::mem::transmute(GetKeyState(::std::mem::transmute(nvirtkey)))
316 }
317 #[cfg(not(windows))]
318 unimplemented!("Unsupported target OS");
319 }
320 #[cfg(feature = "Win32_UI_TextServices")]
321 #[inline]
GetKeyboardLayout(idthread: u32) -> super::super::TextServices::HKL322 pub unsafe fn GetKeyboardLayout(idthread: u32) -> super::super::TextServices::HKL {
323 #[cfg(windows)]
324 {
325 #[link(name = "windows")]
326 extern "system" {
327 fn GetKeyboardLayout(idthread: u32) -> super::super::TextServices::HKL;
328 }
329 ::std::mem::transmute(GetKeyboardLayout(::std::mem::transmute(idthread)))
330 }
331 #[cfg(not(windows))]
332 unimplemented!("Unsupported target OS");
333 }
334 #[cfg(feature = "Win32_UI_TextServices")]
335 #[inline]
GetKeyboardLayoutList(nbuff: i32, lplist: *mut super::super::TextServices::HKL) -> i32336 pub unsafe fn GetKeyboardLayoutList(nbuff: i32, lplist: *mut super::super::TextServices::HKL) -> i32 {
337 #[cfg(windows)]
338 {
339 #[link(name = "windows")]
340 extern "system" {
341 fn GetKeyboardLayoutList(nbuff: i32, lplist: *mut super::super::TextServices::HKL) -> i32;
342 }
343 ::std::mem::transmute(GetKeyboardLayoutList(::std::mem::transmute(nbuff), ::std::mem::transmute(lplist)))
344 }
345 #[cfg(not(windows))]
346 unimplemented!("Unsupported target OS");
347 }
348 #[cfg(feature = "Win32_Foundation")]
349 #[inline]
GetKeyboardLayoutNameA(pwszklid: super::super::super::Foundation::PSTR) -> super::super::super::Foundation::BOOL350 pub unsafe fn GetKeyboardLayoutNameA(pwszklid: super::super::super::Foundation::PSTR) -> super::super::super::Foundation::BOOL {
351 #[cfg(windows)]
352 {
353 #[link(name = "windows")]
354 extern "system" {
355 fn GetKeyboardLayoutNameA(pwszklid: super::super::super::Foundation::PSTR) -> super::super::super::Foundation::BOOL;
356 }
357 ::std::mem::transmute(GetKeyboardLayoutNameA(::std::mem::transmute(pwszklid)))
358 }
359 #[cfg(not(windows))]
360 unimplemented!("Unsupported target OS");
361 }
362 #[cfg(feature = "Win32_Foundation")]
363 #[inline]
GetKeyboardLayoutNameW(pwszklid: super::super::super::Foundation::PWSTR) -> super::super::super::Foundation::BOOL364 pub unsafe fn GetKeyboardLayoutNameW(pwszklid: super::super::super::Foundation::PWSTR) -> super::super::super::Foundation::BOOL {
365 #[cfg(windows)]
366 {
367 #[link(name = "windows")]
368 extern "system" {
369 fn GetKeyboardLayoutNameW(pwszklid: super::super::super::Foundation::PWSTR) -> super::super::super::Foundation::BOOL;
370 }
371 ::std::mem::transmute(GetKeyboardLayoutNameW(::std::mem::transmute(pwszklid)))
372 }
373 #[cfg(not(windows))]
374 unimplemented!("Unsupported target OS");
375 }
376 #[cfg(feature = "Win32_Foundation")]
377 #[inline]
GetKeyboardState(lpkeystate: *mut u8) -> super::super::super::Foundation::BOOL378 pub unsafe fn GetKeyboardState(lpkeystate: *mut u8) -> super::super::super::Foundation::BOOL {
379 #[cfg(windows)]
380 {
381 #[link(name = "windows")]
382 extern "system" {
383 fn GetKeyboardState(lpkeystate: *mut u8) -> super::super::super::Foundation::BOOL;
384 }
385 ::std::mem::transmute(GetKeyboardState(::std::mem::transmute(lpkeystate)))
386 }
387 #[cfg(not(windows))]
388 unimplemented!("Unsupported target OS");
389 }
390 #[inline]
GetKeyboardType(ntypeflag: i32) -> i32391 pub unsafe fn GetKeyboardType(ntypeflag: i32) -> i32 {
392 #[cfg(windows)]
393 {
394 #[link(name = "windows")]
395 extern "system" {
396 fn GetKeyboardType(ntypeflag: i32) -> i32;
397 }
398 ::std::mem::transmute(GetKeyboardType(::std::mem::transmute(ntypeflag)))
399 }
400 #[cfg(not(windows))]
401 unimplemented!("Unsupported target OS");
402 }
403 #[cfg(feature = "Win32_Foundation")]
404 #[inline]
GetLastInputInfo(plii: *mut LASTINPUTINFO) -> super::super::super::Foundation::BOOL405 pub unsafe fn GetLastInputInfo(plii: *mut LASTINPUTINFO) -> super::super::super::Foundation::BOOL {
406 #[cfg(windows)]
407 {
408 #[link(name = "windows")]
409 extern "system" {
410 fn GetLastInputInfo(plii: *mut LASTINPUTINFO) -> super::super::super::Foundation::BOOL;
411 }
412 ::std::mem::transmute(GetLastInputInfo(::std::mem::transmute(plii)))
413 }
414 #[cfg(not(windows))]
415 unimplemented!("Unsupported target OS");
416 }
417 #[inline]
GetMouseMovePointsEx(cbsize: u32, lppt: *const MOUSEMOVEPOINT, lpptbuf: *mut MOUSEMOVEPOINT, nbufpoints: i32, resolution: GET_MOUSE_MOVE_POINTS_EX_RESOLUTION) -> i32418 pub unsafe fn GetMouseMovePointsEx(cbsize: u32, lppt: *const MOUSEMOVEPOINT, lpptbuf: *mut MOUSEMOVEPOINT, nbufpoints: i32, resolution: GET_MOUSE_MOVE_POINTS_EX_RESOLUTION) -> i32 {
419 #[cfg(windows)]
420 {
421 #[link(name = "windows")]
422 extern "system" {
423 fn GetMouseMovePointsEx(cbsize: u32, lppt: *const MOUSEMOVEPOINT, lpptbuf: *mut MOUSEMOVEPOINT, nbufpoints: i32, resolution: GET_MOUSE_MOVE_POINTS_EX_RESOLUTION) -> i32;
424 }
425 ::std::mem::transmute(GetMouseMovePointsEx(::std::mem::transmute(cbsize), ::std::mem::transmute(lppt), ::std::mem::transmute(lpptbuf), ::std::mem::transmute(nbufpoints), ::std::mem::transmute(resolution)))
426 }
427 #[cfg(not(windows))]
428 unimplemented!("Unsupported target OS");
429 }
430 pub const HACEK: u32 = 780u32;
431 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
432 #[repr(C)]
433 pub struct HARDWAREINPUT {
434 pub uMsg: u32,
435 pub wParamL: u16,
436 pub wParamH: u16,
437 }
438 impl HARDWAREINPUT {}
439 impl ::std::default::Default for HARDWAREINPUT {
default() -> Self440 fn default() -> Self {
441 unsafe { ::std::mem::zeroed() }
442 }
443 }
444 impl ::std::fmt::Debug for HARDWAREINPUT {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result445 fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
446 fmt.debug_struct("HARDWAREINPUT").field("uMsg", &self.uMsg).field("wParamL", &self.wParamL).field("wParamH", &self.wParamH).finish()
447 }
448 }
449 impl ::std::cmp::PartialEq for HARDWAREINPUT {
eq(&self, other: &Self) -> bool450 fn eq(&self, other: &Self) -> bool {
451 self.uMsg == other.uMsg && self.wParamL == other.wParamL && self.wParamH == other.wParamH
452 }
453 }
454 impl ::std::cmp::Eq for HARDWAREINPUT {}
455 unsafe impl ::windows::runtime::Abi for HARDWAREINPUT {
456 type Abi = Self;
457 type DefaultType = Self;
458 }
459 pub const HOOK_ABOVE: u32 = 777u32;
460 #[derive(:: std :: cmp :: PartialEq, :: std :: cmp :: Eq, :: std :: marker :: Copy, :: std :: clone :: Clone, :: std :: default :: Default, :: std :: fmt :: Debug)]
461 #[repr(transparent)]
462 pub struct HOT_KEY_MODIFIERS(pub u32);
463 pub const MOD_ALT: HOT_KEY_MODIFIERS = HOT_KEY_MODIFIERS(1u32);
464 pub const MOD_CONTROL: HOT_KEY_MODIFIERS = HOT_KEY_MODIFIERS(2u32);
465 pub const MOD_NOREPEAT: HOT_KEY_MODIFIERS = HOT_KEY_MODIFIERS(16384u32);
466 pub const MOD_SHIFT: HOT_KEY_MODIFIERS = HOT_KEY_MODIFIERS(4u32);
467 pub const MOD_WIN: HOT_KEY_MODIFIERS = HOT_KEY_MODIFIERS(8u32);
468 impl ::std::convert::From<u32> for HOT_KEY_MODIFIERS {
from(value: u32) -> Self469 fn from(value: u32) -> Self {
470 Self(value)
471 }
472 }
473 unsafe impl ::windows::runtime::Abi for HOT_KEY_MODIFIERS {
474 type Abi = Self;
475 type DefaultType = Self;
476 }
477 impl ::std::ops::BitOr for HOT_KEY_MODIFIERS {
478 type Output = Self;
bitor(self, rhs: Self) -> Self479 fn bitor(self, rhs: Self) -> Self {
480 Self(self.0 | rhs.0)
481 }
482 }
483 impl ::std::ops::BitAnd for HOT_KEY_MODIFIERS {
484 type Output = Self;
bitand(self, rhs: Self) -> Self485 fn bitand(self, rhs: Self) -> Self {
486 Self(self.0 & rhs.0)
487 }
488 }
489 impl ::std::ops::BitOrAssign for HOT_KEY_MODIFIERS {
bitor_assign(&mut self, rhs: Self)490 fn bitor_assign(&mut self, rhs: Self) {
491 self.0.bitor_assign(rhs.0)
492 }
493 }
494 impl ::std::ops::BitAndAssign for HOT_KEY_MODIFIERS {
bitand_assign(&mut self, rhs: Self)495 fn bitand_assign(&mut self, rhs: Self) {
496 self.0.bitand_assign(rhs.0)
497 }
498 }
499 impl ::std::ops::Not for HOT_KEY_MODIFIERS {
500 type Output = Self;
not(self) -> Self501 fn not(self) -> Self {
502 Self(self.0.not())
503 }
504 }
505 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
506 #[repr(C)]
507 pub struct INPUT {
508 pub r#type: INPUT_TYPE,
509 pub Anonymous: INPUT_0,
510 }
511 impl INPUT {}
512 impl ::std::default::Default for INPUT {
default() -> Self513 fn default() -> Self {
514 unsafe { ::std::mem::zeroed() }
515 }
516 }
517 impl ::std::cmp::PartialEq for INPUT {
eq(&self, _other: &Self) -> bool518 fn eq(&self, _other: &Self) -> bool {
519 unimplemented!()
520 }
521 }
522 impl ::std::cmp::Eq for INPUT {}
523 unsafe impl ::windows::runtime::Abi for INPUT {
524 type Abi = Self;
525 type DefaultType = Self;
526 }
527 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
528 #[repr(C)]
529 pub union INPUT_0 {
530 pub mi: MOUSEINPUT,
531 pub ki: KEYBDINPUT,
532 pub hi: HARDWAREINPUT,
533 }
534 impl INPUT_0 {}
535 impl ::std::default::Default for INPUT_0 {
default() -> Self536 fn default() -> Self {
537 unsafe { ::std::mem::zeroed() }
538 }
539 }
540 impl ::std::cmp::PartialEq for INPUT_0 {
eq(&self, _other: &Self) -> bool541 fn eq(&self, _other: &Self) -> bool {
542 unimplemented!()
543 }
544 }
545 impl ::std::cmp::Eq for INPUT_0 {}
546 unsafe impl ::windows::runtime::Abi for INPUT_0 {
547 type Abi = Self;
548 type DefaultType = Self;
549 }
550 #[derive(:: std :: cmp :: PartialEq, :: std :: cmp :: Eq, :: std :: marker :: Copy, :: std :: clone :: Clone, :: std :: default :: Default, :: std :: fmt :: Debug)]
551 #[repr(transparent)]
552 pub struct INPUT_TYPE(pub u32);
553 pub const INPUT_MOUSE: INPUT_TYPE = INPUT_TYPE(0u32);
554 pub const INPUT_KEYBOARD: INPUT_TYPE = INPUT_TYPE(1u32);
555 pub const INPUT_HARDWARE: INPUT_TYPE = INPUT_TYPE(2u32);
556 impl ::std::convert::From<u32> for INPUT_TYPE {
from(value: u32) -> Self557 fn from(value: u32) -> Self {
558 Self(value)
559 }
560 }
561 unsafe impl ::windows::runtime::Abi for INPUT_TYPE {
562 type Abi = Self;
563 type DefaultType = Self;
564 }
565 impl ::std::ops::BitOr for INPUT_TYPE {
566 type Output = Self;
bitor(self, rhs: Self) -> Self567 fn bitor(self, rhs: Self) -> Self {
568 Self(self.0 | rhs.0)
569 }
570 }
571 impl ::std::ops::BitAnd for INPUT_TYPE {
572 type Output = Self;
bitand(self, rhs: Self) -> Self573 fn bitand(self, rhs: Self) -> Self {
574 Self(self.0 & rhs.0)
575 }
576 }
577 impl ::std::ops::BitOrAssign for INPUT_TYPE {
bitor_assign(&mut self, rhs: Self)578 fn bitor_assign(&mut self, rhs: Self) {
579 self.0.bitor_assign(rhs.0)
580 }
581 }
582 impl ::std::ops::BitAndAssign for INPUT_TYPE {
bitand_assign(&mut self, rhs: Self)583 fn bitand_assign(&mut self, rhs: Self) {
584 self.0.bitand_assign(rhs.0)
585 }
586 }
587 impl ::std::ops::Not for INPUT_TYPE {
588 type Output = Self;
not(self) -> Self589 fn not(self) -> Self {
590 Self(self.0.not())
591 }
592 }
593 #[cfg(feature = "Win32_Foundation")]
594 #[inline]
IsWindowEnabled<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::super::Foundation::HWND>>(hwnd: Param0) -> super::super::super::Foundation::BOOL595 pub unsafe fn IsWindowEnabled<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::super::Foundation::HWND>>(hwnd: Param0) -> super::super::super::Foundation::BOOL {
596 #[cfg(windows)]
597 {
598 #[link(name = "windows")]
599 extern "system" {
600 fn IsWindowEnabled(hwnd: super::super::super::Foundation::HWND) -> super::super::super::Foundation::BOOL;
601 }
602 ::std::mem::transmute(IsWindowEnabled(hwnd.into_param().abi()))
603 }
604 #[cfg(not(windows))]
605 unimplemented!("Unsupported target OS");
606 }
607 pub const KANALOK: u32 = 8u32;
608 pub const KBDALT: u32 = 4u32;
609 pub const KBDBASE: u32 = 0u32;
610 pub const KBDCTRL: u32 = 2u32;
611 pub const KBDGRPSELTAP: u32 = 128u32;
612 pub const KBDKANA: u32 = 8u32;
613 pub const KBDLOYA: u32 = 32u32;
614 pub const KBDNLS_ALPHANUM: u32 = 5u32;
615 pub const KBDNLS_CODEINPUT: u32 = 10u32;
616 pub const KBDNLS_CONV_OR_NONCONV: u32 = 15u32;
617 pub const KBDNLS_HELP_OR_END: u32 = 11u32;
618 pub const KBDNLS_HIRAGANA: u32 = 6u32;
619 pub const KBDNLS_HOME_OR_CLEAR: u32 = 12u32;
620 pub const KBDNLS_INDEX_ALT: u32 = 2u32;
621 pub const KBDNLS_INDEX_NORMAL: u32 = 1u32;
622 pub const KBDNLS_KANAEVENT: u32 = 14u32;
623 pub const KBDNLS_KANALOCK: u32 = 4u32;
624 pub const KBDNLS_KATAKANA: u32 = 7u32;
625 pub const KBDNLS_NOEVENT: u32 = 1u32;
626 pub const KBDNLS_NULL: u32 = 0u32;
627 pub const KBDNLS_NUMPAD: u32 = 13u32;
628 pub const KBDNLS_ROMAN: u32 = 9u32;
629 pub const KBDNLS_SBCSDBCS: u32 = 8u32;
630 pub const KBDNLS_SEND_BASE_VK: u32 = 2u32;
631 pub const KBDNLS_SEND_PARAM_VK: u32 = 3u32;
632 pub const KBDNLS_TYPE_NORMAL: u32 = 1u32;
633 pub const KBDNLS_TYPE_NULL: u32 = 0u32;
634 pub const KBDNLS_TYPE_TOGGLE: u32 = 2u32;
635 pub const KBDROYA: u32 = 16u32;
636 pub const KBDSHIFT: u32 = 1u32;
637 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
638 #[repr(C)]
639 pub struct KBDTABLE_DESC {
640 pub wszDllName: [u16; 32],
641 pub dwType: u32,
642 pub dwSubType: u32,
643 }
644 impl KBDTABLE_DESC {}
645 impl ::std::default::Default for KBDTABLE_DESC {
default() -> Self646 fn default() -> Self {
647 unsafe { ::std::mem::zeroed() }
648 }
649 }
650 impl ::std::fmt::Debug for KBDTABLE_DESC {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result651 fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
652 fmt.debug_struct("KBDTABLE_DESC").field("wszDllName", &self.wszDllName).field("dwType", &self.dwType).field("dwSubType", &self.dwSubType).finish()
653 }
654 }
655 impl ::std::cmp::PartialEq for KBDTABLE_DESC {
eq(&self, other: &Self) -> bool656 fn eq(&self, other: &Self) -> bool {
657 self.wszDllName == other.wszDllName && self.dwType == other.dwType && self.dwSubType == other.dwSubType
658 }
659 }
660 impl ::std::cmp::Eq for KBDTABLE_DESC {}
661 unsafe impl ::windows::runtime::Abi for KBDTABLE_DESC {
662 type Abi = Self;
663 type DefaultType = Self;
664 }
665 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
666 #[repr(C)]
667 pub struct KBDTABLE_MULTI {
668 pub nTables: u32,
669 pub aKbdTables: [KBDTABLE_DESC; 8],
670 }
671 impl KBDTABLE_MULTI {}
672 impl ::std::default::Default for KBDTABLE_MULTI {
default() -> Self673 fn default() -> Self {
674 unsafe { ::std::mem::zeroed() }
675 }
676 }
677 impl ::std::fmt::Debug for KBDTABLE_MULTI {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result678 fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
679 fmt.debug_struct("KBDTABLE_MULTI").field("nTables", &self.nTables).field("aKbdTables", &self.aKbdTables).finish()
680 }
681 }
682 impl ::std::cmp::PartialEq for KBDTABLE_MULTI {
eq(&self, other: &Self) -> bool683 fn eq(&self, other: &Self) -> bool {
684 self.nTables == other.nTables && self.aKbdTables == other.aKbdTables
685 }
686 }
687 impl ::std::cmp::Eq for KBDTABLE_MULTI {}
688 unsafe impl ::windows::runtime::Abi for KBDTABLE_MULTI {
689 type Abi = Self;
690 type DefaultType = Self;
691 }
692 pub const KBDTABLE_MULTI_MAX: u32 = 8u32;
693 pub const KBD_TYPE: u32 = 4u32;
694 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
695 #[repr(C)]
696 pub struct KBD_TYPE_INFO {
697 pub dwVersion: u32,
698 pub dwType: u32,
699 pub dwSubType: u32,
700 }
701 impl KBD_TYPE_INFO {}
702 impl ::std::default::Default for KBD_TYPE_INFO {
default() -> Self703 fn default() -> Self {
704 unsafe { ::std::mem::zeroed() }
705 }
706 }
707 impl ::std::fmt::Debug for KBD_TYPE_INFO {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result708 fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
709 fmt.debug_struct("KBD_TYPE_INFO").field("dwVersion", &self.dwVersion).field("dwType", &self.dwType).field("dwSubType", &self.dwSubType).finish()
710 }
711 }
712 impl ::std::cmp::PartialEq for KBD_TYPE_INFO {
eq(&self, other: &Self) -> bool713 fn eq(&self, other: &Self) -> bool {
714 self.dwVersion == other.dwVersion && self.dwType == other.dwType && self.dwSubType == other.dwSubType
715 }
716 }
717 impl ::std::cmp::Eq for KBD_TYPE_INFO {}
718 unsafe impl ::windows::runtime::Abi for KBD_TYPE_INFO {
719 type Abi = Self;
720 type DefaultType = Self;
721 }
722 pub const KBD_VERSION: u32 = 1u32;
723 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
724 #[repr(C)]
725 pub struct KEYBDINPUT {
726 pub wVk: VIRTUAL_KEY,
727 pub wScan: u16,
728 pub dwFlags: KEYBD_EVENT_FLAGS,
729 pub time: u32,
730 pub dwExtraInfo: usize,
731 }
732 impl KEYBDINPUT {}
733 impl ::std::default::Default for KEYBDINPUT {
default() -> Self734 fn default() -> Self {
735 unsafe { ::std::mem::zeroed() }
736 }
737 }
738 impl ::std::fmt::Debug for KEYBDINPUT {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result739 fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
740 fmt.debug_struct("KEYBDINPUT").field("wVk", &self.wVk).field("wScan", &self.wScan).field("dwFlags", &self.dwFlags).field("time", &self.time).field("dwExtraInfo", &self.dwExtraInfo).finish()
741 }
742 }
743 impl ::std::cmp::PartialEq for KEYBDINPUT {
eq(&self, other: &Self) -> bool744 fn eq(&self, other: &Self) -> bool {
745 self.wVk == other.wVk && self.wScan == other.wScan && self.dwFlags == other.dwFlags && self.time == other.time && self.dwExtraInfo == other.dwExtraInfo
746 }
747 }
748 impl ::std::cmp::Eq for KEYBDINPUT {}
749 unsafe impl ::windows::runtime::Abi for KEYBDINPUT {
750 type Abi = Self;
751 type DefaultType = Self;
752 }
753 #[derive(:: std :: cmp :: PartialEq, :: std :: cmp :: Eq, :: std :: marker :: Copy, :: std :: clone :: Clone, :: std :: default :: Default, :: std :: fmt :: Debug)]
754 #[repr(transparent)]
755 pub struct KEYBD_EVENT_FLAGS(pub u32);
756 pub const KEYEVENTF_EXTENDEDKEY: KEYBD_EVENT_FLAGS = KEYBD_EVENT_FLAGS(1u32);
757 pub const KEYEVENTF_KEYUP: KEYBD_EVENT_FLAGS = KEYBD_EVENT_FLAGS(2u32);
758 pub const KEYEVENTF_SCANCODE: KEYBD_EVENT_FLAGS = KEYBD_EVENT_FLAGS(8u32);
759 pub const KEYEVENTF_UNICODE: KEYBD_EVENT_FLAGS = KEYBD_EVENT_FLAGS(4u32);
760 impl ::std::convert::From<u32> for KEYBD_EVENT_FLAGS {
from(value: u32) -> Self761 fn from(value: u32) -> Self {
762 Self(value)
763 }
764 }
765 unsafe impl ::windows::runtime::Abi for KEYBD_EVENT_FLAGS {
766 type Abi = Self;
767 type DefaultType = Self;
768 }
769 impl ::std::ops::BitOr for KEYBD_EVENT_FLAGS {
770 type Output = Self;
bitor(self, rhs: Self) -> Self771 fn bitor(self, rhs: Self) -> Self {
772 Self(self.0 | rhs.0)
773 }
774 }
775 impl ::std::ops::BitAnd for KEYBD_EVENT_FLAGS {
776 type Output = Self;
bitand(self, rhs: Self) -> Self777 fn bitand(self, rhs: Self) -> Self {
778 Self(self.0 & rhs.0)
779 }
780 }
781 impl ::std::ops::BitOrAssign for KEYBD_EVENT_FLAGS {
bitor_assign(&mut self, rhs: Self)782 fn bitor_assign(&mut self, rhs: Self) {
783 self.0.bitor_assign(rhs.0)
784 }
785 }
786 impl ::std::ops::BitAndAssign for KEYBD_EVENT_FLAGS {
bitand_assign(&mut self, rhs: Self)787 fn bitand_assign(&mut self, rhs: Self) {
788 self.0.bitand_assign(rhs.0)
789 }
790 }
791 impl ::std::ops::Not for KEYBD_EVENT_FLAGS {
792 type Output = Self;
not(self) -> Self793 fn not(self) -> Self {
794 Self(self.0.not())
795 }
796 }
797 pub const KEYBOARD_TYPE_GENERIC_101: u32 = 4u32;
798 pub const KEYBOARD_TYPE_JAPAN: u32 = 7u32;
799 pub const KEYBOARD_TYPE_KOREA: u32 = 8u32;
800 pub const KEYBOARD_TYPE_UNKNOWN: u32 = 81u32;
801 pub const KLLF_ALTGR: u32 = 1u32;
802 pub const KLLF_GLOBAL_ATTRS: u32 = 2u32;
803 pub const KLLF_LRM_RLM: u32 = 4u32;
804 pub const KLLF_SHIFTLOCK: u32 = 2u32;
805 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
806 #[repr(C)]
807 pub struct LASTINPUTINFO {
808 pub cbSize: u32,
809 pub dwTime: u32,
810 }
811 impl LASTINPUTINFO {}
812 impl ::std::default::Default for LASTINPUTINFO {
default() -> Self813 fn default() -> Self {
814 unsafe { ::std::mem::zeroed() }
815 }
816 }
817 impl ::std::fmt::Debug for LASTINPUTINFO {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result818 fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
819 fmt.debug_struct("LASTINPUTINFO").field("cbSize", &self.cbSize).field("dwTime", &self.dwTime).finish()
820 }
821 }
822 impl ::std::cmp::PartialEq for LASTINPUTINFO {
eq(&self, other: &Self) -> bool823 fn eq(&self, other: &Self) -> bool {
824 self.cbSize == other.cbSize && self.dwTime == other.dwTime
825 }
826 }
827 impl ::std::cmp::Eq for LASTINPUTINFO {}
828 unsafe impl ::windows::runtime::Abi for LASTINPUTINFO {
829 type Abi = Self;
830 type DefaultType = Self;
831 }
832 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
833 #[repr(C)]
834 pub struct LIGATURE1 {
835 pub VirtualKey: u8,
836 pub ModificationNumber: u16,
837 pub wch: [u16; 1],
838 }
839 impl LIGATURE1 {}
840 impl ::std::default::Default for LIGATURE1 {
default() -> Self841 fn default() -> Self {
842 unsafe { ::std::mem::zeroed() }
843 }
844 }
845 impl ::std::fmt::Debug for LIGATURE1 {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result846 fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
847 fmt.debug_struct("LIGATURE1").field("VirtualKey", &self.VirtualKey).field("ModificationNumber", &self.ModificationNumber).field("wch", &self.wch).finish()
848 }
849 }
850 impl ::std::cmp::PartialEq for LIGATURE1 {
eq(&self, other: &Self) -> bool851 fn eq(&self, other: &Self) -> bool {
852 self.VirtualKey == other.VirtualKey && self.ModificationNumber == other.ModificationNumber && self.wch == other.wch
853 }
854 }
855 impl ::std::cmp::Eq for LIGATURE1 {}
856 unsafe impl ::windows::runtime::Abi for LIGATURE1 {
857 type Abi = Self;
858 type DefaultType = Self;
859 }
860 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
861 #[repr(C)]
862 pub struct LIGATURE2 {
863 pub VirtualKey: u8,
864 pub ModificationNumber: u16,
865 pub wch: [u16; 2],
866 }
867 impl LIGATURE2 {}
868 impl ::std::default::Default for LIGATURE2 {
default() -> Self869 fn default() -> Self {
870 unsafe { ::std::mem::zeroed() }
871 }
872 }
873 impl ::std::fmt::Debug for LIGATURE2 {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result874 fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
875 fmt.debug_struct("LIGATURE2").field("VirtualKey", &self.VirtualKey).field("ModificationNumber", &self.ModificationNumber).field("wch", &self.wch).finish()
876 }
877 }
878 impl ::std::cmp::PartialEq for LIGATURE2 {
eq(&self, other: &Self) -> bool879 fn eq(&self, other: &Self) -> bool {
880 self.VirtualKey == other.VirtualKey && self.ModificationNumber == other.ModificationNumber && self.wch == other.wch
881 }
882 }
883 impl ::std::cmp::Eq for LIGATURE2 {}
884 unsafe impl ::windows::runtime::Abi for LIGATURE2 {
885 type Abi = Self;
886 type DefaultType = Self;
887 }
888 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
889 #[repr(C)]
890 pub struct LIGATURE3 {
891 pub VirtualKey: u8,
892 pub ModificationNumber: u16,
893 pub wch: [u16; 3],
894 }
895 impl LIGATURE3 {}
896 impl ::std::default::Default for LIGATURE3 {
default() -> Self897 fn default() -> Self {
898 unsafe { ::std::mem::zeroed() }
899 }
900 }
901 impl ::std::fmt::Debug for LIGATURE3 {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result902 fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
903 fmt.debug_struct("LIGATURE3").field("VirtualKey", &self.VirtualKey).field("ModificationNumber", &self.ModificationNumber).field("wch", &self.wch).finish()
904 }
905 }
906 impl ::std::cmp::PartialEq for LIGATURE3 {
eq(&self, other: &Self) -> bool907 fn eq(&self, other: &Self) -> bool {
908 self.VirtualKey == other.VirtualKey && self.ModificationNumber == other.ModificationNumber && self.wch == other.wch
909 }
910 }
911 impl ::std::cmp::Eq for LIGATURE3 {}
912 unsafe impl ::windows::runtime::Abi for LIGATURE3 {
913 type Abi = Self;
914 type DefaultType = Self;
915 }
916 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
917 #[repr(C)]
918 pub struct LIGATURE4 {
919 pub VirtualKey: u8,
920 pub ModificationNumber: u16,
921 pub wch: [u16; 4],
922 }
923 impl LIGATURE4 {}
924 impl ::std::default::Default for LIGATURE4 {
default() -> Self925 fn default() -> Self {
926 unsafe { ::std::mem::zeroed() }
927 }
928 }
929 impl ::std::fmt::Debug for LIGATURE4 {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result930 fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
931 fmt.debug_struct("LIGATURE4").field("VirtualKey", &self.VirtualKey).field("ModificationNumber", &self.ModificationNumber).field("wch", &self.wch).finish()
932 }
933 }
934 impl ::std::cmp::PartialEq for LIGATURE4 {
eq(&self, other: &Self) -> bool935 fn eq(&self, other: &Self) -> bool {
936 self.VirtualKey == other.VirtualKey && self.ModificationNumber == other.ModificationNumber && self.wch == other.wch
937 }
938 }
939 impl ::std::cmp::Eq for LIGATURE4 {}
940 unsafe impl ::windows::runtime::Abi for LIGATURE4 {
941 type Abi = Self;
942 type DefaultType = Self;
943 }
944 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
945 #[repr(C)]
946 pub struct LIGATURE5 {
947 pub VirtualKey: u8,
948 pub ModificationNumber: u16,
949 pub wch: [u16; 5],
950 }
951 impl LIGATURE5 {}
952 impl ::std::default::Default for LIGATURE5 {
default() -> Self953 fn default() -> Self {
954 unsafe { ::std::mem::zeroed() }
955 }
956 }
957 impl ::std::fmt::Debug for LIGATURE5 {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result958 fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
959 fmt.debug_struct("LIGATURE5").field("VirtualKey", &self.VirtualKey).field("ModificationNumber", &self.ModificationNumber).field("wch", &self.wch).finish()
960 }
961 }
962 impl ::std::cmp::PartialEq for LIGATURE5 {
eq(&self, other: &Self) -> bool963 fn eq(&self, other: &Self) -> bool {
964 self.VirtualKey == other.VirtualKey && self.ModificationNumber == other.ModificationNumber && self.wch == other.wch
965 }
966 }
967 impl ::std::cmp::Eq for LIGATURE5 {}
968 unsafe impl ::windows::runtime::Abi for LIGATURE5 {
969 type Abi = Self;
970 type DefaultType = Self;
971 }
972 #[cfg(all(feature = "Win32_Foundation", feature = "Win32_UI_TextServices"))]
973 #[inline]
LoadKeyboardLayoutA<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::super::Foundation::PSTR>>(pwszklid: Param0, flags: ACTIVATE_KEYBOARD_LAYOUT_FLAGS) -> super::super::TextServices::HKL974 pub unsafe fn LoadKeyboardLayoutA<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::super::Foundation::PSTR>>(pwszklid: Param0, flags: ACTIVATE_KEYBOARD_LAYOUT_FLAGS) -> super::super::TextServices::HKL {
975 #[cfg(windows)]
976 {
977 #[link(name = "windows")]
978 extern "system" {
979 fn LoadKeyboardLayoutA(pwszklid: super::super::super::Foundation::PSTR, flags: ACTIVATE_KEYBOARD_LAYOUT_FLAGS) -> super::super::TextServices::HKL;
980 }
981 ::std::mem::transmute(LoadKeyboardLayoutA(pwszklid.into_param().abi(), ::std::mem::transmute(flags)))
982 }
983 #[cfg(not(windows))]
984 unimplemented!("Unsupported target OS");
985 }
986 #[cfg(all(feature = "Win32_Foundation", feature = "Win32_UI_TextServices"))]
987 #[inline]
LoadKeyboardLayoutW<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::super::Foundation::PWSTR>>(pwszklid: Param0, flags: ACTIVATE_KEYBOARD_LAYOUT_FLAGS) -> super::super::TextServices::HKL988 pub unsafe fn LoadKeyboardLayoutW<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::super::Foundation::PWSTR>>(pwszklid: Param0, flags: ACTIVATE_KEYBOARD_LAYOUT_FLAGS) -> super::super::TextServices::HKL {
989 #[cfg(windows)]
990 {
991 #[link(name = "windows")]
992 extern "system" {
993 fn LoadKeyboardLayoutW(pwszklid: super::super::super::Foundation::PWSTR, flags: ACTIVATE_KEYBOARD_LAYOUT_FLAGS) -> super::super::TextServices::HKL;
994 }
995 ::std::mem::transmute(LoadKeyboardLayoutW(pwszklid.into_param().abi(), ::std::mem::transmute(flags)))
996 }
997 #[cfg(not(windows))]
998 unimplemented!("Unsupported target OS");
999 }
1000 pub const MACRON: u32 = 772u32;
1001 pub const MICROSOFT_KBD_001_TYPE: u32 = 4u32;
1002 pub const MICROSOFT_KBD_002_TYPE: u32 = 3u32;
1003 pub const MICROSOFT_KBD_101A_TYPE: u32 = 0u32;
1004 pub const MICROSOFT_KBD_101B_TYPE: u32 = 4u32;
1005 pub const MICROSOFT_KBD_101C_TYPE: u32 = 5u32;
1006 pub const MICROSOFT_KBD_101_TYPE: u32 = 0u32;
1007 pub const MICROSOFT_KBD_103_TYPE: u32 = 6u32;
1008 pub const MICROSOFT_KBD_106_TYPE: u32 = 2u32;
1009 pub const MICROSOFT_KBD_AX_TYPE: u32 = 1u32;
1010 pub const MICROSOFT_KBD_FUNC: u32 = 12u32;
1011 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
1012 #[repr(C)]
1013 pub struct MODIFIERS {
1014 pub pVkToBit: *mut VK_TO_BIT,
1015 pub wMaxModBits: u16,
1016 pub ModNumber: [u8; 1],
1017 }
1018 impl MODIFIERS {}
1019 impl ::std::default::Default for MODIFIERS {
default() -> Self1020 fn default() -> Self {
1021 unsafe { ::std::mem::zeroed() }
1022 }
1023 }
1024 impl ::std::fmt::Debug for MODIFIERS {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result1025 fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
1026 fmt.debug_struct("MODIFIERS").field("pVkToBit", &self.pVkToBit).field("wMaxModBits", &self.wMaxModBits).field("ModNumber", &self.ModNumber).finish()
1027 }
1028 }
1029 impl ::std::cmp::PartialEq for MODIFIERS {
eq(&self, other: &Self) -> bool1030 fn eq(&self, other: &Self) -> bool {
1031 self.pVkToBit == other.pVkToBit && self.wMaxModBits == other.wMaxModBits && self.ModNumber == other.ModNumber
1032 }
1033 }
1034 impl ::std::cmp::Eq for MODIFIERS {}
1035 unsafe impl ::windows::runtime::Abi for MODIFIERS {
1036 type Abi = Self;
1037 type DefaultType = Self;
1038 }
1039 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
1040 #[repr(C)]
1041 pub struct MOUSEINPUT {
1042 pub dx: i32,
1043 pub dy: i32,
1044 pub mouseData: u32,
1045 pub dwFlags: MOUSE_EVENT_FLAGS,
1046 pub time: u32,
1047 pub dwExtraInfo: usize,
1048 }
1049 impl MOUSEINPUT {}
1050 impl ::std::default::Default for MOUSEINPUT {
default() -> Self1051 fn default() -> Self {
1052 unsafe { ::std::mem::zeroed() }
1053 }
1054 }
1055 impl ::std::fmt::Debug for MOUSEINPUT {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result1056 fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
1057 fmt.debug_struct("MOUSEINPUT").field("dx", &self.dx).field("dy", &self.dy).field("mouseData", &self.mouseData).field("dwFlags", &self.dwFlags).field("time", &self.time).field("dwExtraInfo", &self.dwExtraInfo).finish()
1058 }
1059 }
1060 impl ::std::cmp::PartialEq for MOUSEINPUT {
eq(&self, other: &Self) -> bool1061 fn eq(&self, other: &Self) -> bool {
1062 self.dx == other.dx && self.dy == other.dy && self.mouseData == other.mouseData && self.dwFlags == other.dwFlags && self.time == other.time && self.dwExtraInfo == other.dwExtraInfo
1063 }
1064 }
1065 impl ::std::cmp::Eq for MOUSEINPUT {}
1066 unsafe impl ::windows::runtime::Abi for MOUSEINPUT {
1067 type Abi = Self;
1068 type DefaultType = Self;
1069 }
1070 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
1071 #[repr(C)]
1072 pub struct MOUSEMOVEPOINT {
1073 pub x: i32,
1074 pub y: i32,
1075 pub time: u32,
1076 pub dwExtraInfo: usize,
1077 }
1078 impl MOUSEMOVEPOINT {}
1079 impl ::std::default::Default for MOUSEMOVEPOINT {
default() -> Self1080 fn default() -> Self {
1081 unsafe { ::std::mem::zeroed() }
1082 }
1083 }
1084 impl ::std::fmt::Debug for MOUSEMOVEPOINT {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result1085 fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
1086 fmt.debug_struct("MOUSEMOVEPOINT").field("x", &self.x).field("y", &self.y).field("time", &self.time).field("dwExtraInfo", &self.dwExtraInfo).finish()
1087 }
1088 }
1089 impl ::std::cmp::PartialEq for MOUSEMOVEPOINT {
eq(&self, other: &Self) -> bool1090 fn eq(&self, other: &Self) -> bool {
1091 self.x == other.x && self.y == other.y && self.time == other.time && self.dwExtraInfo == other.dwExtraInfo
1092 }
1093 }
1094 impl ::std::cmp::Eq for MOUSEMOVEPOINT {}
1095 unsafe impl ::windows::runtime::Abi for MOUSEMOVEPOINT {
1096 type Abi = Self;
1097 type DefaultType = Self;
1098 }
1099 #[derive(:: std :: cmp :: PartialEq, :: std :: cmp :: Eq, :: std :: marker :: Copy, :: std :: clone :: Clone, :: std :: default :: Default, :: std :: fmt :: Debug)]
1100 #[repr(transparent)]
1101 pub struct MOUSE_EVENT_FLAGS(pub u32);
1102 pub const MOUSEEVENTF_ABSOLUTE: MOUSE_EVENT_FLAGS = MOUSE_EVENT_FLAGS(32768u32);
1103 pub const MOUSEEVENTF_LEFTDOWN: MOUSE_EVENT_FLAGS = MOUSE_EVENT_FLAGS(2u32);
1104 pub const MOUSEEVENTF_LEFTUP: MOUSE_EVENT_FLAGS = MOUSE_EVENT_FLAGS(4u32);
1105 pub const MOUSEEVENTF_MIDDLEDOWN: MOUSE_EVENT_FLAGS = MOUSE_EVENT_FLAGS(32u32);
1106 pub const MOUSEEVENTF_MIDDLEUP: MOUSE_EVENT_FLAGS = MOUSE_EVENT_FLAGS(64u32);
1107 pub const MOUSEEVENTF_MOVE: MOUSE_EVENT_FLAGS = MOUSE_EVENT_FLAGS(1u32);
1108 pub const MOUSEEVENTF_RIGHTDOWN: MOUSE_EVENT_FLAGS = MOUSE_EVENT_FLAGS(8u32);
1109 pub const MOUSEEVENTF_RIGHTUP: MOUSE_EVENT_FLAGS = MOUSE_EVENT_FLAGS(16u32);
1110 pub const MOUSEEVENTF_WHEEL: MOUSE_EVENT_FLAGS = MOUSE_EVENT_FLAGS(2048u32);
1111 pub const MOUSEEVENTF_XDOWN: MOUSE_EVENT_FLAGS = MOUSE_EVENT_FLAGS(128u32);
1112 pub const MOUSEEVENTF_XUP: MOUSE_EVENT_FLAGS = MOUSE_EVENT_FLAGS(256u32);
1113 pub const MOUSEEVENTF_HWHEEL: MOUSE_EVENT_FLAGS = MOUSE_EVENT_FLAGS(4096u32);
1114 pub const MOUSEEVENTF_MOVE_NOCOALESCE: MOUSE_EVENT_FLAGS = MOUSE_EVENT_FLAGS(8192u32);
1115 pub const MOUSEEVENTF_VIRTUALDESK: MOUSE_EVENT_FLAGS = MOUSE_EVENT_FLAGS(16384u32);
1116 impl ::std::convert::From<u32> for MOUSE_EVENT_FLAGS {
from(value: u32) -> Self1117 fn from(value: u32) -> Self {
1118 Self(value)
1119 }
1120 }
1121 unsafe impl ::windows::runtime::Abi for MOUSE_EVENT_FLAGS {
1122 type Abi = Self;
1123 type DefaultType = Self;
1124 }
1125 impl ::std::ops::BitOr for MOUSE_EVENT_FLAGS {
1126 type Output = Self;
bitor(self, rhs: Self) -> Self1127 fn bitor(self, rhs: Self) -> Self {
1128 Self(self.0 | rhs.0)
1129 }
1130 }
1131 impl ::std::ops::BitAnd for MOUSE_EVENT_FLAGS {
1132 type Output = Self;
bitand(self, rhs: Self) -> Self1133 fn bitand(self, rhs: Self) -> Self {
1134 Self(self.0 & rhs.0)
1135 }
1136 }
1137 impl ::std::ops::BitOrAssign for MOUSE_EVENT_FLAGS {
bitor_assign(&mut self, rhs: Self)1138 fn bitor_assign(&mut self, rhs: Self) {
1139 self.0.bitor_assign(rhs.0)
1140 }
1141 }
1142 impl ::std::ops::BitAndAssign for MOUSE_EVENT_FLAGS {
bitand_assign(&mut self, rhs: Self)1143 fn bitand_assign(&mut self, rhs: Self) {
1144 self.0.bitand_assign(rhs.0)
1145 }
1146 }
1147 impl ::std::ops::Not for MOUSE_EVENT_FLAGS {
1148 type Output = Self;
not(self) -> Self1149 fn not(self) -> Self {
1150 Self(self.0.not())
1151 }
1152 }
1153 #[inline]
MapVirtualKeyA(ucode: u32, umaptype: u32) -> u321154 pub unsafe fn MapVirtualKeyA(ucode: u32, umaptype: u32) -> u32 {
1155 #[cfg(windows)]
1156 {
1157 #[link(name = "windows")]
1158 extern "system" {
1159 fn MapVirtualKeyA(ucode: u32, umaptype: u32) -> u32;
1160 }
1161 ::std::mem::transmute(MapVirtualKeyA(::std::mem::transmute(ucode), ::std::mem::transmute(umaptype)))
1162 }
1163 #[cfg(not(windows))]
1164 unimplemented!("Unsupported target OS");
1165 }
1166 #[cfg(feature = "Win32_UI_TextServices")]
1167 #[inline]
MapVirtualKeyExA<'a, Param2: ::windows::runtime::IntoParam<'a, super::super::TextServices::HKL>>(ucode: u32, umaptype: u32, dwhkl: Param2) -> u321168 pub unsafe fn MapVirtualKeyExA<'a, Param2: ::windows::runtime::IntoParam<'a, super::super::TextServices::HKL>>(ucode: u32, umaptype: u32, dwhkl: Param2) -> u32 {
1169 #[cfg(windows)]
1170 {
1171 #[link(name = "windows")]
1172 extern "system" {
1173 fn MapVirtualKeyExA(ucode: u32, umaptype: u32, dwhkl: super::super::TextServices::HKL) -> u32;
1174 }
1175 ::std::mem::transmute(MapVirtualKeyExA(::std::mem::transmute(ucode), ::std::mem::transmute(umaptype), dwhkl.into_param().abi()))
1176 }
1177 #[cfg(not(windows))]
1178 unimplemented!("Unsupported target OS");
1179 }
1180 #[cfg(feature = "Win32_UI_TextServices")]
1181 #[inline]
MapVirtualKeyExW<'a, Param2: ::windows::runtime::IntoParam<'a, super::super::TextServices::HKL>>(ucode: u32, umaptype: u32, dwhkl: Param2) -> u321182 pub unsafe fn MapVirtualKeyExW<'a, Param2: ::windows::runtime::IntoParam<'a, super::super::TextServices::HKL>>(ucode: u32, umaptype: u32, dwhkl: Param2) -> u32 {
1183 #[cfg(windows)]
1184 {
1185 #[link(name = "windows")]
1186 extern "system" {
1187 fn MapVirtualKeyExW(ucode: u32, umaptype: u32, dwhkl: super::super::TextServices::HKL) -> u32;
1188 }
1189 ::std::mem::transmute(MapVirtualKeyExW(::std::mem::transmute(ucode), ::std::mem::transmute(umaptype), dwhkl.into_param().abi()))
1190 }
1191 #[cfg(not(windows))]
1192 unimplemented!("Unsupported target OS");
1193 }
1194 #[inline]
MapVirtualKeyW(ucode: u32, umaptype: u32) -> u321195 pub unsafe fn MapVirtualKeyW(ucode: u32, umaptype: u32) -> u32 {
1196 #[cfg(windows)]
1197 {
1198 #[link(name = "windows")]
1199 extern "system" {
1200 fn MapVirtualKeyW(ucode: u32, umaptype: u32) -> u32;
1201 }
1202 ::std::mem::transmute(MapVirtualKeyW(::std::mem::transmute(ucode), ::std::mem::transmute(umaptype)))
1203 }
1204 #[cfg(not(windows))]
1205 unimplemented!("Unsupported target OS");
1206 }
1207 pub const NEC_KBD_106_TYPE: u32 = 5u32;
1208 pub const NEC_KBD_H_MODE_TYPE: u32 = 3u32;
1209 pub const NEC_KBD_LAPTOP_TYPE: u32 = 4u32;
1210 pub const NEC_KBD_NORMAL_TYPE: u32 = 1u32;
1211 pub const NEC_KBD_N_MODE_TYPE: u32 = 2u32;
1212 pub const NLSKBD_INFO_ACCESSIBILITY_KEYMAP: u32 = 2u32;
1213 pub const NLSKBD_INFO_EMURATE_101_KEYBOARD: u32 = 16u32;
1214 pub const NLSKBD_INFO_EMURATE_106_KEYBOARD: u32 = 32u32;
1215 pub const NLSKBD_INFO_SEND_IME_NOTIFICATION: u32 = 1u32;
1216 pub const NLSKBD_OEM_AX: u32 = 1u32;
1217 pub const NLSKBD_OEM_DEC: u32 = 24u32;
1218 pub const NLSKBD_OEM_EPSON: u32 = 4u32;
1219 pub const NLSKBD_OEM_FUJITSU: u32 = 5u32;
1220 pub const NLSKBD_OEM_IBM: u32 = 7u32;
1221 pub const NLSKBD_OEM_MATSUSHITA: u32 = 10u32;
1222 pub const NLSKBD_OEM_MICROSOFT: u32 = 0u32;
1223 pub const NLSKBD_OEM_NEC: u32 = 13u32;
1224 pub const NLSKBD_OEM_TOSHIBA: u32 = 18u32;
1225 pub const OGONEK: u32 = 808u32;
1226 pub const OVERSCORE: u32 = 773u32;
1227 #[inline]
OemKeyScan(woemchar: u16) -> u321228 pub unsafe fn OemKeyScan(woemchar: u16) -> u32 {
1229 #[cfg(windows)]
1230 {
1231 #[link(name = "windows")]
1232 extern "system" {
1233 fn OemKeyScan(woemchar: u16) -> u32;
1234 }
1235 ::std::mem::transmute(OemKeyScan(::std::mem::transmute(woemchar)))
1236 }
1237 #[cfg(not(windows))]
1238 unimplemented!("Unsupported target OS");
1239 }
1240 pub const RING: u32 = 778u32;
1241 #[cfg(feature = "Win32_Foundation")]
1242 #[inline]
RegisterHotKey<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::super::Foundation::HWND>>(hwnd: Param0, id: i32, fsmodifiers: HOT_KEY_MODIFIERS, vk: u32) -> super::super::super::Foundation::BOOL1243 pub unsafe fn RegisterHotKey<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::super::Foundation::HWND>>(hwnd: Param0, id: i32, fsmodifiers: HOT_KEY_MODIFIERS, vk: u32) -> super::super::super::Foundation::BOOL {
1244 #[cfg(windows)]
1245 {
1246 #[link(name = "windows")]
1247 extern "system" {
1248 fn RegisterHotKey(hwnd: super::super::super::Foundation::HWND, id: i32, fsmodifiers: HOT_KEY_MODIFIERS, vk: u32) -> super::super::super::Foundation::BOOL;
1249 }
1250 ::std::mem::transmute(RegisterHotKey(hwnd.into_param().abi(), ::std::mem::transmute(id), ::std::mem::transmute(fsmodifiers), ::std::mem::transmute(vk)))
1251 }
1252 #[cfg(not(windows))]
1253 unimplemented!("Unsupported target OS");
1254 }
1255 #[cfg(feature = "Win32_Foundation")]
1256 #[inline]
ReleaseCapture() -> super::super::super::Foundation::BOOL1257 pub unsafe fn ReleaseCapture() -> super::super::super::Foundation::BOOL {
1258 #[cfg(windows)]
1259 {
1260 #[link(name = "windows")]
1261 extern "system" {
1262 fn ReleaseCapture() -> super::super::super::Foundation::BOOL;
1263 }
1264 ::std::mem::transmute(ReleaseCapture())
1265 }
1266 #[cfg(not(windows))]
1267 unimplemented!("Unsupported target OS");
1268 }
1269 pub const SCANCODE_ALT: u32 = 56u32;
1270 pub const SCANCODE_CTRL: u32 = 29u32;
1271 pub const SCANCODE_LSHIFT: u32 = 42u32;
1272 pub const SCANCODE_LWIN: u32 = 91u32;
1273 pub const SCANCODE_NUMPAD_FIRST: u32 = 71u32;
1274 pub const SCANCODE_NUMPAD_LAST: u32 = 82u32;
1275 pub const SCANCODE_RSHIFT: u32 = 54u32;
1276 pub const SCANCODE_RWIN: u32 = 92u32;
1277 pub const SCANCODE_THAI_LAYOUT_TOGGLE: u32 = 41u32;
1278 pub const SGCAPS: u32 = 2u32;
1279 pub const SHFT_INVALID: u32 = 15u32;
1280 #[inline]
SendInput(cinputs: u32, pinputs: *const INPUT, cbsize: i32) -> u321281 pub unsafe fn SendInput(cinputs: u32, pinputs: *const INPUT, cbsize: i32) -> u32 {
1282 #[cfg(windows)]
1283 {
1284 #[link(name = "windows")]
1285 extern "system" {
1286 fn SendInput(cinputs: u32, pinputs: *const INPUT, cbsize: i32) -> u32;
1287 }
1288 ::std::mem::transmute(SendInput(::std::mem::transmute(cinputs), ::std::mem::transmute(pinputs), ::std::mem::transmute(cbsize)))
1289 }
1290 #[cfg(not(windows))]
1291 unimplemented!("Unsupported target OS");
1292 }
1293 #[cfg(feature = "Win32_Foundation")]
1294 #[inline]
SetActiveWindow<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::super::Foundation::HWND>>(hwnd: Param0) -> super::super::super::Foundation::HWND1295 pub unsafe fn SetActiveWindow<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::super::Foundation::HWND>>(hwnd: Param0) -> super::super::super::Foundation::HWND {
1296 #[cfg(windows)]
1297 {
1298 #[link(name = "windows")]
1299 extern "system" {
1300 fn SetActiveWindow(hwnd: super::super::super::Foundation::HWND) -> super::super::super::Foundation::HWND;
1301 }
1302 ::std::mem::transmute(SetActiveWindow(hwnd.into_param().abi()))
1303 }
1304 #[cfg(not(windows))]
1305 unimplemented!("Unsupported target OS");
1306 }
1307 #[cfg(feature = "Win32_Foundation")]
1308 #[inline]
SetCapture<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::super::Foundation::HWND>>(hwnd: Param0) -> super::super::super::Foundation::HWND1309 pub unsafe fn SetCapture<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::super::Foundation::HWND>>(hwnd: Param0) -> super::super::super::Foundation::HWND {
1310 #[cfg(windows)]
1311 {
1312 #[link(name = "windows")]
1313 extern "system" {
1314 fn SetCapture(hwnd: super::super::super::Foundation::HWND) -> super::super::super::Foundation::HWND;
1315 }
1316 ::std::mem::transmute(SetCapture(hwnd.into_param().abi()))
1317 }
1318 #[cfg(not(windows))]
1319 unimplemented!("Unsupported target OS");
1320 }
1321 #[cfg(feature = "Win32_Foundation")]
1322 #[inline]
SetDoubleClickTime(param0: u32) -> super::super::super::Foundation::BOOL1323 pub unsafe fn SetDoubleClickTime(param0: u32) -> super::super::super::Foundation::BOOL {
1324 #[cfg(windows)]
1325 {
1326 #[link(name = "windows")]
1327 extern "system" {
1328 fn SetDoubleClickTime(param0: u32) -> super::super::super::Foundation::BOOL;
1329 }
1330 ::std::mem::transmute(SetDoubleClickTime(::std::mem::transmute(param0)))
1331 }
1332 #[cfg(not(windows))]
1333 unimplemented!("Unsupported target OS");
1334 }
1335 #[cfg(feature = "Win32_Foundation")]
1336 #[inline]
SetFocus<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::super::Foundation::HWND>>(hwnd: Param0) -> super::super::super::Foundation::HWND1337 pub unsafe fn SetFocus<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::super::Foundation::HWND>>(hwnd: Param0) -> super::super::super::Foundation::HWND {
1338 #[cfg(windows)]
1339 {
1340 #[link(name = "windows")]
1341 extern "system" {
1342 fn SetFocus(hwnd: super::super::super::Foundation::HWND) -> super::super::super::Foundation::HWND;
1343 }
1344 ::std::mem::transmute(SetFocus(hwnd.into_param().abi()))
1345 }
1346 #[cfg(not(windows))]
1347 unimplemented!("Unsupported target OS");
1348 }
1349 #[cfg(feature = "Win32_Foundation")]
1350 #[inline]
SetKeyboardState(lpkeystate: *const u8) -> super::super::super::Foundation::BOOL1351 pub unsafe fn SetKeyboardState(lpkeystate: *const u8) -> super::super::super::Foundation::BOOL {
1352 #[cfg(windows)]
1353 {
1354 #[link(name = "windows")]
1355 extern "system" {
1356 fn SetKeyboardState(lpkeystate: *const u8) -> super::super::super::Foundation::BOOL;
1357 }
1358 ::std::mem::transmute(SetKeyboardState(::std::mem::transmute(lpkeystate)))
1359 }
1360 #[cfg(not(windows))]
1361 unimplemented!("Unsupported target OS");
1362 }
1363 #[cfg(feature = "Win32_Foundation")]
1364 #[inline]
SwapMouseButton<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::super::Foundation::BOOL>>(fswap: Param0) -> super::super::super::Foundation::BOOL1365 pub unsafe fn SwapMouseButton<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::super::Foundation::BOOL>>(fswap: Param0) -> super::super::super::Foundation::BOOL {
1366 #[cfg(windows)]
1367 {
1368 #[link(name = "windows")]
1369 extern "system" {
1370 fn SwapMouseButton(fswap: super::super::super::Foundation::BOOL) -> super::super::super::Foundation::BOOL;
1371 }
1372 ::std::mem::transmute(SwapMouseButton(fswap.into_param().abi()))
1373 }
1374 #[cfg(not(windows))]
1375 unimplemented!("Unsupported target OS");
1376 }
1377 pub const TILDE: u32 = 771u32;
1378 pub const TONOS: u32 = 900u32;
1379 pub const TOSHIBA_KBD_DESKTOP_TYPE: u32 = 13u32;
1380 pub const TOSHIBA_KBD_LAPTOP_TYPE: u32 = 15u32;
1381 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
1382 #[repr(C)]
1383 #[cfg(feature = "Win32_Foundation")]
1384 pub struct TRACKMOUSEEVENT {
1385 pub cbSize: u32,
1386 pub dwFlags: TRACKMOUSEEVENT_FLAGS,
1387 pub hwndTrack: super::super::super::Foundation::HWND,
1388 pub dwHoverTime: u32,
1389 }
1390 #[cfg(feature = "Win32_Foundation")]
1391 impl TRACKMOUSEEVENT {}
1392 #[cfg(feature = "Win32_Foundation")]
1393 impl ::std::default::Default for TRACKMOUSEEVENT {
default() -> Self1394 fn default() -> Self {
1395 unsafe { ::std::mem::zeroed() }
1396 }
1397 }
1398 #[cfg(feature = "Win32_Foundation")]
1399 impl ::std::fmt::Debug for TRACKMOUSEEVENT {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result1400 fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
1401 fmt.debug_struct("TRACKMOUSEEVENT").field("cbSize", &self.cbSize).field("dwFlags", &self.dwFlags).field("hwndTrack", &self.hwndTrack).field("dwHoverTime", &self.dwHoverTime).finish()
1402 }
1403 }
1404 #[cfg(feature = "Win32_Foundation")]
1405 impl ::std::cmp::PartialEq for TRACKMOUSEEVENT {
eq(&self, other: &Self) -> bool1406 fn eq(&self, other: &Self) -> bool {
1407 self.cbSize == other.cbSize && self.dwFlags == other.dwFlags && self.hwndTrack == other.hwndTrack && self.dwHoverTime == other.dwHoverTime
1408 }
1409 }
1410 #[cfg(feature = "Win32_Foundation")]
1411 impl ::std::cmp::Eq for TRACKMOUSEEVENT {}
1412 #[cfg(feature = "Win32_Foundation")]
1413 unsafe impl ::windows::runtime::Abi for TRACKMOUSEEVENT {
1414 type Abi = Self;
1415 type DefaultType = Self;
1416 }
1417 #[derive(:: std :: cmp :: PartialEq, :: std :: cmp :: Eq, :: std :: marker :: Copy, :: std :: clone :: Clone, :: std :: default :: Default, :: std :: fmt :: Debug)]
1418 #[repr(transparent)]
1419 pub struct TRACKMOUSEEVENT_FLAGS(pub u32);
1420 pub const TME_CANCEL: TRACKMOUSEEVENT_FLAGS = TRACKMOUSEEVENT_FLAGS(2147483648u32);
1421 pub const TME_HOVER: TRACKMOUSEEVENT_FLAGS = TRACKMOUSEEVENT_FLAGS(1u32);
1422 pub const TME_LEAVE: TRACKMOUSEEVENT_FLAGS = TRACKMOUSEEVENT_FLAGS(2u32);
1423 pub const TME_NONCLIENT: TRACKMOUSEEVENT_FLAGS = TRACKMOUSEEVENT_FLAGS(16u32);
1424 pub const TME_QUERY: TRACKMOUSEEVENT_FLAGS = TRACKMOUSEEVENT_FLAGS(1073741824u32);
1425 impl ::std::convert::From<u32> for TRACKMOUSEEVENT_FLAGS {
from(value: u32) -> Self1426 fn from(value: u32) -> Self {
1427 Self(value)
1428 }
1429 }
1430 unsafe impl ::windows::runtime::Abi for TRACKMOUSEEVENT_FLAGS {
1431 type Abi = Self;
1432 type DefaultType = Self;
1433 }
1434 impl ::std::ops::BitOr for TRACKMOUSEEVENT_FLAGS {
1435 type Output = Self;
bitor(self, rhs: Self) -> Self1436 fn bitor(self, rhs: Self) -> Self {
1437 Self(self.0 | rhs.0)
1438 }
1439 }
1440 impl ::std::ops::BitAnd for TRACKMOUSEEVENT_FLAGS {
1441 type Output = Self;
bitand(self, rhs: Self) -> Self1442 fn bitand(self, rhs: Self) -> Self {
1443 Self(self.0 & rhs.0)
1444 }
1445 }
1446 impl ::std::ops::BitOrAssign for TRACKMOUSEEVENT_FLAGS {
bitor_assign(&mut self, rhs: Self)1447 fn bitor_assign(&mut self, rhs: Self) {
1448 self.0.bitor_assign(rhs.0)
1449 }
1450 }
1451 impl ::std::ops::BitAndAssign for TRACKMOUSEEVENT_FLAGS {
bitand_assign(&mut self, rhs: Self)1452 fn bitand_assign(&mut self, rhs: Self) {
1453 self.0.bitand_assign(rhs.0)
1454 }
1455 }
1456 impl ::std::ops::Not for TRACKMOUSEEVENT_FLAGS {
1457 type Output = Self;
not(self) -> Self1458 fn not(self) -> Self {
1459 Self(self.0.not())
1460 }
1461 }
1462 #[inline]
ToAscii(uvirtkey: u32, uscancode: u32, lpkeystate: *const u8, lpchar: *mut u16, uflags: u32) -> i321463 pub unsafe fn ToAscii(uvirtkey: u32, uscancode: u32, lpkeystate: *const u8, lpchar: *mut u16, uflags: u32) -> i32 {
1464 #[cfg(windows)]
1465 {
1466 #[link(name = "windows")]
1467 extern "system" {
1468 fn ToAscii(uvirtkey: u32, uscancode: u32, lpkeystate: *const u8, lpchar: *mut u16, uflags: u32) -> i32;
1469 }
1470 ::std::mem::transmute(ToAscii(::std::mem::transmute(uvirtkey), ::std::mem::transmute(uscancode), ::std::mem::transmute(lpkeystate), ::std::mem::transmute(lpchar), ::std::mem::transmute(uflags)))
1471 }
1472 #[cfg(not(windows))]
1473 unimplemented!("Unsupported target OS");
1474 }
1475 #[cfg(feature = "Win32_UI_TextServices")]
1476 #[inline]
ToAsciiEx<'a, Param5: ::windows::runtime::IntoParam<'a, super::super::TextServices::HKL>>(uvirtkey: u32, uscancode: u32, lpkeystate: *const u8, lpchar: *mut u16, uflags: u32, dwhkl: Param5) -> i321477 pub unsafe fn ToAsciiEx<'a, Param5: ::windows::runtime::IntoParam<'a, super::super::TextServices::HKL>>(uvirtkey: u32, uscancode: u32, lpkeystate: *const u8, lpchar: *mut u16, uflags: u32, dwhkl: Param5) -> i32 {
1478 #[cfg(windows)]
1479 {
1480 #[link(name = "windows")]
1481 extern "system" {
1482 fn ToAsciiEx(uvirtkey: u32, uscancode: u32, lpkeystate: *const u8, lpchar: *mut u16, uflags: u32, dwhkl: super::super::TextServices::HKL) -> i32;
1483 }
1484 ::std::mem::transmute(ToAsciiEx(::std::mem::transmute(uvirtkey), ::std::mem::transmute(uscancode), ::std::mem::transmute(lpkeystate), ::std::mem::transmute(lpchar), ::std::mem::transmute(uflags), dwhkl.into_param().abi()))
1485 }
1486 #[cfg(not(windows))]
1487 unimplemented!("Unsupported target OS");
1488 }
1489 #[cfg(feature = "Win32_Foundation")]
1490 #[inline]
ToUnicode(wvirtkey: u32, wscancode: u32, lpkeystate: *const u8, pwszbuff: super::super::super::Foundation::PWSTR, cchbuff: i32, wflags: u32) -> i321491 pub unsafe fn ToUnicode(wvirtkey: u32, wscancode: u32, lpkeystate: *const u8, pwszbuff: super::super::super::Foundation::PWSTR, cchbuff: i32, wflags: u32) -> i32 {
1492 #[cfg(windows)]
1493 {
1494 #[link(name = "windows")]
1495 extern "system" {
1496 fn ToUnicode(wvirtkey: u32, wscancode: u32, lpkeystate: *const u8, pwszbuff: super::super::super::Foundation::PWSTR, cchbuff: i32, wflags: u32) -> i32;
1497 }
1498 ::std::mem::transmute(ToUnicode(::std::mem::transmute(wvirtkey), ::std::mem::transmute(wscancode), ::std::mem::transmute(lpkeystate), ::std::mem::transmute(pwszbuff), ::std::mem::transmute(cchbuff), ::std::mem::transmute(wflags)))
1499 }
1500 #[cfg(not(windows))]
1501 unimplemented!("Unsupported target OS");
1502 }
1503 #[cfg(all(feature = "Win32_Foundation", feature = "Win32_UI_TextServices"))]
1504 #[inline]
ToUnicodeEx<'a, Param6: ::windows::runtime::IntoParam<'a, super::super::TextServices::HKL>>(wvirtkey: u32, wscancode: u32, lpkeystate: *const u8, pwszbuff: super::super::super::Foundation::PWSTR, cchbuff: i32, wflags: u32, dwhkl: Param6) -> i321505 pub unsafe fn ToUnicodeEx<'a, Param6: ::windows::runtime::IntoParam<'a, super::super::TextServices::HKL>>(wvirtkey: u32, wscancode: u32, lpkeystate: *const u8, pwszbuff: super::super::super::Foundation::PWSTR, cchbuff: i32, wflags: u32, dwhkl: Param6) -> i32 {
1506 #[cfg(windows)]
1507 {
1508 #[link(name = "windows")]
1509 extern "system" {
1510 fn ToUnicodeEx(wvirtkey: u32, wscancode: u32, lpkeystate: *const u8, pwszbuff: super::super::super::Foundation::PWSTR, cchbuff: i32, wflags: u32, dwhkl: super::super::TextServices::HKL) -> i32;
1511 }
1512 ::std::mem::transmute(ToUnicodeEx(::std::mem::transmute(wvirtkey), ::std::mem::transmute(wscancode), ::std::mem::transmute(lpkeystate), ::std::mem::transmute(pwszbuff), ::std::mem::transmute(cchbuff), ::std::mem::transmute(wflags), dwhkl.into_param().abi()))
1513 }
1514 #[cfg(not(windows))]
1515 unimplemented!("Unsupported target OS");
1516 }
1517 #[cfg(feature = "Win32_Foundation")]
1518 #[inline]
TrackMouseEvent(lpeventtrack: *mut TRACKMOUSEEVENT) -> super::super::super::Foundation::BOOL1519 pub unsafe fn TrackMouseEvent(lpeventtrack: *mut TRACKMOUSEEVENT) -> super::super::super::Foundation::BOOL {
1520 #[cfg(windows)]
1521 {
1522 #[link(name = "windows")]
1523 extern "system" {
1524 fn TrackMouseEvent(lpeventtrack: *mut TRACKMOUSEEVENT) -> super::super::super::Foundation::BOOL;
1525 }
1526 ::std::mem::transmute(TrackMouseEvent(::std::mem::transmute(lpeventtrack)))
1527 }
1528 #[cfg(not(windows))]
1529 unimplemented!("Unsupported target OS");
1530 }
1531 pub const UMLAUT: u32 = 776u32;
1532 #[cfg(all(feature = "Win32_Foundation", feature = "Win32_UI_TextServices"))]
1533 #[inline]
UnloadKeyboardLayout<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::TextServices::HKL>>(hkl: Param0) -> super::super::super::Foundation::BOOL1534 pub unsafe fn UnloadKeyboardLayout<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::TextServices::HKL>>(hkl: Param0) -> super::super::super::Foundation::BOOL {
1535 #[cfg(windows)]
1536 {
1537 #[link(name = "windows")]
1538 extern "system" {
1539 fn UnloadKeyboardLayout(hkl: super::super::TextServices::HKL) -> super::super::super::Foundation::BOOL;
1540 }
1541 ::std::mem::transmute(UnloadKeyboardLayout(hkl.into_param().abi()))
1542 }
1543 #[cfg(not(windows))]
1544 unimplemented!("Unsupported target OS");
1545 }
1546 #[cfg(feature = "Win32_Foundation")]
1547 #[inline]
UnregisterHotKey<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::super::Foundation::HWND>>(hwnd: Param0, id: i32) -> super::super::super::Foundation::BOOL1548 pub unsafe fn UnregisterHotKey<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::super::Foundation::HWND>>(hwnd: Param0, id: i32) -> super::super::super::Foundation::BOOL {
1549 #[cfg(windows)]
1550 {
1551 #[link(name = "windows")]
1552 extern "system" {
1553 fn UnregisterHotKey(hwnd: super::super::super::Foundation::HWND, id: i32) -> super::super::super::Foundation::BOOL;
1554 }
1555 ::std::mem::transmute(UnregisterHotKey(hwnd.into_param().abi(), ::std::mem::transmute(id)))
1556 }
1557 #[cfg(not(windows))]
1558 unimplemented!("Unsupported target OS");
1559 }
1560 #[derive(:: std :: cmp :: PartialEq, :: std :: cmp :: Eq, :: std :: marker :: Copy, :: std :: clone :: Clone, :: std :: default :: Default, :: std :: fmt :: Debug)]
1561 #[repr(transparent)]
1562 pub struct VIRTUAL_KEY(pub u16);
1563 pub const VK_0: VIRTUAL_KEY = VIRTUAL_KEY(48u16);
1564 pub const VK_1: VIRTUAL_KEY = VIRTUAL_KEY(49u16);
1565 pub const VK_2: VIRTUAL_KEY = VIRTUAL_KEY(50u16);
1566 pub const VK_3: VIRTUAL_KEY = VIRTUAL_KEY(51u16);
1567 pub const VK_4: VIRTUAL_KEY = VIRTUAL_KEY(52u16);
1568 pub const VK_5: VIRTUAL_KEY = VIRTUAL_KEY(53u16);
1569 pub const VK_6: VIRTUAL_KEY = VIRTUAL_KEY(54u16);
1570 pub const VK_7: VIRTUAL_KEY = VIRTUAL_KEY(55u16);
1571 pub const VK_8: VIRTUAL_KEY = VIRTUAL_KEY(56u16);
1572 pub const VK_9: VIRTUAL_KEY = VIRTUAL_KEY(57u16);
1573 pub const VK_A: VIRTUAL_KEY = VIRTUAL_KEY(65u16);
1574 pub const VK_B: VIRTUAL_KEY = VIRTUAL_KEY(66u16);
1575 pub const VK_C: VIRTUAL_KEY = VIRTUAL_KEY(67u16);
1576 pub const VK_D: VIRTUAL_KEY = VIRTUAL_KEY(68u16);
1577 pub const VK_E: VIRTUAL_KEY = VIRTUAL_KEY(69u16);
1578 pub const VK_F: VIRTUAL_KEY = VIRTUAL_KEY(70u16);
1579 pub const VK_G: VIRTUAL_KEY = VIRTUAL_KEY(71u16);
1580 pub const VK_H: VIRTUAL_KEY = VIRTUAL_KEY(72u16);
1581 pub const VK_I: VIRTUAL_KEY = VIRTUAL_KEY(73u16);
1582 pub const VK_J: VIRTUAL_KEY = VIRTUAL_KEY(74u16);
1583 pub const VK_K: VIRTUAL_KEY = VIRTUAL_KEY(75u16);
1584 pub const VK_L: VIRTUAL_KEY = VIRTUAL_KEY(76u16);
1585 pub const VK_M: VIRTUAL_KEY = VIRTUAL_KEY(77u16);
1586 pub const VK_N: VIRTUAL_KEY = VIRTUAL_KEY(78u16);
1587 pub const VK_O: VIRTUAL_KEY = VIRTUAL_KEY(79u16);
1588 pub const VK_P: VIRTUAL_KEY = VIRTUAL_KEY(80u16);
1589 pub const VK_Q: VIRTUAL_KEY = VIRTUAL_KEY(81u16);
1590 pub const VK_R: VIRTUAL_KEY = VIRTUAL_KEY(82u16);
1591 pub const VK_S: VIRTUAL_KEY = VIRTUAL_KEY(83u16);
1592 pub const VK_T: VIRTUAL_KEY = VIRTUAL_KEY(84u16);
1593 pub const VK_U: VIRTUAL_KEY = VIRTUAL_KEY(85u16);
1594 pub const VK_V: VIRTUAL_KEY = VIRTUAL_KEY(86u16);
1595 pub const VK_W: VIRTUAL_KEY = VIRTUAL_KEY(87u16);
1596 pub const VK_X: VIRTUAL_KEY = VIRTUAL_KEY(88u16);
1597 pub const VK_Y: VIRTUAL_KEY = VIRTUAL_KEY(89u16);
1598 pub const VK_Z: VIRTUAL_KEY = VIRTUAL_KEY(90u16);
1599 pub const VK_LBUTTON: VIRTUAL_KEY = VIRTUAL_KEY(1u16);
1600 pub const VK_RBUTTON: VIRTUAL_KEY = VIRTUAL_KEY(2u16);
1601 pub const VK_CANCEL: VIRTUAL_KEY = VIRTUAL_KEY(3u16);
1602 pub const VK_MBUTTON: VIRTUAL_KEY = VIRTUAL_KEY(4u16);
1603 pub const VK_XBUTTON1: VIRTUAL_KEY = VIRTUAL_KEY(5u16);
1604 pub const VK_XBUTTON2: VIRTUAL_KEY = VIRTUAL_KEY(6u16);
1605 pub const VK_BACK: VIRTUAL_KEY = VIRTUAL_KEY(8u16);
1606 pub const VK_TAB: VIRTUAL_KEY = VIRTUAL_KEY(9u16);
1607 pub const VK_CLEAR: VIRTUAL_KEY = VIRTUAL_KEY(12u16);
1608 pub const VK_RETURN: VIRTUAL_KEY = VIRTUAL_KEY(13u16);
1609 pub const VK_SHIFT: VIRTUAL_KEY = VIRTUAL_KEY(16u16);
1610 pub const VK_CONTROL: VIRTUAL_KEY = VIRTUAL_KEY(17u16);
1611 pub const VK_MENU: VIRTUAL_KEY = VIRTUAL_KEY(18u16);
1612 pub const VK_PAUSE: VIRTUAL_KEY = VIRTUAL_KEY(19u16);
1613 pub const VK_CAPITAL: VIRTUAL_KEY = VIRTUAL_KEY(20u16);
1614 pub const VK_KANA: VIRTUAL_KEY = VIRTUAL_KEY(21u16);
1615 pub const VK_HANGEUL: VIRTUAL_KEY = VIRTUAL_KEY(21u16);
1616 pub const VK_HANGUL: VIRTUAL_KEY = VIRTUAL_KEY(21u16);
1617 pub const VK_IME_ON: VIRTUAL_KEY = VIRTUAL_KEY(22u16);
1618 pub const VK_JUNJA: VIRTUAL_KEY = VIRTUAL_KEY(23u16);
1619 pub const VK_FINAL: VIRTUAL_KEY = VIRTUAL_KEY(24u16);
1620 pub const VK_HANJA: VIRTUAL_KEY = VIRTUAL_KEY(25u16);
1621 pub const VK_KANJI: VIRTUAL_KEY = VIRTUAL_KEY(25u16);
1622 pub const VK_IME_OFF: VIRTUAL_KEY = VIRTUAL_KEY(26u16);
1623 pub const VK_ESCAPE: VIRTUAL_KEY = VIRTUAL_KEY(27u16);
1624 pub const VK_CONVERT: VIRTUAL_KEY = VIRTUAL_KEY(28u16);
1625 pub const VK_NONCONVERT: VIRTUAL_KEY = VIRTUAL_KEY(29u16);
1626 pub const VK_ACCEPT: VIRTUAL_KEY = VIRTUAL_KEY(30u16);
1627 pub const VK_MODECHANGE: VIRTUAL_KEY = VIRTUAL_KEY(31u16);
1628 pub const VK_SPACE: VIRTUAL_KEY = VIRTUAL_KEY(32u16);
1629 pub const VK_PRIOR: VIRTUAL_KEY = VIRTUAL_KEY(33u16);
1630 pub const VK_NEXT: VIRTUAL_KEY = VIRTUAL_KEY(34u16);
1631 pub const VK_END: VIRTUAL_KEY = VIRTUAL_KEY(35u16);
1632 pub const VK_HOME: VIRTUAL_KEY = VIRTUAL_KEY(36u16);
1633 pub const VK_LEFT: VIRTUAL_KEY = VIRTUAL_KEY(37u16);
1634 pub const VK_UP: VIRTUAL_KEY = VIRTUAL_KEY(38u16);
1635 pub const VK_RIGHT: VIRTUAL_KEY = VIRTUAL_KEY(39u16);
1636 pub const VK_DOWN: VIRTUAL_KEY = VIRTUAL_KEY(40u16);
1637 pub const VK_SELECT: VIRTUAL_KEY = VIRTUAL_KEY(41u16);
1638 pub const VK_PRINT: VIRTUAL_KEY = VIRTUAL_KEY(42u16);
1639 pub const VK_EXECUTE: VIRTUAL_KEY = VIRTUAL_KEY(43u16);
1640 pub const VK_SNAPSHOT: VIRTUAL_KEY = VIRTUAL_KEY(44u16);
1641 pub const VK_INSERT: VIRTUAL_KEY = VIRTUAL_KEY(45u16);
1642 pub const VK_DELETE: VIRTUAL_KEY = VIRTUAL_KEY(46u16);
1643 pub const VK_HELP: VIRTUAL_KEY = VIRTUAL_KEY(47u16);
1644 pub const VK_LWIN: VIRTUAL_KEY = VIRTUAL_KEY(91u16);
1645 pub const VK_RWIN: VIRTUAL_KEY = VIRTUAL_KEY(92u16);
1646 pub const VK_APPS: VIRTUAL_KEY = VIRTUAL_KEY(93u16);
1647 pub const VK_SLEEP: VIRTUAL_KEY = VIRTUAL_KEY(95u16);
1648 pub const VK_NUMPAD0: VIRTUAL_KEY = VIRTUAL_KEY(96u16);
1649 pub const VK_NUMPAD1: VIRTUAL_KEY = VIRTUAL_KEY(97u16);
1650 pub const VK_NUMPAD2: VIRTUAL_KEY = VIRTUAL_KEY(98u16);
1651 pub const VK_NUMPAD3: VIRTUAL_KEY = VIRTUAL_KEY(99u16);
1652 pub const VK_NUMPAD4: VIRTUAL_KEY = VIRTUAL_KEY(100u16);
1653 pub const VK_NUMPAD5: VIRTUAL_KEY = VIRTUAL_KEY(101u16);
1654 pub const VK_NUMPAD6: VIRTUAL_KEY = VIRTUAL_KEY(102u16);
1655 pub const VK_NUMPAD7: VIRTUAL_KEY = VIRTUAL_KEY(103u16);
1656 pub const VK_NUMPAD8: VIRTUAL_KEY = VIRTUAL_KEY(104u16);
1657 pub const VK_NUMPAD9: VIRTUAL_KEY = VIRTUAL_KEY(105u16);
1658 pub const VK_MULTIPLY: VIRTUAL_KEY = VIRTUAL_KEY(106u16);
1659 pub const VK_ADD: VIRTUAL_KEY = VIRTUAL_KEY(107u16);
1660 pub const VK_SEPARATOR: VIRTUAL_KEY = VIRTUAL_KEY(108u16);
1661 pub const VK_SUBTRACT: VIRTUAL_KEY = VIRTUAL_KEY(109u16);
1662 pub const VK_DECIMAL: VIRTUAL_KEY = VIRTUAL_KEY(110u16);
1663 pub const VK_DIVIDE: VIRTUAL_KEY = VIRTUAL_KEY(111u16);
1664 pub const VK_F1: VIRTUAL_KEY = VIRTUAL_KEY(112u16);
1665 pub const VK_F2: VIRTUAL_KEY = VIRTUAL_KEY(113u16);
1666 pub const VK_F3: VIRTUAL_KEY = VIRTUAL_KEY(114u16);
1667 pub const VK_F4: VIRTUAL_KEY = VIRTUAL_KEY(115u16);
1668 pub const VK_F5: VIRTUAL_KEY = VIRTUAL_KEY(116u16);
1669 pub const VK_F6: VIRTUAL_KEY = VIRTUAL_KEY(117u16);
1670 pub const VK_F7: VIRTUAL_KEY = VIRTUAL_KEY(118u16);
1671 pub const VK_F8: VIRTUAL_KEY = VIRTUAL_KEY(119u16);
1672 pub const VK_F9: VIRTUAL_KEY = VIRTUAL_KEY(120u16);
1673 pub const VK_F10: VIRTUAL_KEY = VIRTUAL_KEY(121u16);
1674 pub const VK_F11: VIRTUAL_KEY = VIRTUAL_KEY(122u16);
1675 pub const VK_F12: VIRTUAL_KEY = VIRTUAL_KEY(123u16);
1676 pub const VK_F13: VIRTUAL_KEY = VIRTUAL_KEY(124u16);
1677 pub const VK_F14: VIRTUAL_KEY = VIRTUAL_KEY(125u16);
1678 pub const VK_F15: VIRTUAL_KEY = VIRTUAL_KEY(126u16);
1679 pub const VK_F16: VIRTUAL_KEY = VIRTUAL_KEY(127u16);
1680 pub const VK_F17: VIRTUAL_KEY = VIRTUAL_KEY(128u16);
1681 pub const VK_F18: VIRTUAL_KEY = VIRTUAL_KEY(129u16);
1682 pub const VK_F19: VIRTUAL_KEY = VIRTUAL_KEY(130u16);
1683 pub const VK_F20: VIRTUAL_KEY = VIRTUAL_KEY(131u16);
1684 pub const VK_F21: VIRTUAL_KEY = VIRTUAL_KEY(132u16);
1685 pub const VK_F22: VIRTUAL_KEY = VIRTUAL_KEY(133u16);
1686 pub const VK_F23: VIRTUAL_KEY = VIRTUAL_KEY(134u16);
1687 pub const VK_F24: VIRTUAL_KEY = VIRTUAL_KEY(135u16);
1688 pub const VK_NAVIGATION_VIEW: VIRTUAL_KEY = VIRTUAL_KEY(136u16);
1689 pub const VK_NAVIGATION_MENU: VIRTUAL_KEY = VIRTUAL_KEY(137u16);
1690 pub const VK_NAVIGATION_UP: VIRTUAL_KEY = VIRTUAL_KEY(138u16);
1691 pub const VK_NAVIGATION_DOWN: VIRTUAL_KEY = VIRTUAL_KEY(139u16);
1692 pub const VK_NAVIGATION_LEFT: VIRTUAL_KEY = VIRTUAL_KEY(140u16);
1693 pub const VK_NAVIGATION_RIGHT: VIRTUAL_KEY = VIRTUAL_KEY(141u16);
1694 pub const VK_NAVIGATION_ACCEPT: VIRTUAL_KEY = VIRTUAL_KEY(142u16);
1695 pub const VK_NAVIGATION_CANCEL: VIRTUAL_KEY = VIRTUAL_KEY(143u16);
1696 pub const VK_NUMLOCK: VIRTUAL_KEY = VIRTUAL_KEY(144u16);
1697 pub const VK_SCROLL: VIRTUAL_KEY = VIRTUAL_KEY(145u16);
1698 pub const VK_OEM_NEC_EQUAL: VIRTUAL_KEY = VIRTUAL_KEY(146u16);
1699 pub const VK_OEM_FJ_JISHO: VIRTUAL_KEY = VIRTUAL_KEY(146u16);
1700 pub const VK_OEM_FJ_MASSHOU: VIRTUAL_KEY = VIRTUAL_KEY(147u16);
1701 pub const VK_OEM_FJ_TOUROKU: VIRTUAL_KEY = VIRTUAL_KEY(148u16);
1702 pub const VK_OEM_FJ_LOYA: VIRTUAL_KEY = VIRTUAL_KEY(149u16);
1703 pub const VK_OEM_FJ_ROYA: VIRTUAL_KEY = VIRTUAL_KEY(150u16);
1704 pub const VK_LSHIFT: VIRTUAL_KEY = VIRTUAL_KEY(160u16);
1705 pub const VK_RSHIFT: VIRTUAL_KEY = VIRTUAL_KEY(161u16);
1706 pub const VK_LCONTROL: VIRTUAL_KEY = VIRTUAL_KEY(162u16);
1707 pub const VK_RCONTROL: VIRTUAL_KEY = VIRTUAL_KEY(163u16);
1708 pub const VK_LMENU: VIRTUAL_KEY = VIRTUAL_KEY(164u16);
1709 pub const VK_RMENU: VIRTUAL_KEY = VIRTUAL_KEY(165u16);
1710 pub const VK_BROWSER_BACK: VIRTUAL_KEY = VIRTUAL_KEY(166u16);
1711 pub const VK_BROWSER_FORWARD: VIRTUAL_KEY = VIRTUAL_KEY(167u16);
1712 pub const VK_BROWSER_REFRESH: VIRTUAL_KEY = VIRTUAL_KEY(168u16);
1713 pub const VK_BROWSER_STOP: VIRTUAL_KEY = VIRTUAL_KEY(169u16);
1714 pub const VK_BROWSER_SEARCH: VIRTUAL_KEY = VIRTUAL_KEY(170u16);
1715 pub const VK_BROWSER_FAVORITES: VIRTUAL_KEY = VIRTUAL_KEY(171u16);
1716 pub const VK_BROWSER_HOME: VIRTUAL_KEY = VIRTUAL_KEY(172u16);
1717 pub const VK_VOLUME_MUTE: VIRTUAL_KEY = VIRTUAL_KEY(173u16);
1718 pub const VK_VOLUME_DOWN: VIRTUAL_KEY = VIRTUAL_KEY(174u16);
1719 pub const VK_VOLUME_UP: VIRTUAL_KEY = VIRTUAL_KEY(175u16);
1720 pub const VK_MEDIA_NEXT_TRACK: VIRTUAL_KEY = VIRTUAL_KEY(176u16);
1721 pub const VK_MEDIA_PREV_TRACK: VIRTUAL_KEY = VIRTUAL_KEY(177u16);
1722 pub const VK_MEDIA_STOP: VIRTUAL_KEY = VIRTUAL_KEY(178u16);
1723 pub const VK_MEDIA_PLAY_PAUSE: VIRTUAL_KEY = VIRTUAL_KEY(179u16);
1724 pub const VK_LAUNCH_MAIL: VIRTUAL_KEY = VIRTUAL_KEY(180u16);
1725 pub const VK_LAUNCH_MEDIA_SELECT: VIRTUAL_KEY = VIRTUAL_KEY(181u16);
1726 pub const VK_LAUNCH_APP1: VIRTUAL_KEY = VIRTUAL_KEY(182u16);
1727 pub const VK_LAUNCH_APP2: VIRTUAL_KEY = VIRTUAL_KEY(183u16);
1728 pub const VK_OEM_1: VIRTUAL_KEY = VIRTUAL_KEY(186u16);
1729 pub const VK_OEM_PLUS: VIRTUAL_KEY = VIRTUAL_KEY(187u16);
1730 pub const VK_OEM_COMMA: VIRTUAL_KEY = VIRTUAL_KEY(188u16);
1731 pub const VK_OEM_MINUS: VIRTUAL_KEY = VIRTUAL_KEY(189u16);
1732 pub const VK_OEM_PERIOD: VIRTUAL_KEY = VIRTUAL_KEY(190u16);
1733 pub const VK_OEM_2: VIRTUAL_KEY = VIRTUAL_KEY(191u16);
1734 pub const VK_OEM_3: VIRTUAL_KEY = VIRTUAL_KEY(192u16);
1735 pub const VK_GAMEPAD_A: VIRTUAL_KEY = VIRTUAL_KEY(195u16);
1736 pub const VK_GAMEPAD_B: VIRTUAL_KEY = VIRTUAL_KEY(196u16);
1737 pub const VK_GAMEPAD_X: VIRTUAL_KEY = VIRTUAL_KEY(197u16);
1738 pub const VK_GAMEPAD_Y: VIRTUAL_KEY = VIRTUAL_KEY(198u16);
1739 pub const VK_GAMEPAD_RIGHT_SHOULDER: VIRTUAL_KEY = VIRTUAL_KEY(199u16);
1740 pub const VK_GAMEPAD_LEFT_SHOULDER: VIRTUAL_KEY = VIRTUAL_KEY(200u16);
1741 pub const VK_GAMEPAD_LEFT_TRIGGER: VIRTUAL_KEY = VIRTUAL_KEY(201u16);
1742 pub const VK_GAMEPAD_RIGHT_TRIGGER: VIRTUAL_KEY = VIRTUAL_KEY(202u16);
1743 pub const VK_GAMEPAD_DPAD_UP: VIRTUAL_KEY = VIRTUAL_KEY(203u16);
1744 pub const VK_GAMEPAD_DPAD_DOWN: VIRTUAL_KEY = VIRTUAL_KEY(204u16);
1745 pub const VK_GAMEPAD_DPAD_LEFT: VIRTUAL_KEY = VIRTUAL_KEY(205u16);
1746 pub const VK_GAMEPAD_DPAD_RIGHT: VIRTUAL_KEY = VIRTUAL_KEY(206u16);
1747 pub const VK_GAMEPAD_MENU: VIRTUAL_KEY = VIRTUAL_KEY(207u16);
1748 pub const VK_GAMEPAD_VIEW: VIRTUAL_KEY = VIRTUAL_KEY(208u16);
1749 pub const VK_GAMEPAD_LEFT_THUMBSTICK_BUTTON: VIRTUAL_KEY = VIRTUAL_KEY(209u16);
1750 pub const VK_GAMEPAD_RIGHT_THUMBSTICK_BUTTON: VIRTUAL_KEY = VIRTUAL_KEY(210u16);
1751 pub const VK_GAMEPAD_LEFT_THUMBSTICK_UP: VIRTUAL_KEY = VIRTUAL_KEY(211u16);
1752 pub const VK_GAMEPAD_LEFT_THUMBSTICK_DOWN: VIRTUAL_KEY = VIRTUAL_KEY(212u16);
1753 pub const VK_GAMEPAD_LEFT_THUMBSTICK_RIGHT: VIRTUAL_KEY = VIRTUAL_KEY(213u16);
1754 pub const VK_GAMEPAD_LEFT_THUMBSTICK_LEFT: VIRTUAL_KEY = VIRTUAL_KEY(214u16);
1755 pub const VK_GAMEPAD_RIGHT_THUMBSTICK_UP: VIRTUAL_KEY = VIRTUAL_KEY(215u16);
1756 pub const VK_GAMEPAD_RIGHT_THUMBSTICK_DOWN: VIRTUAL_KEY = VIRTUAL_KEY(216u16);
1757 pub const VK_GAMEPAD_RIGHT_THUMBSTICK_RIGHT: VIRTUAL_KEY = VIRTUAL_KEY(217u16);
1758 pub const VK_GAMEPAD_RIGHT_THUMBSTICK_LEFT: VIRTUAL_KEY = VIRTUAL_KEY(218u16);
1759 pub const VK_OEM_4: VIRTUAL_KEY = VIRTUAL_KEY(219u16);
1760 pub const VK_OEM_5: VIRTUAL_KEY = VIRTUAL_KEY(220u16);
1761 pub const VK_OEM_6: VIRTUAL_KEY = VIRTUAL_KEY(221u16);
1762 pub const VK_OEM_7: VIRTUAL_KEY = VIRTUAL_KEY(222u16);
1763 pub const VK_OEM_8: VIRTUAL_KEY = VIRTUAL_KEY(223u16);
1764 pub const VK_OEM_AX: VIRTUAL_KEY = VIRTUAL_KEY(225u16);
1765 pub const VK_OEM_102: VIRTUAL_KEY = VIRTUAL_KEY(226u16);
1766 pub const VK_ICO_HELP: VIRTUAL_KEY = VIRTUAL_KEY(227u16);
1767 pub const VK_ICO_00: VIRTUAL_KEY = VIRTUAL_KEY(228u16);
1768 pub const VK_PROCESSKEY: VIRTUAL_KEY = VIRTUAL_KEY(229u16);
1769 pub const VK_ICO_CLEAR: VIRTUAL_KEY = VIRTUAL_KEY(230u16);
1770 pub const VK_PACKET: VIRTUAL_KEY = VIRTUAL_KEY(231u16);
1771 pub const VK_OEM_RESET: VIRTUAL_KEY = VIRTUAL_KEY(233u16);
1772 pub const VK_OEM_JUMP: VIRTUAL_KEY = VIRTUAL_KEY(234u16);
1773 pub const VK_OEM_PA1: VIRTUAL_KEY = VIRTUAL_KEY(235u16);
1774 pub const VK_OEM_PA2: VIRTUAL_KEY = VIRTUAL_KEY(236u16);
1775 pub const VK_OEM_PA3: VIRTUAL_KEY = VIRTUAL_KEY(237u16);
1776 pub const VK_OEM_WSCTRL: VIRTUAL_KEY = VIRTUAL_KEY(238u16);
1777 pub const VK_OEM_CUSEL: VIRTUAL_KEY = VIRTUAL_KEY(239u16);
1778 pub const VK_OEM_ATTN: VIRTUAL_KEY = VIRTUAL_KEY(240u16);
1779 pub const VK_OEM_FINISH: VIRTUAL_KEY = VIRTUAL_KEY(241u16);
1780 pub const VK_OEM_COPY: VIRTUAL_KEY = VIRTUAL_KEY(242u16);
1781 pub const VK_OEM_AUTO: VIRTUAL_KEY = VIRTUAL_KEY(243u16);
1782 pub const VK_OEM_ENLW: VIRTUAL_KEY = VIRTUAL_KEY(244u16);
1783 pub const VK_OEM_BACKTAB: VIRTUAL_KEY = VIRTUAL_KEY(245u16);
1784 pub const VK_ATTN: VIRTUAL_KEY = VIRTUAL_KEY(246u16);
1785 pub const VK_CRSEL: VIRTUAL_KEY = VIRTUAL_KEY(247u16);
1786 pub const VK_EXSEL: VIRTUAL_KEY = VIRTUAL_KEY(248u16);
1787 pub const VK_EREOF: VIRTUAL_KEY = VIRTUAL_KEY(249u16);
1788 pub const VK_PLAY: VIRTUAL_KEY = VIRTUAL_KEY(250u16);
1789 pub const VK_ZOOM: VIRTUAL_KEY = VIRTUAL_KEY(251u16);
1790 pub const VK_NONAME: VIRTUAL_KEY = VIRTUAL_KEY(252u16);
1791 pub const VK_PA1: VIRTUAL_KEY = VIRTUAL_KEY(253u16);
1792 pub const VK_OEM_CLEAR: VIRTUAL_KEY = VIRTUAL_KEY(254u16);
1793 impl ::std::convert::From<u16> for VIRTUAL_KEY {
from(value: u16) -> Self1794 fn from(value: u16) -> Self {
1795 Self(value)
1796 }
1797 }
1798 unsafe impl ::windows::runtime::Abi for VIRTUAL_KEY {
1799 type Abi = Self;
1800 type DefaultType = Self;
1801 }
1802 pub const VK_ABNT_C1: u32 = 193u32;
1803 pub const VK_ABNT_C2: u32 = 194u32;
1804 pub const VK_DBE_ALPHANUMERIC: u32 = 240u32;
1805 pub const VK_DBE_CODEINPUT: u32 = 250u32;
1806 pub const VK_DBE_DBCSCHAR: u32 = 244u32;
1807 pub const VK_DBE_DETERMINESTRING: u32 = 252u32;
1808 pub const VK_DBE_ENTERDLGCONVERSIONMODE: u32 = 253u32;
1809 pub const VK_DBE_ENTERIMECONFIGMODE: u32 = 248u32;
1810 pub const VK_DBE_ENTERWORDREGISTERMODE: u32 = 247u32;
1811 pub const VK_DBE_FLUSHSTRING: u32 = 249u32;
1812 pub const VK_DBE_HIRAGANA: u32 = 242u32;
1813 pub const VK_DBE_KATAKANA: u32 = 241u32;
1814 pub const VK_DBE_NOCODEINPUT: u32 = 251u32;
1815 pub const VK_DBE_NOROMAN: u32 = 246u32;
1816 pub const VK_DBE_ROMAN: u32 = 245u32;
1817 pub const VK_DBE_SBCSCHAR: u32 = 243u32;
1818 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
1819 #[repr(C)]
1820 pub struct VK_TO_BIT {
1821 pub Vk: u8,
1822 pub ModBits: u8,
1823 }
1824 impl VK_TO_BIT {}
1825 impl ::std::default::Default for VK_TO_BIT {
default() -> Self1826 fn default() -> Self {
1827 unsafe { ::std::mem::zeroed() }
1828 }
1829 }
1830 impl ::std::fmt::Debug for VK_TO_BIT {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result1831 fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
1832 fmt.debug_struct("VK_TO_BIT").field("Vk", &self.Vk).field("ModBits", &self.ModBits).finish()
1833 }
1834 }
1835 impl ::std::cmp::PartialEq for VK_TO_BIT {
eq(&self, other: &Self) -> bool1836 fn eq(&self, other: &Self) -> bool {
1837 self.Vk == other.Vk && self.ModBits == other.ModBits
1838 }
1839 }
1840 impl ::std::cmp::Eq for VK_TO_BIT {}
1841 unsafe impl ::windows::runtime::Abi for VK_TO_BIT {
1842 type Abi = Self;
1843 type DefaultType = Self;
1844 }
1845 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
1846 #[repr(C)]
1847 pub struct VK_TO_WCHARS1 {
1848 pub VirtualKey: u8,
1849 pub Attributes: u8,
1850 pub wch: [u16; 1],
1851 }
1852 impl VK_TO_WCHARS1 {}
1853 impl ::std::default::Default for VK_TO_WCHARS1 {
default() -> Self1854 fn default() -> Self {
1855 unsafe { ::std::mem::zeroed() }
1856 }
1857 }
1858 impl ::std::fmt::Debug for VK_TO_WCHARS1 {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result1859 fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
1860 fmt.debug_struct("VK_TO_WCHARS1").field("VirtualKey", &self.VirtualKey).field("Attributes", &self.Attributes).field("wch", &self.wch).finish()
1861 }
1862 }
1863 impl ::std::cmp::PartialEq for VK_TO_WCHARS1 {
eq(&self, other: &Self) -> bool1864 fn eq(&self, other: &Self) -> bool {
1865 self.VirtualKey == other.VirtualKey && self.Attributes == other.Attributes && self.wch == other.wch
1866 }
1867 }
1868 impl ::std::cmp::Eq for VK_TO_WCHARS1 {}
1869 unsafe impl ::windows::runtime::Abi for VK_TO_WCHARS1 {
1870 type Abi = Self;
1871 type DefaultType = Self;
1872 }
1873 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
1874 #[repr(C)]
1875 pub struct VK_TO_WCHARS10 {
1876 pub VirtualKey: u8,
1877 pub Attributes: u8,
1878 pub wch: [u16; 10],
1879 }
1880 impl VK_TO_WCHARS10 {}
1881 impl ::std::default::Default for VK_TO_WCHARS10 {
default() -> Self1882 fn default() -> Self {
1883 unsafe { ::std::mem::zeroed() }
1884 }
1885 }
1886 impl ::std::fmt::Debug for VK_TO_WCHARS10 {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result1887 fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
1888 fmt.debug_struct("VK_TO_WCHARS10").field("VirtualKey", &self.VirtualKey).field("Attributes", &self.Attributes).field("wch", &self.wch).finish()
1889 }
1890 }
1891 impl ::std::cmp::PartialEq for VK_TO_WCHARS10 {
eq(&self, other: &Self) -> bool1892 fn eq(&self, other: &Self) -> bool {
1893 self.VirtualKey == other.VirtualKey && self.Attributes == other.Attributes && self.wch == other.wch
1894 }
1895 }
1896 impl ::std::cmp::Eq for VK_TO_WCHARS10 {}
1897 unsafe impl ::windows::runtime::Abi for VK_TO_WCHARS10 {
1898 type Abi = Self;
1899 type DefaultType = Self;
1900 }
1901 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
1902 #[repr(C)]
1903 pub struct VK_TO_WCHARS2 {
1904 pub VirtualKey: u8,
1905 pub Attributes: u8,
1906 pub wch: [u16; 2],
1907 }
1908 impl VK_TO_WCHARS2 {}
1909 impl ::std::default::Default for VK_TO_WCHARS2 {
default() -> Self1910 fn default() -> Self {
1911 unsafe { ::std::mem::zeroed() }
1912 }
1913 }
1914 impl ::std::fmt::Debug for VK_TO_WCHARS2 {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result1915 fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
1916 fmt.debug_struct("VK_TO_WCHARS2").field("VirtualKey", &self.VirtualKey).field("Attributes", &self.Attributes).field("wch", &self.wch).finish()
1917 }
1918 }
1919 impl ::std::cmp::PartialEq for VK_TO_WCHARS2 {
eq(&self, other: &Self) -> bool1920 fn eq(&self, other: &Self) -> bool {
1921 self.VirtualKey == other.VirtualKey && self.Attributes == other.Attributes && self.wch == other.wch
1922 }
1923 }
1924 impl ::std::cmp::Eq for VK_TO_WCHARS2 {}
1925 unsafe impl ::windows::runtime::Abi for VK_TO_WCHARS2 {
1926 type Abi = Self;
1927 type DefaultType = Self;
1928 }
1929 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
1930 #[repr(C)]
1931 pub struct VK_TO_WCHARS3 {
1932 pub VirtualKey: u8,
1933 pub Attributes: u8,
1934 pub wch: [u16; 3],
1935 }
1936 impl VK_TO_WCHARS3 {}
1937 impl ::std::default::Default for VK_TO_WCHARS3 {
default() -> Self1938 fn default() -> Self {
1939 unsafe { ::std::mem::zeroed() }
1940 }
1941 }
1942 impl ::std::fmt::Debug for VK_TO_WCHARS3 {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result1943 fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
1944 fmt.debug_struct("VK_TO_WCHARS3").field("VirtualKey", &self.VirtualKey).field("Attributes", &self.Attributes).field("wch", &self.wch).finish()
1945 }
1946 }
1947 impl ::std::cmp::PartialEq for VK_TO_WCHARS3 {
eq(&self, other: &Self) -> bool1948 fn eq(&self, other: &Self) -> bool {
1949 self.VirtualKey == other.VirtualKey && self.Attributes == other.Attributes && self.wch == other.wch
1950 }
1951 }
1952 impl ::std::cmp::Eq for VK_TO_WCHARS3 {}
1953 unsafe impl ::windows::runtime::Abi for VK_TO_WCHARS3 {
1954 type Abi = Self;
1955 type DefaultType = Self;
1956 }
1957 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
1958 #[repr(C)]
1959 pub struct VK_TO_WCHARS4 {
1960 pub VirtualKey: u8,
1961 pub Attributes: u8,
1962 pub wch: [u16; 4],
1963 }
1964 impl VK_TO_WCHARS4 {}
1965 impl ::std::default::Default for VK_TO_WCHARS4 {
default() -> Self1966 fn default() -> Self {
1967 unsafe { ::std::mem::zeroed() }
1968 }
1969 }
1970 impl ::std::fmt::Debug for VK_TO_WCHARS4 {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result1971 fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
1972 fmt.debug_struct("VK_TO_WCHARS4").field("VirtualKey", &self.VirtualKey).field("Attributes", &self.Attributes).field("wch", &self.wch).finish()
1973 }
1974 }
1975 impl ::std::cmp::PartialEq for VK_TO_WCHARS4 {
eq(&self, other: &Self) -> bool1976 fn eq(&self, other: &Self) -> bool {
1977 self.VirtualKey == other.VirtualKey && self.Attributes == other.Attributes && self.wch == other.wch
1978 }
1979 }
1980 impl ::std::cmp::Eq for VK_TO_WCHARS4 {}
1981 unsafe impl ::windows::runtime::Abi for VK_TO_WCHARS4 {
1982 type Abi = Self;
1983 type DefaultType = Self;
1984 }
1985 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
1986 #[repr(C)]
1987 pub struct VK_TO_WCHARS5 {
1988 pub VirtualKey: u8,
1989 pub Attributes: u8,
1990 pub wch: [u16; 5],
1991 }
1992 impl VK_TO_WCHARS5 {}
1993 impl ::std::default::Default for VK_TO_WCHARS5 {
default() -> Self1994 fn default() -> Self {
1995 unsafe { ::std::mem::zeroed() }
1996 }
1997 }
1998 impl ::std::fmt::Debug for VK_TO_WCHARS5 {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result1999 fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
2000 fmt.debug_struct("VK_TO_WCHARS5").field("VirtualKey", &self.VirtualKey).field("Attributes", &self.Attributes).field("wch", &self.wch).finish()
2001 }
2002 }
2003 impl ::std::cmp::PartialEq for VK_TO_WCHARS5 {
eq(&self, other: &Self) -> bool2004 fn eq(&self, other: &Self) -> bool {
2005 self.VirtualKey == other.VirtualKey && self.Attributes == other.Attributes && self.wch == other.wch
2006 }
2007 }
2008 impl ::std::cmp::Eq for VK_TO_WCHARS5 {}
2009 unsafe impl ::windows::runtime::Abi for VK_TO_WCHARS5 {
2010 type Abi = Self;
2011 type DefaultType = Self;
2012 }
2013 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
2014 #[repr(C)]
2015 pub struct VK_TO_WCHARS6 {
2016 pub VirtualKey: u8,
2017 pub Attributes: u8,
2018 pub wch: [u16; 6],
2019 }
2020 impl VK_TO_WCHARS6 {}
2021 impl ::std::default::Default for VK_TO_WCHARS6 {
default() -> Self2022 fn default() -> Self {
2023 unsafe { ::std::mem::zeroed() }
2024 }
2025 }
2026 impl ::std::fmt::Debug for VK_TO_WCHARS6 {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result2027 fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
2028 fmt.debug_struct("VK_TO_WCHARS6").field("VirtualKey", &self.VirtualKey).field("Attributes", &self.Attributes).field("wch", &self.wch).finish()
2029 }
2030 }
2031 impl ::std::cmp::PartialEq for VK_TO_WCHARS6 {
eq(&self, other: &Self) -> bool2032 fn eq(&self, other: &Self) -> bool {
2033 self.VirtualKey == other.VirtualKey && self.Attributes == other.Attributes && self.wch == other.wch
2034 }
2035 }
2036 impl ::std::cmp::Eq for VK_TO_WCHARS6 {}
2037 unsafe impl ::windows::runtime::Abi for VK_TO_WCHARS6 {
2038 type Abi = Self;
2039 type DefaultType = Self;
2040 }
2041 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
2042 #[repr(C)]
2043 pub struct VK_TO_WCHARS7 {
2044 pub VirtualKey: u8,
2045 pub Attributes: u8,
2046 pub wch: [u16; 7],
2047 }
2048 impl VK_TO_WCHARS7 {}
2049 impl ::std::default::Default for VK_TO_WCHARS7 {
default() -> Self2050 fn default() -> Self {
2051 unsafe { ::std::mem::zeroed() }
2052 }
2053 }
2054 impl ::std::fmt::Debug for VK_TO_WCHARS7 {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result2055 fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
2056 fmt.debug_struct("VK_TO_WCHARS7").field("VirtualKey", &self.VirtualKey).field("Attributes", &self.Attributes).field("wch", &self.wch).finish()
2057 }
2058 }
2059 impl ::std::cmp::PartialEq for VK_TO_WCHARS7 {
eq(&self, other: &Self) -> bool2060 fn eq(&self, other: &Self) -> bool {
2061 self.VirtualKey == other.VirtualKey && self.Attributes == other.Attributes && self.wch == other.wch
2062 }
2063 }
2064 impl ::std::cmp::Eq for VK_TO_WCHARS7 {}
2065 unsafe impl ::windows::runtime::Abi for VK_TO_WCHARS7 {
2066 type Abi = Self;
2067 type DefaultType = Self;
2068 }
2069 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
2070 #[repr(C)]
2071 pub struct VK_TO_WCHARS8 {
2072 pub VirtualKey: u8,
2073 pub Attributes: u8,
2074 pub wch: [u16; 8],
2075 }
2076 impl VK_TO_WCHARS8 {}
2077 impl ::std::default::Default for VK_TO_WCHARS8 {
default() -> Self2078 fn default() -> Self {
2079 unsafe { ::std::mem::zeroed() }
2080 }
2081 }
2082 impl ::std::fmt::Debug for VK_TO_WCHARS8 {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result2083 fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
2084 fmt.debug_struct("VK_TO_WCHARS8").field("VirtualKey", &self.VirtualKey).field("Attributes", &self.Attributes).field("wch", &self.wch).finish()
2085 }
2086 }
2087 impl ::std::cmp::PartialEq for VK_TO_WCHARS8 {
eq(&self, other: &Self) -> bool2088 fn eq(&self, other: &Self) -> bool {
2089 self.VirtualKey == other.VirtualKey && self.Attributes == other.Attributes && self.wch == other.wch
2090 }
2091 }
2092 impl ::std::cmp::Eq for VK_TO_WCHARS8 {}
2093 unsafe impl ::windows::runtime::Abi for VK_TO_WCHARS8 {
2094 type Abi = Self;
2095 type DefaultType = Self;
2096 }
2097 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
2098 #[repr(C)]
2099 pub struct VK_TO_WCHARS9 {
2100 pub VirtualKey: u8,
2101 pub Attributes: u8,
2102 pub wch: [u16; 9],
2103 }
2104 impl VK_TO_WCHARS9 {}
2105 impl ::std::default::Default for VK_TO_WCHARS9 {
default() -> Self2106 fn default() -> Self {
2107 unsafe { ::std::mem::zeroed() }
2108 }
2109 }
2110 impl ::std::fmt::Debug for VK_TO_WCHARS9 {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result2111 fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
2112 fmt.debug_struct("VK_TO_WCHARS9").field("VirtualKey", &self.VirtualKey).field("Attributes", &self.Attributes).field("wch", &self.wch).finish()
2113 }
2114 }
2115 impl ::std::cmp::PartialEq for VK_TO_WCHARS9 {
eq(&self, other: &Self) -> bool2116 fn eq(&self, other: &Self) -> bool {
2117 self.VirtualKey == other.VirtualKey && self.Attributes == other.Attributes && self.wch == other.wch
2118 }
2119 }
2120 impl ::std::cmp::Eq for VK_TO_WCHARS9 {}
2121 unsafe impl ::windows::runtime::Abi for VK_TO_WCHARS9 {
2122 type Abi = Self;
2123 type DefaultType = Self;
2124 }
2125 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
2126 #[repr(C)]
2127 pub struct VK_TO_WCHAR_TABLE {
2128 pub pVkToWchars: *mut VK_TO_WCHARS1,
2129 pub nModifications: u8,
2130 pub cbSize: u8,
2131 }
2132 impl VK_TO_WCHAR_TABLE {}
2133 impl ::std::default::Default for VK_TO_WCHAR_TABLE {
default() -> Self2134 fn default() -> Self {
2135 unsafe { ::std::mem::zeroed() }
2136 }
2137 }
2138 impl ::std::fmt::Debug for VK_TO_WCHAR_TABLE {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result2139 fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
2140 fmt.debug_struct("VK_TO_WCHAR_TABLE").field("pVkToWchars", &self.pVkToWchars).field("nModifications", &self.nModifications).field("cbSize", &self.cbSize).finish()
2141 }
2142 }
2143 impl ::std::cmp::PartialEq for VK_TO_WCHAR_TABLE {
eq(&self, other: &Self) -> bool2144 fn eq(&self, other: &Self) -> bool {
2145 self.pVkToWchars == other.pVkToWchars && self.nModifications == other.nModifications && self.cbSize == other.cbSize
2146 }
2147 }
2148 impl ::std::cmp::Eq for VK_TO_WCHAR_TABLE {}
2149 unsafe impl ::windows::runtime::Abi for VK_TO_WCHAR_TABLE {
2150 type Abi = Self;
2151 type DefaultType = Self;
2152 }
2153 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
2154 #[repr(C)]
2155 pub struct VK_VSC {
2156 pub Vk: u8,
2157 pub Vsc: u8,
2158 }
2159 impl VK_VSC {}
2160 impl ::std::default::Default for VK_VSC {
default() -> Self2161 fn default() -> Self {
2162 unsafe { ::std::mem::zeroed() }
2163 }
2164 }
2165 impl ::std::fmt::Debug for VK_VSC {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result2166 fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
2167 fmt.debug_struct("VK_VSC").field("Vk", &self.Vk).field("Vsc", &self.Vsc).finish()
2168 }
2169 }
2170 impl ::std::cmp::PartialEq for VK_VSC {
eq(&self, other: &Self) -> bool2171 fn eq(&self, other: &Self) -> bool {
2172 self.Vk == other.Vk && self.Vsc == other.Vsc
2173 }
2174 }
2175 impl ::std::cmp::Eq for VK_VSC {}
2176 unsafe impl ::windows::runtime::Abi for VK_VSC {
2177 type Abi = Self;
2178 type DefaultType = Self;
2179 }
2180 pub const VK__none_: u32 = 255u32;
2181 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
2182 #[repr(C)]
2183 #[cfg(feature = "Win32_Foundation")]
2184 pub struct VSC_LPWSTR {
2185 pub vsc: u8,
2186 pub pwsz: super::super::super::Foundation::PWSTR,
2187 }
2188 #[cfg(feature = "Win32_Foundation")]
2189 impl VSC_LPWSTR {}
2190 #[cfg(feature = "Win32_Foundation")]
2191 impl ::std::default::Default for VSC_LPWSTR {
default() -> Self2192 fn default() -> Self {
2193 unsafe { ::std::mem::zeroed() }
2194 }
2195 }
2196 #[cfg(feature = "Win32_Foundation")]
2197 impl ::std::fmt::Debug for VSC_LPWSTR {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result2198 fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
2199 fmt.debug_struct("VSC_LPWSTR").field("vsc", &self.vsc).field("pwsz", &self.pwsz).finish()
2200 }
2201 }
2202 #[cfg(feature = "Win32_Foundation")]
2203 impl ::std::cmp::PartialEq for VSC_LPWSTR {
eq(&self, other: &Self) -> bool2204 fn eq(&self, other: &Self) -> bool {
2205 self.vsc == other.vsc && self.pwsz == other.pwsz
2206 }
2207 }
2208 #[cfg(feature = "Win32_Foundation")]
2209 impl ::std::cmp::Eq for VSC_LPWSTR {}
2210 #[cfg(feature = "Win32_Foundation")]
2211 unsafe impl ::windows::runtime::Abi for VSC_LPWSTR {
2212 type Abi = Self;
2213 type DefaultType = Self;
2214 }
2215 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
2216 #[repr(C)]
2217 pub struct VSC_VK {
2218 pub Vsc: u8,
2219 pub Vk: u16,
2220 }
2221 impl VSC_VK {}
2222 impl ::std::default::Default for VSC_VK {
default() -> Self2223 fn default() -> Self {
2224 unsafe { ::std::mem::zeroed() }
2225 }
2226 }
2227 impl ::std::fmt::Debug for VSC_VK {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result2228 fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
2229 fmt.debug_struct("VSC_VK").field("Vsc", &self.Vsc).field("Vk", &self.Vk).finish()
2230 }
2231 }
2232 impl ::std::cmp::PartialEq for VSC_VK {
eq(&self, other: &Self) -> bool2233 fn eq(&self, other: &Self) -> bool {
2234 self.Vsc == other.Vsc && self.Vk == other.Vk
2235 }
2236 }
2237 impl ::std::cmp::Eq for VSC_VK {}
2238 unsafe impl ::windows::runtime::Abi for VSC_VK {
2239 type Abi = Self;
2240 type DefaultType = Self;
2241 }
2242 #[cfg(feature = "Win32_Foundation")]
2243 #[inline]
VkKeyScanA<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::super::Foundation::CHAR>>(ch: Param0) -> i162244 pub unsafe fn VkKeyScanA<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::super::Foundation::CHAR>>(ch: Param0) -> i16 {
2245 #[cfg(windows)]
2246 {
2247 #[link(name = "windows")]
2248 extern "system" {
2249 fn VkKeyScanA(ch: super::super::super::Foundation::CHAR) -> i16;
2250 }
2251 ::std::mem::transmute(VkKeyScanA(ch.into_param().abi()))
2252 }
2253 #[cfg(not(windows))]
2254 unimplemented!("Unsupported target OS");
2255 }
2256 #[cfg(all(feature = "Win32_Foundation", feature = "Win32_UI_TextServices"))]
2257 #[inline]
VkKeyScanExA<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::super::Foundation::CHAR>, Param1: ::windows::runtime::IntoParam<'a, super::super::TextServices::HKL>>(ch: Param0, dwhkl: Param1) -> i162258 pub unsafe fn VkKeyScanExA<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::super::Foundation::CHAR>, Param1: ::windows::runtime::IntoParam<'a, super::super::TextServices::HKL>>(ch: Param0, dwhkl: Param1) -> i16 {
2259 #[cfg(windows)]
2260 {
2261 #[link(name = "windows")]
2262 extern "system" {
2263 fn VkKeyScanExA(ch: super::super::super::Foundation::CHAR, dwhkl: super::super::TextServices::HKL) -> i16;
2264 }
2265 ::std::mem::transmute(VkKeyScanExA(ch.into_param().abi(), dwhkl.into_param().abi()))
2266 }
2267 #[cfg(not(windows))]
2268 unimplemented!("Unsupported target OS");
2269 }
2270 #[cfg(feature = "Win32_UI_TextServices")]
2271 #[inline]
VkKeyScanExW<'a, Param1: ::windows::runtime::IntoParam<'a, super::super::TextServices::HKL>>(ch: u16, dwhkl: Param1) -> i162272 pub unsafe fn VkKeyScanExW<'a, Param1: ::windows::runtime::IntoParam<'a, super::super::TextServices::HKL>>(ch: u16, dwhkl: Param1) -> i16 {
2273 #[cfg(windows)]
2274 {
2275 #[link(name = "windows")]
2276 extern "system" {
2277 fn VkKeyScanExW(ch: u16, dwhkl: super::super::TextServices::HKL) -> i16;
2278 }
2279 ::std::mem::transmute(VkKeyScanExW(::std::mem::transmute(ch), dwhkl.into_param().abi()))
2280 }
2281 #[cfg(not(windows))]
2282 unimplemented!("Unsupported target OS");
2283 }
2284 #[inline]
VkKeyScanW(ch: u16) -> i162285 pub unsafe fn VkKeyScanW(ch: u16) -> i16 {
2286 #[cfg(windows)]
2287 {
2288 #[link(name = "windows")]
2289 extern "system" {
2290 fn VkKeyScanW(ch: u16) -> i16;
2291 }
2292 ::std::mem::transmute(VkKeyScanW(::std::mem::transmute(ch)))
2293 }
2294 #[cfg(not(windows))]
2295 unimplemented!("Unsupported target OS");
2296 }
2297 pub const WCH_DEAD: u32 = 61441u32;
2298 pub const WCH_LGTR: u32 = 61442u32;
2299 pub const WCH_NONE: u32 = 61440u32;
2300 #[cfg(feature = "Win32_Foundation")]
2301 #[inline]
_TrackMouseEvent(lpeventtrack: *mut TRACKMOUSEEVENT) -> super::super::super::Foundation::BOOL2302 pub unsafe fn _TrackMouseEvent(lpeventtrack: *mut TRACKMOUSEEVENT) -> super::super::super::Foundation::BOOL {
2303 #[cfg(windows)]
2304 {
2305 #[link(name = "windows")]
2306 extern "system" {
2307 fn _TrackMouseEvent(lpeventtrack: *mut TRACKMOUSEEVENT) -> super::super::super::Foundation::BOOL;
2308 }
2309 ::std::mem::transmute(_TrackMouseEvent(::std::mem::transmute(lpeventtrack)))
2310 }
2311 #[cfg(not(windows))]
2312 unimplemented!("Unsupported target OS");
2313 }
2314 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
2315 #[repr(C)]
2316 pub struct _VK_FUNCTION_PARAM {
2317 pub NLSFEProcIndex: u8,
2318 pub NLSFEProcParam: u32,
2319 }
2320 impl _VK_FUNCTION_PARAM {}
2321 impl ::std::default::Default for _VK_FUNCTION_PARAM {
default() -> Self2322 fn default() -> Self {
2323 unsafe { ::std::mem::zeroed() }
2324 }
2325 }
2326 impl ::std::fmt::Debug for _VK_FUNCTION_PARAM {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result2327 fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
2328 fmt.debug_struct("_VK_FUNCTION_PARAM").field("NLSFEProcIndex", &self.NLSFEProcIndex).field("NLSFEProcParam", &self.NLSFEProcParam).finish()
2329 }
2330 }
2331 impl ::std::cmp::PartialEq for _VK_FUNCTION_PARAM {
eq(&self, other: &Self) -> bool2332 fn eq(&self, other: &Self) -> bool {
2333 self.NLSFEProcIndex == other.NLSFEProcIndex && self.NLSFEProcParam == other.NLSFEProcParam
2334 }
2335 }
2336 impl ::std::cmp::Eq for _VK_FUNCTION_PARAM {}
2337 unsafe impl ::windows::runtime::Abi for _VK_FUNCTION_PARAM {
2338 type Abi = Self;
2339 type DefaultType = Self;
2340 }
2341 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
2342 #[repr(C)]
2343 pub struct _VK_TO_FUNCTION_TABLE {
2344 pub Vk: u8,
2345 pub NLSFEProcType: u8,
2346 pub NLSFEProcCurrent: u8,
2347 pub NLSFEProcSwitch: u8,
2348 pub NLSFEProc: [_VK_FUNCTION_PARAM; 8],
2349 pub NLSFEProcAlt: [_VK_FUNCTION_PARAM; 8],
2350 }
2351 impl _VK_TO_FUNCTION_TABLE {}
2352 impl ::std::default::Default for _VK_TO_FUNCTION_TABLE {
default() -> Self2353 fn default() -> Self {
2354 unsafe { ::std::mem::zeroed() }
2355 }
2356 }
2357 impl ::std::fmt::Debug for _VK_TO_FUNCTION_TABLE {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result2358 fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
2359 fmt.debug_struct("_VK_TO_FUNCTION_TABLE").field("Vk", &self.Vk).field("NLSFEProcType", &self.NLSFEProcType).field("NLSFEProcCurrent", &self.NLSFEProcCurrent).field("NLSFEProcSwitch", &self.NLSFEProcSwitch).field("NLSFEProc", &self.NLSFEProc).field("NLSFEProcAlt", &self.NLSFEProcAlt).finish()
2360 }
2361 }
2362 impl ::std::cmp::PartialEq for _VK_TO_FUNCTION_TABLE {
eq(&self, other: &Self) -> bool2363 fn eq(&self, other: &Self) -> bool {
2364 self.Vk == other.Vk && self.NLSFEProcType == other.NLSFEProcType && self.NLSFEProcCurrent == other.NLSFEProcCurrent && self.NLSFEProcSwitch == other.NLSFEProcSwitch && self.NLSFEProc == other.NLSFEProc && self.NLSFEProcAlt == other.NLSFEProcAlt
2365 }
2366 }
2367 impl ::std::cmp::Eq for _VK_TO_FUNCTION_TABLE {}
2368 unsafe impl ::windows::runtime::Abi for _VK_TO_FUNCTION_TABLE {
2369 type Abi = Self;
2370 type DefaultType = Self;
2371 }
2372 #[inline]
keybd_event(bvk: u8, bscan: u8, dwflags: KEYBD_EVENT_FLAGS, dwextrainfo: usize)2373 pub unsafe fn keybd_event(bvk: u8, bscan: u8, dwflags: KEYBD_EVENT_FLAGS, dwextrainfo: usize) {
2374 #[cfg(windows)]
2375 {
2376 #[link(name = "windows")]
2377 extern "system" {
2378 fn keybd_event(bvk: u8, bscan: u8, dwflags: KEYBD_EVENT_FLAGS, dwextrainfo: usize);
2379 }
2380 ::std::mem::transmute(keybd_event(::std::mem::transmute(bvk), ::std::mem::transmute(bscan), ::std::mem::transmute(dwflags), ::std::mem::transmute(dwextrainfo)))
2381 }
2382 #[cfg(not(windows))]
2383 unimplemented!("Unsupported target OS");
2384 }
2385 #[inline]
mouse_event(dwflags: MOUSE_EVENT_FLAGS, dx: i32, dy: i32, dwdata: u32, dwextrainfo: usize)2386 pub unsafe fn mouse_event(dwflags: MOUSE_EVENT_FLAGS, dx: i32, dy: i32, dwdata: u32, dwextrainfo: usize) {
2387 #[cfg(windows)]
2388 {
2389 #[link(name = "windows")]
2390 extern "system" {
2391 fn mouse_event(dwflags: MOUSE_EVENT_FLAGS, dx: i32, dy: i32, dwdata: u32, dwextrainfo: usize);
2392 }
2393 ::std::mem::transmute(mouse_event(::std::mem::transmute(dwflags), ::std::mem::transmute(dx), ::std::mem::transmute(dy), ::std::mem::transmute(dwdata), ::std::mem::transmute(dwextrainfo)))
2394 }
2395 #[cfg(not(windows))]
2396 unimplemented!("Unsupported target OS");
2397 }
2398 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
2399 #[repr(C)]
2400 #[cfg(feature = "Win32_Foundation")]
2401 pub struct tagKbdLayer {
2402 pub pCharModifiers: *mut MODIFIERS,
2403 pub pVkToWcharTable: *mut VK_TO_WCHAR_TABLE,
2404 pub pDeadKey: *mut DEADKEY,
2405 pub pKeyNames: *mut VSC_LPWSTR,
2406 pub pKeyNamesExt: *mut VSC_LPWSTR,
2407 pub pKeyNamesDead: *mut *mut u16,
2408 pub pusVSCtoVK: *mut u16,
2409 pub bMaxVSCtoVK: u8,
2410 pub pVSCtoVK_E0: *mut VSC_VK,
2411 pub pVSCtoVK_E1: *mut VSC_VK,
2412 pub fLocaleFlags: u32,
2413 pub nLgMax: u8,
2414 pub cbLgEntry: u8,
2415 pub pLigature: *mut LIGATURE1,
2416 pub dwType: u32,
2417 pub dwSubType: u32,
2418 }
2419 #[cfg(feature = "Win32_Foundation")]
2420 impl tagKbdLayer {}
2421 #[cfg(feature = "Win32_Foundation")]
2422 impl ::std::default::Default for tagKbdLayer {
default() -> Self2423 fn default() -> Self {
2424 unsafe { ::std::mem::zeroed() }
2425 }
2426 }
2427 #[cfg(feature = "Win32_Foundation")]
2428 impl ::std::fmt::Debug for tagKbdLayer {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result2429 fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
2430 fmt.debug_struct("tagKbdLayer")
2431 .field("pCharModifiers", &self.pCharModifiers)
2432 .field("pVkToWcharTable", &self.pVkToWcharTable)
2433 .field("pDeadKey", &self.pDeadKey)
2434 .field("pKeyNames", &self.pKeyNames)
2435 .field("pKeyNamesExt", &self.pKeyNamesExt)
2436 .field("pKeyNamesDead", &self.pKeyNamesDead)
2437 .field("pusVSCtoVK", &self.pusVSCtoVK)
2438 .field("bMaxVSCtoVK", &self.bMaxVSCtoVK)
2439 .field("pVSCtoVK_E0", &self.pVSCtoVK_E0)
2440 .field("pVSCtoVK_E1", &self.pVSCtoVK_E1)
2441 .field("fLocaleFlags", &self.fLocaleFlags)
2442 .field("nLgMax", &self.nLgMax)
2443 .field("cbLgEntry", &self.cbLgEntry)
2444 .field("pLigature", &self.pLigature)
2445 .field("dwType", &self.dwType)
2446 .field("dwSubType", &self.dwSubType)
2447 .finish()
2448 }
2449 }
2450 #[cfg(feature = "Win32_Foundation")]
2451 impl ::std::cmp::PartialEq for tagKbdLayer {
eq(&self, other: &Self) -> bool2452 fn eq(&self, other: &Self) -> bool {
2453 self.pCharModifiers == other.pCharModifiers
2454 && self.pVkToWcharTable == other.pVkToWcharTable
2455 && self.pDeadKey == other.pDeadKey
2456 && self.pKeyNames == other.pKeyNames
2457 && self.pKeyNamesExt == other.pKeyNamesExt
2458 && self.pKeyNamesDead == other.pKeyNamesDead
2459 && self.pusVSCtoVK == other.pusVSCtoVK
2460 && self.bMaxVSCtoVK == other.bMaxVSCtoVK
2461 && self.pVSCtoVK_E0 == other.pVSCtoVK_E0
2462 && self.pVSCtoVK_E1 == other.pVSCtoVK_E1
2463 && self.fLocaleFlags == other.fLocaleFlags
2464 && self.nLgMax == other.nLgMax
2465 && self.cbLgEntry == other.cbLgEntry
2466 && self.pLigature == other.pLigature
2467 && self.dwType == other.dwType
2468 && self.dwSubType == other.dwSubType
2469 }
2470 }
2471 #[cfg(feature = "Win32_Foundation")]
2472 impl ::std::cmp::Eq for tagKbdLayer {}
2473 #[cfg(feature = "Win32_Foundation")]
2474 unsafe impl ::windows::runtime::Abi for tagKbdLayer {
2475 type Abi = Self;
2476 type DefaultType = Self;
2477 }
2478 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
2479 #[repr(C)]
2480 pub struct tagKbdNlsLayer {
2481 pub OEMIdentifier: u16,
2482 pub LayoutInformation: u16,
2483 pub NumOfVkToF: u32,
2484 pub pVkToF: *mut _VK_TO_FUNCTION_TABLE,
2485 pub NumOfMouseVKey: i32,
2486 pub pusMouseVKey: *mut u16,
2487 }
2488 impl tagKbdNlsLayer {}
2489 impl ::std::default::Default for tagKbdNlsLayer {
default() -> Self2490 fn default() -> Self {
2491 unsafe { ::std::mem::zeroed() }
2492 }
2493 }
2494 impl ::std::fmt::Debug for tagKbdNlsLayer {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result2495 fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
2496 fmt.debug_struct("tagKbdNlsLayer").field("OEMIdentifier", &self.OEMIdentifier).field("LayoutInformation", &self.LayoutInformation).field("NumOfVkToF", &self.NumOfVkToF).field("pVkToF", &self.pVkToF).field("NumOfMouseVKey", &self.NumOfMouseVKey).field("pusMouseVKey", &self.pusMouseVKey).finish()
2497 }
2498 }
2499 impl ::std::cmp::PartialEq for tagKbdNlsLayer {
eq(&self, other: &Self) -> bool2500 fn eq(&self, other: &Self) -> bool {
2501 self.OEMIdentifier == other.OEMIdentifier && self.LayoutInformation == other.LayoutInformation && self.NumOfVkToF == other.NumOfVkToF && self.pVkToF == other.pVkToF && self.NumOfMouseVKey == other.NumOfMouseVKey && self.pusMouseVKey == other.pusMouseVKey
2502 }
2503 }
2504 impl ::std::cmp::Eq for tagKbdNlsLayer {}
2505 unsafe impl ::windows::runtime::Abi for tagKbdNlsLayer {
2506 type Abi = Self;
2507 type DefaultType = Self;
2508 }
2509