1 #![allow(unused_variables, non_upper_case_globals, non_snake_case, unused_unsafe, non_camel_case_types, dead_code, clippy::all)]
2 #[cfg(feature = "Win32_Foundation")]
3 #[inline]
4 pub unsafe fn AdjustWindowRectExForDpi<'a, Param2: ::windows::runtime::IntoParam<'a, super::super::Foundation::BOOL>>(lprect: *mut super::super::Foundation::RECT, dwstyle: u32, bmenu: Param2, dwexstyle: u32, dpi: u32) -> super::super::Foundation::BOOL {
5     #[cfg(windows)]
6     {
7         #[link(name = "windows")]
8         extern "system" {
9             fn AdjustWindowRectExForDpi(lprect: *mut super::super::Foundation::RECT, dwstyle: u32, bmenu: super::super::Foundation::BOOL, dwexstyle: u32, dpi: u32) -> super::super::Foundation::BOOL;
10         }
11         ::std::mem::transmute(AdjustWindowRectExForDpi(::std::mem::transmute(lprect), ::std::mem::transmute(dwstyle), bmenu.into_param().abi(), ::std::mem::transmute(dwexstyle), ::std::mem::transmute(dpi)))
12     }
13     #[cfg(not(windows))]
14     unimplemented!("Unsupported target OS");
15 }
16 #[cfg(feature = "Win32_Foundation")]
17 #[inline]
18 pub unsafe fn AreDpiAwarenessContextsEqual<'a, Param0: ::windows::runtime::IntoParam<'a, DPI_AWARENESS_CONTEXT>, Param1: ::windows::runtime::IntoParam<'a, DPI_AWARENESS_CONTEXT>>(dpicontexta: Param0, dpicontextb: Param1) -> super::super::Foundation::BOOL {
19     #[cfg(windows)]
20     {
21         #[link(name = "windows")]
22         extern "system" {
23             fn AreDpiAwarenessContextsEqual(dpicontexta: DPI_AWARENESS_CONTEXT, dpicontextb: DPI_AWARENESS_CONTEXT) -> super::super::Foundation::BOOL;
24         }
25         ::std::mem::transmute(AreDpiAwarenessContextsEqual(dpicontexta.into_param().abi(), dpicontextb.into_param().abi()))
26     }
27     #[cfg(not(windows))]
28     unimplemented!("Unsupported target OS");
29 }
30 #[derive(:: std :: cmp :: PartialEq, :: std :: cmp :: Eq, :: std :: marker :: Copy, :: std :: clone :: Clone, :: std :: default :: Default, :: std :: fmt :: Debug)]
31 #[repr(transparent)]
32 pub struct DIALOG_CONTROL_DPI_CHANGE_BEHAVIORS(pub u32);
33 pub const DCDC_DEFAULT: DIALOG_CONTROL_DPI_CHANGE_BEHAVIORS = DIALOG_CONTROL_DPI_CHANGE_BEHAVIORS(0u32);
34 pub const DCDC_DISABLE_FONT_UPDATE: DIALOG_CONTROL_DPI_CHANGE_BEHAVIORS = DIALOG_CONTROL_DPI_CHANGE_BEHAVIORS(1u32);
35 pub const DCDC_DISABLE_RELAYOUT: DIALOG_CONTROL_DPI_CHANGE_BEHAVIORS = DIALOG_CONTROL_DPI_CHANGE_BEHAVIORS(2u32);
36 impl ::std::convert::From<u32> for DIALOG_CONTROL_DPI_CHANGE_BEHAVIORS {
37     fn from(value: u32) -> Self {
38         Self(value)
39     }
40 }
41 unsafe impl ::windows::runtime::Abi for DIALOG_CONTROL_DPI_CHANGE_BEHAVIORS {
42     type Abi = Self;
43     type DefaultType = Self;
44 }
45 impl ::std::ops::BitOr for DIALOG_CONTROL_DPI_CHANGE_BEHAVIORS {
46     type Output = Self;
47     fn bitor(self, rhs: Self) -> Self {
48         Self(self.0 | rhs.0)
49     }
50 }
51 impl ::std::ops::BitAnd for DIALOG_CONTROL_DPI_CHANGE_BEHAVIORS {
52     type Output = Self;
53     fn bitand(self, rhs: Self) -> Self {
54         Self(self.0 & rhs.0)
55     }
56 }
57 impl ::std::ops::BitOrAssign for DIALOG_CONTROL_DPI_CHANGE_BEHAVIORS {
58     fn bitor_assign(&mut self, rhs: Self) {
59         self.0.bitor_assign(rhs.0)
60     }
61 }
62 impl ::std::ops::BitAndAssign for DIALOG_CONTROL_DPI_CHANGE_BEHAVIORS {
63     fn bitand_assign(&mut self, rhs: Self) {
64         self.0.bitand_assign(rhs.0)
65     }
66 }
67 impl ::std::ops::Not for DIALOG_CONTROL_DPI_CHANGE_BEHAVIORS {
68     type Output = Self;
69     fn not(self) -> Self {
70         Self(self.0.not())
71     }
72 }
73 #[derive(:: std :: cmp :: PartialEq, :: std :: cmp :: Eq, :: std :: marker :: Copy, :: std :: clone :: Clone, :: std :: default :: Default, :: std :: fmt :: Debug)]
74 #[repr(transparent)]
75 pub struct DIALOG_DPI_CHANGE_BEHAVIORS(pub u32);
76 pub const DDC_DEFAULT: DIALOG_DPI_CHANGE_BEHAVIORS = DIALOG_DPI_CHANGE_BEHAVIORS(0u32);
77 pub const DDC_DISABLE_ALL: DIALOG_DPI_CHANGE_BEHAVIORS = DIALOG_DPI_CHANGE_BEHAVIORS(1u32);
78 pub const DDC_DISABLE_RESIZE: DIALOG_DPI_CHANGE_BEHAVIORS = DIALOG_DPI_CHANGE_BEHAVIORS(2u32);
79 pub const DDC_DISABLE_CONTROL_RELAYOUT: DIALOG_DPI_CHANGE_BEHAVIORS = DIALOG_DPI_CHANGE_BEHAVIORS(4u32);
80 impl ::std::convert::From<u32> for DIALOG_DPI_CHANGE_BEHAVIORS {
81     fn from(value: u32) -> Self {
82         Self(value)
83     }
84 }
85 unsafe impl ::windows::runtime::Abi for DIALOG_DPI_CHANGE_BEHAVIORS {
86     type Abi = Self;
87     type DefaultType = Self;
88 }
89 impl ::std::ops::BitOr for DIALOG_DPI_CHANGE_BEHAVIORS {
90     type Output = Self;
91     fn bitor(self, rhs: Self) -> Self {
92         Self(self.0 | rhs.0)
93     }
94 }
95 impl ::std::ops::BitAnd for DIALOG_DPI_CHANGE_BEHAVIORS {
96     type Output = Self;
97     fn bitand(self, rhs: Self) -> Self {
98         Self(self.0 & rhs.0)
99     }
100 }
101 impl ::std::ops::BitOrAssign for DIALOG_DPI_CHANGE_BEHAVIORS {
102     fn bitor_assign(&mut self, rhs: Self) {
103         self.0.bitor_assign(rhs.0)
104     }
105 }
106 impl ::std::ops::BitAndAssign for DIALOG_DPI_CHANGE_BEHAVIORS {
107     fn bitand_assign(&mut self, rhs: Self) {
108         self.0.bitand_assign(rhs.0)
109     }
110 }
111 impl ::std::ops::Not for DIALOG_DPI_CHANGE_BEHAVIORS {
112     type Output = Self;
113     fn not(self) -> Self {
114         Self(self.0.not())
115     }
116 }
117 #[derive(:: std :: cmp :: PartialEq, :: std :: cmp :: Eq, :: std :: marker :: Copy, :: std :: clone :: Clone, :: std :: default :: Default, :: std :: fmt :: Debug)]
118 #[repr(transparent)]
119 pub struct DPI_AWARENESS(pub i32);
120 pub const DPI_AWARENESS_INVALID: DPI_AWARENESS = DPI_AWARENESS(-1i32);
121 pub const DPI_AWARENESS_UNAWARE: DPI_AWARENESS = DPI_AWARENESS(0i32);
122 pub const DPI_AWARENESS_SYSTEM_AWARE: DPI_AWARENESS = DPI_AWARENESS(1i32);
123 pub const DPI_AWARENESS_PER_MONITOR_AWARE: DPI_AWARENESS = DPI_AWARENESS(2i32);
124 impl ::std::convert::From<i32> for DPI_AWARENESS {
125     fn from(value: i32) -> Self {
126         Self(value)
127     }
128 }
129 unsafe impl ::windows::runtime::Abi for DPI_AWARENESS {
130     type Abi = Self;
131     type DefaultType = Self;
132 }
133 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy, :: std :: fmt :: Debug, :: std :: cmp :: PartialEq, :: std :: cmp :: Eq)]
134 #[repr(transparent)]
135 pub struct DPI_AWARENESS_CONTEXT(pub isize);
136 impl ::std::default::Default for DPI_AWARENESS_CONTEXT {
137     fn default() -> Self {
138         unsafe { ::std::mem::zeroed() }
139     }
140 }
141 unsafe impl ::windows::runtime::Handle for DPI_AWARENESS_CONTEXT {}
142 unsafe impl ::windows::runtime::Abi for DPI_AWARENESS_CONTEXT {
143     type Abi = Self;
144     type DefaultType = Self;
145 }
146 pub const DPI_AWARENESS_CONTEXT_PER_MONITOR_AWARE: DPI_AWARENESS_CONTEXT = DPI_AWARENESS_CONTEXT(-3i32 as _);
147 pub const DPI_AWARENESS_CONTEXT_PER_MONITOR_AWARE_V2: DPI_AWARENESS_CONTEXT = DPI_AWARENESS_CONTEXT(-4i32 as _);
148 pub const DPI_AWARENESS_CONTEXT_SYSTEM_AWARE: DPI_AWARENESS_CONTEXT = DPI_AWARENESS_CONTEXT(-2i32 as _);
149 pub const DPI_AWARENESS_CONTEXT_UNAWARE: DPI_AWARENESS_CONTEXT = DPI_AWARENESS_CONTEXT(-1i32 as _);
150 pub const DPI_AWARENESS_CONTEXT_UNAWARE_GDISCALED: DPI_AWARENESS_CONTEXT = DPI_AWARENESS_CONTEXT(-5i32 as _);
151 #[derive(:: std :: cmp :: PartialEq, :: std :: cmp :: Eq, :: std :: marker :: Copy, :: std :: clone :: Clone, :: std :: default :: Default, :: std :: fmt :: Debug)]
152 #[repr(transparent)]
153 pub struct DPI_HOSTING_BEHAVIOR(pub i32);
154 pub const DPI_HOSTING_BEHAVIOR_INVALID: DPI_HOSTING_BEHAVIOR = DPI_HOSTING_BEHAVIOR(-1i32);
155 pub const DPI_HOSTING_BEHAVIOR_DEFAULT: DPI_HOSTING_BEHAVIOR = DPI_HOSTING_BEHAVIOR(0i32);
156 pub const DPI_HOSTING_BEHAVIOR_MIXED: DPI_HOSTING_BEHAVIOR = DPI_HOSTING_BEHAVIOR(1i32);
157 impl ::std::convert::From<i32> for DPI_HOSTING_BEHAVIOR {
158     fn from(value: i32) -> Self {
159         Self(value)
160     }
161 }
162 unsafe impl ::windows::runtime::Abi for DPI_HOSTING_BEHAVIOR {
163     type Abi = Self;
164     type DefaultType = Self;
165 }
166 #[cfg(feature = "Win32_Foundation")]
167 #[inline]
168 pub unsafe fn EnableNonClientDpiScaling<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::HWND>>(hwnd: Param0) -> super::super::Foundation::BOOL {
169     #[cfg(windows)]
170     {
171         #[link(name = "windows")]
172         extern "system" {
173             fn EnableNonClientDpiScaling(hwnd: super::super::Foundation::HWND) -> super::super::Foundation::BOOL;
174         }
175         ::std::mem::transmute(EnableNonClientDpiScaling(hwnd.into_param().abi()))
176     }
177     #[cfg(not(windows))]
178     unimplemented!("Unsupported target OS");
179 }
180 #[inline]
181 pub unsafe fn GetAwarenessFromDpiAwarenessContext<'a, Param0: ::windows::runtime::IntoParam<'a, DPI_AWARENESS_CONTEXT>>(value: Param0) -> DPI_AWARENESS {
182     #[cfg(windows)]
183     {
184         #[link(name = "windows")]
185         extern "system" {
186             fn GetAwarenessFromDpiAwarenessContext(value: DPI_AWARENESS_CONTEXT) -> DPI_AWARENESS;
187         }
188         ::std::mem::transmute(GetAwarenessFromDpiAwarenessContext(value.into_param().abi()))
189     }
190     #[cfg(not(windows))]
191     unimplemented!("Unsupported target OS");
192 }
193 #[cfg(feature = "Win32_Foundation")]
194 #[inline]
195 pub unsafe fn GetDialogControlDpiChangeBehavior<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::HWND>>(hwnd: Param0) -> DIALOG_CONTROL_DPI_CHANGE_BEHAVIORS {
196     #[cfg(windows)]
197     {
198         #[link(name = "windows")]
199         extern "system" {
200             fn GetDialogControlDpiChangeBehavior(hwnd: super::super::Foundation::HWND) -> DIALOG_CONTROL_DPI_CHANGE_BEHAVIORS;
201         }
202         ::std::mem::transmute(GetDialogControlDpiChangeBehavior(hwnd.into_param().abi()))
203     }
204     #[cfg(not(windows))]
205     unimplemented!("Unsupported target OS");
206 }
207 #[cfg(feature = "Win32_Foundation")]
208 #[inline]
209 pub unsafe fn GetDialogDpiChangeBehavior<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::HWND>>(hdlg: Param0) -> DIALOG_DPI_CHANGE_BEHAVIORS {
210     #[cfg(windows)]
211     {
212         #[link(name = "windows")]
213         extern "system" {
214             fn GetDialogDpiChangeBehavior(hdlg: super::super::Foundation::HWND) -> DIALOG_DPI_CHANGE_BEHAVIORS;
215         }
216         ::std::mem::transmute(GetDialogDpiChangeBehavior(hdlg.into_param().abi()))
217     }
218     #[cfg(not(windows))]
219     unimplemented!("Unsupported target OS");
220 }
221 #[cfg(feature = "Win32_Foundation")]
222 #[inline]
223 pub unsafe fn GetDpiAwarenessContextForProcess<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::HANDLE>>(hprocess: Param0) -> DPI_AWARENESS_CONTEXT {
224     #[cfg(windows)]
225     {
226         #[link(name = "windows")]
227         extern "system" {
228             fn GetDpiAwarenessContextForProcess(hprocess: super::super::Foundation::HANDLE) -> DPI_AWARENESS_CONTEXT;
229         }
230         ::std::mem::transmute(GetDpiAwarenessContextForProcess(hprocess.into_param().abi()))
231     }
232     #[cfg(not(windows))]
233     unimplemented!("Unsupported target OS");
234 }
235 #[cfg(feature = "Win32_Graphics_Gdi")]
236 #[inline]
237 pub unsafe fn GetDpiForMonitor<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Graphics::Gdi::HMONITOR>>(hmonitor: Param0, dpitype: MONITOR_DPI_TYPE, dpix: *mut u32, dpiy: *mut u32) -> ::windows::runtime::Result<()> {
238     #[cfg(windows)]
239     {
240         #[link(name = "windows")]
241         extern "system" {
242             fn GetDpiForMonitor(hmonitor: super::super::Graphics::Gdi::HMONITOR, dpitype: MONITOR_DPI_TYPE, dpix: *mut u32, dpiy: *mut u32) -> ::windows::runtime::HRESULT;
243         }
244         GetDpiForMonitor(hmonitor.into_param().abi(), ::std::mem::transmute(dpitype), ::std::mem::transmute(dpix), ::std::mem::transmute(dpiy)).ok()
245     }
246     #[cfg(not(windows))]
247     unimplemented!("Unsupported target OS");
248 }
249 #[inline]
250 pub unsafe fn GetDpiForSystem() -> u32 {
251     #[cfg(windows)]
252     {
253         #[link(name = "windows")]
254         extern "system" {
255             fn GetDpiForSystem() -> u32;
256         }
257         ::std::mem::transmute(GetDpiForSystem())
258     }
259     #[cfg(not(windows))]
260     unimplemented!("Unsupported target OS");
261 }
262 #[cfg(feature = "Win32_Foundation")]
263 #[inline]
264 pub unsafe fn GetDpiForWindow<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::HWND>>(hwnd: Param0) -> u32 {
265     #[cfg(windows)]
266     {
267         #[link(name = "windows")]
268         extern "system" {
269             fn GetDpiForWindow(hwnd: super::super::Foundation::HWND) -> u32;
270         }
271         ::std::mem::transmute(GetDpiForWindow(hwnd.into_param().abi()))
272     }
273     #[cfg(not(windows))]
274     unimplemented!("Unsupported target OS");
275 }
276 #[inline]
277 pub unsafe fn GetDpiFromDpiAwarenessContext<'a, Param0: ::windows::runtime::IntoParam<'a, DPI_AWARENESS_CONTEXT>>(value: Param0) -> u32 {
278     #[cfg(windows)]
279     {
280         #[link(name = "windows")]
281         extern "system" {
282             fn GetDpiFromDpiAwarenessContext(value: DPI_AWARENESS_CONTEXT) -> u32;
283         }
284         ::std::mem::transmute(GetDpiFromDpiAwarenessContext(value.into_param().abi()))
285     }
286     #[cfg(not(windows))]
287     unimplemented!("Unsupported target OS");
288 }
289 #[cfg(feature = "Win32_Foundation")]
290 #[inline]
291 pub unsafe fn GetProcessDpiAwareness<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::HANDLE>>(hprocess: Param0) -> ::windows::runtime::Result<PROCESS_DPI_AWARENESS> {
292     #[cfg(windows)]
293     {
294         #[link(name = "windows")]
295         extern "system" {
296             fn GetProcessDpiAwareness(hprocess: super::super::Foundation::HANDLE, value: *mut PROCESS_DPI_AWARENESS) -> ::windows::runtime::HRESULT;
297         }
298         let mut result__: <PROCESS_DPI_AWARENESS as ::windows::runtime::Abi>::Abi = ::std::mem::zeroed();
299         GetProcessDpiAwareness(hprocess.into_param().abi(), &mut result__).from_abi::<PROCESS_DPI_AWARENESS>(result__)
300     }
301     #[cfg(not(windows))]
302     unimplemented!("Unsupported target OS");
303 }
304 #[cfg(feature = "Win32_Foundation")]
305 #[inline]
306 pub unsafe fn GetSystemDpiForProcess<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::HANDLE>>(hprocess: Param0) -> u32 {
307     #[cfg(windows)]
308     {
309         #[link(name = "windows")]
310         extern "system" {
311             fn GetSystemDpiForProcess(hprocess: super::super::Foundation::HANDLE) -> u32;
312         }
313         ::std::mem::transmute(GetSystemDpiForProcess(hprocess.into_param().abi()))
314     }
315     #[cfg(not(windows))]
316     unimplemented!("Unsupported target OS");
317 }
318 #[inline]
319 pub unsafe fn GetSystemMetricsForDpi(nindex: i32, dpi: u32) -> i32 {
320     #[cfg(windows)]
321     {
322         #[link(name = "windows")]
323         extern "system" {
324             fn GetSystemMetricsForDpi(nindex: i32, dpi: u32) -> i32;
325         }
326         ::std::mem::transmute(GetSystemMetricsForDpi(::std::mem::transmute(nindex), ::std::mem::transmute(dpi)))
327     }
328     #[cfg(not(windows))]
329     unimplemented!("Unsupported target OS");
330 }
331 #[inline]
332 pub unsafe fn GetThreadDpiAwarenessContext() -> DPI_AWARENESS_CONTEXT {
333     #[cfg(windows)]
334     {
335         #[link(name = "windows")]
336         extern "system" {
337             fn GetThreadDpiAwarenessContext() -> DPI_AWARENESS_CONTEXT;
338         }
339         ::std::mem::transmute(GetThreadDpiAwarenessContext())
340     }
341     #[cfg(not(windows))]
342     unimplemented!("Unsupported target OS");
343 }
344 #[inline]
345 pub unsafe fn GetThreadDpiHostingBehavior() -> DPI_HOSTING_BEHAVIOR {
346     #[cfg(windows)]
347     {
348         #[link(name = "windows")]
349         extern "system" {
350             fn GetThreadDpiHostingBehavior() -> DPI_HOSTING_BEHAVIOR;
351         }
352         ::std::mem::transmute(GetThreadDpiHostingBehavior())
353     }
354     #[cfg(not(windows))]
355     unimplemented!("Unsupported target OS");
356 }
357 #[cfg(feature = "Win32_Foundation")]
358 #[inline]
359 pub unsafe fn GetWindowDpiAwarenessContext<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::HWND>>(hwnd: Param0) -> DPI_AWARENESS_CONTEXT {
360     #[cfg(windows)]
361     {
362         #[link(name = "windows")]
363         extern "system" {
364             fn GetWindowDpiAwarenessContext(hwnd: super::super::Foundation::HWND) -> DPI_AWARENESS_CONTEXT;
365         }
366         ::std::mem::transmute(GetWindowDpiAwarenessContext(hwnd.into_param().abi()))
367     }
368     #[cfg(not(windows))]
369     unimplemented!("Unsupported target OS");
370 }
371 #[cfg(feature = "Win32_Foundation")]
372 #[inline]
373 pub unsafe fn GetWindowDpiHostingBehavior<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::HWND>>(hwnd: Param0) -> DPI_HOSTING_BEHAVIOR {
374     #[cfg(windows)]
375     {
376         #[link(name = "windows")]
377         extern "system" {
378             fn GetWindowDpiHostingBehavior(hwnd: super::super::Foundation::HWND) -> DPI_HOSTING_BEHAVIOR;
379         }
380         ::std::mem::transmute(GetWindowDpiHostingBehavior(hwnd.into_param().abi()))
381     }
382     #[cfg(not(windows))]
383     unimplemented!("Unsupported target OS");
384 }
385 #[cfg(feature = "Win32_Foundation")]
386 #[inline]
387 pub unsafe fn IsValidDpiAwarenessContext<'a, Param0: ::windows::runtime::IntoParam<'a, DPI_AWARENESS_CONTEXT>>(value: Param0) -> super::super::Foundation::BOOL {
388     #[cfg(windows)]
389     {
390         #[link(name = "windows")]
391         extern "system" {
392             fn IsValidDpiAwarenessContext(value: DPI_AWARENESS_CONTEXT) -> super::super::Foundation::BOOL;
393         }
394         ::std::mem::transmute(IsValidDpiAwarenessContext(value.into_param().abi()))
395     }
396     #[cfg(not(windows))]
397     unimplemented!("Unsupported target OS");
398 }
399 #[cfg(feature = "Win32_Foundation")]
400 #[inline]
401 pub unsafe fn LogicalToPhysicalPointForPerMonitorDPI<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::HWND>>(hwnd: Param0, lppoint: *mut super::super::Foundation::POINT) -> super::super::Foundation::BOOL {
402     #[cfg(windows)]
403     {
404         #[link(name = "windows")]
405         extern "system" {
406             fn LogicalToPhysicalPointForPerMonitorDPI(hwnd: super::super::Foundation::HWND, lppoint: *mut super::super::Foundation::POINT) -> super::super::Foundation::BOOL;
407         }
408         ::std::mem::transmute(LogicalToPhysicalPointForPerMonitorDPI(hwnd.into_param().abi(), ::std::mem::transmute(lppoint)))
409     }
410     #[cfg(not(windows))]
411     unimplemented!("Unsupported target OS");
412 }
413 #[derive(:: std :: cmp :: PartialEq, :: std :: cmp :: Eq, :: std :: marker :: Copy, :: std :: clone :: Clone, :: std :: default :: Default, :: std :: fmt :: Debug)]
414 #[repr(transparent)]
415 pub struct MONITOR_DPI_TYPE(pub i32);
416 pub const MDT_EFFECTIVE_DPI: MONITOR_DPI_TYPE = MONITOR_DPI_TYPE(0i32);
417 pub const MDT_ANGULAR_DPI: MONITOR_DPI_TYPE = MONITOR_DPI_TYPE(1i32);
418 pub const MDT_RAW_DPI: MONITOR_DPI_TYPE = MONITOR_DPI_TYPE(2i32);
419 pub const MDT_DEFAULT: MONITOR_DPI_TYPE = MONITOR_DPI_TYPE(0i32);
420 impl ::std::convert::From<i32> for MONITOR_DPI_TYPE {
421     fn from(value: i32) -> Self {
422         Self(value)
423     }
424 }
425 unsafe impl ::windows::runtime::Abi for MONITOR_DPI_TYPE {
426     type Abi = Self;
427     type DefaultType = Self;
428 }
429 #[cfg(feature = "Win32_Foundation")]
430 #[inline]
431 pub unsafe fn OpenThemeDataForDpi<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::HWND>, Param1: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>>(hwnd: Param0, pszclasslist: Param1, dpi: u32) -> isize {
432     #[cfg(windows)]
433     {
434         #[link(name = "windows")]
435         extern "system" {
436             fn OpenThemeDataForDpi(hwnd: super::super::Foundation::HWND, pszclasslist: super::super::Foundation::PWSTR, dpi: u32) -> isize;
437         }
438         ::std::mem::transmute(OpenThemeDataForDpi(hwnd.into_param().abi(), pszclasslist.into_param().abi(), ::std::mem::transmute(dpi)))
439     }
440     #[cfg(not(windows))]
441     unimplemented!("Unsupported target OS");
442 }
443 #[derive(:: std :: cmp :: PartialEq, :: std :: cmp :: Eq, :: std :: marker :: Copy, :: std :: clone :: Clone, :: std :: default :: Default, :: std :: fmt :: Debug)]
444 #[repr(transparent)]
445 pub struct PROCESS_DPI_AWARENESS(pub i32);
446 pub const PROCESS_DPI_UNAWARE: PROCESS_DPI_AWARENESS = PROCESS_DPI_AWARENESS(0i32);
447 pub const PROCESS_SYSTEM_DPI_AWARE: PROCESS_DPI_AWARENESS = PROCESS_DPI_AWARENESS(1i32);
448 pub const PROCESS_PER_MONITOR_DPI_AWARE: PROCESS_DPI_AWARENESS = PROCESS_DPI_AWARENESS(2i32);
449 impl ::std::convert::From<i32> for PROCESS_DPI_AWARENESS {
450     fn from(value: i32) -> Self {
451         Self(value)
452     }
453 }
454 unsafe impl ::windows::runtime::Abi for PROCESS_DPI_AWARENESS {
455     type Abi = Self;
456     type DefaultType = Self;
457 }
458 #[cfg(feature = "Win32_Foundation")]
459 #[inline]
460 pub unsafe fn PhysicalToLogicalPointForPerMonitorDPI<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::HWND>>(hwnd: Param0, lppoint: *mut super::super::Foundation::POINT) -> super::super::Foundation::BOOL {
461     #[cfg(windows)]
462     {
463         #[link(name = "windows")]
464         extern "system" {
465             fn PhysicalToLogicalPointForPerMonitorDPI(hwnd: super::super::Foundation::HWND, lppoint: *mut super::super::Foundation::POINT) -> super::super::Foundation::BOOL;
466         }
467         ::std::mem::transmute(PhysicalToLogicalPointForPerMonitorDPI(hwnd.into_param().abi(), ::std::mem::transmute(lppoint)))
468     }
469     #[cfg(not(windows))]
470     unimplemented!("Unsupported target OS");
471 }
472 #[cfg(feature = "Win32_Foundation")]
473 #[inline]
474 pub unsafe fn SetDialogControlDpiChangeBehavior<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::HWND>>(hwnd: Param0, mask: DIALOG_CONTROL_DPI_CHANGE_BEHAVIORS, values: DIALOG_CONTROL_DPI_CHANGE_BEHAVIORS) -> super::super::Foundation::BOOL {
475     #[cfg(windows)]
476     {
477         #[link(name = "windows")]
478         extern "system" {
479             fn SetDialogControlDpiChangeBehavior(hwnd: super::super::Foundation::HWND, mask: DIALOG_CONTROL_DPI_CHANGE_BEHAVIORS, values: DIALOG_CONTROL_DPI_CHANGE_BEHAVIORS) -> super::super::Foundation::BOOL;
480         }
481         ::std::mem::transmute(SetDialogControlDpiChangeBehavior(hwnd.into_param().abi(), ::std::mem::transmute(mask), ::std::mem::transmute(values)))
482     }
483     #[cfg(not(windows))]
484     unimplemented!("Unsupported target OS");
485 }
486 #[cfg(feature = "Win32_Foundation")]
487 #[inline]
488 pub unsafe fn SetDialogDpiChangeBehavior<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::HWND>>(hdlg: Param0, mask: DIALOG_DPI_CHANGE_BEHAVIORS, values: DIALOG_DPI_CHANGE_BEHAVIORS) -> super::super::Foundation::BOOL {
489     #[cfg(windows)]
490     {
491         #[link(name = "windows")]
492         extern "system" {
493             fn SetDialogDpiChangeBehavior(hdlg: super::super::Foundation::HWND, mask: DIALOG_DPI_CHANGE_BEHAVIORS, values: DIALOG_DPI_CHANGE_BEHAVIORS) -> super::super::Foundation::BOOL;
494         }
495         ::std::mem::transmute(SetDialogDpiChangeBehavior(hdlg.into_param().abi(), ::std::mem::transmute(mask), ::std::mem::transmute(values)))
496     }
497     #[cfg(not(windows))]
498     unimplemented!("Unsupported target OS");
499 }
500 #[inline]
501 pub unsafe fn SetProcessDpiAwareness(value: PROCESS_DPI_AWARENESS) -> ::windows::runtime::Result<()> {
502     #[cfg(windows)]
503     {
504         #[link(name = "windows")]
505         extern "system" {
506             fn SetProcessDpiAwareness(value: PROCESS_DPI_AWARENESS) -> ::windows::runtime::HRESULT;
507         }
508         SetProcessDpiAwareness(::std::mem::transmute(value)).ok()
509     }
510     #[cfg(not(windows))]
511     unimplemented!("Unsupported target OS");
512 }
513 #[cfg(feature = "Win32_Foundation")]
514 #[inline]
515 pub unsafe fn SetProcessDpiAwarenessContext<'a, Param0: ::windows::runtime::IntoParam<'a, DPI_AWARENESS_CONTEXT>>(value: Param0) -> super::super::Foundation::BOOL {
516     #[cfg(windows)]
517     {
518         #[link(name = "windows")]
519         extern "system" {
520             fn SetProcessDpiAwarenessContext(value: DPI_AWARENESS_CONTEXT) -> super::super::Foundation::BOOL;
521         }
522         ::std::mem::transmute(SetProcessDpiAwarenessContext(value.into_param().abi()))
523     }
524     #[cfg(not(windows))]
525     unimplemented!("Unsupported target OS");
526 }
527 #[inline]
528 pub unsafe fn SetThreadDpiAwarenessContext<'a, Param0: ::windows::runtime::IntoParam<'a, DPI_AWARENESS_CONTEXT>>(dpicontext: Param0) -> DPI_AWARENESS_CONTEXT {
529     #[cfg(windows)]
530     {
531         #[link(name = "windows")]
532         extern "system" {
533             fn SetThreadDpiAwarenessContext(dpicontext: DPI_AWARENESS_CONTEXT) -> DPI_AWARENESS_CONTEXT;
534         }
535         ::std::mem::transmute(SetThreadDpiAwarenessContext(dpicontext.into_param().abi()))
536     }
537     #[cfg(not(windows))]
538     unimplemented!("Unsupported target OS");
539 }
540 #[inline]
541 pub unsafe fn SetThreadDpiHostingBehavior(value: DPI_HOSTING_BEHAVIOR) -> DPI_HOSTING_BEHAVIOR {
542     #[cfg(windows)]
543     {
544         #[link(name = "windows")]
545         extern "system" {
546             fn SetThreadDpiHostingBehavior(value: DPI_HOSTING_BEHAVIOR) -> DPI_HOSTING_BEHAVIOR;
547         }
548         ::std::mem::transmute(SetThreadDpiHostingBehavior(::std::mem::transmute(value)))
549     }
550     #[cfg(not(windows))]
551     unimplemented!("Unsupported target OS");
552 }
553 #[cfg(feature = "Win32_Foundation")]
554 #[inline]
555 pub unsafe fn SystemParametersInfoForDpi(uiaction: u32, uiparam: u32, pvparam: *mut ::std::ffi::c_void, fwinini: u32, dpi: u32) -> super::super::Foundation::BOOL {
556     #[cfg(windows)]
557     {
558         #[link(name = "windows")]
559         extern "system" {
560             fn SystemParametersInfoForDpi(uiaction: u32, uiparam: u32, pvparam: *mut ::std::ffi::c_void, fwinini: u32, dpi: u32) -> super::super::Foundation::BOOL;
561         }
562         ::std::mem::transmute(SystemParametersInfoForDpi(::std::mem::transmute(uiaction), ::std::mem::transmute(uiparam), ::std::mem::transmute(pvparam), ::std::mem::transmute(fwinini), ::std::mem::transmute(dpi)))
563     }
564     #[cfg(not(windows))]
565     unimplemented!("Unsupported target OS");
566 }
567