1 #![allow(unused_variables, non_upper_case_globals, non_snake_case, unused_unsafe, non_camel_case_types, dead_code, clippy::all)]
2 pub const ALTNUMPAD_BIT: u32 = 67108864u32;
3 pub const ATTACH_PARENT_PROCESS: u32 = 4294967295u32;
4 #[cfg(feature = "Win32_Foundation")]
5 #[inline]
AddConsoleAliasA<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::PSTR>, Param1: ::windows::runtime::IntoParam<'a, super::super::Foundation::PSTR>, Param2: ::windows::runtime::IntoParam<'a, super::super::Foundation::PSTR>>(source: Param0, target: Param1, exename: Param2) -> super::super::Foundation::BOOL6 pub unsafe fn AddConsoleAliasA<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::PSTR>, Param1: ::windows::runtime::IntoParam<'a, super::super::Foundation::PSTR>, Param2: ::windows::runtime::IntoParam<'a, super::super::Foundation::PSTR>>(source: Param0, target: Param1, exename: Param2) -> super::super::Foundation::BOOL {
7 #[cfg(windows)]
8 {
9 #[link(name = "windows")]
10 extern "system" {
11 fn AddConsoleAliasA(source: super::super::Foundation::PSTR, target: super::super::Foundation::PSTR, exename: super::super::Foundation::PSTR) -> super::super::Foundation::BOOL;
12 }
13 ::std::mem::transmute(AddConsoleAliasA(source.into_param().abi(), target.into_param().abi(), exename.into_param().abi()))
14 }
15 #[cfg(not(windows))]
16 unimplemented!("Unsupported target OS");
17 }
18 #[cfg(feature = "Win32_Foundation")]
19 #[inline]
AddConsoleAliasW<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>, Param1: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>, Param2: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>>(source: Param0, target: Param1, exename: Param2) -> super::super::Foundation::BOOL20 pub unsafe fn AddConsoleAliasW<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>, Param1: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>, Param2: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>>(source: Param0, target: Param1, exename: Param2) -> super::super::Foundation::BOOL {
21 #[cfg(windows)]
22 {
23 #[link(name = "windows")]
24 extern "system" {
25 fn AddConsoleAliasW(source: super::super::Foundation::PWSTR, target: super::super::Foundation::PWSTR, exename: super::super::Foundation::PWSTR) -> super::super::Foundation::BOOL;
26 }
27 ::std::mem::transmute(AddConsoleAliasW(source.into_param().abi(), target.into_param().abi(), exename.into_param().abi()))
28 }
29 #[cfg(not(windows))]
30 unimplemented!("Unsupported target OS");
31 }
32 #[cfg(feature = "Win32_Foundation")]
33 #[inline]
AllocConsole() -> super::super::Foundation::BOOL34 pub unsafe fn AllocConsole() -> super::super::Foundation::BOOL {
35 #[cfg(windows)]
36 {
37 #[link(name = "windows")]
38 extern "system" {
39 fn AllocConsole() -> super::super::Foundation::BOOL;
40 }
41 ::std::mem::transmute(AllocConsole())
42 }
43 #[cfg(not(windows))]
44 unimplemented!("Unsupported target OS");
45 }
46 #[cfg(feature = "Win32_Foundation")]
47 #[inline]
AttachConsole(dwprocessid: u32) -> super::super::Foundation::BOOL48 pub unsafe fn AttachConsole(dwprocessid: u32) -> super::super::Foundation::BOOL {
49 #[cfg(windows)]
50 {
51 #[link(name = "windows")]
52 extern "system" {
53 fn AttachConsole(dwprocessid: u32) -> super::super::Foundation::BOOL;
54 }
55 ::std::mem::transmute(AttachConsole(::std::mem::transmute(dwprocessid)))
56 }
57 #[cfg(not(windows))]
58 unimplemented!("Unsupported target OS");
59 }
60 pub const BACKGROUND_BLUE: u32 = 16u32;
61 pub const BACKGROUND_GREEN: u32 = 32u32;
62 pub const BACKGROUND_INTENSITY: u32 = 128u32;
63 pub const BACKGROUND_RED: u32 = 64u32;
64 pub const CAPSLOCK_ON: u32 = 128u32;
65 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
66 #[repr(C)]
67 #[cfg(feature = "Win32_Foundation")]
68 pub struct CHAR_INFO {
69 pub Char: CHAR_INFO_0,
70 pub Attributes: u16,
71 }
72 #[cfg(feature = "Win32_Foundation")]
73 impl CHAR_INFO {}
74 #[cfg(feature = "Win32_Foundation")]
75 impl ::std::default::Default for CHAR_INFO {
default() -> Self76 fn default() -> Self {
77 unsafe { ::std::mem::zeroed() }
78 }
79 }
80 #[cfg(feature = "Win32_Foundation")]
81 impl ::std::cmp::PartialEq for CHAR_INFO {
eq(&self, _other: &Self) -> bool82 fn eq(&self, _other: &Self) -> bool {
83 unimplemented!()
84 }
85 }
86 #[cfg(feature = "Win32_Foundation")]
87 impl ::std::cmp::Eq for CHAR_INFO {}
88 #[cfg(feature = "Win32_Foundation")]
89 unsafe impl ::windows::runtime::Abi for CHAR_INFO {
90 type Abi = Self;
91 type DefaultType = Self;
92 }
93 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
94 #[repr(C)]
95 #[cfg(feature = "Win32_Foundation")]
96 pub union CHAR_INFO_0 {
97 pub UnicodeChar: u16,
98 pub AsciiChar: super::super::Foundation::CHAR,
99 }
100 #[cfg(feature = "Win32_Foundation")]
101 impl CHAR_INFO_0 {}
102 #[cfg(feature = "Win32_Foundation")]
103 impl ::std::default::Default for CHAR_INFO_0 {
default() -> Self104 fn default() -> Self {
105 unsafe { ::std::mem::zeroed() }
106 }
107 }
108 #[cfg(feature = "Win32_Foundation")]
109 impl ::std::cmp::PartialEq for CHAR_INFO_0 {
eq(&self, _other: &Self) -> bool110 fn eq(&self, _other: &Self) -> bool {
111 unimplemented!()
112 }
113 }
114 #[cfg(feature = "Win32_Foundation")]
115 impl ::std::cmp::Eq for CHAR_INFO_0 {}
116 #[cfg(feature = "Win32_Foundation")]
117 unsafe impl ::windows::runtime::Abi for CHAR_INFO_0 {
118 type Abi = Self;
119 type DefaultType = Self;
120 }
121 pub const COMMON_LVB_GRID_HORIZONTAL: u32 = 1024u32;
122 pub const COMMON_LVB_GRID_LVERTICAL: u32 = 2048u32;
123 pub const COMMON_LVB_GRID_RVERTICAL: u32 = 4096u32;
124 pub const COMMON_LVB_LEADING_BYTE: u32 = 256u32;
125 pub const COMMON_LVB_REVERSE_VIDEO: u32 = 16384u32;
126 pub const COMMON_LVB_SBCSDBCS: u32 = 768u32;
127 pub const COMMON_LVB_TRAILING_BYTE: u32 = 512u32;
128 pub const COMMON_LVB_UNDERSCORE: u32 = 32768u32;
129 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
130 #[repr(C)]
131 #[cfg(feature = "Win32_Foundation")]
132 pub struct CONSOLE_CURSOR_INFO {
133 pub dwSize: u32,
134 pub bVisible: super::super::Foundation::BOOL,
135 }
136 #[cfg(feature = "Win32_Foundation")]
137 impl CONSOLE_CURSOR_INFO {}
138 #[cfg(feature = "Win32_Foundation")]
139 impl ::std::default::Default for CONSOLE_CURSOR_INFO {
default() -> Self140 fn default() -> Self {
141 unsafe { ::std::mem::zeroed() }
142 }
143 }
144 #[cfg(feature = "Win32_Foundation")]
145 impl ::std::fmt::Debug for CONSOLE_CURSOR_INFO {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result146 fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
147 fmt.debug_struct("CONSOLE_CURSOR_INFO").field("dwSize", &self.dwSize).field("bVisible", &self.bVisible).finish()
148 }
149 }
150 #[cfg(feature = "Win32_Foundation")]
151 impl ::std::cmp::PartialEq for CONSOLE_CURSOR_INFO {
eq(&self, other: &Self) -> bool152 fn eq(&self, other: &Self) -> bool {
153 self.dwSize == other.dwSize && self.bVisible == other.bVisible
154 }
155 }
156 #[cfg(feature = "Win32_Foundation")]
157 impl ::std::cmp::Eq for CONSOLE_CURSOR_INFO {}
158 #[cfg(feature = "Win32_Foundation")]
159 unsafe impl ::windows::runtime::Abi for CONSOLE_CURSOR_INFO {
160 type Abi = Self;
161 type DefaultType = Self;
162 }
163 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
164 #[repr(C)]
165 pub struct CONSOLE_FONT_INFO {
166 pub nFont: u32,
167 pub dwFontSize: COORD,
168 }
169 impl CONSOLE_FONT_INFO {}
170 impl ::std::default::Default for CONSOLE_FONT_INFO {
default() -> Self171 fn default() -> Self {
172 unsafe { ::std::mem::zeroed() }
173 }
174 }
175 impl ::std::fmt::Debug for CONSOLE_FONT_INFO {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result176 fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
177 fmt.debug_struct("CONSOLE_FONT_INFO").field("nFont", &self.nFont).field("dwFontSize", &self.dwFontSize).finish()
178 }
179 }
180 impl ::std::cmp::PartialEq for CONSOLE_FONT_INFO {
eq(&self, other: &Self) -> bool181 fn eq(&self, other: &Self) -> bool {
182 self.nFont == other.nFont && self.dwFontSize == other.dwFontSize
183 }
184 }
185 impl ::std::cmp::Eq for CONSOLE_FONT_INFO {}
186 unsafe impl ::windows::runtime::Abi for CONSOLE_FONT_INFO {
187 type Abi = Self;
188 type DefaultType = Self;
189 }
190 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
191 #[repr(C)]
192 pub struct CONSOLE_FONT_INFOEX {
193 pub cbSize: u32,
194 pub nFont: u32,
195 pub dwFontSize: COORD,
196 pub FontFamily: u32,
197 pub FontWeight: u32,
198 pub FaceName: [u16; 32],
199 }
200 impl CONSOLE_FONT_INFOEX {}
201 impl ::std::default::Default for CONSOLE_FONT_INFOEX {
default() -> Self202 fn default() -> Self {
203 unsafe { ::std::mem::zeroed() }
204 }
205 }
206 impl ::std::fmt::Debug for CONSOLE_FONT_INFOEX {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result207 fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
208 fmt.debug_struct("CONSOLE_FONT_INFOEX").field("cbSize", &self.cbSize).field("nFont", &self.nFont).field("dwFontSize", &self.dwFontSize).field("FontFamily", &self.FontFamily).field("FontWeight", &self.FontWeight).field("FaceName", &self.FaceName).finish()
209 }
210 }
211 impl ::std::cmp::PartialEq for CONSOLE_FONT_INFOEX {
eq(&self, other: &Self) -> bool212 fn eq(&self, other: &Self) -> bool {
213 self.cbSize == other.cbSize && self.nFont == other.nFont && self.dwFontSize == other.dwFontSize && self.FontFamily == other.FontFamily && self.FontWeight == other.FontWeight && self.FaceName == other.FaceName
214 }
215 }
216 impl ::std::cmp::Eq for CONSOLE_FONT_INFOEX {}
217 unsafe impl ::windows::runtime::Abi for CONSOLE_FONT_INFOEX {
218 type Abi = Self;
219 type DefaultType = Self;
220 }
221 pub const CONSOLE_FULLSCREEN: u32 = 1u32;
222 pub const CONSOLE_FULLSCREEN_HARDWARE: u32 = 2u32;
223 pub const CONSOLE_FULLSCREEN_MODE: u32 = 1u32;
224 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
225 #[repr(C)]
226 pub struct CONSOLE_HISTORY_INFO {
227 pub cbSize: u32,
228 pub HistoryBufferSize: u32,
229 pub NumberOfHistoryBuffers: u32,
230 pub dwFlags: u32,
231 }
232 impl CONSOLE_HISTORY_INFO {}
233 impl ::std::default::Default for CONSOLE_HISTORY_INFO {
default() -> Self234 fn default() -> Self {
235 unsafe { ::std::mem::zeroed() }
236 }
237 }
238 impl ::std::fmt::Debug for CONSOLE_HISTORY_INFO {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result239 fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
240 fmt.debug_struct("CONSOLE_HISTORY_INFO").field("cbSize", &self.cbSize).field("HistoryBufferSize", &self.HistoryBufferSize).field("NumberOfHistoryBuffers", &self.NumberOfHistoryBuffers).field("dwFlags", &self.dwFlags).finish()
241 }
242 }
243 impl ::std::cmp::PartialEq for CONSOLE_HISTORY_INFO {
eq(&self, other: &Self) -> bool244 fn eq(&self, other: &Self) -> bool {
245 self.cbSize == other.cbSize && self.HistoryBufferSize == other.HistoryBufferSize && self.NumberOfHistoryBuffers == other.NumberOfHistoryBuffers && self.dwFlags == other.dwFlags
246 }
247 }
248 impl ::std::cmp::Eq for CONSOLE_HISTORY_INFO {}
249 unsafe impl ::windows::runtime::Abi for CONSOLE_HISTORY_INFO {
250 type Abi = Self;
251 type DefaultType = Self;
252 }
253 #[derive(:: std :: cmp :: PartialEq, :: std :: cmp :: Eq, :: std :: marker :: Copy, :: std :: clone :: Clone, :: std :: default :: Default, :: std :: fmt :: Debug)]
254 #[repr(transparent)]
255 pub struct CONSOLE_MODE(pub u32);
256 pub const ENABLE_PROCESSED_INPUT: CONSOLE_MODE = CONSOLE_MODE(1u32);
257 pub const ENABLE_LINE_INPUT: CONSOLE_MODE = CONSOLE_MODE(2u32);
258 pub const ENABLE_ECHO_INPUT: CONSOLE_MODE = CONSOLE_MODE(4u32);
259 pub const ENABLE_WINDOW_INPUT: CONSOLE_MODE = CONSOLE_MODE(8u32);
260 pub const ENABLE_MOUSE_INPUT: CONSOLE_MODE = CONSOLE_MODE(16u32);
261 pub const ENABLE_INSERT_MODE: CONSOLE_MODE = CONSOLE_MODE(32u32);
262 pub const ENABLE_QUICK_EDIT_MODE: CONSOLE_MODE = CONSOLE_MODE(64u32);
263 pub const ENABLE_EXTENDED_FLAGS: CONSOLE_MODE = CONSOLE_MODE(128u32);
264 pub const ENABLE_AUTO_POSITION: CONSOLE_MODE = CONSOLE_MODE(256u32);
265 pub const ENABLE_VIRTUAL_TERMINAL_INPUT: CONSOLE_MODE = CONSOLE_MODE(512u32);
266 pub const ENABLE_PROCESSED_OUTPUT: CONSOLE_MODE = CONSOLE_MODE(1u32);
267 pub const ENABLE_WRAP_AT_EOL_OUTPUT: CONSOLE_MODE = CONSOLE_MODE(2u32);
268 pub const ENABLE_VIRTUAL_TERMINAL_PROCESSING: CONSOLE_MODE = CONSOLE_MODE(4u32);
269 pub const DISABLE_NEWLINE_AUTO_RETURN: CONSOLE_MODE = CONSOLE_MODE(8u32);
270 pub const ENABLE_LVB_GRID_WORLDWIDE: CONSOLE_MODE = CONSOLE_MODE(16u32);
271 impl ::std::convert::From<u32> for CONSOLE_MODE {
from(value: u32) -> Self272 fn from(value: u32) -> Self {
273 Self(value)
274 }
275 }
276 unsafe impl ::windows::runtime::Abi for CONSOLE_MODE {
277 type Abi = Self;
278 type DefaultType = Self;
279 }
280 impl ::std::ops::BitOr for CONSOLE_MODE {
281 type Output = Self;
bitor(self, rhs: Self) -> Self282 fn bitor(self, rhs: Self) -> Self {
283 Self(self.0 | rhs.0)
284 }
285 }
286 impl ::std::ops::BitAnd for CONSOLE_MODE {
287 type Output = Self;
bitand(self, rhs: Self) -> Self288 fn bitand(self, rhs: Self) -> Self {
289 Self(self.0 & rhs.0)
290 }
291 }
292 impl ::std::ops::BitOrAssign for CONSOLE_MODE {
bitor_assign(&mut self, rhs: Self)293 fn bitor_assign(&mut self, rhs: Self) {
294 self.0.bitor_assign(rhs.0)
295 }
296 }
297 impl ::std::ops::BitAndAssign for CONSOLE_MODE {
bitand_assign(&mut self, rhs: Self)298 fn bitand_assign(&mut self, rhs: Self) {
299 self.0.bitand_assign(rhs.0)
300 }
301 }
302 impl ::std::ops::Not for CONSOLE_MODE {
303 type Output = Self;
not(self) -> Self304 fn not(self) -> Self {
305 Self(self.0.not())
306 }
307 }
308 pub const CONSOLE_MOUSE_DOWN: u32 = 8u32;
309 pub const CONSOLE_MOUSE_SELECTION: u32 = 4u32;
310 pub const CONSOLE_NO_SELECTION: u32 = 0u32;
311 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
312 #[repr(C)]
313 pub struct CONSOLE_READCONSOLE_CONTROL {
314 pub nLength: u32,
315 pub nInitialChars: u32,
316 pub dwCtrlWakeupMask: u32,
317 pub dwControlKeyState: u32,
318 }
319 impl CONSOLE_READCONSOLE_CONTROL {}
320 impl ::std::default::Default for CONSOLE_READCONSOLE_CONTROL {
default() -> Self321 fn default() -> Self {
322 unsafe { ::std::mem::zeroed() }
323 }
324 }
325 impl ::std::fmt::Debug for CONSOLE_READCONSOLE_CONTROL {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result326 fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
327 fmt.debug_struct("CONSOLE_READCONSOLE_CONTROL").field("nLength", &self.nLength).field("nInitialChars", &self.nInitialChars).field("dwCtrlWakeupMask", &self.dwCtrlWakeupMask).field("dwControlKeyState", &self.dwControlKeyState).finish()
328 }
329 }
330 impl ::std::cmp::PartialEq for CONSOLE_READCONSOLE_CONTROL {
eq(&self, other: &Self) -> bool331 fn eq(&self, other: &Self) -> bool {
332 self.nLength == other.nLength && self.nInitialChars == other.nInitialChars && self.dwCtrlWakeupMask == other.dwCtrlWakeupMask && self.dwControlKeyState == other.dwControlKeyState
333 }
334 }
335 impl ::std::cmp::Eq for CONSOLE_READCONSOLE_CONTROL {}
336 unsafe impl ::windows::runtime::Abi for CONSOLE_READCONSOLE_CONTROL {
337 type Abi = Self;
338 type DefaultType = Self;
339 }
340 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
341 #[repr(C)]
342 pub struct CONSOLE_SCREEN_BUFFER_INFO {
343 pub dwSize: COORD,
344 pub dwCursorPosition: COORD,
345 pub wAttributes: u16,
346 pub srWindow: SMALL_RECT,
347 pub dwMaximumWindowSize: COORD,
348 }
349 impl CONSOLE_SCREEN_BUFFER_INFO {}
350 impl ::std::default::Default for CONSOLE_SCREEN_BUFFER_INFO {
default() -> Self351 fn default() -> Self {
352 unsafe { ::std::mem::zeroed() }
353 }
354 }
355 impl ::std::fmt::Debug for CONSOLE_SCREEN_BUFFER_INFO {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result356 fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
357 fmt.debug_struct("CONSOLE_SCREEN_BUFFER_INFO").field("dwSize", &self.dwSize).field("dwCursorPosition", &self.dwCursorPosition).field("wAttributes", &self.wAttributes).field("srWindow", &self.srWindow).field("dwMaximumWindowSize", &self.dwMaximumWindowSize).finish()
358 }
359 }
360 impl ::std::cmp::PartialEq for CONSOLE_SCREEN_BUFFER_INFO {
eq(&self, other: &Self) -> bool361 fn eq(&self, other: &Self) -> bool {
362 self.dwSize == other.dwSize && self.dwCursorPosition == other.dwCursorPosition && self.wAttributes == other.wAttributes && self.srWindow == other.srWindow && self.dwMaximumWindowSize == other.dwMaximumWindowSize
363 }
364 }
365 impl ::std::cmp::Eq for CONSOLE_SCREEN_BUFFER_INFO {}
366 unsafe impl ::windows::runtime::Abi for CONSOLE_SCREEN_BUFFER_INFO {
367 type Abi = Self;
368 type DefaultType = Self;
369 }
370 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
371 #[repr(C)]
372 #[cfg(feature = "Win32_Foundation")]
373 pub struct CONSOLE_SCREEN_BUFFER_INFOEX {
374 pub cbSize: u32,
375 pub dwSize: COORD,
376 pub dwCursorPosition: COORD,
377 pub wAttributes: u16,
378 pub srWindow: SMALL_RECT,
379 pub dwMaximumWindowSize: COORD,
380 pub wPopupAttributes: u16,
381 pub bFullscreenSupported: super::super::Foundation::BOOL,
382 pub ColorTable: [u32; 16],
383 }
384 #[cfg(feature = "Win32_Foundation")]
385 impl CONSOLE_SCREEN_BUFFER_INFOEX {}
386 #[cfg(feature = "Win32_Foundation")]
387 impl ::std::default::Default for CONSOLE_SCREEN_BUFFER_INFOEX {
default() -> Self388 fn default() -> Self {
389 unsafe { ::std::mem::zeroed() }
390 }
391 }
392 #[cfg(feature = "Win32_Foundation")]
393 impl ::std::fmt::Debug for CONSOLE_SCREEN_BUFFER_INFOEX {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result394 fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
395 fmt.debug_struct("CONSOLE_SCREEN_BUFFER_INFOEX")
396 .field("cbSize", &self.cbSize)
397 .field("dwSize", &self.dwSize)
398 .field("dwCursorPosition", &self.dwCursorPosition)
399 .field("wAttributes", &self.wAttributes)
400 .field("srWindow", &self.srWindow)
401 .field("dwMaximumWindowSize", &self.dwMaximumWindowSize)
402 .field("wPopupAttributes", &self.wPopupAttributes)
403 .field("bFullscreenSupported", &self.bFullscreenSupported)
404 .field("ColorTable", &self.ColorTable)
405 .finish()
406 }
407 }
408 #[cfg(feature = "Win32_Foundation")]
409 impl ::std::cmp::PartialEq for CONSOLE_SCREEN_BUFFER_INFOEX {
eq(&self, other: &Self) -> bool410 fn eq(&self, other: &Self) -> bool {
411 self.cbSize == other.cbSize && self.dwSize == other.dwSize && self.dwCursorPosition == other.dwCursorPosition && self.wAttributes == other.wAttributes && self.srWindow == other.srWindow && self.dwMaximumWindowSize == other.dwMaximumWindowSize && self.wPopupAttributes == other.wPopupAttributes && self.bFullscreenSupported == other.bFullscreenSupported && self.ColorTable == other.ColorTable
412 }
413 }
414 #[cfg(feature = "Win32_Foundation")]
415 impl ::std::cmp::Eq for CONSOLE_SCREEN_BUFFER_INFOEX {}
416 #[cfg(feature = "Win32_Foundation")]
417 unsafe impl ::windows::runtime::Abi for CONSOLE_SCREEN_BUFFER_INFOEX {
418 type Abi = Self;
419 type DefaultType = Self;
420 }
421 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
422 #[repr(C)]
423 pub struct CONSOLE_SELECTION_INFO {
424 pub dwFlags: u32,
425 pub dwSelectionAnchor: COORD,
426 pub srSelection: SMALL_RECT,
427 }
428 impl CONSOLE_SELECTION_INFO {}
429 impl ::std::default::Default for CONSOLE_SELECTION_INFO {
default() -> Self430 fn default() -> Self {
431 unsafe { ::std::mem::zeroed() }
432 }
433 }
434 impl ::std::fmt::Debug for CONSOLE_SELECTION_INFO {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result435 fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
436 fmt.debug_struct("CONSOLE_SELECTION_INFO").field("dwFlags", &self.dwFlags).field("dwSelectionAnchor", &self.dwSelectionAnchor).field("srSelection", &self.srSelection).finish()
437 }
438 }
439 impl ::std::cmp::PartialEq for CONSOLE_SELECTION_INFO {
eq(&self, other: &Self) -> bool440 fn eq(&self, other: &Self) -> bool {
441 self.dwFlags == other.dwFlags && self.dwSelectionAnchor == other.dwSelectionAnchor && self.srSelection == other.srSelection
442 }
443 }
444 impl ::std::cmp::Eq for CONSOLE_SELECTION_INFO {}
445 unsafe impl ::windows::runtime::Abi for CONSOLE_SELECTION_INFO {
446 type Abi = Self;
447 type DefaultType = Self;
448 }
449 pub const CONSOLE_SELECTION_IN_PROGRESS: u32 = 1u32;
450 pub const CONSOLE_SELECTION_NOT_EMPTY: u32 = 2u32;
451 pub const CONSOLE_TEXTMODE_BUFFER: u32 = 1u32;
452 pub const CONSOLE_WINDOWED_MODE: u32 = 2u32;
453 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
454 #[repr(C)]
455 pub struct COORD {
456 pub X: i16,
457 pub Y: i16,
458 }
459 impl COORD {}
460 impl ::std::default::Default for COORD {
default() -> Self461 fn default() -> Self {
462 unsafe { ::std::mem::zeroed() }
463 }
464 }
465 impl ::std::fmt::Debug for COORD {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result466 fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
467 fmt.debug_struct("COORD").field("X", &self.X).field("Y", &self.Y).finish()
468 }
469 }
470 impl ::std::cmp::PartialEq for COORD {
eq(&self, other: &Self) -> bool471 fn eq(&self, other: &Self) -> bool {
472 self.X == other.X && self.Y == other.Y
473 }
474 }
475 impl ::std::cmp::Eq for COORD {}
476 unsafe impl ::windows::runtime::Abi for COORD {
477 type Abi = Self;
478 type DefaultType = Self;
479 }
480 pub const CTRL_BREAK_EVENT: u32 = 1u32;
481 pub const CTRL_CLOSE_EVENT: u32 = 2u32;
482 pub const CTRL_C_EVENT: u32 = 0u32;
483 pub const CTRL_LOGOFF_EVENT: u32 = 5u32;
484 pub const CTRL_SHUTDOWN_EVENT: u32 = 6u32;
485 #[inline]
ClosePseudoConsole<'a, Param0: ::windows::runtime::IntoParam<'a, HPCON>>(hpc: Param0)486 pub unsafe fn ClosePseudoConsole<'a, Param0: ::windows::runtime::IntoParam<'a, HPCON>>(hpc: Param0) {
487 #[cfg(windows)]
488 {
489 #[link(name = "windows")]
490 extern "system" {
491 fn ClosePseudoConsole(hpc: HPCON);
492 }
493 ::std::mem::transmute(ClosePseudoConsole(hpc.into_param().abi()))
494 }
495 #[cfg(not(windows))]
496 unimplemented!("Unsupported target OS");
497 }
498 #[cfg(all(feature = "Win32_Foundation", feature = "Win32_Security"))]
499 #[inline]
CreateConsoleScreenBuffer(dwdesiredaccess: u32, dwsharemode: u32, lpsecurityattributes: *const super::super::Security::SECURITY_ATTRIBUTES, dwflags: u32, lpscreenbufferdata: *mut ::std::ffi::c_void) -> super::super::Foundation::HANDLE500 pub unsafe fn CreateConsoleScreenBuffer(dwdesiredaccess: u32, dwsharemode: u32, lpsecurityattributes: *const super::super::Security::SECURITY_ATTRIBUTES, dwflags: u32, lpscreenbufferdata: *mut ::std::ffi::c_void) -> super::super::Foundation::HANDLE {
501 #[cfg(windows)]
502 {
503 #[link(name = "windows")]
504 extern "system" {
505 fn CreateConsoleScreenBuffer(dwdesiredaccess: u32, dwsharemode: u32, lpsecurityattributes: *const super::super::Security::SECURITY_ATTRIBUTES, dwflags: u32, lpscreenbufferdata: *mut ::std::ffi::c_void) -> super::super::Foundation::HANDLE;
506 }
507 ::std::mem::transmute(CreateConsoleScreenBuffer(::std::mem::transmute(dwdesiredaccess), ::std::mem::transmute(dwsharemode), ::std::mem::transmute(lpsecurityattributes), ::std::mem::transmute(dwflags), ::std::mem::transmute(lpscreenbufferdata)))
508 }
509 #[cfg(not(windows))]
510 unimplemented!("Unsupported target OS");
511 }
512 #[cfg(feature = "Win32_Foundation")]
513 #[inline]
CreatePseudoConsole<'a, Param0: ::windows::runtime::IntoParam<'a, COORD>, Param1: ::windows::runtime::IntoParam<'a, super::super::Foundation::HANDLE>, Param2: ::windows::runtime::IntoParam<'a, super::super::Foundation::HANDLE>>(size: Param0, hinput: Param1, houtput: Param2, dwflags: u32) -> ::windows::runtime::Result<HPCON>514 pub unsafe fn CreatePseudoConsole<'a, Param0: ::windows::runtime::IntoParam<'a, COORD>, Param1: ::windows::runtime::IntoParam<'a, super::super::Foundation::HANDLE>, Param2: ::windows::runtime::IntoParam<'a, super::super::Foundation::HANDLE>>(size: Param0, hinput: Param1, houtput: Param2, dwflags: u32) -> ::windows::runtime::Result<HPCON> {
515 #[cfg(windows)]
516 {
517 #[link(name = "windows")]
518 extern "system" {
519 fn CreatePseudoConsole(size: COORD, hinput: super::super::Foundation::HANDLE, houtput: super::super::Foundation::HANDLE, dwflags: u32, phpc: *mut HPCON) -> ::windows::runtime::HRESULT;
520 }
521 let mut result__: <HPCON as ::windows::runtime::Abi>::Abi = ::std::mem::zeroed();
522 CreatePseudoConsole(size.into_param().abi(), hinput.into_param().abi(), houtput.into_param().abi(), ::std::mem::transmute(dwflags), &mut result__).from_abi::<HPCON>(result__)
523 }
524 #[cfg(not(windows))]
525 unimplemented!("Unsupported target OS");
526 }
527 pub const DOUBLE_CLICK: u32 = 2u32;
528 pub const ENHANCED_KEY: u32 = 256u32;
529 #[cfg(feature = "Win32_Foundation")]
530 #[inline]
ExpungeConsoleCommandHistoryA<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::PSTR>>(exename: Param0)531 pub unsafe fn ExpungeConsoleCommandHistoryA<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::PSTR>>(exename: Param0) {
532 #[cfg(windows)]
533 {
534 #[link(name = "windows")]
535 extern "system" {
536 fn ExpungeConsoleCommandHistoryA(exename: super::super::Foundation::PSTR);
537 }
538 ::std::mem::transmute(ExpungeConsoleCommandHistoryA(exename.into_param().abi()))
539 }
540 #[cfg(not(windows))]
541 unimplemented!("Unsupported target OS");
542 }
543 #[cfg(feature = "Win32_Foundation")]
544 #[inline]
ExpungeConsoleCommandHistoryW<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>>(exename: Param0)545 pub unsafe fn ExpungeConsoleCommandHistoryW<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>>(exename: Param0) {
546 #[cfg(windows)]
547 {
548 #[link(name = "windows")]
549 extern "system" {
550 fn ExpungeConsoleCommandHistoryW(exename: super::super::Foundation::PWSTR);
551 }
552 ::std::mem::transmute(ExpungeConsoleCommandHistoryW(exename.into_param().abi()))
553 }
554 #[cfg(not(windows))]
555 unimplemented!("Unsupported target OS");
556 }
557 pub const FOCUS_EVENT: u32 = 16u32;
558 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
559 #[repr(C)]
560 #[cfg(feature = "Win32_Foundation")]
561 pub struct FOCUS_EVENT_RECORD {
562 pub bSetFocus: super::super::Foundation::BOOL,
563 }
564 #[cfg(feature = "Win32_Foundation")]
565 impl FOCUS_EVENT_RECORD {}
566 #[cfg(feature = "Win32_Foundation")]
567 impl ::std::default::Default for FOCUS_EVENT_RECORD {
default() -> Self568 fn default() -> Self {
569 unsafe { ::std::mem::zeroed() }
570 }
571 }
572 #[cfg(feature = "Win32_Foundation")]
573 impl ::std::fmt::Debug for FOCUS_EVENT_RECORD {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result574 fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
575 fmt.debug_struct("FOCUS_EVENT_RECORD").field("bSetFocus", &self.bSetFocus).finish()
576 }
577 }
578 #[cfg(feature = "Win32_Foundation")]
579 impl ::std::cmp::PartialEq for FOCUS_EVENT_RECORD {
eq(&self, other: &Self) -> bool580 fn eq(&self, other: &Self) -> bool {
581 self.bSetFocus == other.bSetFocus
582 }
583 }
584 #[cfg(feature = "Win32_Foundation")]
585 impl ::std::cmp::Eq for FOCUS_EVENT_RECORD {}
586 #[cfg(feature = "Win32_Foundation")]
587 unsafe impl ::windows::runtime::Abi for FOCUS_EVENT_RECORD {
588 type Abi = Self;
589 type DefaultType = Self;
590 }
591 pub const FOREGROUND_BLUE: u32 = 1u32;
592 pub const FOREGROUND_GREEN: u32 = 2u32;
593 pub const FOREGROUND_INTENSITY: u32 = 8u32;
594 pub const FOREGROUND_RED: u32 = 4u32;
595 pub const FROM_LEFT_1ST_BUTTON_PRESSED: u32 = 1u32;
596 pub const FROM_LEFT_2ND_BUTTON_PRESSED: u32 = 4u32;
597 pub const FROM_LEFT_3RD_BUTTON_PRESSED: u32 = 8u32;
598 pub const FROM_LEFT_4TH_BUTTON_PRESSED: u32 = 16u32;
599 #[cfg(feature = "Win32_Foundation")]
600 #[inline]
FillConsoleOutputAttribute<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::HANDLE>, Param3: ::windows::runtime::IntoParam<'a, COORD>>(hconsoleoutput: Param0, wattribute: u16, nlength: u32, dwwritecoord: Param3, lpnumberofattrswritten: *mut u32) -> super::super::Foundation::BOOL601 pub unsafe fn FillConsoleOutputAttribute<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::HANDLE>, Param3: ::windows::runtime::IntoParam<'a, COORD>>(hconsoleoutput: Param0, wattribute: u16, nlength: u32, dwwritecoord: Param3, lpnumberofattrswritten: *mut u32) -> super::super::Foundation::BOOL {
602 #[cfg(windows)]
603 {
604 #[link(name = "windows")]
605 extern "system" {
606 fn FillConsoleOutputAttribute(hconsoleoutput: super::super::Foundation::HANDLE, wattribute: u16, nlength: u32, dwwritecoord: COORD, lpnumberofattrswritten: *mut u32) -> super::super::Foundation::BOOL;
607 }
608 ::std::mem::transmute(FillConsoleOutputAttribute(hconsoleoutput.into_param().abi(), ::std::mem::transmute(wattribute), ::std::mem::transmute(nlength), dwwritecoord.into_param().abi(), ::std::mem::transmute(lpnumberofattrswritten)))
609 }
610 #[cfg(not(windows))]
611 unimplemented!("Unsupported target OS");
612 }
613 #[cfg(feature = "Win32_Foundation")]
614 #[inline]
FillConsoleOutputCharacterA<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::HANDLE>, Param1: ::windows::runtime::IntoParam<'a, super::super::Foundation::CHAR>, Param3: ::windows::runtime::IntoParam<'a, COORD>>(hconsoleoutput: Param0, ccharacter: Param1, nlength: u32, dwwritecoord: Param3, lpnumberofcharswritten: *mut u32) -> super::super::Foundation::BOOL615 pub unsafe fn FillConsoleOutputCharacterA<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::HANDLE>, Param1: ::windows::runtime::IntoParam<'a, super::super::Foundation::CHAR>, Param3: ::windows::runtime::IntoParam<'a, COORD>>(hconsoleoutput: Param0, ccharacter: Param1, nlength: u32, dwwritecoord: Param3, lpnumberofcharswritten: *mut u32) -> super::super::Foundation::BOOL {
616 #[cfg(windows)]
617 {
618 #[link(name = "windows")]
619 extern "system" {
620 fn FillConsoleOutputCharacterA(hconsoleoutput: super::super::Foundation::HANDLE, ccharacter: super::super::Foundation::CHAR, nlength: u32, dwwritecoord: COORD, lpnumberofcharswritten: *mut u32) -> super::super::Foundation::BOOL;
621 }
622 ::std::mem::transmute(FillConsoleOutputCharacterA(hconsoleoutput.into_param().abi(), ccharacter.into_param().abi(), ::std::mem::transmute(nlength), dwwritecoord.into_param().abi(), ::std::mem::transmute(lpnumberofcharswritten)))
623 }
624 #[cfg(not(windows))]
625 unimplemented!("Unsupported target OS");
626 }
627 #[cfg(feature = "Win32_Foundation")]
628 #[inline]
FillConsoleOutputCharacterW<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::HANDLE>, Param3: ::windows::runtime::IntoParam<'a, COORD>>(hconsoleoutput: Param0, ccharacter: u16, nlength: u32, dwwritecoord: Param3, lpnumberofcharswritten: *mut u32) -> super::super::Foundation::BOOL629 pub unsafe fn FillConsoleOutputCharacterW<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::HANDLE>, Param3: ::windows::runtime::IntoParam<'a, COORD>>(hconsoleoutput: Param0, ccharacter: u16, nlength: u32, dwwritecoord: Param3, lpnumberofcharswritten: *mut u32) -> super::super::Foundation::BOOL {
630 #[cfg(windows)]
631 {
632 #[link(name = "windows")]
633 extern "system" {
634 fn FillConsoleOutputCharacterW(hconsoleoutput: super::super::Foundation::HANDLE, ccharacter: u16, nlength: u32, dwwritecoord: COORD, lpnumberofcharswritten: *mut u32) -> super::super::Foundation::BOOL;
635 }
636 ::std::mem::transmute(FillConsoleOutputCharacterW(hconsoleoutput.into_param().abi(), ::std::mem::transmute(ccharacter), ::std::mem::transmute(nlength), dwwritecoord.into_param().abi(), ::std::mem::transmute(lpnumberofcharswritten)))
637 }
638 #[cfg(not(windows))]
639 unimplemented!("Unsupported target OS");
640 }
641 #[cfg(feature = "Win32_Foundation")]
642 #[inline]
FlushConsoleInputBuffer<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::HANDLE>>(hconsoleinput: Param0) -> super::super::Foundation::BOOL643 pub unsafe fn FlushConsoleInputBuffer<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::HANDLE>>(hconsoleinput: Param0) -> super::super::Foundation::BOOL {
644 #[cfg(windows)]
645 {
646 #[link(name = "windows")]
647 extern "system" {
648 fn FlushConsoleInputBuffer(hconsoleinput: super::super::Foundation::HANDLE) -> super::super::Foundation::BOOL;
649 }
650 ::std::mem::transmute(FlushConsoleInputBuffer(hconsoleinput.into_param().abi()))
651 }
652 #[cfg(not(windows))]
653 unimplemented!("Unsupported target OS");
654 }
655 #[cfg(feature = "Win32_Foundation")]
656 #[inline]
FreeConsole() -> super::super::Foundation::BOOL657 pub unsafe fn FreeConsole() -> super::super::Foundation::BOOL {
658 #[cfg(windows)]
659 {
660 #[link(name = "windows")]
661 extern "system" {
662 fn FreeConsole() -> super::super::Foundation::BOOL;
663 }
664 ::std::mem::transmute(FreeConsole())
665 }
666 #[cfg(not(windows))]
667 unimplemented!("Unsupported target OS");
668 }
669 #[cfg(feature = "Win32_Foundation")]
670 #[inline]
GenerateConsoleCtrlEvent(dwctrlevent: u32, dwprocessgroupid: u32) -> super::super::Foundation::BOOL671 pub unsafe fn GenerateConsoleCtrlEvent(dwctrlevent: u32, dwprocessgroupid: u32) -> super::super::Foundation::BOOL {
672 #[cfg(windows)]
673 {
674 #[link(name = "windows")]
675 extern "system" {
676 fn GenerateConsoleCtrlEvent(dwctrlevent: u32, dwprocessgroupid: u32) -> super::super::Foundation::BOOL;
677 }
678 ::std::mem::transmute(GenerateConsoleCtrlEvent(::std::mem::transmute(dwctrlevent), ::std::mem::transmute(dwprocessgroupid)))
679 }
680 #[cfg(not(windows))]
681 unimplemented!("Unsupported target OS");
682 }
683 #[cfg(feature = "Win32_Foundation")]
684 #[inline]
GetConsoleAliasA<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::PSTR>, Param3: ::windows::runtime::IntoParam<'a, super::super::Foundation::PSTR>>(source: Param0, targetbuffer: super::super::Foundation::PSTR, targetbufferlength: u32, exename: Param3) -> u32685 pub unsafe fn GetConsoleAliasA<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::PSTR>, Param3: ::windows::runtime::IntoParam<'a, super::super::Foundation::PSTR>>(source: Param0, targetbuffer: super::super::Foundation::PSTR, targetbufferlength: u32, exename: Param3) -> u32 {
686 #[cfg(windows)]
687 {
688 #[link(name = "windows")]
689 extern "system" {
690 fn GetConsoleAliasA(source: super::super::Foundation::PSTR, targetbuffer: super::super::Foundation::PSTR, targetbufferlength: u32, exename: super::super::Foundation::PSTR) -> u32;
691 }
692 ::std::mem::transmute(GetConsoleAliasA(source.into_param().abi(), ::std::mem::transmute(targetbuffer), ::std::mem::transmute(targetbufferlength), exename.into_param().abi()))
693 }
694 #[cfg(not(windows))]
695 unimplemented!("Unsupported target OS");
696 }
697 #[cfg(feature = "Win32_Foundation")]
698 #[inline]
GetConsoleAliasExesA(exenamebuffer: super::super::Foundation::PSTR, exenamebufferlength: u32) -> u32699 pub unsafe fn GetConsoleAliasExesA(exenamebuffer: super::super::Foundation::PSTR, exenamebufferlength: u32) -> u32 {
700 #[cfg(windows)]
701 {
702 #[link(name = "windows")]
703 extern "system" {
704 fn GetConsoleAliasExesA(exenamebuffer: super::super::Foundation::PSTR, exenamebufferlength: u32) -> u32;
705 }
706 ::std::mem::transmute(GetConsoleAliasExesA(::std::mem::transmute(exenamebuffer), ::std::mem::transmute(exenamebufferlength)))
707 }
708 #[cfg(not(windows))]
709 unimplemented!("Unsupported target OS");
710 }
711 #[inline]
GetConsoleAliasExesLengthA() -> u32712 pub unsafe fn GetConsoleAliasExesLengthA() -> u32 {
713 #[cfg(windows)]
714 {
715 #[link(name = "windows")]
716 extern "system" {
717 fn GetConsoleAliasExesLengthA() -> u32;
718 }
719 ::std::mem::transmute(GetConsoleAliasExesLengthA())
720 }
721 #[cfg(not(windows))]
722 unimplemented!("Unsupported target OS");
723 }
724 #[inline]
GetConsoleAliasExesLengthW() -> u32725 pub unsafe fn GetConsoleAliasExesLengthW() -> u32 {
726 #[cfg(windows)]
727 {
728 #[link(name = "windows")]
729 extern "system" {
730 fn GetConsoleAliasExesLengthW() -> u32;
731 }
732 ::std::mem::transmute(GetConsoleAliasExesLengthW())
733 }
734 #[cfg(not(windows))]
735 unimplemented!("Unsupported target OS");
736 }
737 #[cfg(feature = "Win32_Foundation")]
738 #[inline]
GetConsoleAliasExesW(exenamebuffer: super::super::Foundation::PWSTR, exenamebufferlength: u32) -> u32739 pub unsafe fn GetConsoleAliasExesW(exenamebuffer: super::super::Foundation::PWSTR, exenamebufferlength: u32) -> u32 {
740 #[cfg(windows)]
741 {
742 #[link(name = "windows")]
743 extern "system" {
744 fn GetConsoleAliasExesW(exenamebuffer: super::super::Foundation::PWSTR, exenamebufferlength: u32) -> u32;
745 }
746 ::std::mem::transmute(GetConsoleAliasExesW(::std::mem::transmute(exenamebuffer), ::std::mem::transmute(exenamebufferlength)))
747 }
748 #[cfg(not(windows))]
749 unimplemented!("Unsupported target OS");
750 }
751 #[cfg(feature = "Win32_Foundation")]
752 #[inline]
GetConsoleAliasW<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>, Param3: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>>(source: Param0, targetbuffer: super::super::Foundation::PWSTR, targetbufferlength: u32, exename: Param3) -> u32753 pub unsafe fn GetConsoleAliasW<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>, Param3: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>>(source: Param0, targetbuffer: super::super::Foundation::PWSTR, targetbufferlength: u32, exename: Param3) -> u32 {
754 #[cfg(windows)]
755 {
756 #[link(name = "windows")]
757 extern "system" {
758 fn GetConsoleAliasW(source: super::super::Foundation::PWSTR, targetbuffer: super::super::Foundation::PWSTR, targetbufferlength: u32, exename: super::super::Foundation::PWSTR) -> u32;
759 }
760 ::std::mem::transmute(GetConsoleAliasW(source.into_param().abi(), ::std::mem::transmute(targetbuffer), ::std::mem::transmute(targetbufferlength), exename.into_param().abi()))
761 }
762 #[cfg(not(windows))]
763 unimplemented!("Unsupported target OS");
764 }
765 #[cfg(feature = "Win32_Foundation")]
766 #[inline]
GetConsoleAliasesA<'a, Param2: ::windows::runtime::IntoParam<'a, super::super::Foundation::PSTR>>(aliasbuffer: super::super::Foundation::PSTR, aliasbufferlength: u32, exename: Param2) -> u32767 pub unsafe fn GetConsoleAliasesA<'a, Param2: ::windows::runtime::IntoParam<'a, super::super::Foundation::PSTR>>(aliasbuffer: super::super::Foundation::PSTR, aliasbufferlength: u32, exename: Param2) -> u32 {
768 #[cfg(windows)]
769 {
770 #[link(name = "windows")]
771 extern "system" {
772 fn GetConsoleAliasesA(aliasbuffer: super::super::Foundation::PSTR, aliasbufferlength: u32, exename: super::super::Foundation::PSTR) -> u32;
773 }
774 ::std::mem::transmute(GetConsoleAliasesA(::std::mem::transmute(aliasbuffer), ::std::mem::transmute(aliasbufferlength), exename.into_param().abi()))
775 }
776 #[cfg(not(windows))]
777 unimplemented!("Unsupported target OS");
778 }
779 #[cfg(feature = "Win32_Foundation")]
780 #[inline]
GetConsoleAliasesLengthA<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::PSTR>>(exename: Param0) -> u32781 pub unsafe fn GetConsoleAliasesLengthA<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::PSTR>>(exename: Param0) -> u32 {
782 #[cfg(windows)]
783 {
784 #[link(name = "windows")]
785 extern "system" {
786 fn GetConsoleAliasesLengthA(exename: super::super::Foundation::PSTR) -> u32;
787 }
788 ::std::mem::transmute(GetConsoleAliasesLengthA(exename.into_param().abi()))
789 }
790 #[cfg(not(windows))]
791 unimplemented!("Unsupported target OS");
792 }
793 #[cfg(feature = "Win32_Foundation")]
794 #[inline]
GetConsoleAliasesLengthW<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>>(exename: Param0) -> u32795 pub unsafe fn GetConsoleAliasesLengthW<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>>(exename: Param0) -> u32 {
796 #[cfg(windows)]
797 {
798 #[link(name = "windows")]
799 extern "system" {
800 fn GetConsoleAliasesLengthW(exename: super::super::Foundation::PWSTR) -> u32;
801 }
802 ::std::mem::transmute(GetConsoleAliasesLengthW(exename.into_param().abi()))
803 }
804 #[cfg(not(windows))]
805 unimplemented!("Unsupported target OS");
806 }
807 #[cfg(feature = "Win32_Foundation")]
808 #[inline]
GetConsoleAliasesW<'a, Param2: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>>(aliasbuffer: super::super::Foundation::PWSTR, aliasbufferlength: u32, exename: Param2) -> u32809 pub unsafe fn GetConsoleAliasesW<'a, Param2: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>>(aliasbuffer: super::super::Foundation::PWSTR, aliasbufferlength: u32, exename: Param2) -> u32 {
810 #[cfg(windows)]
811 {
812 #[link(name = "windows")]
813 extern "system" {
814 fn GetConsoleAliasesW(aliasbuffer: super::super::Foundation::PWSTR, aliasbufferlength: u32, exename: super::super::Foundation::PWSTR) -> u32;
815 }
816 ::std::mem::transmute(GetConsoleAliasesW(::std::mem::transmute(aliasbuffer), ::std::mem::transmute(aliasbufferlength), exename.into_param().abi()))
817 }
818 #[cfg(not(windows))]
819 unimplemented!("Unsupported target OS");
820 }
821 #[inline]
GetConsoleCP() -> u32822 pub unsafe fn GetConsoleCP() -> u32 {
823 #[cfg(windows)]
824 {
825 #[link(name = "windows")]
826 extern "system" {
827 fn GetConsoleCP() -> u32;
828 }
829 ::std::mem::transmute(GetConsoleCP())
830 }
831 #[cfg(not(windows))]
832 unimplemented!("Unsupported target OS");
833 }
834 #[cfg(feature = "Win32_Foundation")]
835 #[inline]
GetConsoleCommandHistoryA<'a, Param2: ::windows::runtime::IntoParam<'a, super::super::Foundation::PSTR>>(commands: super::super::Foundation::PSTR, commandbufferlength: u32, exename: Param2) -> u32836 pub unsafe fn GetConsoleCommandHistoryA<'a, Param2: ::windows::runtime::IntoParam<'a, super::super::Foundation::PSTR>>(commands: super::super::Foundation::PSTR, commandbufferlength: u32, exename: Param2) -> u32 {
837 #[cfg(windows)]
838 {
839 #[link(name = "windows")]
840 extern "system" {
841 fn GetConsoleCommandHistoryA(commands: super::super::Foundation::PSTR, commandbufferlength: u32, exename: super::super::Foundation::PSTR) -> u32;
842 }
843 ::std::mem::transmute(GetConsoleCommandHistoryA(::std::mem::transmute(commands), ::std::mem::transmute(commandbufferlength), exename.into_param().abi()))
844 }
845 #[cfg(not(windows))]
846 unimplemented!("Unsupported target OS");
847 }
848 #[cfg(feature = "Win32_Foundation")]
849 #[inline]
GetConsoleCommandHistoryLengthA<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::PSTR>>(exename: Param0) -> u32850 pub unsafe fn GetConsoleCommandHistoryLengthA<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::PSTR>>(exename: Param0) -> u32 {
851 #[cfg(windows)]
852 {
853 #[link(name = "windows")]
854 extern "system" {
855 fn GetConsoleCommandHistoryLengthA(exename: super::super::Foundation::PSTR) -> u32;
856 }
857 ::std::mem::transmute(GetConsoleCommandHistoryLengthA(exename.into_param().abi()))
858 }
859 #[cfg(not(windows))]
860 unimplemented!("Unsupported target OS");
861 }
862 #[cfg(feature = "Win32_Foundation")]
863 #[inline]
GetConsoleCommandHistoryLengthW<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>>(exename: Param0) -> u32864 pub unsafe fn GetConsoleCommandHistoryLengthW<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>>(exename: Param0) -> u32 {
865 #[cfg(windows)]
866 {
867 #[link(name = "windows")]
868 extern "system" {
869 fn GetConsoleCommandHistoryLengthW(exename: super::super::Foundation::PWSTR) -> u32;
870 }
871 ::std::mem::transmute(GetConsoleCommandHistoryLengthW(exename.into_param().abi()))
872 }
873 #[cfg(not(windows))]
874 unimplemented!("Unsupported target OS");
875 }
876 #[cfg(feature = "Win32_Foundation")]
877 #[inline]
GetConsoleCommandHistoryW<'a, Param2: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>>(commands: super::super::Foundation::PWSTR, commandbufferlength: u32, exename: Param2) -> u32878 pub unsafe fn GetConsoleCommandHistoryW<'a, Param2: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>>(commands: super::super::Foundation::PWSTR, commandbufferlength: u32, exename: Param2) -> u32 {
879 #[cfg(windows)]
880 {
881 #[link(name = "windows")]
882 extern "system" {
883 fn GetConsoleCommandHistoryW(commands: super::super::Foundation::PWSTR, commandbufferlength: u32, exename: super::super::Foundation::PWSTR) -> u32;
884 }
885 ::std::mem::transmute(GetConsoleCommandHistoryW(::std::mem::transmute(commands), ::std::mem::transmute(commandbufferlength), exename.into_param().abi()))
886 }
887 #[cfg(not(windows))]
888 unimplemented!("Unsupported target OS");
889 }
890 #[cfg(feature = "Win32_Foundation")]
891 #[inline]
GetConsoleCursorInfo<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::HANDLE>>(hconsoleoutput: Param0, lpconsolecursorinfo: *mut CONSOLE_CURSOR_INFO) -> super::super::Foundation::BOOL892 pub unsafe fn GetConsoleCursorInfo<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::HANDLE>>(hconsoleoutput: Param0, lpconsolecursorinfo: *mut CONSOLE_CURSOR_INFO) -> super::super::Foundation::BOOL {
893 #[cfg(windows)]
894 {
895 #[link(name = "windows")]
896 extern "system" {
897 fn GetConsoleCursorInfo(hconsoleoutput: super::super::Foundation::HANDLE, lpconsolecursorinfo: *mut CONSOLE_CURSOR_INFO) -> super::super::Foundation::BOOL;
898 }
899 ::std::mem::transmute(GetConsoleCursorInfo(hconsoleoutput.into_param().abi(), ::std::mem::transmute(lpconsolecursorinfo)))
900 }
901 #[cfg(not(windows))]
902 unimplemented!("Unsupported target OS");
903 }
904 #[cfg(feature = "Win32_Foundation")]
905 #[inline]
GetConsoleDisplayMode(lpmodeflags: *mut u32) -> super::super::Foundation::BOOL906 pub unsafe fn GetConsoleDisplayMode(lpmodeflags: *mut u32) -> super::super::Foundation::BOOL {
907 #[cfg(windows)]
908 {
909 #[link(name = "windows")]
910 extern "system" {
911 fn GetConsoleDisplayMode(lpmodeflags: *mut u32) -> super::super::Foundation::BOOL;
912 }
913 ::std::mem::transmute(GetConsoleDisplayMode(::std::mem::transmute(lpmodeflags)))
914 }
915 #[cfg(not(windows))]
916 unimplemented!("Unsupported target OS");
917 }
918 #[cfg(feature = "Win32_Foundation")]
919 #[inline]
GetConsoleFontSize<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::HANDLE>>(hconsoleoutput: Param0, nfont: u32) -> COORD920 pub unsafe fn GetConsoleFontSize<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::HANDLE>>(hconsoleoutput: Param0, nfont: u32) -> COORD {
921 #[cfg(windows)]
922 {
923 #[link(name = "windows")]
924 extern "system" {
925 fn GetConsoleFontSize(hconsoleoutput: super::super::Foundation::HANDLE, nfont: u32) -> COORD;
926 }
927 ::std::mem::transmute(GetConsoleFontSize(hconsoleoutput.into_param().abi(), ::std::mem::transmute(nfont)))
928 }
929 #[cfg(not(windows))]
930 unimplemented!("Unsupported target OS");
931 }
932 #[cfg(feature = "Win32_Foundation")]
933 #[inline]
GetConsoleHistoryInfo(lpconsolehistoryinfo: *mut CONSOLE_HISTORY_INFO) -> super::super::Foundation::BOOL934 pub unsafe fn GetConsoleHistoryInfo(lpconsolehistoryinfo: *mut CONSOLE_HISTORY_INFO) -> super::super::Foundation::BOOL {
935 #[cfg(windows)]
936 {
937 #[link(name = "windows")]
938 extern "system" {
939 fn GetConsoleHistoryInfo(lpconsolehistoryinfo: *mut CONSOLE_HISTORY_INFO) -> super::super::Foundation::BOOL;
940 }
941 ::std::mem::transmute(GetConsoleHistoryInfo(::std::mem::transmute(lpconsolehistoryinfo)))
942 }
943 #[cfg(not(windows))]
944 unimplemented!("Unsupported target OS");
945 }
946 #[cfg(feature = "Win32_Foundation")]
947 #[inline]
GetConsoleMode<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::HANDLE>>(hconsolehandle: Param0, lpmode: *mut CONSOLE_MODE) -> super::super::Foundation::BOOL948 pub unsafe fn GetConsoleMode<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::HANDLE>>(hconsolehandle: Param0, lpmode: *mut CONSOLE_MODE) -> super::super::Foundation::BOOL {
949 #[cfg(windows)]
950 {
951 #[link(name = "windows")]
952 extern "system" {
953 fn GetConsoleMode(hconsolehandle: super::super::Foundation::HANDLE, lpmode: *mut CONSOLE_MODE) -> super::super::Foundation::BOOL;
954 }
955 ::std::mem::transmute(GetConsoleMode(hconsolehandle.into_param().abi(), ::std::mem::transmute(lpmode)))
956 }
957 #[cfg(not(windows))]
958 unimplemented!("Unsupported target OS");
959 }
960 #[cfg(feature = "Win32_Foundation")]
961 #[inline]
GetConsoleOriginalTitleA(lpconsoletitle: super::super::Foundation::PSTR, nsize: u32) -> u32962 pub unsafe fn GetConsoleOriginalTitleA(lpconsoletitle: super::super::Foundation::PSTR, nsize: u32) -> u32 {
963 #[cfg(windows)]
964 {
965 #[link(name = "windows")]
966 extern "system" {
967 fn GetConsoleOriginalTitleA(lpconsoletitle: super::super::Foundation::PSTR, nsize: u32) -> u32;
968 }
969 ::std::mem::transmute(GetConsoleOriginalTitleA(::std::mem::transmute(lpconsoletitle), ::std::mem::transmute(nsize)))
970 }
971 #[cfg(not(windows))]
972 unimplemented!("Unsupported target OS");
973 }
974 #[cfg(feature = "Win32_Foundation")]
975 #[inline]
GetConsoleOriginalTitleW(lpconsoletitle: super::super::Foundation::PWSTR, nsize: u32) -> u32976 pub unsafe fn GetConsoleOriginalTitleW(lpconsoletitle: super::super::Foundation::PWSTR, nsize: u32) -> u32 {
977 #[cfg(windows)]
978 {
979 #[link(name = "windows")]
980 extern "system" {
981 fn GetConsoleOriginalTitleW(lpconsoletitle: super::super::Foundation::PWSTR, nsize: u32) -> u32;
982 }
983 ::std::mem::transmute(GetConsoleOriginalTitleW(::std::mem::transmute(lpconsoletitle), ::std::mem::transmute(nsize)))
984 }
985 #[cfg(not(windows))]
986 unimplemented!("Unsupported target OS");
987 }
988 #[inline]
GetConsoleOutputCP() -> u32989 pub unsafe fn GetConsoleOutputCP() -> u32 {
990 #[cfg(windows)]
991 {
992 #[link(name = "windows")]
993 extern "system" {
994 fn GetConsoleOutputCP() -> u32;
995 }
996 ::std::mem::transmute(GetConsoleOutputCP())
997 }
998 #[cfg(not(windows))]
999 unimplemented!("Unsupported target OS");
1000 }
1001 #[inline]
GetConsoleProcessList(lpdwprocesslist: *mut u32, dwprocesscount: u32) -> u321002 pub unsafe fn GetConsoleProcessList(lpdwprocesslist: *mut u32, dwprocesscount: u32) -> u32 {
1003 #[cfg(windows)]
1004 {
1005 #[link(name = "windows")]
1006 extern "system" {
1007 fn GetConsoleProcessList(lpdwprocesslist: *mut u32, dwprocesscount: u32) -> u32;
1008 }
1009 ::std::mem::transmute(GetConsoleProcessList(::std::mem::transmute(lpdwprocesslist), ::std::mem::transmute(dwprocesscount)))
1010 }
1011 #[cfg(not(windows))]
1012 unimplemented!("Unsupported target OS");
1013 }
1014 #[cfg(feature = "Win32_Foundation")]
1015 #[inline]
GetConsoleScreenBufferInfo<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::HANDLE>>(hconsoleoutput: Param0, lpconsolescreenbufferinfo: *mut CONSOLE_SCREEN_BUFFER_INFO) -> super::super::Foundation::BOOL1016 pub unsafe fn GetConsoleScreenBufferInfo<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::HANDLE>>(hconsoleoutput: Param0, lpconsolescreenbufferinfo: *mut CONSOLE_SCREEN_BUFFER_INFO) -> super::super::Foundation::BOOL {
1017 #[cfg(windows)]
1018 {
1019 #[link(name = "windows")]
1020 extern "system" {
1021 fn GetConsoleScreenBufferInfo(hconsoleoutput: super::super::Foundation::HANDLE, lpconsolescreenbufferinfo: *mut CONSOLE_SCREEN_BUFFER_INFO) -> super::super::Foundation::BOOL;
1022 }
1023 ::std::mem::transmute(GetConsoleScreenBufferInfo(hconsoleoutput.into_param().abi(), ::std::mem::transmute(lpconsolescreenbufferinfo)))
1024 }
1025 #[cfg(not(windows))]
1026 unimplemented!("Unsupported target OS");
1027 }
1028 #[cfg(feature = "Win32_Foundation")]
1029 #[inline]
GetConsoleScreenBufferInfoEx<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::HANDLE>>(hconsoleoutput: Param0, lpconsolescreenbufferinfoex: *mut CONSOLE_SCREEN_BUFFER_INFOEX) -> super::super::Foundation::BOOL1030 pub unsafe fn GetConsoleScreenBufferInfoEx<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::HANDLE>>(hconsoleoutput: Param0, lpconsolescreenbufferinfoex: *mut CONSOLE_SCREEN_BUFFER_INFOEX) -> super::super::Foundation::BOOL {
1031 #[cfg(windows)]
1032 {
1033 #[link(name = "windows")]
1034 extern "system" {
1035 fn GetConsoleScreenBufferInfoEx(hconsoleoutput: super::super::Foundation::HANDLE, lpconsolescreenbufferinfoex: *mut CONSOLE_SCREEN_BUFFER_INFOEX) -> super::super::Foundation::BOOL;
1036 }
1037 ::std::mem::transmute(GetConsoleScreenBufferInfoEx(hconsoleoutput.into_param().abi(), ::std::mem::transmute(lpconsolescreenbufferinfoex)))
1038 }
1039 #[cfg(not(windows))]
1040 unimplemented!("Unsupported target OS");
1041 }
1042 #[cfg(feature = "Win32_Foundation")]
1043 #[inline]
GetConsoleSelectionInfo(lpconsoleselectioninfo: *mut CONSOLE_SELECTION_INFO) -> super::super::Foundation::BOOL1044 pub unsafe fn GetConsoleSelectionInfo(lpconsoleselectioninfo: *mut CONSOLE_SELECTION_INFO) -> super::super::Foundation::BOOL {
1045 #[cfg(windows)]
1046 {
1047 #[link(name = "windows")]
1048 extern "system" {
1049 fn GetConsoleSelectionInfo(lpconsoleselectioninfo: *mut CONSOLE_SELECTION_INFO) -> super::super::Foundation::BOOL;
1050 }
1051 ::std::mem::transmute(GetConsoleSelectionInfo(::std::mem::transmute(lpconsoleselectioninfo)))
1052 }
1053 #[cfg(not(windows))]
1054 unimplemented!("Unsupported target OS");
1055 }
1056 #[cfg(feature = "Win32_Foundation")]
1057 #[inline]
GetConsoleTitleA(lpconsoletitle: super::super::Foundation::PSTR, nsize: u32) -> u321058 pub unsafe fn GetConsoleTitleA(lpconsoletitle: super::super::Foundation::PSTR, nsize: u32) -> u32 {
1059 #[cfg(windows)]
1060 {
1061 #[link(name = "windows")]
1062 extern "system" {
1063 fn GetConsoleTitleA(lpconsoletitle: super::super::Foundation::PSTR, nsize: u32) -> u32;
1064 }
1065 ::std::mem::transmute(GetConsoleTitleA(::std::mem::transmute(lpconsoletitle), ::std::mem::transmute(nsize)))
1066 }
1067 #[cfg(not(windows))]
1068 unimplemented!("Unsupported target OS");
1069 }
1070 #[cfg(feature = "Win32_Foundation")]
1071 #[inline]
GetConsoleTitleW(lpconsoletitle: super::super::Foundation::PWSTR, nsize: u32) -> u321072 pub unsafe fn GetConsoleTitleW(lpconsoletitle: super::super::Foundation::PWSTR, nsize: u32) -> u32 {
1073 #[cfg(windows)]
1074 {
1075 #[link(name = "windows")]
1076 extern "system" {
1077 fn GetConsoleTitleW(lpconsoletitle: super::super::Foundation::PWSTR, nsize: u32) -> u32;
1078 }
1079 ::std::mem::transmute(GetConsoleTitleW(::std::mem::transmute(lpconsoletitle), ::std::mem::transmute(nsize)))
1080 }
1081 #[cfg(not(windows))]
1082 unimplemented!("Unsupported target OS");
1083 }
1084 #[cfg(feature = "Win32_Foundation")]
1085 #[inline]
GetConsoleWindow() -> super::super::Foundation::HWND1086 pub unsafe fn GetConsoleWindow() -> super::super::Foundation::HWND {
1087 #[cfg(windows)]
1088 {
1089 #[link(name = "windows")]
1090 extern "system" {
1091 fn GetConsoleWindow() -> super::super::Foundation::HWND;
1092 }
1093 ::std::mem::transmute(GetConsoleWindow())
1094 }
1095 #[cfg(not(windows))]
1096 unimplemented!("Unsupported target OS");
1097 }
1098 #[cfg(feature = "Win32_Foundation")]
1099 #[inline]
GetCurrentConsoleFont<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::HANDLE>, Param1: ::windows::runtime::IntoParam<'a, super::super::Foundation::BOOL>>(hconsoleoutput: Param0, bmaximumwindow: Param1, lpconsolecurrentfont: *mut CONSOLE_FONT_INFO) -> super::super::Foundation::BOOL1100 pub unsafe fn GetCurrentConsoleFont<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::HANDLE>, Param1: ::windows::runtime::IntoParam<'a, super::super::Foundation::BOOL>>(hconsoleoutput: Param0, bmaximumwindow: Param1, lpconsolecurrentfont: *mut CONSOLE_FONT_INFO) -> super::super::Foundation::BOOL {
1101 #[cfg(windows)]
1102 {
1103 #[link(name = "windows")]
1104 extern "system" {
1105 fn GetCurrentConsoleFont(hconsoleoutput: super::super::Foundation::HANDLE, bmaximumwindow: super::super::Foundation::BOOL, lpconsolecurrentfont: *mut CONSOLE_FONT_INFO) -> super::super::Foundation::BOOL;
1106 }
1107 ::std::mem::transmute(GetCurrentConsoleFont(hconsoleoutput.into_param().abi(), bmaximumwindow.into_param().abi(), ::std::mem::transmute(lpconsolecurrentfont)))
1108 }
1109 #[cfg(not(windows))]
1110 unimplemented!("Unsupported target OS");
1111 }
1112 #[cfg(feature = "Win32_Foundation")]
1113 #[inline]
GetCurrentConsoleFontEx<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::HANDLE>, Param1: ::windows::runtime::IntoParam<'a, super::super::Foundation::BOOL>>(hconsoleoutput: Param0, bmaximumwindow: Param1, lpconsolecurrentfontex: *mut CONSOLE_FONT_INFOEX) -> super::super::Foundation::BOOL1114 pub unsafe fn GetCurrentConsoleFontEx<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::HANDLE>, Param1: ::windows::runtime::IntoParam<'a, super::super::Foundation::BOOL>>(hconsoleoutput: Param0, bmaximumwindow: Param1, lpconsolecurrentfontex: *mut CONSOLE_FONT_INFOEX) -> super::super::Foundation::BOOL {
1115 #[cfg(windows)]
1116 {
1117 #[link(name = "windows")]
1118 extern "system" {
1119 fn GetCurrentConsoleFontEx(hconsoleoutput: super::super::Foundation::HANDLE, bmaximumwindow: super::super::Foundation::BOOL, lpconsolecurrentfontex: *mut CONSOLE_FONT_INFOEX) -> super::super::Foundation::BOOL;
1120 }
1121 ::std::mem::transmute(GetCurrentConsoleFontEx(hconsoleoutput.into_param().abi(), bmaximumwindow.into_param().abi(), ::std::mem::transmute(lpconsolecurrentfontex)))
1122 }
1123 #[cfg(not(windows))]
1124 unimplemented!("Unsupported target OS");
1125 }
1126 #[cfg(feature = "Win32_Foundation")]
1127 #[inline]
GetLargestConsoleWindowSize<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::HANDLE>>(hconsoleoutput: Param0) -> COORD1128 pub unsafe fn GetLargestConsoleWindowSize<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::HANDLE>>(hconsoleoutput: Param0) -> COORD {
1129 #[cfg(windows)]
1130 {
1131 #[link(name = "windows")]
1132 extern "system" {
1133 fn GetLargestConsoleWindowSize(hconsoleoutput: super::super::Foundation::HANDLE) -> COORD;
1134 }
1135 ::std::mem::transmute(GetLargestConsoleWindowSize(hconsoleoutput.into_param().abi()))
1136 }
1137 #[cfg(not(windows))]
1138 unimplemented!("Unsupported target OS");
1139 }
1140 #[cfg(feature = "Win32_Foundation")]
1141 #[inline]
GetNumberOfConsoleInputEvents<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::HANDLE>>(hconsoleinput: Param0, lpnumberofevents: *mut u32) -> super::super::Foundation::BOOL1142 pub unsafe fn GetNumberOfConsoleInputEvents<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::HANDLE>>(hconsoleinput: Param0, lpnumberofevents: *mut u32) -> super::super::Foundation::BOOL {
1143 #[cfg(windows)]
1144 {
1145 #[link(name = "windows")]
1146 extern "system" {
1147 fn GetNumberOfConsoleInputEvents(hconsoleinput: super::super::Foundation::HANDLE, lpnumberofevents: *mut u32) -> super::super::Foundation::BOOL;
1148 }
1149 ::std::mem::transmute(GetNumberOfConsoleInputEvents(hconsoleinput.into_param().abi(), ::std::mem::transmute(lpnumberofevents)))
1150 }
1151 #[cfg(not(windows))]
1152 unimplemented!("Unsupported target OS");
1153 }
1154 #[cfg(feature = "Win32_Foundation")]
1155 #[inline]
GetNumberOfConsoleMouseButtons(lpnumberofmousebuttons: *mut u32) -> super::super::Foundation::BOOL1156 pub unsafe fn GetNumberOfConsoleMouseButtons(lpnumberofmousebuttons: *mut u32) -> super::super::Foundation::BOOL {
1157 #[cfg(windows)]
1158 {
1159 #[link(name = "windows")]
1160 extern "system" {
1161 fn GetNumberOfConsoleMouseButtons(lpnumberofmousebuttons: *mut u32) -> super::super::Foundation::BOOL;
1162 }
1163 ::std::mem::transmute(GetNumberOfConsoleMouseButtons(::std::mem::transmute(lpnumberofmousebuttons)))
1164 }
1165 #[cfg(not(windows))]
1166 unimplemented!("Unsupported target OS");
1167 }
1168 #[cfg(feature = "Win32_Foundation")]
1169 #[inline]
GetStdHandle(nstdhandle: STD_HANDLE) -> super::super::Foundation::HANDLE1170 pub unsafe fn GetStdHandle(nstdhandle: STD_HANDLE) -> super::super::Foundation::HANDLE {
1171 #[cfg(windows)]
1172 {
1173 #[link(name = "windows")]
1174 extern "system" {
1175 fn GetStdHandle(nstdhandle: STD_HANDLE) -> super::super::Foundation::HANDLE;
1176 }
1177 ::std::mem::transmute(GetStdHandle(::std::mem::transmute(nstdhandle)))
1178 }
1179 #[cfg(not(windows))]
1180 unimplemented!("Unsupported target OS");
1181 }
1182 pub const HISTORY_NO_DUP_FLAG: u32 = 1u32;
1183 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy, :: std :: fmt :: Debug, :: std :: cmp :: PartialEq, :: std :: cmp :: Eq)]
1184 #[repr(transparent)]
1185 pub struct HPCON(pub isize);
1186 impl ::std::default::Default for HPCON {
default() -> Self1187 fn default() -> Self {
1188 unsafe { ::std::mem::zeroed() }
1189 }
1190 }
1191 unsafe impl ::windows::runtime::Handle for HPCON {}
1192 unsafe impl ::windows::runtime::Abi for HPCON {
1193 type Abi = Self;
1194 type DefaultType = Self;
1195 }
1196 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
1197 #[repr(C)]
1198 #[cfg(feature = "Win32_Foundation")]
1199 pub struct INPUT_RECORD {
1200 pub EventType: u16,
1201 pub Event: INPUT_RECORD_0,
1202 }
1203 #[cfg(feature = "Win32_Foundation")]
1204 impl INPUT_RECORD {}
1205 #[cfg(feature = "Win32_Foundation")]
1206 impl ::std::default::Default for INPUT_RECORD {
default() -> Self1207 fn default() -> Self {
1208 unsafe { ::std::mem::zeroed() }
1209 }
1210 }
1211 #[cfg(feature = "Win32_Foundation")]
1212 impl ::std::cmp::PartialEq for INPUT_RECORD {
eq(&self, _other: &Self) -> bool1213 fn eq(&self, _other: &Self) -> bool {
1214 unimplemented!()
1215 }
1216 }
1217 #[cfg(feature = "Win32_Foundation")]
1218 impl ::std::cmp::Eq for INPUT_RECORD {}
1219 #[cfg(feature = "Win32_Foundation")]
1220 unsafe impl ::windows::runtime::Abi for INPUT_RECORD {
1221 type Abi = Self;
1222 type DefaultType = Self;
1223 }
1224 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
1225 #[repr(C)]
1226 #[cfg(feature = "Win32_Foundation")]
1227 pub union INPUT_RECORD_0 {
1228 pub KeyEvent: KEY_EVENT_RECORD,
1229 pub MouseEvent: MOUSE_EVENT_RECORD,
1230 pub WindowBufferSizeEvent: WINDOW_BUFFER_SIZE_RECORD,
1231 pub MenuEvent: MENU_EVENT_RECORD,
1232 pub FocusEvent: FOCUS_EVENT_RECORD,
1233 }
1234 #[cfg(feature = "Win32_Foundation")]
1235 impl INPUT_RECORD_0 {}
1236 #[cfg(feature = "Win32_Foundation")]
1237 impl ::std::default::Default for INPUT_RECORD_0 {
default() -> Self1238 fn default() -> Self {
1239 unsafe { ::std::mem::zeroed() }
1240 }
1241 }
1242 #[cfg(feature = "Win32_Foundation")]
1243 impl ::std::cmp::PartialEq for INPUT_RECORD_0 {
eq(&self, _other: &Self) -> bool1244 fn eq(&self, _other: &Self) -> bool {
1245 unimplemented!()
1246 }
1247 }
1248 #[cfg(feature = "Win32_Foundation")]
1249 impl ::std::cmp::Eq for INPUT_RECORD_0 {}
1250 #[cfg(feature = "Win32_Foundation")]
1251 unsafe impl ::windows::runtime::Abi for INPUT_RECORD_0 {
1252 type Abi = Self;
1253 type DefaultType = Self;
1254 }
1255 pub const KEY_EVENT: u32 = 1u32;
1256 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
1257 #[repr(C)]
1258 #[cfg(feature = "Win32_Foundation")]
1259 pub struct KEY_EVENT_RECORD {
1260 pub bKeyDown: super::super::Foundation::BOOL,
1261 pub wRepeatCount: u16,
1262 pub wVirtualKeyCode: u16,
1263 pub wVirtualScanCode: u16,
1264 pub uChar: KEY_EVENT_RECORD_0,
1265 pub dwControlKeyState: u32,
1266 }
1267 #[cfg(feature = "Win32_Foundation")]
1268 impl KEY_EVENT_RECORD {}
1269 #[cfg(feature = "Win32_Foundation")]
1270 impl ::std::default::Default for KEY_EVENT_RECORD {
default() -> Self1271 fn default() -> Self {
1272 unsafe { ::std::mem::zeroed() }
1273 }
1274 }
1275 #[cfg(feature = "Win32_Foundation")]
1276 impl ::std::cmp::PartialEq for KEY_EVENT_RECORD {
eq(&self, _other: &Self) -> bool1277 fn eq(&self, _other: &Self) -> bool {
1278 unimplemented!()
1279 }
1280 }
1281 #[cfg(feature = "Win32_Foundation")]
1282 impl ::std::cmp::Eq for KEY_EVENT_RECORD {}
1283 #[cfg(feature = "Win32_Foundation")]
1284 unsafe impl ::windows::runtime::Abi for KEY_EVENT_RECORD {
1285 type Abi = Self;
1286 type DefaultType = Self;
1287 }
1288 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
1289 #[repr(C)]
1290 #[cfg(feature = "Win32_Foundation")]
1291 pub union KEY_EVENT_RECORD_0 {
1292 pub UnicodeChar: u16,
1293 pub AsciiChar: super::super::Foundation::CHAR,
1294 }
1295 #[cfg(feature = "Win32_Foundation")]
1296 impl KEY_EVENT_RECORD_0 {}
1297 #[cfg(feature = "Win32_Foundation")]
1298 impl ::std::default::Default for KEY_EVENT_RECORD_0 {
default() -> Self1299 fn default() -> Self {
1300 unsafe { ::std::mem::zeroed() }
1301 }
1302 }
1303 #[cfg(feature = "Win32_Foundation")]
1304 impl ::std::cmp::PartialEq for KEY_EVENT_RECORD_0 {
eq(&self, _other: &Self) -> bool1305 fn eq(&self, _other: &Self) -> bool {
1306 unimplemented!()
1307 }
1308 }
1309 #[cfg(feature = "Win32_Foundation")]
1310 impl ::std::cmp::Eq for KEY_EVENT_RECORD_0 {}
1311 #[cfg(feature = "Win32_Foundation")]
1312 unsafe impl ::windows::runtime::Abi for KEY_EVENT_RECORD_0 {
1313 type Abi = Self;
1314 type DefaultType = Self;
1315 }
1316 pub const LEFT_ALT_PRESSED: u32 = 2u32;
1317 pub const LEFT_CTRL_PRESSED: u32 = 8u32;
1318 pub const MENU_EVENT: u32 = 8u32;
1319 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
1320 #[repr(C)]
1321 pub struct MENU_EVENT_RECORD {
1322 pub dwCommandId: u32,
1323 }
1324 impl MENU_EVENT_RECORD {}
1325 impl ::std::default::Default for MENU_EVENT_RECORD {
default() -> Self1326 fn default() -> Self {
1327 unsafe { ::std::mem::zeroed() }
1328 }
1329 }
1330 impl ::std::fmt::Debug for MENU_EVENT_RECORD {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result1331 fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
1332 fmt.debug_struct("MENU_EVENT_RECORD").field("dwCommandId", &self.dwCommandId).finish()
1333 }
1334 }
1335 impl ::std::cmp::PartialEq for MENU_EVENT_RECORD {
eq(&self, other: &Self) -> bool1336 fn eq(&self, other: &Self) -> bool {
1337 self.dwCommandId == other.dwCommandId
1338 }
1339 }
1340 impl ::std::cmp::Eq for MENU_EVENT_RECORD {}
1341 unsafe impl ::windows::runtime::Abi for MENU_EVENT_RECORD {
1342 type Abi = Self;
1343 type DefaultType = Self;
1344 }
1345 pub const MOUSE_EVENT: u32 = 2u32;
1346 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
1347 #[repr(C)]
1348 pub struct MOUSE_EVENT_RECORD {
1349 pub dwMousePosition: COORD,
1350 pub dwButtonState: u32,
1351 pub dwControlKeyState: u32,
1352 pub dwEventFlags: u32,
1353 }
1354 impl MOUSE_EVENT_RECORD {}
1355 impl ::std::default::Default for MOUSE_EVENT_RECORD {
default() -> Self1356 fn default() -> Self {
1357 unsafe { ::std::mem::zeroed() }
1358 }
1359 }
1360 impl ::std::fmt::Debug for MOUSE_EVENT_RECORD {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result1361 fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
1362 fmt.debug_struct("MOUSE_EVENT_RECORD").field("dwMousePosition", &self.dwMousePosition).field("dwButtonState", &self.dwButtonState).field("dwControlKeyState", &self.dwControlKeyState).field("dwEventFlags", &self.dwEventFlags).finish()
1363 }
1364 }
1365 impl ::std::cmp::PartialEq for MOUSE_EVENT_RECORD {
eq(&self, other: &Self) -> bool1366 fn eq(&self, other: &Self) -> bool {
1367 self.dwMousePosition == other.dwMousePosition && self.dwButtonState == other.dwButtonState && self.dwControlKeyState == other.dwControlKeyState && self.dwEventFlags == other.dwEventFlags
1368 }
1369 }
1370 impl ::std::cmp::Eq for MOUSE_EVENT_RECORD {}
1371 unsafe impl ::windows::runtime::Abi for MOUSE_EVENT_RECORD {
1372 type Abi = Self;
1373 type DefaultType = Self;
1374 }
1375 pub const MOUSE_HWHEELED: u32 = 8u32;
1376 pub const MOUSE_MOVED: u32 = 1u32;
1377 pub const MOUSE_WHEELED: u32 = 4u32;
1378 pub const NLS_ALPHANUMERIC: u32 = 0u32;
1379 pub const NLS_DBCSCHAR: u32 = 65536u32;
1380 pub const NLS_HIRAGANA: u32 = 262144u32;
1381 pub const NLS_IME_CONVERSION: u32 = 8388608u32;
1382 pub const NLS_IME_DISABLE: u32 = 536870912u32;
1383 pub const NLS_KATAKANA: u32 = 131072u32;
1384 pub const NLS_ROMAN: u32 = 4194304u32;
1385 pub const NUMLOCK_ON: u32 = 32u32;
1386 #[cfg(feature = "Win32_Foundation")]
1387 pub type PHANDLER_ROUTINE = unsafe extern "system" fn(ctrltype: u32) -> super::super::Foundation::BOOL;
1388 pub const PSEUDOCONSOLE_INHERIT_CURSOR: u32 = 1u32;
1389 #[cfg(feature = "Win32_Foundation")]
1390 #[inline]
PeekConsoleInputA<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::HANDLE>>(hconsoleinput: Param0, lpbuffer: *mut INPUT_RECORD, nlength: u32, lpnumberofeventsread: *mut u32) -> super::super::Foundation::BOOL1391 pub unsafe fn PeekConsoleInputA<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::HANDLE>>(hconsoleinput: Param0, lpbuffer: *mut INPUT_RECORD, nlength: u32, lpnumberofeventsread: *mut u32) -> super::super::Foundation::BOOL {
1392 #[cfg(windows)]
1393 {
1394 #[link(name = "windows")]
1395 extern "system" {
1396 fn PeekConsoleInputA(hconsoleinput: super::super::Foundation::HANDLE, lpbuffer: *mut INPUT_RECORD, nlength: u32, lpnumberofeventsread: *mut u32) -> super::super::Foundation::BOOL;
1397 }
1398 ::std::mem::transmute(PeekConsoleInputA(hconsoleinput.into_param().abi(), ::std::mem::transmute(lpbuffer), ::std::mem::transmute(nlength), ::std::mem::transmute(lpnumberofeventsread)))
1399 }
1400 #[cfg(not(windows))]
1401 unimplemented!("Unsupported target OS");
1402 }
1403 #[cfg(feature = "Win32_Foundation")]
1404 #[inline]
PeekConsoleInputW<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::HANDLE>>(hconsoleinput: Param0, lpbuffer: *mut INPUT_RECORD, nlength: u32, lpnumberofeventsread: *mut u32) -> super::super::Foundation::BOOL1405 pub unsafe fn PeekConsoleInputW<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::HANDLE>>(hconsoleinput: Param0, lpbuffer: *mut INPUT_RECORD, nlength: u32, lpnumberofeventsread: *mut u32) -> super::super::Foundation::BOOL {
1406 #[cfg(windows)]
1407 {
1408 #[link(name = "windows")]
1409 extern "system" {
1410 fn PeekConsoleInputW(hconsoleinput: super::super::Foundation::HANDLE, lpbuffer: *mut INPUT_RECORD, nlength: u32, lpnumberofeventsread: *mut u32) -> super::super::Foundation::BOOL;
1411 }
1412 ::std::mem::transmute(PeekConsoleInputW(hconsoleinput.into_param().abi(), ::std::mem::transmute(lpbuffer), ::std::mem::transmute(nlength), ::std::mem::transmute(lpnumberofeventsread)))
1413 }
1414 #[cfg(not(windows))]
1415 unimplemented!("Unsupported target OS");
1416 }
1417 pub const RIGHTMOST_BUTTON_PRESSED: u32 = 2u32;
1418 pub const RIGHT_ALT_PRESSED: u32 = 1u32;
1419 pub const RIGHT_CTRL_PRESSED: u32 = 4u32;
1420 #[cfg(feature = "Win32_Foundation")]
1421 #[inline]
ReadConsoleA<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::HANDLE>>(hconsoleinput: Param0, lpbuffer: *mut ::std::ffi::c_void, nnumberofcharstoread: u32, lpnumberofcharsread: *mut u32, pinputcontrol: *const CONSOLE_READCONSOLE_CONTROL) -> super::super::Foundation::BOOL1422 pub unsafe fn ReadConsoleA<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::HANDLE>>(hconsoleinput: Param0, lpbuffer: *mut ::std::ffi::c_void, nnumberofcharstoread: u32, lpnumberofcharsread: *mut u32, pinputcontrol: *const CONSOLE_READCONSOLE_CONTROL) -> super::super::Foundation::BOOL {
1423 #[cfg(windows)]
1424 {
1425 #[link(name = "windows")]
1426 extern "system" {
1427 fn ReadConsoleA(hconsoleinput: super::super::Foundation::HANDLE, lpbuffer: *mut ::std::ffi::c_void, nnumberofcharstoread: u32, lpnumberofcharsread: *mut u32, pinputcontrol: *const CONSOLE_READCONSOLE_CONTROL) -> super::super::Foundation::BOOL;
1428 }
1429 ::std::mem::transmute(ReadConsoleA(hconsoleinput.into_param().abi(), ::std::mem::transmute(lpbuffer), ::std::mem::transmute(nnumberofcharstoread), ::std::mem::transmute(lpnumberofcharsread), ::std::mem::transmute(pinputcontrol)))
1430 }
1431 #[cfg(not(windows))]
1432 unimplemented!("Unsupported target OS");
1433 }
1434 #[cfg(feature = "Win32_Foundation")]
1435 #[inline]
ReadConsoleInputA<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::HANDLE>>(hconsoleinput: Param0, lpbuffer: *mut INPUT_RECORD, nlength: u32, lpnumberofeventsread: *mut u32) -> super::super::Foundation::BOOL1436 pub unsafe fn ReadConsoleInputA<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::HANDLE>>(hconsoleinput: Param0, lpbuffer: *mut INPUT_RECORD, nlength: u32, lpnumberofeventsread: *mut u32) -> super::super::Foundation::BOOL {
1437 #[cfg(windows)]
1438 {
1439 #[link(name = "windows")]
1440 extern "system" {
1441 fn ReadConsoleInputA(hconsoleinput: super::super::Foundation::HANDLE, lpbuffer: *mut INPUT_RECORD, nlength: u32, lpnumberofeventsread: *mut u32) -> super::super::Foundation::BOOL;
1442 }
1443 ::std::mem::transmute(ReadConsoleInputA(hconsoleinput.into_param().abi(), ::std::mem::transmute(lpbuffer), ::std::mem::transmute(nlength), ::std::mem::transmute(lpnumberofeventsread)))
1444 }
1445 #[cfg(not(windows))]
1446 unimplemented!("Unsupported target OS");
1447 }
1448 #[cfg(feature = "Win32_Foundation")]
1449 #[inline]
ReadConsoleInputW<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::HANDLE>>(hconsoleinput: Param0, lpbuffer: *mut INPUT_RECORD, nlength: u32, lpnumberofeventsread: *mut u32) -> super::super::Foundation::BOOL1450 pub unsafe fn ReadConsoleInputW<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::HANDLE>>(hconsoleinput: Param0, lpbuffer: *mut INPUT_RECORD, nlength: u32, lpnumberofeventsread: *mut u32) -> super::super::Foundation::BOOL {
1451 #[cfg(windows)]
1452 {
1453 #[link(name = "windows")]
1454 extern "system" {
1455 fn ReadConsoleInputW(hconsoleinput: super::super::Foundation::HANDLE, lpbuffer: *mut INPUT_RECORD, nlength: u32, lpnumberofeventsread: *mut u32) -> super::super::Foundation::BOOL;
1456 }
1457 ::std::mem::transmute(ReadConsoleInputW(hconsoleinput.into_param().abi(), ::std::mem::transmute(lpbuffer), ::std::mem::transmute(nlength), ::std::mem::transmute(lpnumberofeventsread)))
1458 }
1459 #[cfg(not(windows))]
1460 unimplemented!("Unsupported target OS");
1461 }
1462 #[cfg(feature = "Win32_Foundation")]
1463 #[inline]
ReadConsoleOutputA<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::HANDLE>, Param2: ::windows::runtime::IntoParam<'a, COORD>, Param3: ::windows::runtime::IntoParam<'a, COORD>>(hconsoleoutput: Param0, lpbuffer: *mut CHAR_INFO, dwbuffersize: Param2, dwbuffercoord: Param3, lpreadregion: *mut SMALL_RECT) -> super::super::Foundation::BOOL1464 pub unsafe fn ReadConsoleOutputA<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::HANDLE>, Param2: ::windows::runtime::IntoParam<'a, COORD>, Param3: ::windows::runtime::IntoParam<'a, COORD>>(hconsoleoutput: Param0, lpbuffer: *mut CHAR_INFO, dwbuffersize: Param2, dwbuffercoord: Param3, lpreadregion: *mut SMALL_RECT) -> super::super::Foundation::BOOL {
1465 #[cfg(windows)]
1466 {
1467 #[link(name = "windows")]
1468 extern "system" {
1469 fn ReadConsoleOutputA(hconsoleoutput: super::super::Foundation::HANDLE, lpbuffer: *mut CHAR_INFO, dwbuffersize: COORD, dwbuffercoord: COORD, lpreadregion: *mut SMALL_RECT) -> super::super::Foundation::BOOL;
1470 }
1471 ::std::mem::transmute(ReadConsoleOutputA(hconsoleoutput.into_param().abi(), ::std::mem::transmute(lpbuffer), dwbuffersize.into_param().abi(), dwbuffercoord.into_param().abi(), ::std::mem::transmute(lpreadregion)))
1472 }
1473 #[cfg(not(windows))]
1474 unimplemented!("Unsupported target OS");
1475 }
1476 #[cfg(feature = "Win32_Foundation")]
1477 #[inline]
ReadConsoleOutputAttribute<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::HANDLE>, Param3: ::windows::runtime::IntoParam<'a, COORD>>(hconsoleoutput: Param0, lpattribute: *mut u16, nlength: u32, dwreadcoord: Param3, lpnumberofattrsread: *mut u32) -> super::super::Foundation::BOOL1478 pub unsafe fn ReadConsoleOutputAttribute<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::HANDLE>, Param3: ::windows::runtime::IntoParam<'a, COORD>>(hconsoleoutput: Param0, lpattribute: *mut u16, nlength: u32, dwreadcoord: Param3, lpnumberofattrsread: *mut u32) -> super::super::Foundation::BOOL {
1479 #[cfg(windows)]
1480 {
1481 #[link(name = "windows")]
1482 extern "system" {
1483 fn ReadConsoleOutputAttribute(hconsoleoutput: super::super::Foundation::HANDLE, lpattribute: *mut u16, nlength: u32, dwreadcoord: COORD, lpnumberofattrsread: *mut u32) -> super::super::Foundation::BOOL;
1484 }
1485 ::std::mem::transmute(ReadConsoleOutputAttribute(hconsoleoutput.into_param().abi(), ::std::mem::transmute(lpattribute), ::std::mem::transmute(nlength), dwreadcoord.into_param().abi(), ::std::mem::transmute(lpnumberofattrsread)))
1486 }
1487 #[cfg(not(windows))]
1488 unimplemented!("Unsupported target OS");
1489 }
1490 #[cfg(feature = "Win32_Foundation")]
1491 #[inline]
ReadConsoleOutputCharacterA<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::HANDLE>, Param3: ::windows::runtime::IntoParam<'a, COORD>>(hconsoleoutput: Param0, lpcharacter: super::super::Foundation::PSTR, nlength: u32, dwreadcoord: Param3, lpnumberofcharsread: *mut u32) -> super::super::Foundation::BOOL1492 pub unsafe fn ReadConsoleOutputCharacterA<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::HANDLE>, Param3: ::windows::runtime::IntoParam<'a, COORD>>(hconsoleoutput: Param0, lpcharacter: super::super::Foundation::PSTR, nlength: u32, dwreadcoord: Param3, lpnumberofcharsread: *mut u32) -> super::super::Foundation::BOOL {
1493 #[cfg(windows)]
1494 {
1495 #[link(name = "windows")]
1496 extern "system" {
1497 fn ReadConsoleOutputCharacterA(hconsoleoutput: super::super::Foundation::HANDLE, lpcharacter: super::super::Foundation::PSTR, nlength: u32, dwreadcoord: COORD, lpnumberofcharsread: *mut u32) -> super::super::Foundation::BOOL;
1498 }
1499 ::std::mem::transmute(ReadConsoleOutputCharacterA(hconsoleoutput.into_param().abi(), ::std::mem::transmute(lpcharacter), ::std::mem::transmute(nlength), dwreadcoord.into_param().abi(), ::std::mem::transmute(lpnumberofcharsread)))
1500 }
1501 #[cfg(not(windows))]
1502 unimplemented!("Unsupported target OS");
1503 }
1504 #[cfg(feature = "Win32_Foundation")]
1505 #[inline]
ReadConsoleOutputCharacterW<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::HANDLE>, Param3: ::windows::runtime::IntoParam<'a, COORD>>(hconsoleoutput: Param0, lpcharacter: super::super::Foundation::PWSTR, nlength: u32, dwreadcoord: Param3, lpnumberofcharsread: *mut u32) -> super::super::Foundation::BOOL1506 pub unsafe fn ReadConsoleOutputCharacterW<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::HANDLE>, Param3: ::windows::runtime::IntoParam<'a, COORD>>(hconsoleoutput: Param0, lpcharacter: super::super::Foundation::PWSTR, nlength: u32, dwreadcoord: Param3, lpnumberofcharsread: *mut u32) -> super::super::Foundation::BOOL {
1507 #[cfg(windows)]
1508 {
1509 #[link(name = "windows")]
1510 extern "system" {
1511 fn ReadConsoleOutputCharacterW(hconsoleoutput: super::super::Foundation::HANDLE, lpcharacter: super::super::Foundation::PWSTR, nlength: u32, dwreadcoord: COORD, lpnumberofcharsread: *mut u32) -> super::super::Foundation::BOOL;
1512 }
1513 ::std::mem::transmute(ReadConsoleOutputCharacterW(hconsoleoutput.into_param().abi(), ::std::mem::transmute(lpcharacter), ::std::mem::transmute(nlength), dwreadcoord.into_param().abi(), ::std::mem::transmute(lpnumberofcharsread)))
1514 }
1515 #[cfg(not(windows))]
1516 unimplemented!("Unsupported target OS");
1517 }
1518 #[cfg(feature = "Win32_Foundation")]
1519 #[inline]
ReadConsoleOutputW<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::HANDLE>, Param2: ::windows::runtime::IntoParam<'a, COORD>, Param3: ::windows::runtime::IntoParam<'a, COORD>>(hconsoleoutput: Param0, lpbuffer: *mut CHAR_INFO, dwbuffersize: Param2, dwbuffercoord: Param3, lpreadregion: *mut SMALL_RECT) -> super::super::Foundation::BOOL1520 pub unsafe fn ReadConsoleOutputW<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::HANDLE>, Param2: ::windows::runtime::IntoParam<'a, COORD>, Param3: ::windows::runtime::IntoParam<'a, COORD>>(hconsoleoutput: Param0, lpbuffer: *mut CHAR_INFO, dwbuffersize: Param2, dwbuffercoord: Param3, lpreadregion: *mut SMALL_RECT) -> super::super::Foundation::BOOL {
1521 #[cfg(windows)]
1522 {
1523 #[link(name = "windows")]
1524 extern "system" {
1525 fn ReadConsoleOutputW(hconsoleoutput: super::super::Foundation::HANDLE, lpbuffer: *mut CHAR_INFO, dwbuffersize: COORD, dwbuffercoord: COORD, lpreadregion: *mut SMALL_RECT) -> super::super::Foundation::BOOL;
1526 }
1527 ::std::mem::transmute(ReadConsoleOutputW(hconsoleoutput.into_param().abi(), ::std::mem::transmute(lpbuffer), dwbuffersize.into_param().abi(), dwbuffercoord.into_param().abi(), ::std::mem::transmute(lpreadregion)))
1528 }
1529 #[cfg(not(windows))]
1530 unimplemented!("Unsupported target OS");
1531 }
1532 #[cfg(feature = "Win32_Foundation")]
1533 #[inline]
ReadConsoleW<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::HANDLE>>(hconsoleinput: Param0, lpbuffer: *mut ::std::ffi::c_void, nnumberofcharstoread: u32, lpnumberofcharsread: *mut u32, pinputcontrol: *const CONSOLE_READCONSOLE_CONTROL) -> super::super::Foundation::BOOL1534 pub unsafe fn ReadConsoleW<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::HANDLE>>(hconsoleinput: Param0, lpbuffer: *mut ::std::ffi::c_void, nnumberofcharstoread: u32, lpnumberofcharsread: *mut u32, pinputcontrol: *const CONSOLE_READCONSOLE_CONTROL) -> super::super::Foundation::BOOL {
1535 #[cfg(windows)]
1536 {
1537 #[link(name = "windows")]
1538 extern "system" {
1539 fn ReadConsoleW(hconsoleinput: super::super::Foundation::HANDLE, lpbuffer: *mut ::std::ffi::c_void, nnumberofcharstoread: u32, lpnumberofcharsread: *mut u32, pinputcontrol: *const CONSOLE_READCONSOLE_CONTROL) -> super::super::Foundation::BOOL;
1540 }
1541 ::std::mem::transmute(ReadConsoleW(hconsoleinput.into_param().abi(), ::std::mem::transmute(lpbuffer), ::std::mem::transmute(nnumberofcharstoread), ::std::mem::transmute(lpnumberofcharsread), ::std::mem::transmute(pinputcontrol)))
1542 }
1543 #[cfg(not(windows))]
1544 unimplemented!("Unsupported target OS");
1545 }
1546 #[inline]
ResizePseudoConsole<'a, Param0: ::windows::runtime::IntoParam<'a, HPCON>, Param1: ::windows::runtime::IntoParam<'a, COORD>>(hpc: Param0, size: Param1) -> ::windows::runtime::Result<()>1547 pub unsafe fn ResizePseudoConsole<'a, Param0: ::windows::runtime::IntoParam<'a, HPCON>, Param1: ::windows::runtime::IntoParam<'a, COORD>>(hpc: Param0, size: Param1) -> ::windows::runtime::Result<()> {
1548 #[cfg(windows)]
1549 {
1550 #[link(name = "windows")]
1551 extern "system" {
1552 fn ResizePseudoConsole(hpc: HPCON, size: COORD) -> ::windows::runtime::HRESULT;
1553 }
1554 ResizePseudoConsole(hpc.into_param().abi(), size.into_param().abi()).ok()
1555 }
1556 #[cfg(not(windows))]
1557 unimplemented!("Unsupported target OS");
1558 }
1559 pub const SCROLLLOCK_ON: u32 = 64u32;
1560 pub const SHIFT_PRESSED: u32 = 16u32;
1561 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
1562 #[repr(C)]
1563 pub struct SMALL_RECT {
1564 pub Left: i16,
1565 pub Top: i16,
1566 pub Right: i16,
1567 pub Bottom: i16,
1568 }
1569 impl SMALL_RECT {}
1570 impl ::std::default::Default for SMALL_RECT {
default() -> Self1571 fn default() -> Self {
1572 unsafe { ::std::mem::zeroed() }
1573 }
1574 }
1575 impl ::std::fmt::Debug for SMALL_RECT {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result1576 fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
1577 fmt.debug_struct("SMALL_RECT").field("Left", &self.Left).field("Top", &self.Top).field("Right", &self.Right).field("Bottom", &self.Bottom).finish()
1578 }
1579 }
1580 impl ::std::cmp::PartialEq for SMALL_RECT {
eq(&self, other: &Self) -> bool1581 fn eq(&self, other: &Self) -> bool {
1582 self.Left == other.Left && self.Top == other.Top && self.Right == other.Right && self.Bottom == other.Bottom
1583 }
1584 }
1585 impl ::std::cmp::Eq for SMALL_RECT {}
1586 unsafe impl ::windows::runtime::Abi for SMALL_RECT {
1587 type Abi = Self;
1588 type DefaultType = Self;
1589 }
1590 #[derive(:: std :: cmp :: PartialEq, :: std :: cmp :: Eq, :: std :: marker :: Copy, :: std :: clone :: Clone, :: std :: default :: Default, :: std :: fmt :: Debug)]
1591 #[repr(transparent)]
1592 pub struct STD_HANDLE(pub u32);
1593 pub const STD_INPUT_HANDLE: STD_HANDLE = STD_HANDLE(4294967286u32);
1594 pub const STD_OUTPUT_HANDLE: STD_HANDLE = STD_HANDLE(4294967285u32);
1595 pub const STD_ERROR_HANDLE: STD_HANDLE = STD_HANDLE(4294967284u32);
1596 impl ::std::convert::From<u32> for STD_HANDLE {
from(value: u32) -> Self1597 fn from(value: u32) -> Self {
1598 Self(value)
1599 }
1600 }
1601 unsafe impl ::windows::runtime::Abi for STD_HANDLE {
1602 type Abi = Self;
1603 type DefaultType = Self;
1604 }
1605 impl ::std::ops::BitOr for STD_HANDLE {
1606 type Output = Self;
bitor(self, rhs: Self) -> Self1607 fn bitor(self, rhs: Self) -> Self {
1608 Self(self.0 | rhs.0)
1609 }
1610 }
1611 impl ::std::ops::BitAnd for STD_HANDLE {
1612 type Output = Self;
bitand(self, rhs: Self) -> Self1613 fn bitand(self, rhs: Self) -> Self {
1614 Self(self.0 & rhs.0)
1615 }
1616 }
1617 impl ::std::ops::BitOrAssign for STD_HANDLE {
bitor_assign(&mut self, rhs: Self)1618 fn bitor_assign(&mut self, rhs: Self) {
1619 self.0.bitor_assign(rhs.0)
1620 }
1621 }
1622 impl ::std::ops::BitAndAssign for STD_HANDLE {
bitand_assign(&mut self, rhs: Self)1623 fn bitand_assign(&mut self, rhs: Self) {
1624 self.0.bitand_assign(rhs.0)
1625 }
1626 }
1627 impl ::std::ops::Not for STD_HANDLE {
1628 type Output = Self;
not(self) -> Self1629 fn not(self) -> Self {
1630 Self(self.0.not())
1631 }
1632 }
1633 #[cfg(feature = "Win32_Foundation")]
1634 #[inline]
ScrollConsoleScreenBufferA<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::HANDLE>, Param3: ::windows::runtime::IntoParam<'a, COORD>>(hconsoleoutput: Param0, lpscrollrectangle: *const SMALL_RECT, lpcliprectangle: *const SMALL_RECT, dwdestinationorigin: Param3, lpfill: *const CHAR_INFO) -> super::super::Foundation::BOOL1635 pub unsafe fn ScrollConsoleScreenBufferA<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::HANDLE>, Param3: ::windows::runtime::IntoParam<'a, COORD>>(hconsoleoutput: Param0, lpscrollrectangle: *const SMALL_RECT, lpcliprectangle: *const SMALL_RECT, dwdestinationorigin: Param3, lpfill: *const CHAR_INFO) -> super::super::Foundation::BOOL {
1636 #[cfg(windows)]
1637 {
1638 #[link(name = "windows")]
1639 extern "system" {
1640 fn ScrollConsoleScreenBufferA(hconsoleoutput: super::super::Foundation::HANDLE, lpscrollrectangle: *const SMALL_RECT, lpcliprectangle: *const SMALL_RECT, dwdestinationorigin: COORD, lpfill: *const CHAR_INFO) -> super::super::Foundation::BOOL;
1641 }
1642 ::std::mem::transmute(ScrollConsoleScreenBufferA(hconsoleoutput.into_param().abi(), ::std::mem::transmute(lpscrollrectangle), ::std::mem::transmute(lpcliprectangle), dwdestinationorigin.into_param().abi(), ::std::mem::transmute(lpfill)))
1643 }
1644 #[cfg(not(windows))]
1645 unimplemented!("Unsupported target OS");
1646 }
1647 #[cfg(feature = "Win32_Foundation")]
1648 #[inline]
ScrollConsoleScreenBufferW<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::HANDLE>, Param3: ::windows::runtime::IntoParam<'a, COORD>>(hconsoleoutput: Param0, lpscrollrectangle: *const SMALL_RECT, lpcliprectangle: *const SMALL_RECT, dwdestinationorigin: Param3, lpfill: *const CHAR_INFO) -> super::super::Foundation::BOOL1649 pub unsafe fn ScrollConsoleScreenBufferW<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::HANDLE>, Param3: ::windows::runtime::IntoParam<'a, COORD>>(hconsoleoutput: Param0, lpscrollrectangle: *const SMALL_RECT, lpcliprectangle: *const SMALL_RECT, dwdestinationorigin: Param3, lpfill: *const CHAR_INFO) -> super::super::Foundation::BOOL {
1650 #[cfg(windows)]
1651 {
1652 #[link(name = "windows")]
1653 extern "system" {
1654 fn ScrollConsoleScreenBufferW(hconsoleoutput: super::super::Foundation::HANDLE, lpscrollrectangle: *const SMALL_RECT, lpcliprectangle: *const SMALL_RECT, dwdestinationorigin: COORD, lpfill: *const CHAR_INFO) -> super::super::Foundation::BOOL;
1655 }
1656 ::std::mem::transmute(ScrollConsoleScreenBufferW(hconsoleoutput.into_param().abi(), ::std::mem::transmute(lpscrollrectangle), ::std::mem::transmute(lpcliprectangle), dwdestinationorigin.into_param().abi(), ::std::mem::transmute(lpfill)))
1657 }
1658 #[cfg(not(windows))]
1659 unimplemented!("Unsupported target OS");
1660 }
1661 #[cfg(feature = "Win32_Foundation")]
1662 #[inline]
SetConsoleActiveScreenBuffer<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::HANDLE>>(hconsoleoutput: Param0) -> super::super::Foundation::BOOL1663 pub unsafe fn SetConsoleActiveScreenBuffer<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::HANDLE>>(hconsoleoutput: Param0) -> super::super::Foundation::BOOL {
1664 #[cfg(windows)]
1665 {
1666 #[link(name = "windows")]
1667 extern "system" {
1668 fn SetConsoleActiveScreenBuffer(hconsoleoutput: super::super::Foundation::HANDLE) -> super::super::Foundation::BOOL;
1669 }
1670 ::std::mem::transmute(SetConsoleActiveScreenBuffer(hconsoleoutput.into_param().abi()))
1671 }
1672 #[cfg(not(windows))]
1673 unimplemented!("Unsupported target OS");
1674 }
1675 #[cfg(feature = "Win32_Foundation")]
1676 #[inline]
SetConsoleCP(wcodepageid: u32) -> super::super::Foundation::BOOL1677 pub unsafe fn SetConsoleCP(wcodepageid: u32) -> super::super::Foundation::BOOL {
1678 #[cfg(windows)]
1679 {
1680 #[link(name = "windows")]
1681 extern "system" {
1682 fn SetConsoleCP(wcodepageid: u32) -> super::super::Foundation::BOOL;
1683 }
1684 ::std::mem::transmute(SetConsoleCP(::std::mem::transmute(wcodepageid)))
1685 }
1686 #[cfg(not(windows))]
1687 unimplemented!("Unsupported target OS");
1688 }
1689 #[cfg(feature = "Win32_Foundation")]
1690 #[inline]
SetConsoleCtrlHandler<'a, Param1: ::windows::runtime::IntoParam<'a, super::super::Foundation::BOOL>>(handlerroutine: ::std::option::Option<PHANDLER_ROUTINE>, add: Param1) -> super::super::Foundation::BOOL1691 pub unsafe fn SetConsoleCtrlHandler<'a, Param1: ::windows::runtime::IntoParam<'a, super::super::Foundation::BOOL>>(handlerroutine: ::std::option::Option<PHANDLER_ROUTINE>, add: Param1) -> super::super::Foundation::BOOL {
1692 #[cfg(windows)]
1693 {
1694 #[link(name = "windows")]
1695 extern "system" {
1696 fn SetConsoleCtrlHandler(handlerroutine: ::windows::runtime::RawPtr, add: super::super::Foundation::BOOL) -> super::super::Foundation::BOOL;
1697 }
1698 ::std::mem::transmute(SetConsoleCtrlHandler(::std::mem::transmute(handlerroutine), add.into_param().abi()))
1699 }
1700 #[cfg(not(windows))]
1701 unimplemented!("Unsupported target OS");
1702 }
1703 #[cfg(feature = "Win32_Foundation")]
1704 #[inline]
SetConsoleCursorInfo<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::HANDLE>>(hconsoleoutput: Param0, lpconsolecursorinfo: *const CONSOLE_CURSOR_INFO) -> super::super::Foundation::BOOL1705 pub unsafe fn SetConsoleCursorInfo<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::HANDLE>>(hconsoleoutput: Param0, lpconsolecursorinfo: *const CONSOLE_CURSOR_INFO) -> super::super::Foundation::BOOL {
1706 #[cfg(windows)]
1707 {
1708 #[link(name = "windows")]
1709 extern "system" {
1710 fn SetConsoleCursorInfo(hconsoleoutput: super::super::Foundation::HANDLE, lpconsolecursorinfo: *const CONSOLE_CURSOR_INFO) -> super::super::Foundation::BOOL;
1711 }
1712 ::std::mem::transmute(SetConsoleCursorInfo(hconsoleoutput.into_param().abi(), ::std::mem::transmute(lpconsolecursorinfo)))
1713 }
1714 #[cfg(not(windows))]
1715 unimplemented!("Unsupported target OS");
1716 }
1717 #[cfg(feature = "Win32_Foundation")]
1718 #[inline]
SetConsoleCursorPosition<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::HANDLE>, Param1: ::windows::runtime::IntoParam<'a, COORD>>(hconsoleoutput: Param0, dwcursorposition: Param1) -> super::super::Foundation::BOOL1719 pub unsafe fn SetConsoleCursorPosition<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::HANDLE>, Param1: ::windows::runtime::IntoParam<'a, COORD>>(hconsoleoutput: Param0, dwcursorposition: Param1) -> super::super::Foundation::BOOL {
1720 #[cfg(windows)]
1721 {
1722 #[link(name = "windows")]
1723 extern "system" {
1724 fn SetConsoleCursorPosition(hconsoleoutput: super::super::Foundation::HANDLE, dwcursorposition: COORD) -> super::super::Foundation::BOOL;
1725 }
1726 ::std::mem::transmute(SetConsoleCursorPosition(hconsoleoutput.into_param().abi(), dwcursorposition.into_param().abi()))
1727 }
1728 #[cfg(not(windows))]
1729 unimplemented!("Unsupported target OS");
1730 }
1731 #[cfg(feature = "Win32_Foundation")]
1732 #[inline]
SetConsoleDisplayMode<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::HANDLE>>(hconsoleoutput: Param0, dwflags: u32, lpnewscreenbufferdimensions: *mut COORD) -> super::super::Foundation::BOOL1733 pub unsafe fn SetConsoleDisplayMode<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::HANDLE>>(hconsoleoutput: Param0, dwflags: u32, lpnewscreenbufferdimensions: *mut COORD) -> super::super::Foundation::BOOL {
1734 #[cfg(windows)]
1735 {
1736 #[link(name = "windows")]
1737 extern "system" {
1738 fn SetConsoleDisplayMode(hconsoleoutput: super::super::Foundation::HANDLE, dwflags: u32, lpnewscreenbufferdimensions: *mut COORD) -> super::super::Foundation::BOOL;
1739 }
1740 ::std::mem::transmute(SetConsoleDisplayMode(hconsoleoutput.into_param().abi(), ::std::mem::transmute(dwflags), ::std::mem::transmute(lpnewscreenbufferdimensions)))
1741 }
1742 #[cfg(not(windows))]
1743 unimplemented!("Unsupported target OS");
1744 }
1745 #[cfg(feature = "Win32_Foundation")]
1746 #[inline]
SetConsoleHistoryInfo(lpconsolehistoryinfo: *const CONSOLE_HISTORY_INFO) -> super::super::Foundation::BOOL1747 pub unsafe fn SetConsoleHistoryInfo(lpconsolehistoryinfo: *const CONSOLE_HISTORY_INFO) -> super::super::Foundation::BOOL {
1748 #[cfg(windows)]
1749 {
1750 #[link(name = "windows")]
1751 extern "system" {
1752 fn SetConsoleHistoryInfo(lpconsolehistoryinfo: *const CONSOLE_HISTORY_INFO) -> super::super::Foundation::BOOL;
1753 }
1754 ::std::mem::transmute(SetConsoleHistoryInfo(::std::mem::transmute(lpconsolehistoryinfo)))
1755 }
1756 #[cfg(not(windows))]
1757 unimplemented!("Unsupported target OS");
1758 }
1759 #[cfg(feature = "Win32_Foundation")]
1760 #[inline]
SetConsoleMode<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::HANDLE>>(hconsolehandle: Param0, dwmode: CONSOLE_MODE) -> super::super::Foundation::BOOL1761 pub unsafe fn SetConsoleMode<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::HANDLE>>(hconsolehandle: Param0, dwmode: CONSOLE_MODE) -> super::super::Foundation::BOOL {
1762 #[cfg(windows)]
1763 {
1764 #[link(name = "windows")]
1765 extern "system" {
1766 fn SetConsoleMode(hconsolehandle: super::super::Foundation::HANDLE, dwmode: CONSOLE_MODE) -> super::super::Foundation::BOOL;
1767 }
1768 ::std::mem::transmute(SetConsoleMode(hconsolehandle.into_param().abi(), ::std::mem::transmute(dwmode)))
1769 }
1770 #[cfg(not(windows))]
1771 unimplemented!("Unsupported target OS");
1772 }
1773 #[cfg(feature = "Win32_Foundation")]
1774 #[inline]
SetConsoleNumberOfCommandsA<'a, Param1: ::windows::runtime::IntoParam<'a, super::super::Foundation::PSTR>>(number: u32, exename: Param1) -> super::super::Foundation::BOOL1775 pub unsafe fn SetConsoleNumberOfCommandsA<'a, Param1: ::windows::runtime::IntoParam<'a, super::super::Foundation::PSTR>>(number: u32, exename: Param1) -> super::super::Foundation::BOOL {
1776 #[cfg(windows)]
1777 {
1778 #[link(name = "windows")]
1779 extern "system" {
1780 fn SetConsoleNumberOfCommandsA(number: u32, exename: super::super::Foundation::PSTR) -> super::super::Foundation::BOOL;
1781 }
1782 ::std::mem::transmute(SetConsoleNumberOfCommandsA(::std::mem::transmute(number), exename.into_param().abi()))
1783 }
1784 #[cfg(not(windows))]
1785 unimplemented!("Unsupported target OS");
1786 }
1787 #[cfg(feature = "Win32_Foundation")]
1788 #[inline]
SetConsoleNumberOfCommandsW<'a, Param1: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>>(number: u32, exename: Param1) -> super::super::Foundation::BOOL1789 pub unsafe fn SetConsoleNumberOfCommandsW<'a, Param1: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>>(number: u32, exename: Param1) -> super::super::Foundation::BOOL {
1790 #[cfg(windows)]
1791 {
1792 #[link(name = "windows")]
1793 extern "system" {
1794 fn SetConsoleNumberOfCommandsW(number: u32, exename: super::super::Foundation::PWSTR) -> super::super::Foundation::BOOL;
1795 }
1796 ::std::mem::transmute(SetConsoleNumberOfCommandsW(::std::mem::transmute(number), exename.into_param().abi()))
1797 }
1798 #[cfg(not(windows))]
1799 unimplemented!("Unsupported target OS");
1800 }
1801 #[cfg(feature = "Win32_Foundation")]
1802 #[inline]
SetConsoleOutputCP(wcodepageid: u32) -> super::super::Foundation::BOOL1803 pub unsafe fn SetConsoleOutputCP(wcodepageid: u32) -> super::super::Foundation::BOOL {
1804 #[cfg(windows)]
1805 {
1806 #[link(name = "windows")]
1807 extern "system" {
1808 fn SetConsoleOutputCP(wcodepageid: u32) -> super::super::Foundation::BOOL;
1809 }
1810 ::std::mem::transmute(SetConsoleOutputCP(::std::mem::transmute(wcodepageid)))
1811 }
1812 #[cfg(not(windows))]
1813 unimplemented!("Unsupported target OS");
1814 }
1815 #[cfg(feature = "Win32_Foundation")]
1816 #[inline]
SetConsoleScreenBufferInfoEx<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::HANDLE>>(hconsoleoutput: Param0, lpconsolescreenbufferinfoex: *const CONSOLE_SCREEN_BUFFER_INFOEX) -> super::super::Foundation::BOOL1817 pub unsafe fn SetConsoleScreenBufferInfoEx<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::HANDLE>>(hconsoleoutput: Param0, lpconsolescreenbufferinfoex: *const CONSOLE_SCREEN_BUFFER_INFOEX) -> super::super::Foundation::BOOL {
1818 #[cfg(windows)]
1819 {
1820 #[link(name = "windows")]
1821 extern "system" {
1822 fn SetConsoleScreenBufferInfoEx(hconsoleoutput: super::super::Foundation::HANDLE, lpconsolescreenbufferinfoex: *const CONSOLE_SCREEN_BUFFER_INFOEX) -> super::super::Foundation::BOOL;
1823 }
1824 ::std::mem::transmute(SetConsoleScreenBufferInfoEx(hconsoleoutput.into_param().abi(), ::std::mem::transmute(lpconsolescreenbufferinfoex)))
1825 }
1826 #[cfg(not(windows))]
1827 unimplemented!("Unsupported target OS");
1828 }
1829 #[cfg(feature = "Win32_Foundation")]
1830 #[inline]
SetConsoleScreenBufferSize<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::HANDLE>, Param1: ::windows::runtime::IntoParam<'a, COORD>>(hconsoleoutput: Param0, dwsize: Param1) -> super::super::Foundation::BOOL1831 pub unsafe fn SetConsoleScreenBufferSize<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::HANDLE>, Param1: ::windows::runtime::IntoParam<'a, COORD>>(hconsoleoutput: Param0, dwsize: Param1) -> super::super::Foundation::BOOL {
1832 #[cfg(windows)]
1833 {
1834 #[link(name = "windows")]
1835 extern "system" {
1836 fn SetConsoleScreenBufferSize(hconsoleoutput: super::super::Foundation::HANDLE, dwsize: COORD) -> super::super::Foundation::BOOL;
1837 }
1838 ::std::mem::transmute(SetConsoleScreenBufferSize(hconsoleoutput.into_param().abi(), dwsize.into_param().abi()))
1839 }
1840 #[cfg(not(windows))]
1841 unimplemented!("Unsupported target OS");
1842 }
1843 #[cfg(feature = "Win32_Foundation")]
1844 #[inline]
SetConsoleTextAttribute<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::HANDLE>>(hconsoleoutput: Param0, wattributes: u16) -> super::super::Foundation::BOOL1845 pub unsafe fn SetConsoleTextAttribute<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::HANDLE>>(hconsoleoutput: Param0, wattributes: u16) -> super::super::Foundation::BOOL {
1846 #[cfg(windows)]
1847 {
1848 #[link(name = "windows")]
1849 extern "system" {
1850 fn SetConsoleTextAttribute(hconsoleoutput: super::super::Foundation::HANDLE, wattributes: u16) -> super::super::Foundation::BOOL;
1851 }
1852 ::std::mem::transmute(SetConsoleTextAttribute(hconsoleoutput.into_param().abi(), ::std::mem::transmute(wattributes)))
1853 }
1854 #[cfg(not(windows))]
1855 unimplemented!("Unsupported target OS");
1856 }
1857 #[cfg(feature = "Win32_Foundation")]
1858 #[inline]
SetConsoleTitleA<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::PSTR>>(lpconsoletitle: Param0) -> super::super::Foundation::BOOL1859 pub unsafe fn SetConsoleTitleA<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::PSTR>>(lpconsoletitle: Param0) -> super::super::Foundation::BOOL {
1860 #[cfg(windows)]
1861 {
1862 #[link(name = "windows")]
1863 extern "system" {
1864 fn SetConsoleTitleA(lpconsoletitle: super::super::Foundation::PSTR) -> super::super::Foundation::BOOL;
1865 }
1866 ::std::mem::transmute(SetConsoleTitleA(lpconsoletitle.into_param().abi()))
1867 }
1868 #[cfg(not(windows))]
1869 unimplemented!("Unsupported target OS");
1870 }
1871 #[cfg(feature = "Win32_Foundation")]
1872 #[inline]
SetConsoleTitleW<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>>(lpconsoletitle: Param0) -> super::super::Foundation::BOOL1873 pub unsafe fn SetConsoleTitleW<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>>(lpconsoletitle: Param0) -> super::super::Foundation::BOOL {
1874 #[cfg(windows)]
1875 {
1876 #[link(name = "windows")]
1877 extern "system" {
1878 fn SetConsoleTitleW(lpconsoletitle: super::super::Foundation::PWSTR) -> super::super::Foundation::BOOL;
1879 }
1880 ::std::mem::transmute(SetConsoleTitleW(lpconsoletitle.into_param().abi()))
1881 }
1882 #[cfg(not(windows))]
1883 unimplemented!("Unsupported target OS");
1884 }
1885 #[cfg(feature = "Win32_Foundation")]
1886 #[inline]
SetConsoleWindowInfo<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::HANDLE>, Param1: ::windows::runtime::IntoParam<'a, super::super::Foundation::BOOL>>(hconsoleoutput: Param0, babsolute: Param1, lpconsolewindow: *const SMALL_RECT) -> super::super::Foundation::BOOL1887 pub unsafe fn SetConsoleWindowInfo<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::HANDLE>, Param1: ::windows::runtime::IntoParam<'a, super::super::Foundation::BOOL>>(hconsoleoutput: Param0, babsolute: Param1, lpconsolewindow: *const SMALL_RECT) -> super::super::Foundation::BOOL {
1888 #[cfg(windows)]
1889 {
1890 #[link(name = "windows")]
1891 extern "system" {
1892 fn SetConsoleWindowInfo(hconsoleoutput: super::super::Foundation::HANDLE, babsolute: super::super::Foundation::BOOL, lpconsolewindow: *const SMALL_RECT) -> super::super::Foundation::BOOL;
1893 }
1894 ::std::mem::transmute(SetConsoleWindowInfo(hconsoleoutput.into_param().abi(), babsolute.into_param().abi(), ::std::mem::transmute(lpconsolewindow)))
1895 }
1896 #[cfg(not(windows))]
1897 unimplemented!("Unsupported target OS");
1898 }
1899 #[cfg(feature = "Win32_Foundation")]
1900 #[inline]
SetCurrentConsoleFontEx<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::HANDLE>, Param1: ::windows::runtime::IntoParam<'a, super::super::Foundation::BOOL>>(hconsoleoutput: Param0, bmaximumwindow: Param1, lpconsolecurrentfontex: *const CONSOLE_FONT_INFOEX) -> super::super::Foundation::BOOL1901 pub unsafe fn SetCurrentConsoleFontEx<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::HANDLE>, Param1: ::windows::runtime::IntoParam<'a, super::super::Foundation::BOOL>>(hconsoleoutput: Param0, bmaximumwindow: Param1, lpconsolecurrentfontex: *const CONSOLE_FONT_INFOEX) -> super::super::Foundation::BOOL {
1902 #[cfg(windows)]
1903 {
1904 #[link(name = "windows")]
1905 extern "system" {
1906 fn SetCurrentConsoleFontEx(hconsoleoutput: super::super::Foundation::HANDLE, bmaximumwindow: super::super::Foundation::BOOL, lpconsolecurrentfontex: *const CONSOLE_FONT_INFOEX) -> super::super::Foundation::BOOL;
1907 }
1908 ::std::mem::transmute(SetCurrentConsoleFontEx(hconsoleoutput.into_param().abi(), bmaximumwindow.into_param().abi(), ::std::mem::transmute(lpconsolecurrentfontex)))
1909 }
1910 #[cfg(not(windows))]
1911 unimplemented!("Unsupported target OS");
1912 }
1913 #[cfg(feature = "Win32_Foundation")]
1914 #[inline]
SetStdHandle<'a, Param1: ::windows::runtime::IntoParam<'a, super::super::Foundation::HANDLE>>(nstdhandle: STD_HANDLE, hhandle: Param1) -> super::super::Foundation::BOOL1915 pub unsafe fn SetStdHandle<'a, Param1: ::windows::runtime::IntoParam<'a, super::super::Foundation::HANDLE>>(nstdhandle: STD_HANDLE, hhandle: Param1) -> super::super::Foundation::BOOL {
1916 #[cfg(windows)]
1917 {
1918 #[link(name = "windows")]
1919 extern "system" {
1920 fn SetStdHandle(nstdhandle: STD_HANDLE, hhandle: super::super::Foundation::HANDLE) -> super::super::Foundation::BOOL;
1921 }
1922 ::std::mem::transmute(SetStdHandle(::std::mem::transmute(nstdhandle), hhandle.into_param().abi()))
1923 }
1924 #[cfg(not(windows))]
1925 unimplemented!("Unsupported target OS");
1926 }
1927 #[cfg(feature = "Win32_Foundation")]
1928 #[inline]
SetStdHandleEx<'a, Param1: ::windows::runtime::IntoParam<'a, super::super::Foundation::HANDLE>>(nstdhandle: STD_HANDLE, hhandle: Param1, phprevvalue: *mut super::super::Foundation::HANDLE) -> super::super::Foundation::BOOL1929 pub unsafe fn SetStdHandleEx<'a, Param1: ::windows::runtime::IntoParam<'a, super::super::Foundation::HANDLE>>(nstdhandle: STD_HANDLE, hhandle: Param1, phprevvalue: *mut super::super::Foundation::HANDLE) -> super::super::Foundation::BOOL {
1930 #[cfg(windows)]
1931 {
1932 #[link(name = "windows")]
1933 extern "system" {
1934 fn SetStdHandleEx(nstdhandle: STD_HANDLE, hhandle: super::super::Foundation::HANDLE, phprevvalue: *mut super::super::Foundation::HANDLE) -> super::super::Foundation::BOOL;
1935 }
1936 ::std::mem::transmute(SetStdHandleEx(::std::mem::transmute(nstdhandle), hhandle.into_param().abi(), ::std::mem::transmute(phprevvalue)))
1937 }
1938 #[cfg(not(windows))]
1939 unimplemented!("Unsupported target OS");
1940 }
1941 pub const WINDOW_BUFFER_SIZE_EVENT: u32 = 4u32;
1942 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
1943 #[repr(C)]
1944 pub struct WINDOW_BUFFER_SIZE_RECORD {
1945 pub dwSize: COORD,
1946 }
1947 impl WINDOW_BUFFER_SIZE_RECORD {}
1948 impl ::std::default::Default for WINDOW_BUFFER_SIZE_RECORD {
default() -> Self1949 fn default() -> Self {
1950 unsafe { ::std::mem::zeroed() }
1951 }
1952 }
1953 impl ::std::fmt::Debug for WINDOW_BUFFER_SIZE_RECORD {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result1954 fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
1955 fmt.debug_struct("WINDOW_BUFFER_SIZE_RECORD").field("dwSize", &self.dwSize).finish()
1956 }
1957 }
1958 impl ::std::cmp::PartialEq for WINDOW_BUFFER_SIZE_RECORD {
eq(&self, other: &Self) -> bool1959 fn eq(&self, other: &Self) -> bool {
1960 self.dwSize == other.dwSize
1961 }
1962 }
1963 impl ::std::cmp::Eq for WINDOW_BUFFER_SIZE_RECORD {}
1964 unsafe impl ::windows::runtime::Abi for WINDOW_BUFFER_SIZE_RECORD {
1965 type Abi = Self;
1966 type DefaultType = Self;
1967 }
1968 #[cfg(feature = "Win32_Foundation")]
1969 #[inline]
WriteConsoleA<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::HANDLE>>(hconsoleoutput: Param0, lpbuffer: *const ::std::ffi::c_void, nnumberofcharstowrite: u32, lpnumberofcharswritten: *mut u32, lpreserved: *mut ::std::ffi::c_void) -> super::super::Foundation::BOOL1970 pub unsafe fn WriteConsoleA<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::HANDLE>>(hconsoleoutput: Param0, lpbuffer: *const ::std::ffi::c_void, nnumberofcharstowrite: u32, lpnumberofcharswritten: *mut u32, lpreserved: *mut ::std::ffi::c_void) -> super::super::Foundation::BOOL {
1971 #[cfg(windows)]
1972 {
1973 #[link(name = "windows")]
1974 extern "system" {
1975 fn WriteConsoleA(hconsoleoutput: super::super::Foundation::HANDLE, lpbuffer: *const ::std::ffi::c_void, nnumberofcharstowrite: u32, lpnumberofcharswritten: *mut u32, lpreserved: *mut ::std::ffi::c_void) -> super::super::Foundation::BOOL;
1976 }
1977 ::std::mem::transmute(WriteConsoleA(hconsoleoutput.into_param().abi(), ::std::mem::transmute(lpbuffer), ::std::mem::transmute(nnumberofcharstowrite), ::std::mem::transmute(lpnumberofcharswritten), ::std::mem::transmute(lpreserved)))
1978 }
1979 #[cfg(not(windows))]
1980 unimplemented!("Unsupported target OS");
1981 }
1982 #[cfg(feature = "Win32_Foundation")]
1983 #[inline]
WriteConsoleInputA<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::HANDLE>>(hconsoleinput: Param0, lpbuffer: *const INPUT_RECORD, nlength: u32, lpnumberofeventswritten: *mut u32) -> super::super::Foundation::BOOL1984 pub unsafe fn WriteConsoleInputA<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::HANDLE>>(hconsoleinput: Param0, lpbuffer: *const INPUT_RECORD, nlength: u32, lpnumberofeventswritten: *mut u32) -> super::super::Foundation::BOOL {
1985 #[cfg(windows)]
1986 {
1987 #[link(name = "windows")]
1988 extern "system" {
1989 fn WriteConsoleInputA(hconsoleinput: super::super::Foundation::HANDLE, lpbuffer: *const INPUT_RECORD, nlength: u32, lpnumberofeventswritten: *mut u32) -> super::super::Foundation::BOOL;
1990 }
1991 ::std::mem::transmute(WriteConsoleInputA(hconsoleinput.into_param().abi(), ::std::mem::transmute(lpbuffer), ::std::mem::transmute(nlength), ::std::mem::transmute(lpnumberofeventswritten)))
1992 }
1993 #[cfg(not(windows))]
1994 unimplemented!("Unsupported target OS");
1995 }
1996 #[cfg(feature = "Win32_Foundation")]
1997 #[inline]
WriteConsoleInputW<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::HANDLE>>(hconsoleinput: Param0, lpbuffer: *const INPUT_RECORD, nlength: u32, lpnumberofeventswritten: *mut u32) -> super::super::Foundation::BOOL1998 pub unsafe fn WriteConsoleInputW<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::HANDLE>>(hconsoleinput: Param0, lpbuffer: *const INPUT_RECORD, nlength: u32, lpnumberofeventswritten: *mut u32) -> super::super::Foundation::BOOL {
1999 #[cfg(windows)]
2000 {
2001 #[link(name = "windows")]
2002 extern "system" {
2003 fn WriteConsoleInputW(hconsoleinput: super::super::Foundation::HANDLE, lpbuffer: *const INPUT_RECORD, nlength: u32, lpnumberofeventswritten: *mut u32) -> super::super::Foundation::BOOL;
2004 }
2005 ::std::mem::transmute(WriteConsoleInputW(hconsoleinput.into_param().abi(), ::std::mem::transmute(lpbuffer), ::std::mem::transmute(nlength), ::std::mem::transmute(lpnumberofeventswritten)))
2006 }
2007 #[cfg(not(windows))]
2008 unimplemented!("Unsupported target OS");
2009 }
2010 #[cfg(feature = "Win32_Foundation")]
2011 #[inline]
WriteConsoleOutputA<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::HANDLE>, Param2: ::windows::runtime::IntoParam<'a, COORD>, Param3: ::windows::runtime::IntoParam<'a, COORD>>(hconsoleoutput: Param0, lpbuffer: *const CHAR_INFO, dwbuffersize: Param2, dwbuffercoord: Param3, lpwriteregion: *mut SMALL_RECT) -> super::super::Foundation::BOOL2012 pub unsafe fn WriteConsoleOutputA<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::HANDLE>, Param2: ::windows::runtime::IntoParam<'a, COORD>, Param3: ::windows::runtime::IntoParam<'a, COORD>>(hconsoleoutput: Param0, lpbuffer: *const CHAR_INFO, dwbuffersize: Param2, dwbuffercoord: Param3, lpwriteregion: *mut SMALL_RECT) -> super::super::Foundation::BOOL {
2013 #[cfg(windows)]
2014 {
2015 #[link(name = "windows")]
2016 extern "system" {
2017 fn WriteConsoleOutputA(hconsoleoutput: super::super::Foundation::HANDLE, lpbuffer: *const CHAR_INFO, dwbuffersize: COORD, dwbuffercoord: COORD, lpwriteregion: *mut SMALL_RECT) -> super::super::Foundation::BOOL;
2018 }
2019 ::std::mem::transmute(WriteConsoleOutputA(hconsoleoutput.into_param().abi(), ::std::mem::transmute(lpbuffer), dwbuffersize.into_param().abi(), dwbuffercoord.into_param().abi(), ::std::mem::transmute(lpwriteregion)))
2020 }
2021 #[cfg(not(windows))]
2022 unimplemented!("Unsupported target OS");
2023 }
2024 #[cfg(feature = "Win32_Foundation")]
2025 #[inline]
WriteConsoleOutputAttribute<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::HANDLE>, Param3: ::windows::runtime::IntoParam<'a, COORD>>(hconsoleoutput: Param0, lpattribute: *const u16, nlength: u32, dwwritecoord: Param3, lpnumberofattrswritten: *mut u32) -> super::super::Foundation::BOOL2026 pub unsafe fn WriteConsoleOutputAttribute<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::HANDLE>, Param3: ::windows::runtime::IntoParam<'a, COORD>>(hconsoleoutput: Param0, lpattribute: *const u16, nlength: u32, dwwritecoord: Param3, lpnumberofattrswritten: *mut u32) -> super::super::Foundation::BOOL {
2027 #[cfg(windows)]
2028 {
2029 #[link(name = "windows")]
2030 extern "system" {
2031 fn WriteConsoleOutputAttribute(hconsoleoutput: super::super::Foundation::HANDLE, lpattribute: *const u16, nlength: u32, dwwritecoord: COORD, lpnumberofattrswritten: *mut u32) -> super::super::Foundation::BOOL;
2032 }
2033 ::std::mem::transmute(WriteConsoleOutputAttribute(hconsoleoutput.into_param().abi(), ::std::mem::transmute(lpattribute), ::std::mem::transmute(nlength), dwwritecoord.into_param().abi(), ::std::mem::transmute(lpnumberofattrswritten)))
2034 }
2035 #[cfg(not(windows))]
2036 unimplemented!("Unsupported target OS");
2037 }
2038 #[cfg(feature = "Win32_Foundation")]
2039 #[inline]
WriteConsoleOutputCharacterA<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::HANDLE>, Param1: ::windows::runtime::IntoParam<'a, super::super::Foundation::PSTR>, Param3: ::windows::runtime::IntoParam<'a, COORD>>(hconsoleoutput: Param0, lpcharacter: Param1, nlength: u32, dwwritecoord: Param3, lpnumberofcharswritten: *mut u32) -> super::super::Foundation::BOOL2040 pub unsafe fn WriteConsoleOutputCharacterA<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::HANDLE>, Param1: ::windows::runtime::IntoParam<'a, super::super::Foundation::PSTR>, Param3: ::windows::runtime::IntoParam<'a, COORD>>(hconsoleoutput: Param0, lpcharacter: Param1, nlength: u32, dwwritecoord: Param3, lpnumberofcharswritten: *mut u32) -> super::super::Foundation::BOOL {
2041 #[cfg(windows)]
2042 {
2043 #[link(name = "windows")]
2044 extern "system" {
2045 fn WriteConsoleOutputCharacterA(hconsoleoutput: super::super::Foundation::HANDLE, lpcharacter: super::super::Foundation::PSTR, nlength: u32, dwwritecoord: COORD, lpnumberofcharswritten: *mut u32) -> super::super::Foundation::BOOL;
2046 }
2047 ::std::mem::transmute(WriteConsoleOutputCharacterA(hconsoleoutput.into_param().abi(), lpcharacter.into_param().abi(), ::std::mem::transmute(nlength), dwwritecoord.into_param().abi(), ::std::mem::transmute(lpnumberofcharswritten)))
2048 }
2049 #[cfg(not(windows))]
2050 unimplemented!("Unsupported target OS");
2051 }
2052 #[cfg(feature = "Win32_Foundation")]
2053 #[inline]
WriteConsoleOutputCharacterW<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::HANDLE>, Param1: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>, Param3: ::windows::runtime::IntoParam<'a, COORD>>(hconsoleoutput: Param0, lpcharacter: Param1, nlength: u32, dwwritecoord: Param3, lpnumberofcharswritten: *mut u32) -> super::super::Foundation::BOOL2054 pub unsafe fn WriteConsoleOutputCharacterW<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::HANDLE>, Param1: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>, Param3: ::windows::runtime::IntoParam<'a, COORD>>(hconsoleoutput: Param0, lpcharacter: Param1, nlength: u32, dwwritecoord: Param3, lpnumberofcharswritten: *mut u32) -> super::super::Foundation::BOOL {
2055 #[cfg(windows)]
2056 {
2057 #[link(name = "windows")]
2058 extern "system" {
2059 fn WriteConsoleOutputCharacterW(hconsoleoutput: super::super::Foundation::HANDLE, lpcharacter: super::super::Foundation::PWSTR, nlength: u32, dwwritecoord: COORD, lpnumberofcharswritten: *mut u32) -> super::super::Foundation::BOOL;
2060 }
2061 ::std::mem::transmute(WriteConsoleOutputCharacterW(hconsoleoutput.into_param().abi(), lpcharacter.into_param().abi(), ::std::mem::transmute(nlength), dwwritecoord.into_param().abi(), ::std::mem::transmute(lpnumberofcharswritten)))
2062 }
2063 #[cfg(not(windows))]
2064 unimplemented!("Unsupported target OS");
2065 }
2066 #[cfg(feature = "Win32_Foundation")]
2067 #[inline]
WriteConsoleOutputW<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::HANDLE>, Param2: ::windows::runtime::IntoParam<'a, COORD>, Param3: ::windows::runtime::IntoParam<'a, COORD>>(hconsoleoutput: Param0, lpbuffer: *const CHAR_INFO, dwbuffersize: Param2, dwbuffercoord: Param3, lpwriteregion: *mut SMALL_RECT) -> super::super::Foundation::BOOL2068 pub unsafe fn WriteConsoleOutputW<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::HANDLE>, Param2: ::windows::runtime::IntoParam<'a, COORD>, Param3: ::windows::runtime::IntoParam<'a, COORD>>(hconsoleoutput: Param0, lpbuffer: *const CHAR_INFO, dwbuffersize: Param2, dwbuffercoord: Param3, lpwriteregion: *mut SMALL_RECT) -> super::super::Foundation::BOOL {
2069 #[cfg(windows)]
2070 {
2071 #[link(name = "windows")]
2072 extern "system" {
2073 fn WriteConsoleOutputW(hconsoleoutput: super::super::Foundation::HANDLE, lpbuffer: *const CHAR_INFO, dwbuffersize: COORD, dwbuffercoord: COORD, lpwriteregion: *mut SMALL_RECT) -> super::super::Foundation::BOOL;
2074 }
2075 ::std::mem::transmute(WriteConsoleOutputW(hconsoleoutput.into_param().abi(), ::std::mem::transmute(lpbuffer), dwbuffersize.into_param().abi(), dwbuffercoord.into_param().abi(), ::std::mem::transmute(lpwriteregion)))
2076 }
2077 #[cfg(not(windows))]
2078 unimplemented!("Unsupported target OS");
2079 }
2080 #[cfg(feature = "Win32_Foundation")]
2081 #[inline]
WriteConsoleW<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::HANDLE>>(hconsoleoutput: Param0, lpbuffer: *const ::std::ffi::c_void, nnumberofcharstowrite: u32, lpnumberofcharswritten: *mut u32, lpreserved: *mut ::std::ffi::c_void) -> super::super::Foundation::BOOL2082 pub unsafe fn WriteConsoleW<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::HANDLE>>(hconsoleoutput: Param0, lpbuffer: *const ::std::ffi::c_void, nnumberofcharstowrite: u32, lpnumberofcharswritten: *mut u32, lpreserved: *mut ::std::ffi::c_void) -> super::super::Foundation::BOOL {
2083 #[cfg(windows)]
2084 {
2085 #[link(name = "windows")]
2086 extern "system" {
2087 fn WriteConsoleW(hconsoleoutput: super::super::Foundation::HANDLE, lpbuffer: *const ::std::ffi::c_void, nnumberofcharstowrite: u32, lpnumberofcharswritten: *mut u32, lpreserved: *mut ::std::ffi::c_void) -> super::super::Foundation::BOOL;
2088 }
2089 ::std::mem::transmute(WriteConsoleW(hconsoleoutput.into_param().abi(), ::std::mem::transmute(lpbuffer), ::std::mem::transmute(nnumberofcharstowrite), ::std::mem::transmute(lpnumberofcharswritten), ::std::mem::transmute(lpreserved)))
2090 }
2091 #[cfg(not(windows))]
2092 unimplemented!("Unsupported target OS");
2093 }
2094