1 #![allow(unused_variables, non_upper_case_globals, non_snake_case, unused_unsafe, non_camel_case_types, dead_code, clippy::all)]
2 pub const ATTRIB_MATTE: u32 = 2u32;
3 pub const ATTRIB_TRANSPARENCY: u32 = 1u32;
4 #[cfg(feature = "Win32_Foundation")]
5 #[inline]
AssociateColorProfileWithDeviceA<'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>>(pmachinename: Param0, pprofilename: Param1, pdevicename: Param2) -> super::super::Foundation::BOOL6 pub unsafe fn AssociateColorProfileWithDeviceA<'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>>(pmachinename: Param0, pprofilename: Param1, pdevicename: Param2) -> super::super::Foundation::BOOL {
7     #[cfg(windows)]
8     {
9         #[link(name = "windows")]
10         extern "system" {
11             fn AssociateColorProfileWithDeviceA(pmachinename: super::super::Foundation::PSTR, pprofilename: super::super::Foundation::PSTR, pdevicename: super::super::Foundation::PSTR) -> super::super::Foundation::BOOL;
12         }
13         ::std::mem::transmute(AssociateColorProfileWithDeviceA(pmachinename.into_param().abi(), pprofilename.into_param().abi(), pdevicename.into_param().abi()))
14     }
15     #[cfg(not(windows))]
16     unimplemented!("Unsupported target OS");
17 }
18 #[cfg(feature = "Win32_Foundation")]
19 #[inline]
AssociateColorProfileWithDeviceW<'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>>(pmachinename: Param0, pprofilename: Param1, pdevicename: Param2) -> super::super::Foundation::BOOL20 pub unsafe fn AssociateColorProfileWithDeviceW<'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>>(pmachinename: Param0, pprofilename: Param1, pdevicename: Param2) -> super::super::Foundation::BOOL {
21     #[cfg(windows)]
22     {
23         #[link(name = "windows")]
24         extern "system" {
25             fn AssociateColorProfileWithDeviceW(pmachinename: super::super::Foundation::PWSTR, pprofilename: super::super::Foundation::PWSTR, pdevicename: super::super::Foundation::PWSTR) -> super::super::Foundation::BOOL;
26         }
27         ::std::mem::transmute(AssociateColorProfileWithDeviceW(pmachinename.into_param().abi(), pprofilename.into_param().abi(), pdevicename.into_param().abi()))
28     }
29     #[cfg(not(windows))]
30     unimplemented!("Unsupported target OS");
31 }
32 pub const BEST_MODE: u32 = 3u32;
33 #[derive(:: std :: cmp :: PartialEq, :: std :: cmp :: Eq, :: std :: marker :: Copy, :: std :: clone :: Clone, :: std :: default :: Default, :: std :: fmt :: Debug)]
34 #[repr(transparent)]
35 pub struct BMFORMAT(pub i32);
36 pub const BM_x555RGB: BMFORMAT = BMFORMAT(0i32);
37 pub const BM_x555XYZ: BMFORMAT = BMFORMAT(257i32);
38 pub const BM_x555Yxy: BMFORMAT = BMFORMAT(258i32);
39 pub const BM_x555Lab: BMFORMAT = BMFORMAT(259i32);
40 pub const BM_x555G3CH: BMFORMAT = BMFORMAT(260i32);
41 pub const BM_RGBTRIPLETS: BMFORMAT = BMFORMAT(2i32);
42 pub const BM_BGRTRIPLETS: BMFORMAT = BMFORMAT(4i32);
43 pub const BM_XYZTRIPLETS: BMFORMAT = BMFORMAT(513i32);
44 pub const BM_YxyTRIPLETS: BMFORMAT = BMFORMAT(514i32);
45 pub const BM_LabTRIPLETS: BMFORMAT = BMFORMAT(515i32);
46 pub const BM_G3CHTRIPLETS: BMFORMAT = BMFORMAT(516i32);
47 pub const BM_5CHANNEL: BMFORMAT = BMFORMAT(517i32);
48 pub const BM_6CHANNEL: BMFORMAT = BMFORMAT(518i32);
49 pub const BM_7CHANNEL: BMFORMAT = BMFORMAT(519i32);
50 pub const BM_8CHANNEL: BMFORMAT = BMFORMAT(520i32);
51 pub const BM_GRAY: BMFORMAT = BMFORMAT(521i32);
52 pub const BM_xRGBQUADS: BMFORMAT = BMFORMAT(8i32);
53 pub const BM_xBGRQUADS: BMFORMAT = BMFORMAT(16i32);
54 pub const BM_xG3CHQUADS: BMFORMAT = BMFORMAT(772i32);
55 pub const BM_KYMCQUADS: BMFORMAT = BMFORMAT(773i32);
56 pub const BM_CMYKQUADS: BMFORMAT = BMFORMAT(32i32);
57 pub const BM_10b_RGB: BMFORMAT = BMFORMAT(9i32);
58 pub const BM_10b_XYZ: BMFORMAT = BMFORMAT(1025i32);
59 pub const BM_10b_Yxy: BMFORMAT = BMFORMAT(1026i32);
60 pub const BM_10b_Lab: BMFORMAT = BMFORMAT(1027i32);
61 pub const BM_10b_G3CH: BMFORMAT = BMFORMAT(1028i32);
62 pub const BM_NAMED_INDEX: BMFORMAT = BMFORMAT(1029i32);
63 pub const BM_16b_RGB: BMFORMAT = BMFORMAT(10i32);
64 pub const BM_16b_XYZ: BMFORMAT = BMFORMAT(1281i32);
65 pub const BM_16b_Yxy: BMFORMAT = BMFORMAT(1282i32);
66 pub const BM_16b_Lab: BMFORMAT = BMFORMAT(1283i32);
67 pub const BM_16b_G3CH: BMFORMAT = BMFORMAT(1284i32);
68 pub const BM_16b_GRAY: BMFORMAT = BMFORMAT(1285i32);
69 pub const BM_565RGB: BMFORMAT = BMFORMAT(1i32);
70 pub const BM_32b_scRGB: BMFORMAT = BMFORMAT(1537i32);
71 pub const BM_32b_scARGB: BMFORMAT = BMFORMAT(1538i32);
72 pub const BM_S2DOT13FIXED_scRGB: BMFORMAT = BMFORMAT(1539i32);
73 pub const BM_S2DOT13FIXED_scARGB: BMFORMAT = BMFORMAT(1540i32);
74 pub const BM_R10G10B10A2: BMFORMAT = BMFORMAT(1793i32);
75 pub const BM_R10G10B10A2_XR: BMFORMAT = BMFORMAT(1794i32);
76 pub const BM_R16G16B16A16_FLOAT: BMFORMAT = BMFORMAT(1795i32);
77 impl ::std::convert::From<i32> for BMFORMAT {
from(value: i32) -> Self78     fn from(value: i32) -> Self {
79         Self(value)
80     }
81 }
82 unsafe impl ::windows::runtime::Abi for BMFORMAT {
83     type Abi = Self;
84     type DefaultType = Self;
85 }
86 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
87 #[repr(C)]
88 #[cfg(feature = "Win32_Foundation")]
89 pub struct BlackInformation {
90     pub fBlackOnly: super::super::Foundation::BOOL,
91     pub blackWeight: f32,
92 }
93 #[cfg(feature = "Win32_Foundation")]
94 impl BlackInformation {}
95 #[cfg(feature = "Win32_Foundation")]
96 impl ::std::default::Default for BlackInformation {
default() -> Self97     fn default() -> Self {
98         unsafe { ::std::mem::zeroed() }
99     }
100 }
101 #[cfg(feature = "Win32_Foundation")]
102 impl ::std::fmt::Debug for BlackInformation {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result103     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
104         fmt.debug_struct("BlackInformation").field("fBlackOnly", &self.fBlackOnly).field("blackWeight", &self.blackWeight).finish()
105     }
106 }
107 #[cfg(feature = "Win32_Foundation")]
108 impl ::std::cmp::PartialEq for BlackInformation {
eq(&self, other: &Self) -> bool109     fn eq(&self, other: &Self) -> bool {
110         self.fBlackOnly == other.fBlackOnly && self.blackWeight == other.blackWeight
111     }
112 }
113 #[cfg(feature = "Win32_Foundation")]
114 impl ::std::cmp::Eq for BlackInformation {}
115 #[cfg(feature = "Win32_Foundation")]
116 unsafe impl ::windows::runtime::Abi for BlackInformation {
117     type Abi = Self;
118     type DefaultType = Self;
119 }
120 pub const CATID_WcsPlugin: ::windows::runtime::GUID = ::windows::runtime::GUID::from_values(2696151776, 33344, 16479, [138, 22, 138, 91, 77, 242, 240, 221]);
121 #[cfg(feature = "Win32_Foundation")]
122 #[inline]
CMCheckColors(hcmtransform: isize, lpainputcolors: *const COLOR, ncolors: u32, ctinput: COLORTYPE, lparesult: *mut u8) -> super::super::Foundation::BOOL123 pub unsafe fn CMCheckColors(hcmtransform: isize, lpainputcolors: *const COLOR, ncolors: u32, ctinput: COLORTYPE, lparesult: *mut u8) -> super::super::Foundation::BOOL {
124     #[cfg(windows)]
125     {
126         #[link(name = "windows")]
127         extern "system" {
128             fn CMCheckColors(hcmtransform: isize, lpainputcolors: *const COLOR, ncolors: u32, ctinput: COLORTYPE, lparesult: *mut u8) -> super::super::Foundation::BOOL;
129         }
130         ::std::mem::transmute(CMCheckColors(::std::mem::transmute(hcmtransform), ::std::mem::transmute(lpainputcolors), ::std::mem::transmute(ncolors), ::std::mem::transmute(ctinput), ::std::mem::transmute(lparesult)))
131     }
132     #[cfg(not(windows))]
133     unimplemented!("Unsupported target OS");
134 }
135 #[cfg(all(feature = "Win32_Foundation", feature = "Win32_Graphics_Gdi"))]
136 #[inline]
CMCheckColorsInGamut(hcmtransform: isize, lpargbtriple: *const super::super::Graphics::Gdi::RGBTRIPLE, lparesult: *mut u8, ncount: u32) -> super::super::Foundation::BOOL137 pub unsafe fn CMCheckColorsInGamut(hcmtransform: isize, lpargbtriple: *const super::super::Graphics::Gdi::RGBTRIPLE, lparesult: *mut u8, ncount: u32) -> super::super::Foundation::BOOL {
138     #[cfg(windows)]
139     {
140         #[link(name = "windows")]
141         extern "system" {
142             fn CMCheckColorsInGamut(hcmtransform: isize, lpargbtriple: *const super::super::Graphics::Gdi::RGBTRIPLE, lparesult: *mut u8, ncount: u32) -> super::super::Foundation::BOOL;
143         }
144         ::std::mem::transmute(CMCheckColorsInGamut(::std::mem::transmute(hcmtransform), ::std::mem::transmute(lpargbtriple), ::std::mem::transmute(lparesult), ::std::mem::transmute(ncount)))
145     }
146     #[cfg(not(windows))]
147     unimplemented!("Unsupported target OS");
148 }
149 #[cfg(feature = "Win32_Foundation")]
150 #[inline]
CMCheckRGBs<'a, Param8: ::windows::runtime::IntoParam<'a, super::super::Foundation::LPARAM>>(hcmtransform: isize, lpsrcbits: *const ::std::ffi::c_void, bminput: BMFORMAT, dwwidth: u32, dwheight: u32, dwstride: u32, lparesult: *mut u8, pfncallback: ::std::option::Option<LPBMCALLBACKFN>, ulcallbackdata: Param8) -> super::super::Foundation::BOOL151 pub unsafe fn CMCheckRGBs<'a, Param8: ::windows::runtime::IntoParam<'a, super::super::Foundation::LPARAM>>(hcmtransform: isize, lpsrcbits: *const ::std::ffi::c_void, bminput: BMFORMAT, dwwidth: u32, dwheight: u32, dwstride: u32, lparesult: *mut u8, pfncallback: ::std::option::Option<LPBMCALLBACKFN>, ulcallbackdata: Param8) -> super::super::Foundation::BOOL {
152     #[cfg(windows)]
153     {
154         #[link(name = "windows")]
155         extern "system" {
156             fn CMCheckRGBs(hcmtransform: isize, lpsrcbits: *const ::std::ffi::c_void, bminput: BMFORMAT, dwwidth: u32, dwheight: u32, dwstride: u32, lparesult: *mut u8, pfncallback: ::windows::runtime::RawPtr, ulcallbackdata: super::super::Foundation::LPARAM) -> super::super::Foundation::BOOL;
157         }
158         ::std::mem::transmute(CMCheckRGBs(
159             ::std::mem::transmute(hcmtransform),
160             ::std::mem::transmute(lpsrcbits),
161             ::std::mem::transmute(bminput),
162             ::std::mem::transmute(dwwidth),
163             ::std::mem::transmute(dwheight),
164             ::std::mem::transmute(dwstride),
165             ::std::mem::transmute(lparesult),
166             ::std::mem::transmute(pfncallback),
167             ulcallbackdata.into_param().abi(),
168         ))
169     }
170     #[cfg(not(windows))]
171     unimplemented!("Unsupported target OS");
172 }
173 #[cfg(feature = "Win32_Foundation")]
174 #[inline]
CMConvertColorNameToIndex(hprofile: isize, pacolorname: *const *const i8, paindex: *mut u32, dwcount: u32) -> super::super::Foundation::BOOL175 pub unsafe fn CMConvertColorNameToIndex(hprofile: isize, pacolorname: *const *const i8, paindex: *mut u32, dwcount: u32) -> super::super::Foundation::BOOL {
176     #[cfg(windows)]
177     {
178         #[link(name = "windows")]
179         extern "system" {
180             fn CMConvertColorNameToIndex(hprofile: isize, pacolorname: *const *const i8, paindex: *mut u32, dwcount: u32) -> super::super::Foundation::BOOL;
181         }
182         ::std::mem::transmute(CMConvertColorNameToIndex(::std::mem::transmute(hprofile), ::std::mem::transmute(pacolorname), ::std::mem::transmute(paindex), ::std::mem::transmute(dwcount)))
183     }
184     #[cfg(not(windows))]
185     unimplemented!("Unsupported target OS");
186 }
187 #[cfg(feature = "Win32_Foundation")]
188 #[inline]
CMConvertIndexToColorName(hprofile: isize, paindex: *const u32, pacolorname: *mut *mut i8, dwcount: u32) -> super::super::Foundation::BOOL189 pub unsafe fn CMConvertIndexToColorName(hprofile: isize, paindex: *const u32, pacolorname: *mut *mut i8, dwcount: u32) -> super::super::Foundation::BOOL {
190     #[cfg(windows)]
191     {
192         #[link(name = "windows")]
193         extern "system" {
194             fn CMConvertIndexToColorName(hprofile: isize, paindex: *const u32, pacolorname: *mut *mut i8, dwcount: u32) -> super::super::Foundation::BOOL;
195         }
196         ::std::mem::transmute(CMConvertIndexToColorName(::std::mem::transmute(hprofile), ::std::mem::transmute(paindex), ::std::mem::transmute(pacolorname), ::std::mem::transmute(dwcount)))
197     }
198     #[cfg(not(windows))]
199     unimplemented!("Unsupported target OS");
200 }
201 #[cfg(feature = "Win32_Foundation")]
202 #[inline]
CMCreateDeviceLinkProfile(pahprofiles: *const isize, nprofiles: u32, padwintents: *const u32, nintents: u32, dwflags: u32, lpprofiledata: *mut *mut u8) -> super::super::Foundation::BOOL203 pub unsafe fn CMCreateDeviceLinkProfile(pahprofiles: *const isize, nprofiles: u32, padwintents: *const u32, nintents: u32, dwflags: u32, lpprofiledata: *mut *mut u8) -> super::super::Foundation::BOOL {
204     #[cfg(windows)]
205     {
206         #[link(name = "windows")]
207         extern "system" {
208             fn CMCreateDeviceLinkProfile(pahprofiles: *const isize, nprofiles: u32, padwintents: *const u32, nintents: u32, dwflags: u32, lpprofiledata: *mut *mut u8) -> super::super::Foundation::BOOL;
209         }
210         ::std::mem::transmute(CMCreateDeviceLinkProfile(::std::mem::transmute(pahprofiles), ::std::mem::transmute(nprofiles), ::std::mem::transmute(padwintents), ::std::mem::transmute(nintents), ::std::mem::transmute(dwflags), ::std::mem::transmute(lpprofiledata)))
211     }
212     #[cfg(not(windows))]
213     unimplemented!("Unsupported target OS");
214 }
215 #[inline]
CMCreateMultiProfileTransform(pahprofiles: *const isize, nprofiles: u32, padwintents: *const u32, nintents: u32, dwflags: u32) -> isize216 pub unsafe fn CMCreateMultiProfileTransform(pahprofiles: *const isize, nprofiles: u32, padwintents: *const u32, nintents: u32, dwflags: u32) -> isize {
217     #[cfg(windows)]
218     {
219         #[link(name = "windows")]
220         extern "system" {
221             fn CMCreateMultiProfileTransform(pahprofiles: *const isize, nprofiles: u32, padwintents: *const u32, nintents: u32, dwflags: u32) -> isize;
222         }
223         ::std::mem::transmute(CMCreateMultiProfileTransform(::std::mem::transmute(pahprofiles), ::std::mem::transmute(nprofiles), ::std::mem::transmute(padwintents), ::std::mem::transmute(nintents), ::std::mem::transmute(dwflags)))
224     }
225     #[cfg(not(windows))]
226     unimplemented!("Unsupported target OS");
227 }
228 #[cfg(all(feature = "Win32_Foundation", feature = "Win32_Graphics_Gdi"))]
229 #[inline]
CMCreateProfile(lpcolorspace: *mut LOGCOLORSPACEA, lpprofiledata: *mut *mut ::std::ffi::c_void) -> super::super::Foundation::BOOL230 pub unsafe fn CMCreateProfile(lpcolorspace: *mut LOGCOLORSPACEA, lpprofiledata: *mut *mut ::std::ffi::c_void) -> super::super::Foundation::BOOL {
231     #[cfg(windows)]
232     {
233         #[link(name = "windows")]
234         extern "system" {
235             fn CMCreateProfile(lpcolorspace: *mut LOGCOLORSPACEA, lpprofiledata: *mut *mut ::std::ffi::c_void) -> super::super::Foundation::BOOL;
236         }
237         ::std::mem::transmute(CMCreateProfile(::std::mem::transmute(lpcolorspace), ::std::mem::transmute(lpprofiledata)))
238     }
239     #[cfg(not(windows))]
240     unimplemented!("Unsupported target OS");
241 }
242 #[cfg(all(feature = "Win32_Foundation", feature = "Win32_Graphics_Gdi"))]
243 #[inline]
CMCreateProfileW(lpcolorspace: *mut LOGCOLORSPACEW, lpprofiledata: *mut *mut ::std::ffi::c_void) -> super::super::Foundation::BOOL244 pub unsafe fn CMCreateProfileW(lpcolorspace: *mut LOGCOLORSPACEW, lpprofiledata: *mut *mut ::std::ffi::c_void) -> super::super::Foundation::BOOL {
245     #[cfg(windows)]
246     {
247         #[link(name = "windows")]
248         extern "system" {
249             fn CMCreateProfileW(lpcolorspace: *mut LOGCOLORSPACEW, lpprofiledata: *mut *mut ::std::ffi::c_void) -> super::super::Foundation::BOOL;
250         }
251         ::std::mem::transmute(CMCreateProfileW(::std::mem::transmute(lpcolorspace), ::std::mem::transmute(lpprofiledata)))
252     }
253     #[cfg(not(windows))]
254     unimplemented!("Unsupported target OS");
255 }
256 #[cfg(all(feature = "Win32_Foundation", feature = "Win32_Graphics_Gdi"))]
257 #[inline]
CMCreateTransform(lpcolorspace: *const LOGCOLORSPACEA, lpdevcharacter: *const ::std::ffi::c_void, lptargetdevcharacter: *const ::std::ffi::c_void) -> isize258 pub unsafe fn CMCreateTransform(lpcolorspace: *const LOGCOLORSPACEA, lpdevcharacter: *const ::std::ffi::c_void, lptargetdevcharacter: *const ::std::ffi::c_void) -> isize {
259     #[cfg(windows)]
260     {
261         #[link(name = "windows")]
262         extern "system" {
263             fn CMCreateTransform(lpcolorspace: *const LOGCOLORSPACEA, lpdevcharacter: *const ::std::ffi::c_void, lptargetdevcharacter: *const ::std::ffi::c_void) -> isize;
264         }
265         ::std::mem::transmute(CMCreateTransform(::std::mem::transmute(lpcolorspace), ::std::mem::transmute(lpdevcharacter), ::std::mem::transmute(lptargetdevcharacter)))
266     }
267     #[cfg(not(windows))]
268     unimplemented!("Unsupported target OS");
269 }
270 #[cfg(all(feature = "Win32_Foundation", feature = "Win32_Graphics_Gdi"))]
271 #[inline]
CMCreateTransformExt(lpcolorspace: *const LOGCOLORSPACEA, lpdevcharacter: *const ::std::ffi::c_void, lptargetdevcharacter: *const ::std::ffi::c_void, dwflags: u32) -> isize272 pub unsafe fn CMCreateTransformExt(lpcolorspace: *const LOGCOLORSPACEA, lpdevcharacter: *const ::std::ffi::c_void, lptargetdevcharacter: *const ::std::ffi::c_void, dwflags: u32) -> isize {
273     #[cfg(windows)]
274     {
275         #[link(name = "windows")]
276         extern "system" {
277             fn CMCreateTransformExt(lpcolorspace: *const LOGCOLORSPACEA, lpdevcharacter: *const ::std::ffi::c_void, lptargetdevcharacter: *const ::std::ffi::c_void, dwflags: u32) -> isize;
278         }
279         ::std::mem::transmute(CMCreateTransformExt(::std::mem::transmute(lpcolorspace), ::std::mem::transmute(lpdevcharacter), ::std::mem::transmute(lptargetdevcharacter), ::std::mem::transmute(dwflags)))
280     }
281     #[cfg(not(windows))]
282     unimplemented!("Unsupported target OS");
283 }
284 #[cfg(feature = "Win32_Graphics_Gdi")]
285 #[inline]
CMCreateTransformExtW(lpcolorspace: *const LOGCOLORSPACEW, lpdevcharacter: *const ::std::ffi::c_void, lptargetdevcharacter: *const ::std::ffi::c_void, dwflags: u32) -> isize286 pub unsafe fn CMCreateTransformExtW(lpcolorspace: *const LOGCOLORSPACEW, lpdevcharacter: *const ::std::ffi::c_void, lptargetdevcharacter: *const ::std::ffi::c_void, dwflags: u32) -> isize {
287     #[cfg(windows)]
288     {
289         #[link(name = "windows")]
290         extern "system" {
291             fn CMCreateTransformExtW(lpcolorspace: *const LOGCOLORSPACEW, lpdevcharacter: *const ::std::ffi::c_void, lptargetdevcharacter: *const ::std::ffi::c_void, dwflags: u32) -> isize;
292         }
293         ::std::mem::transmute(CMCreateTransformExtW(::std::mem::transmute(lpcolorspace), ::std::mem::transmute(lpdevcharacter), ::std::mem::transmute(lptargetdevcharacter), ::std::mem::transmute(dwflags)))
294     }
295     #[cfg(not(windows))]
296     unimplemented!("Unsupported target OS");
297 }
298 #[cfg(feature = "Win32_Graphics_Gdi")]
299 #[inline]
CMCreateTransformW(lpcolorspace: *const LOGCOLORSPACEW, lpdevcharacter: *const ::std::ffi::c_void, lptargetdevcharacter: *const ::std::ffi::c_void) -> isize300 pub unsafe fn CMCreateTransformW(lpcolorspace: *const LOGCOLORSPACEW, lpdevcharacter: *const ::std::ffi::c_void, lptargetdevcharacter: *const ::std::ffi::c_void) -> isize {
301     #[cfg(windows)]
302     {
303         #[link(name = "windows")]
304         extern "system" {
305             fn CMCreateTransformW(lpcolorspace: *const LOGCOLORSPACEW, lpdevcharacter: *const ::std::ffi::c_void, lptargetdevcharacter: *const ::std::ffi::c_void) -> isize;
306         }
307         ::std::mem::transmute(CMCreateTransformW(::std::mem::transmute(lpcolorspace), ::std::mem::transmute(lpdevcharacter), ::std::mem::transmute(lptargetdevcharacter)))
308     }
309     #[cfg(not(windows))]
310     unimplemented!("Unsupported target OS");
311 }
312 #[cfg(feature = "Win32_Foundation")]
313 #[inline]
CMDeleteTransform(hcmtransform: isize) -> super::super::Foundation::BOOL314 pub unsafe fn CMDeleteTransform(hcmtransform: isize) -> super::super::Foundation::BOOL {
315     #[cfg(windows)]
316     {
317         #[link(name = "windows")]
318         extern "system" {
319             fn CMDeleteTransform(hcmtransform: isize) -> super::super::Foundation::BOOL;
320         }
321         ::std::mem::transmute(CMDeleteTransform(::std::mem::transmute(hcmtransform)))
322     }
323     #[cfg(not(windows))]
324     unimplemented!("Unsupported target OS");
325 }
326 #[inline]
CMGetInfo(dwinfo: u32) -> u32327 pub unsafe fn CMGetInfo(dwinfo: u32) -> u32 {
328     #[cfg(windows)]
329     {
330         #[link(name = "windows")]
331         extern "system" {
332             fn CMGetInfo(dwinfo: u32) -> u32;
333         }
334         ::std::mem::transmute(CMGetInfo(::std::mem::transmute(dwinfo)))
335     }
336     #[cfg(not(windows))]
337     unimplemented!("Unsupported target OS");
338 }
339 #[cfg(feature = "Win32_Foundation")]
340 #[inline]
CMGetNamedProfileInfo(hprofile: isize, pnamedprofileinfo: *mut NAMED_PROFILE_INFO) -> super::super::Foundation::BOOL341 pub unsafe fn CMGetNamedProfileInfo(hprofile: isize, pnamedprofileinfo: *mut NAMED_PROFILE_INFO) -> super::super::Foundation::BOOL {
342     #[cfg(windows)]
343     {
344         #[link(name = "windows")]
345         extern "system" {
346             fn CMGetNamedProfileInfo(hprofile: isize, pnamedprofileinfo: *mut NAMED_PROFILE_INFO) -> super::super::Foundation::BOOL;
347         }
348         ::std::mem::transmute(CMGetNamedProfileInfo(::std::mem::transmute(hprofile), ::std::mem::transmute(pnamedprofileinfo)))
349     }
350     #[cfg(not(windows))]
351     unimplemented!("Unsupported target OS");
352 }
353 #[cfg(feature = "Win32_Foundation")]
354 #[inline]
CMIsProfileValid(hprofile: isize, lpbvalid: *mut i32) -> super::super::Foundation::BOOL355 pub unsafe fn CMIsProfileValid(hprofile: isize, lpbvalid: *mut i32) -> super::super::Foundation::BOOL {
356     #[cfg(windows)]
357     {
358         #[link(name = "windows")]
359         extern "system" {
360             fn CMIsProfileValid(hprofile: isize, lpbvalid: *mut i32) -> super::super::Foundation::BOOL;
361         }
362         ::std::mem::transmute(CMIsProfileValid(::std::mem::transmute(hprofile), ::std::mem::transmute(lpbvalid)))
363     }
364     #[cfg(not(windows))]
365     unimplemented!("Unsupported target OS");
366 }
367 pub const CMM_DESCRIPTION: u32 = 5u32;
368 pub const CMM_DLL_VERSION: u32 = 3u32;
369 pub const CMM_DRIVER_VERSION: u32 = 2u32;
370 pub const CMM_FROM_PROFILE: u32 = 0u32;
371 pub const CMM_IDENT: u32 = 1u32;
372 pub const CMM_LOGOICON: u32 = 6u32;
373 pub const CMM_VERSION: u32 = 4u32;
374 pub const CMM_WIN_VERSION: u32 = 0u32;
375 pub const CMS_BACKWARD: u32 = 1u32;
376 pub const CMS_DISABLEICM: u32 = 1u32;
377 pub const CMS_DISABLEINTENT: u32 = 1024u32;
378 pub const CMS_DISABLERENDERINTENT: u32 = 2048u32;
379 pub const CMS_ENABLEPROOFING: u32 = 2u32;
380 pub const CMS_FORWARD: u32 = 0u32;
381 pub const CMS_MONITOROVERFLOW: i32 = -2147483648i32;
382 pub const CMS_PRINTEROVERFLOW: i32 = 1073741824i32;
383 pub const CMS_SETMONITORPROFILE: u32 = 16u32;
384 pub const CMS_SETPRINTERPROFILE: u32 = 32u32;
385 pub const CMS_SETPROOFINTENT: u32 = 8u32;
386 pub const CMS_SETRENDERINTENT: u32 = 4u32;
387 pub const CMS_SETTARGETPROFILE: u32 = 64u32;
388 pub const CMS_TARGETOVERFLOW: i32 = 536870912i32;
389 pub const CMS_USEAPPLYCALLBACK: u32 = 256u32;
390 pub const CMS_USEDESCRIPTION: u32 = 512u32;
391 pub const CMS_USEHOOK: u32 = 128u32;
392 #[cfg(feature = "Win32_Foundation")]
393 #[inline]
CMTranslateColors(hcmtransform: isize, lpainputcolors: *const COLOR, ncolors: u32, ctinput: COLORTYPE, lpaoutputcolors: *mut COLOR, ctoutput: COLORTYPE) -> super::super::Foundation::BOOL394 pub unsafe fn CMTranslateColors(hcmtransform: isize, lpainputcolors: *const COLOR, ncolors: u32, ctinput: COLORTYPE, lpaoutputcolors: *mut COLOR, ctoutput: COLORTYPE) -> super::super::Foundation::BOOL {
395     #[cfg(windows)]
396     {
397         #[link(name = "windows")]
398         extern "system" {
399             fn CMTranslateColors(hcmtransform: isize, lpainputcolors: *const COLOR, ncolors: u32, ctinput: COLORTYPE, lpaoutputcolors: *mut COLOR, ctoutput: COLORTYPE) -> super::super::Foundation::BOOL;
400         }
401         ::std::mem::transmute(CMTranslateColors(::std::mem::transmute(hcmtransform), ::std::mem::transmute(lpainputcolors), ::std::mem::transmute(ncolors), ::std::mem::transmute(ctinput), ::std::mem::transmute(lpaoutputcolors), ::std::mem::transmute(ctoutput)))
402     }
403     #[cfg(not(windows))]
404     unimplemented!("Unsupported target OS");
405 }
406 #[cfg(feature = "Win32_Foundation")]
407 #[inline]
CMTranslateRGB(hcmtransform: isize, colorref: u32, lpcolorref: *mut u32, dwflags: u32) -> super::super::Foundation::BOOL408 pub unsafe fn CMTranslateRGB(hcmtransform: isize, colorref: u32, lpcolorref: *mut u32, dwflags: u32) -> super::super::Foundation::BOOL {
409     #[cfg(windows)]
410     {
411         #[link(name = "windows")]
412         extern "system" {
413             fn CMTranslateRGB(hcmtransform: isize, colorref: u32, lpcolorref: *mut u32, dwflags: u32) -> super::super::Foundation::BOOL;
414         }
415         ::std::mem::transmute(CMTranslateRGB(::std::mem::transmute(hcmtransform), ::std::mem::transmute(colorref), ::std::mem::transmute(lpcolorref), ::std::mem::transmute(dwflags)))
416     }
417     #[cfg(not(windows))]
418     unimplemented!("Unsupported target OS");
419 }
420 #[cfg(feature = "Win32_Foundation")]
421 #[inline]
CMTranslateRGBs(hcmtransform: isize, lpsrcbits: *const ::std::ffi::c_void, bminput: BMFORMAT, dwwidth: u32, dwheight: u32, dwstride: u32, lpdestbits: *mut ::std::ffi::c_void, bmoutput: BMFORMAT, dwtranslatedirection: u32) -> super::super::Foundation::BOOL422 pub unsafe fn CMTranslateRGBs(hcmtransform: isize, lpsrcbits: *const ::std::ffi::c_void, bminput: BMFORMAT, dwwidth: u32, dwheight: u32, dwstride: u32, lpdestbits: *mut ::std::ffi::c_void, bmoutput: BMFORMAT, dwtranslatedirection: u32) -> super::super::Foundation::BOOL {
423     #[cfg(windows)]
424     {
425         #[link(name = "windows")]
426         extern "system" {
427             fn CMTranslateRGBs(hcmtransform: isize, lpsrcbits: *const ::std::ffi::c_void, bminput: BMFORMAT, dwwidth: u32, dwheight: u32, dwstride: u32, lpdestbits: *mut ::std::ffi::c_void, bmoutput: BMFORMAT, dwtranslatedirection: u32) -> super::super::Foundation::BOOL;
428         }
429         ::std::mem::transmute(CMTranslateRGBs(
430             ::std::mem::transmute(hcmtransform),
431             ::std::mem::transmute(lpsrcbits),
432             ::std::mem::transmute(bminput),
433             ::std::mem::transmute(dwwidth),
434             ::std::mem::transmute(dwheight),
435             ::std::mem::transmute(dwstride),
436             ::std::mem::transmute(lpdestbits),
437             ::std::mem::transmute(bmoutput),
438             ::std::mem::transmute(dwtranslatedirection),
439         ))
440     }
441     #[cfg(not(windows))]
442     unimplemented!("Unsupported target OS");
443 }
444 #[cfg(feature = "Win32_Foundation")]
445 #[inline]
CMTranslateRGBsExt<'a, Param10: ::windows::runtime::IntoParam<'a, super::super::Foundation::LPARAM>>(hcmtransform: isize, lpsrcbits: *const ::std::ffi::c_void, bminput: BMFORMAT, dwwidth: u32, dwheight: u32, dwinputstride: u32, lpdestbits: *mut ::std::ffi::c_void, bmoutput: BMFORMAT, dwoutputstride: u32, lpfncallback: ::std::option::Option<LPBMCALLBACKFN>, ulcallbackdata: Param10) -> super::super::Foundation::BOOL446 pub unsafe fn CMTranslateRGBsExt<'a, Param10: ::windows::runtime::IntoParam<'a, super::super::Foundation::LPARAM>>(hcmtransform: isize, lpsrcbits: *const ::std::ffi::c_void, bminput: BMFORMAT, dwwidth: u32, dwheight: u32, dwinputstride: u32, lpdestbits: *mut ::std::ffi::c_void, bmoutput: BMFORMAT, dwoutputstride: u32, lpfncallback: ::std::option::Option<LPBMCALLBACKFN>, ulcallbackdata: Param10) -> super::super::Foundation::BOOL {
447     #[cfg(windows)]
448     {
449         #[link(name = "windows")]
450         extern "system" {
451             fn CMTranslateRGBsExt(hcmtransform: isize, lpsrcbits: *const ::std::ffi::c_void, bminput: BMFORMAT, dwwidth: u32, dwheight: u32, dwinputstride: u32, lpdestbits: *mut ::std::ffi::c_void, bmoutput: BMFORMAT, dwoutputstride: u32, lpfncallback: ::windows::runtime::RawPtr, ulcallbackdata: super::super::Foundation::LPARAM) -> super::super::Foundation::BOOL;
452         }
453         ::std::mem::transmute(CMTranslateRGBsExt(
454             ::std::mem::transmute(hcmtransform),
455             ::std::mem::transmute(lpsrcbits),
456             ::std::mem::transmute(bminput),
457             ::std::mem::transmute(dwwidth),
458             ::std::mem::transmute(dwheight),
459             ::std::mem::transmute(dwinputstride),
460             ::std::mem::transmute(lpdestbits),
461             ::std::mem::transmute(bmoutput),
462             ::std::mem::transmute(dwoutputstride),
463             ::std::mem::transmute(lpfncallback),
464             ulcallbackdata.into_param().abi(),
465         ))
466     }
467     #[cfg(not(windows))]
468     unimplemented!("Unsupported target OS");
469 }
470 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
471 #[repr(C)]
472 pub struct CMYKCOLOR {
473     pub cyan: u16,
474     pub magenta: u16,
475     pub yellow: u16,
476     pub black: u16,
477 }
478 impl CMYKCOLOR {}
479 impl ::std::default::Default for CMYKCOLOR {
default() -> Self480     fn default() -> Self {
481         unsafe { ::std::mem::zeroed() }
482     }
483 }
484 impl ::std::fmt::Debug for CMYKCOLOR {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result485     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
486         fmt.debug_struct("CMYKCOLOR").field("cyan", &self.cyan).field("magenta", &self.magenta).field("yellow", &self.yellow).field("black", &self.black).finish()
487     }
488 }
489 impl ::std::cmp::PartialEq for CMYKCOLOR {
eq(&self, other: &Self) -> bool490     fn eq(&self, other: &Self) -> bool {
491         self.cyan == other.cyan && self.magenta == other.magenta && self.yellow == other.yellow && self.black == other.black
492     }
493 }
494 impl ::std::cmp::Eq for CMYKCOLOR {}
495 unsafe impl ::windows::runtime::Abi for CMYKCOLOR {
496     type Abi = Self;
497     type DefaultType = Self;
498 }
499 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
500 #[repr(C)]
501 pub union COLOR {
502     pub gray: GRAYCOLOR,
503     pub rgb: RGBCOLOR,
504     pub cmyk: CMYKCOLOR,
505     pub XYZ: XYZCOLOR,
506     pub Yxy: YxyCOLOR,
507     pub Lab: LabCOLOR,
508     pub gen3ch: GENERIC3CHANNEL,
509     pub named: NAMEDCOLOR,
510     pub hifi: HiFiCOLOR,
511     pub Anonymous: COLOR_0,
512 }
513 impl COLOR {}
514 impl ::std::default::Default for COLOR {
default() -> Self515     fn default() -> Self {
516         unsafe { ::std::mem::zeroed() }
517     }
518 }
519 impl ::std::cmp::PartialEq for COLOR {
eq(&self, _other: &Self) -> bool520     fn eq(&self, _other: &Self) -> bool {
521         unimplemented!()
522     }
523 }
524 impl ::std::cmp::Eq for COLOR {}
525 unsafe impl ::windows::runtime::Abi for COLOR {
526     type Abi = Self;
527     type DefaultType = Self;
528 }
529 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
530 #[repr(C)]
531 pub struct COLOR_0 {
532     pub reserved1: u32,
533     pub reserved2: *mut ::std::ffi::c_void,
534 }
535 impl COLOR_0 {}
536 impl ::std::default::Default for COLOR_0 {
default() -> Self537     fn default() -> Self {
538         unsafe { ::std::mem::zeroed() }
539     }
540 }
541 impl ::std::fmt::Debug for COLOR_0 {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result542     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
543         fmt.debug_struct("_Anonymous_e__Struct").field("reserved1", &self.reserved1).field("reserved2", &self.reserved2).finish()
544     }
545 }
546 impl ::std::cmp::PartialEq for COLOR_0 {
eq(&self, other: &Self) -> bool547     fn eq(&self, other: &Self) -> bool {
548         self.reserved1 == other.reserved1 && self.reserved2 == other.reserved2
549     }
550 }
551 impl ::std::cmp::Eq for COLOR_0 {}
552 unsafe impl ::windows::runtime::Abi for COLOR_0 {
553     type Abi = Self;
554     type DefaultType = Self;
555 }
556 #[derive(:: std :: cmp :: PartialEq, :: std :: cmp :: Eq, :: std :: marker :: Copy, :: std :: clone :: Clone, :: std :: default :: Default, :: std :: fmt :: Debug)]
557 #[repr(transparent)]
558 pub struct COLORDATATYPE(pub i32);
559 pub const COLOR_BYTE: COLORDATATYPE = COLORDATATYPE(1i32);
560 pub const COLOR_WORD: COLORDATATYPE = COLORDATATYPE(2i32);
561 pub const COLOR_FLOAT: COLORDATATYPE = COLORDATATYPE(3i32);
562 pub const COLOR_S2DOT13FIXED: COLORDATATYPE = COLORDATATYPE(4i32);
563 pub const COLOR_10b_R10G10B10A2: COLORDATATYPE = COLORDATATYPE(5i32);
564 pub const COLOR_10b_R10G10B10A2_XR: COLORDATATYPE = COLORDATATYPE(6i32);
565 pub const COLOR_FLOAT16: COLORDATATYPE = COLORDATATYPE(7i32);
566 impl ::std::convert::From<i32> for COLORDATATYPE {
from(value: i32) -> Self567     fn from(value: i32) -> Self {
568         Self(value)
569     }
570 }
571 unsafe impl ::windows::runtime::Abi for COLORDATATYPE {
572     type Abi = Self;
573     type DefaultType = Self;
574 }
575 #[derive(:: std :: clone :: Clone)]
576 #[repr(C)]
577 #[cfg(all(feature = "Win32_Foundation", feature = "Win32_UI_WindowsAndMessaging"))]
578 pub struct COLORMATCHSETUPA {
579     pub dwSize: u32,
580     pub dwVersion: u32,
581     pub dwFlags: u32,
582     pub hwndOwner: super::super::Foundation::HWND,
583     pub pSourceName: super::super::Foundation::PSTR,
584     pub pDisplayName: super::super::Foundation::PSTR,
585     pub pPrinterName: super::super::Foundation::PSTR,
586     pub dwRenderIntent: u32,
587     pub dwProofingIntent: u32,
588     pub pMonitorProfile: super::super::Foundation::PSTR,
589     pub ccMonitorProfile: u32,
590     pub pPrinterProfile: super::super::Foundation::PSTR,
591     pub ccPrinterProfile: u32,
592     pub pTargetProfile: super::super::Foundation::PSTR,
593     pub ccTargetProfile: u32,
594     pub lpfnHook: ::std::option::Option<super::WindowsAndMessaging::DLGPROC>,
595     pub lParam: super::super::Foundation::LPARAM,
596     pub lpfnApplyCallback: ::std::option::Option<PCMSCALLBACKA>,
597     pub lParamApplyCallback: super::super::Foundation::LPARAM,
598 }
599 #[cfg(all(feature = "Win32_Foundation", feature = "Win32_UI_WindowsAndMessaging"))]
600 impl COLORMATCHSETUPA {}
601 #[cfg(all(feature = "Win32_Foundation", feature = "Win32_UI_WindowsAndMessaging"))]
602 impl ::std::default::Default for COLORMATCHSETUPA {
default() -> Self603     fn default() -> Self {
604         unsafe { ::std::mem::zeroed() }
605     }
606 }
607 #[cfg(all(feature = "Win32_Foundation", feature = "Win32_UI_WindowsAndMessaging"))]
608 impl ::std::fmt::Debug for COLORMATCHSETUPA {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result609     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
610         fmt.debug_struct("COLORMATCHSETUPA")
611             .field("dwSize", &self.dwSize)
612             .field("dwVersion", &self.dwVersion)
613             .field("dwFlags", &self.dwFlags)
614             .field("hwndOwner", &self.hwndOwner)
615             .field("pSourceName", &self.pSourceName)
616             .field("pDisplayName", &self.pDisplayName)
617             .field("pPrinterName", &self.pPrinterName)
618             .field("dwRenderIntent", &self.dwRenderIntent)
619             .field("dwProofingIntent", &self.dwProofingIntent)
620             .field("pMonitorProfile", &self.pMonitorProfile)
621             .field("ccMonitorProfile", &self.ccMonitorProfile)
622             .field("pPrinterProfile", &self.pPrinterProfile)
623             .field("ccPrinterProfile", &self.ccPrinterProfile)
624             .field("pTargetProfile", &self.pTargetProfile)
625             .field("ccTargetProfile", &self.ccTargetProfile)
626             .field("lParam", &self.lParam)
627             .field("lParamApplyCallback", &self.lParamApplyCallback)
628             .finish()
629     }
630 }
631 #[cfg(all(feature = "Win32_Foundation", feature = "Win32_UI_WindowsAndMessaging"))]
632 impl ::std::cmp::PartialEq for COLORMATCHSETUPA {
eq(&self, other: &Self) -> bool633     fn eq(&self, other: &Self) -> bool {
634         self.dwSize == other.dwSize
635             && self.dwVersion == other.dwVersion
636             && self.dwFlags == other.dwFlags
637             && self.hwndOwner == other.hwndOwner
638             && self.pSourceName == other.pSourceName
639             && self.pDisplayName == other.pDisplayName
640             && self.pPrinterName == other.pPrinterName
641             && self.dwRenderIntent == other.dwRenderIntent
642             && self.dwProofingIntent == other.dwProofingIntent
643             && self.pMonitorProfile == other.pMonitorProfile
644             && self.ccMonitorProfile == other.ccMonitorProfile
645             && self.pPrinterProfile == other.pPrinterProfile
646             && self.ccPrinterProfile == other.ccPrinterProfile
647             && self.pTargetProfile == other.pTargetProfile
648             && self.ccTargetProfile == other.ccTargetProfile
649             && self.lpfnHook.map(|f| f as usize) == other.lpfnHook.map(|f| f as usize)
650             && self.lParam == other.lParam
651             && self.lpfnApplyCallback.map(|f| f as usize) == other.lpfnApplyCallback.map(|f| f as usize)
652             && self.lParamApplyCallback == other.lParamApplyCallback
653     }
654 }
655 #[cfg(all(feature = "Win32_Foundation", feature = "Win32_UI_WindowsAndMessaging"))]
656 impl ::std::cmp::Eq for COLORMATCHSETUPA {}
657 #[cfg(all(feature = "Win32_Foundation", feature = "Win32_UI_WindowsAndMessaging"))]
658 unsafe impl ::windows::runtime::Abi for COLORMATCHSETUPA {
659     type Abi = ::std::mem::ManuallyDrop<Self>;
660     type DefaultType = Self;
661 }
662 #[derive(:: std :: clone :: Clone)]
663 #[repr(C)]
664 #[cfg(all(feature = "Win32_Foundation", feature = "Win32_UI_WindowsAndMessaging"))]
665 pub struct COLORMATCHSETUPW {
666     pub dwSize: u32,
667     pub dwVersion: u32,
668     pub dwFlags: u32,
669     pub hwndOwner: super::super::Foundation::HWND,
670     pub pSourceName: super::super::Foundation::PWSTR,
671     pub pDisplayName: super::super::Foundation::PWSTR,
672     pub pPrinterName: super::super::Foundation::PWSTR,
673     pub dwRenderIntent: u32,
674     pub dwProofingIntent: u32,
675     pub pMonitorProfile: super::super::Foundation::PWSTR,
676     pub ccMonitorProfile: u32,
677     pub pPrinterProfile: super::super::Foundation::PWSTR,
678     pub ccPrinterProfile: u32,
679     pub pTargetProfile: super::super::Foundation::PWSTR,
680     pub ccTargetProfile: u32,
681     pub lpfnHook: ::std::option::Option<super::WindowsAndMessaging::DLGPROC>,
682     pub lParam: super::super::Foundation::LPARAM,
683     pub lpfnApplyCallback: ::std::option::Option<PCMSCALLBACKW>,
684     pub lParamApplyCallback: super::super::Foundation::LPARAM,
685 }
686 #[cfg(all(feature = "Win32_Foundation", feature = "Win32_UI_WindowsAndMessaging"))]
687 impl COLORMATCHSETUPW {}
688 #[cfg(all(feature = "Win32_Foundation", feature = "Win32_UI_WindowsAndMessaging"))]
689 impl ::std::default::Default for COLORMATCHSETUPW {
default() -> Self690     fn default() -> Self {
691         unsafe { ::std::mem::zeroed() }
692     }
693 }
694 #[cfg(all(feature = "Win32_Foundation", feature = "Win32_UI_WindowsAndMessaging"))]
695 impl ::std::fmt::Debug for COLORMATCHSETUPW {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result696     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
697         fmt.debug_struct("COLORMATCHSETUPW")
698             .field("dwSize", &self.dwSize)
699             .field("dwVersion", &self.dwVersion)
700             .field("dwFlags", &self.dwFlags)
701             .field("hwndOwner", &self.hwndOwner)
702             .field("pSourceName", &self.pSourceName)
703             .field("pDisplayName", &self.pDisplayName)
704             .field("pPrinterName", &self.pPrinterName)
705             .field("dwRenderIntent", &self.dwRenderIntent)
706             .field("dwProofingIntent", &self.dwProofingIntent)
707             .field("pMonitorProfile", &self.pMonitorProfile)
708             .field("ccMonitorProfile", &self.ccMonitorProfile)
709             .field("pPrinterProfile", &self.pPrinterProfile)
710             .field("ccPrinterProfile", &self.ccPrinterProfile)
711             .field("pTargetProfile", &self.pTargetProfile)
712             .field("ccTargetProfile", &self.ccTargetProfile)
713             .field("lParam", &self.lParam)
714             .field("lParamApplyCallback", &self.lParamApplyCallback)
715             .finish()
716     }
717 }
718 #[cfg(all(feature = "Win32_Foundation", feature = "Win32_UI_WindowsAndMessaging"))]
719 impl ::std::cmp::PartialEq for COLORMATCHSETUPW {
eq(&self, other: &Self) -> bool720     fn eq(&self, other: &Self) -> bool {
721         self.dwSize == other.dwSize
722             && self.dwVersion == other.dwVersion
723             && self.dwFlags == other.dwFlags
724             && self.hwndOwner == other.hwndOwner
725             && self.pSourceName == other.pSourceName
726             && self.pDisplayName == other.pDisplayName
727             && self.pPrinterName == other.pPrinterName
728             && self.dwRenderIntent == other.dwRenderIntent
729             && self.dwProofingIntent == other.dwProofingIntent
730             && self.pMonitorProfile == other.pMonitorProfile
731             && self.ccMonitorProfile == other.ccMonitorProfile
732             && self.pPrinterProfile == other.pPrinterProfile
733             && self.ccPrinterProfile == other.ccPrinterProfile
734             && self.pTargetProfile == other.pTargetProfile
735             && self.ccTargetProfile == other.ccTargetProfile
736             && self.lpfnHook.map(|f| f as usize) == other.lpfnHook.map(|f| f as usize)
737             && self.lParam == other.lParam
738             && self.lpfnApplyCallback.map(|f| f as usize) == other.lpfnApplyCallback.map(|f| f as usize)
739             && self.lParamApplyCallback == other.lParamApplyCallback
740     }
741 }
742 #[cfg(all(feature = "Win32_Foundation", feature = "Win32_UI_WindowsAndMessaging"))]
743 impl ::std::cmp::Eq for COLORMATCHSETUPW {}
744 #[cfg(all(feature = "Win32_Foundation", feature = "Win32_UI_WindowsAndMessaging"))]
745 unsafe impl ::windows::runtime::Abi for COLORMATCHSETUPW {
746     type Abi = ::std::mem::ManuallyDrop<Self>;
747     type DefaultType = Self;
748 }
749 #[derive(:: std :: cmp :: PartialEq, :: std :: cmp :: Eq, :: std :: marker :: Copy, :: std :: clone :: Clone, :: std :: default :: Default, :: std :: fmt :: Debug)]
750 #[repr(transparent)]
751 pub struct COLORPROFILESUBTYPE(pub i32);
752 pub const CPST_PERCEPTUAL: COLORPROFILESUBTYPE = COLORPROFILESUBTYPE(0i32);
753 pub const CPST_RELATIVE_COLORIMETRIC: COLORPROFILESUBTYPE = COLORPROFILESUBTYPE(1i32);
754 pub const CPST_SATURATION: COLORPROFILESUBTYPE = COLORPROFILESUBTYPE(2i32);
755 pub const CPST_ABSOLUTE_COLORIMETRIC: COLORPROFILESUBTYPE = COLORPROFILESUBTYPE(3i32);
756 pub const CPST_NONE: COLORPROFILESUBTYPE = COLORPROFILESUBTYPE(4i32);
757 pub const CPST_RGB_WORKING_SPACE: COLORPROFILESUBTYPE = COLORPROFILESUBTYPE(5i32);
758 pub const CPST_CUSTOM_WORKING_SPACE: COLORPROFILESUBTYPE = COLORPROFILESUBTYPE(6i32);
759 pub const CPST_STANDARD_DISPLAY_COLOR_MODE: COLORPROFILESUBTYPE = COLORPROFILESUBTYPE(7i32);
760 pub const CPST_EXTENDED_DISPLAY_COLOR_MODE: COLORPROFILESUBTYPE = COLORPROFILESUBTYPE(8i32);
761 impl ::std::convert::From<i32> for COLORPROFILESUBTYPE {
from(value: i32) -> Self762     fn from(value: i32) -> Self {
763         Self(value)
764     }
765 }
766 unsafe impl ::windows::runtime::Abi for COLORPROFILESUBTYPE {
767     type Abi = Self;
768     type DefaultType = Self;
769 }
770 #[derive(:: std :: cmp :: PartialEq, :: std :: cmp :: Eq, :: std :: marker :: Copy, :: std :: clone :: Clone, :: std :: default :: Default, :: std :: fmt :: Debug)]
771 #[repr(transparent)]
772 pub struct COLORPROFILETYPE(pub i32);
773 pub const CPT_ICC: COLORPROFILETYPE = COLORPROFILETYPE(0i32);
774 pub const CPT_DMP: COLORPROFILETYPE = COLORPROFILETYPE(1i32);
775 pub const CPT_CAMP: COLORPROFILETYPE = COLORPROFILETYPE(2i32);
776 pub const CPT_GMMP: COLORPROFILETYPE = COLORPROFILETYPE(3i32);
777 impl ::std::convert::From<i32> for COLORPROFILETYPE {
from(value: i32) -> Self778     fn from(value: i32) -> Self {
779         Self(value)
780     }
781 }
782 unsafe impl ::windows::runtime::Abi for COLORPROFILETYPE {
783     type Abi = Self;
784     type DefaultType = Self;
785 }
786 #[derive(:: std :: cmp :: PartialEq, :: std :: cmp :: Eq, :: std :: marker :: Copy, :: std :: clone :: Clone, :: std :: default :: Default, :: std :: fmt :: Debug)]
787 #[repr(transparent)]
788 pub struct COLORTYPE(pub i32);
789 pub const COLOR_GRAY: COLORTYPE = COLORTYPE(1i32);
790 pub const COLOR_RGB: COLORTYPE = COLORTYPE(2i32);
791 pub const COLOR_XYZ: COLORTYPE = COLORTYPE(3i32);
792 pub const COLOR_Yxy: COLORTYPE = COLORTYPE(4i32);
793 pub const COLOR_Lab: COLORTYPE = COLORTYPE(5i32);
794 pub const COLOR_3_CHANNEL: COLORTYPE = COLORTYPE(6i32);
795 pub const COLOR_CMYK: COLORTYPE = COLORTYPE(7i32);
796 pub const COLOR_5_CHANNEL: COLORTYPE = COLORTYPE(8i32);
797 pub const COLOR_6_CHANNEL: COLORTYPE = COLORTYPE(9i32);
798 pub const COLOR_7_CHANNEL: COLORTYPE = COLORTYPE(10i32);
799 pub const COLOR_8_CHANNEL: COLORTYPE = COLORTYPE(11i32);
800 pub const COLOR_NAMED: COLORTYPE = COLORTYPE(12i32);
801 impl ::std::convert::From<i32> for COLORTYPE {
from(value: i32) -> Self802     fn from(value: i32) -> Self {
803         Self(value)
804     }
805 }
806 unsafe impl ::windows::runtime::Abi for COLORTYPE {
807     type Abi = Self;
808     type DefaultType = Self;
809 }
810 #[derive(:: std :: cmp :: PartialEq, :: std :: cmp :: Eq, :: std :: marker :: Copy, :: std :: clone :: Clone, :: std :: default :: Default, :: std :: fmt :: Debug)]
811 #[repr(transparent)]
812 pub struct COLOR_MATCH_TO_TARGET_ACTION(pub i32);
813 pub const CS_ENABLE: COLOR_MATCH_TO_TARGET_ACTION = COLOR_MATCH_TO_TARGET_ACTION(1i32);
814 pub const CS_DISABLE: COLOR_MATCH_TO_TARGET_ACTION = COLOR_MATCH_TO_TARGET_ACTION(2i32);
815 pub const CS_DELETE_TRANSFORM: COLOR_MATCH_TO_TARGET_ACTION = COLOR_MATCH_TO_TARGET_ACTION(3i32);
816 impl ::std::convert::From<i32> for COLOR_MATCH_TO_TARGET_ACTION {
from(value: i32) -> Self817     fn from(value: i32) -> Self {
818         Self(value)
819     }
820 }
821 unsafe impl ::windows::runtime::Abi for COLOR_MATCH_TO_TARGET_ACTION {
822     type Abi = Self;
823     type DefaultType = Self;
824 }
825 pub const COLOR_MATCH_VERSION: u32 = 512u32;
826 pub const CSA_A: u32 = 1u32;
827 pub const CSA_ABC: u32 = 2u32;
828 pub const CSA_CMYK: u32 = 7u32;
829 pub const CSA_DEF: u32 = 3u32;
830 pub const CSA_DEFG: u32 = 4u32;
831 pub const CSA_GRAY: u32 = 5u32;
832 pub const CSA_Lab: u32 = 8u32;
833 pub const CSA_RGB: u32 = 6u32;
834 #[cfg(feature = "Win32_Foundation")]
835 #[inline]
CheckBitmapBits<'a, Param8: ::windows::runtime::IntoParam<'a, super::super::Foundation::LPARAM>>(hcolortransform: isize, psrcbits: *const ::std::ffi::c_void, bminput: BMFORMAT, dwwidth: u32, dwheight: u32, dwstride: u32, paresult: *mut u8, pfncallback: ::std::option::Option<LPBMCALLBACKFN>, lpcallbackdata: Param8) -> super::super::Foundation::BOOL836 pub unsafe fn CheckBitmapBits<'a, Param8: ::windows::runtime::IntoParam<'a, super::super::Foundation::LPARAM>>(hcolortransform: isize, psrcbits: *const ::std::ffi::c_void, bminput: BMFORMAT, dwwidth: u32, dwheight: u32, dwstride: u32, paresult: *mut u8, pfncallback: ::std::option::Option<LPBMCALLBACKFN>, lpcallbackdata: Param8) -> super::super::Foundation::BOOL {
837     #[cfg(windows)]
838     {
839         #[link(name = "windows")]
840         extern "system" {
841             fn CheckBitmapBits(hcolortransform: isize, psrcbits: *const ::std::ffi::c_void, bminput: BMFORMAT, dwwidth: u32, dwheight: u32, dwstride: u32, paresult: *mut u8, pfncallback: ::windows::runtime::RawPtr, lpcallbackdata: super::super::Foundation::LPARAM) -> super::super::Foundation::BOOL;
842         }
843         ::std::mem::transmute(CheckBitmapBits(
844             ::std::mem::transmute(hcolortransform),
845             ::std::mem::transmute(psrcbits),
846             ::std::mem::transmute(bminput),
847             ::std::mem::transmute(dwwidth),
848             ::std::mem::transmute(dwheight),
849             ::std::mem::transmute(dwstride),
850             ::std::mem::transmute(paresult),
851             ::std::mem::transmute(pfncallback),
852             lpcallbackdata.into_param().abi(),
853         ))
854     }
855     #[cfg(not(windows))]
856     unimplemented!("Unsupported target OS");
857 }
858 #[cfg(feature = "Win32_Foundation")]
859 #[inline]
CheckColors(hcolortransform: isize, painputcolors: *const COLOR, ncolors: u32, ctinput: COLORTYPE, paresult: *mut u8) -> super::super::Foundation::BOOL860 pub unsafe fn CheckColors(hcolortransform: isize, painputcolors: *const COLOR, ncolors: u32, ctinput: COLORTYPE, paresult: *mut u8) -> super::super::Foundation::BOOL {
861     #[cfg(windows)]
862     {
863         #[link(name = "windows")]
864         extern "system" {
865             fn CheckColors(hcolortransform: isize, painputcolors: *const COLOR, ncolors: u32, ctinput: COLORTYPE, paresult: *mut u8) -> super::super::Foundation::BOOL;
866         }
867         ::std::mem::transmute(CheckColors(::std::mem::transmute(hcolortransform), ::std::mem::transmute(painputcolors), ::std::mem::transmute(ncolors), ::std::mem::transmute(ctinput), ::std::mem::transmute(paresult)))
868     }
869     #[cfg(not(windows))]
870     unimplemented!("Unsupported target OS");
871 }
872 #[cfg(all(feature = "Win32_Foundation", feature = "Win32_Graphics_Gdi"))]
873 #[inline]
CheckColorsInGamut<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Graphics::Gdi::HDC>>(hdc: Param0, lprgbtriple: *const super::super::Graphics::Gdi::RGBTRIPLE, dlpbuffer: *mut ::std::ffi::c_void, ncount: u32) -> super::super::Foundation::BOOL874 pub unsafe fn CheckColorsInGamut<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Graphics::Gdi::HDC>>(hdc: Param0, lprgbtriple: *const super::super::Graphics::Gdi::RGBTRIPLE, dlpbuffer: *mut ::std::ffi::c_void, ncount: u32) -> super::super::Foundation::BOOL {
875     #[cfg(windows)]
876     {
877         #[link(name = "windows")]
878         extern "system" {
879             fn CheckColorsInGamut(hdc: super::super::Graphics::Gdi::HDC, lprgbtriple: *const super::super::Graphics::Gdi::RGBTRIPLE, dlpbuffer: *mut ::std::ffi::c_void, ncount: u32) -> super::super::Foundation::BOOL;
880         }
881         ::std::mem::transmute(CheckColorsInGamut(hdc.into_param().abi(), ::std::mem::transmute(lprgbtriple), ::std::mem::transmute(dlpbuffer), ::std::mem::transmute(ncount)))
882     }
883     #[cfg(not(windows))]
884     unimplemented!("Unsupported target OS");
885 }
886 #[cfg(feature = "Win32_Foundation")]
887 #[inline]
CloseColorProfile(hprofile: isize) -> super::super::Foundation::BOOL888 pub unsafe fn CloseColorProfile(hprofile: isize) -> super::super::Foundation::BOOL {
889     #[cfg(windows)]
890     {
891         #[link(name = "windows")]
892         extern "system" {
893             fn CloseColorProfile(hprofile: isize) -> super::super::Foundation::BOOL;
894         }
895         ::std::mem::transmute(CloseColorProfile(::std::mem::transmute(hprofile)))
896     }
897     #[cfg(not(windows))]
898     unimplemented!("Unsupported target OS");
899 }
900 #[cfg(all(feature = "Win32_Foundation", feature = "Win32_Graphics_Gdi"))]
901 #[inline]
ColorCorrectPalette<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Graphics::Gdi::HDC>, Param1: ::windows::runtime::IntoParam<'a, super::super::Graphics::Gdi::HPALETTE>>(hdc: Param0, hpal: Param1, defirst: u32, num: u32) -> super::super::Foundation::BOOL902 pub unsafe fn ColorCorrectPalette<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Graphics::Gdi::HDC>, Param1: ::windows::runtime::IntoParam<'a, super::super::Graphics::Gdi::HPALETTE>>(hdc: Param0, hpal: Param1, defirst: u32, num: u32) -> super::super::Foundation::BOOL {
903     #[cfg(windows)]
904     {
905         #[link(name = "windows")]
906         extern "system" {
907             fn ColorCorrectPalette(hdc: super::super::Graphics::Gdi::HDC, hpal: super::super::Graphics::Gdi::HPALETTE, defirst: u32, num: u32) -> super::super::Foundation::BOOL;
908         }
909         ::std::mem::transmute(ColorCorrectPalette(hdc.into_param().abi(), hpal.into_param().abi(), ::std::mem::transmute(defirst), ::std::mem::transmute(num)))
910     }
911     #[cfg(not(windows))]
912     unimplemented!("Unsupported target OS");
913 }
914 #[cfg(all(feature = "Win32_Foundation", feature = "Win32_Graphics_Gdi"))]
915 #[inline]
ColorMatchToTarget<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Graphics::Gdi::HDC>, Param1: ::windows::runtime::IntoParam<'a, super::super::Graphics::Gdi::HDC>>(hdc: Param0, hdctarget: Param1, action: COLOR_MATCH_TO_TARGET_ACTION) -> super::super::Foundation::BOOL916 pub unsafe fn ColorMatchToTarget<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Graphics::Gdi::HDC>, Param1: ::windows::runtime::IntoParam<'a, super::super::Graphics::Gdi::HDC>>(hdc: Param0, hdctarget: Param1, action: COLOR_MATCH_TO_TARGET_ACTION) -> super::super::Foundation::BOOL {
917     #[cfg(windows)]
918     {
919         #[link(name = "windows")]
920         extern "system" {
921             fn ColorMatchToTarget(hdc: super::super::Graphics::Gdi::HDC, hdctarget: super::super::Graphics::Gdi::HDC, action: COLOR_MATCH_TO_TARGET_ACTION) -> super::super::Foundation::BOOL;
922         }
923         ::std::mem::transmute(ColorMatchToTarget(hdc.into_param().abi(), hdctarget.into_param().abi(), ::std::mem::transmute(action)))
924     }
925     #[cfg(not(windows))]
926     unimplemented!("Unsupported target OS");
927 }
928 #[cfg(feature = "Win32_Foundation")]
929 #[inline]
ColorProfileAddDisplayAssociation<'a, Param1: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>, Param2: ::windows::runtime::IntoParam<'a, super::super::Foundation::LUID>, Param4: ::windows::runtime::IntoParam<'a, super::super::Foundation::BOOL>, Param5: ::windows::runtime::IntoParam<'a, super::super::Foundation::BOOL>>( scope: WCS_PROFILE_MANAGEMENT_SCOPE, profilename: Param1, targetadapterid: Param2, sourceid: u32, setasdefault: Param4, associateasadvancedcolor: Param5, ) -> ::windows::runtime::Result<()>930 pub unsafe fn ColorProfileAddDisplayAssociation<'a, Param1: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>, Param2: ::windows::runtime::IntoParam<'a, super::super::Foundation::LUID>, Param4: ::windows::runtime::IntoParam<'a, super::super::Foundation::BOOL>, Param5: ::windows::runtime::IntoParam<'a, super::super::Foundation::BOOL>>(
931     scope: WCS_PROFILE_MANAGEMENT_SCOPE,
932     profilename: Param1,
933     targetadapterid: Param2,
934     sourceid: u32,
935     setasdefault: Param4,
936     associateasadvancedcolor: Param5,
937 ) -> ::windows::runtime::Result<()> {
938     #[cfg(windows)]
939     {
940         #[link(name = "windows")]
941         extern "system" {
942             fn ColorProfileAddDisplayAssociation(scope: WCS_PROFILE_MANAGEMENT_SCOPE, profilename: super::super::Foundation::PWSTR, targetadapterid: super::super::Foundation::LUID, sourceid: u32, setasdefault: super::super::Foundation::BOOL, associateasadvancedcolor: super::super::Foundation::BOOL) -> ::windows::runtime::HRESULT;
943         }
944         ColorProfileAddDisplayAssociation(::std::mem::transmute(scope), profilename.into_param().abi(), targetadapterid.into_param().abi(), ::std::mem::transmute(sourceid), setasdefault.into_param().abi(), associateasadvancedcolor.into_param().abi()).ok()
945     }
946     #[cfg(not(windows))]
947     unimplemented!("Unsupported target OS");
948 }
949 #[cfg(feature = "Win32_Foundation")]
950 #[inline]
ColorProfileGetDisplayDefault<'a, Param1: ::windows::runtime::IntoParam<'a, super::super::Foundation::LUID>>(scope: WCS_PROFILE_MANAGEMENT_SCOPE, targetadapterid: Param1, sourceid: u32, profiletype: COLORPROFILETYPE, profilesubtype: COLORPROFILESUBTYPE) -> ::windows::runtime::Result<super::super::Foundation::PWSTR>951 pub unsafe fn ColorProfileGetDisplayDefault<'a, Param1: ::windows::runtime::IntoParam<'a, super::super::Foundation::LUID>>(scope: WCS_PROFILE_MANAGEMENT_SCOPE, targetadapterid: Param1, sourceid: u32, profiletype: COLORPROFILETYPE, profilesubtype: COLORPROFILESUBTYPE) -> ::windows::runtime::Result<super::super::Foundation::PWSTR> {
952     #[cfg(windows)]
953     {
954         #[link(name = "windows")]
955         extern "system" {
956             fn ColorProfileGetDisplayDefault(scope: WCS_PROFILE_MANAGEMENT_SCOPE, targetadapterid: super::super::Foundation::LUID, sourceid: u32, profiletype: COLORPROFILETYPE, profilesubtype: COLORPROFILESUBTYPE, profilename: *mut super::super::Foundation::PWSTR) -> ::windows::runtime::HRESULT;
957         }
958         let mut result__: <super::super::Foundation::PWSTR as ::windows::runtime::Abi>::Abi = ::std::mem::zeroed();
959         ColorProfileGetDisplayDefault(::std::mem::transmute(scope), targetadapterid.into_param().abi(), ::std::mem::transmute(sourceid), ::std::mem::transmute(profiletype), ::std::mem::transmute(profilesubtype), &mut result__).from_abi::<super::super::Foundation::PWSTR>(result__)
960     }
961     #[cfg(not(windows))]
962     unimplemented!("Unsupported target OS");
963 }
964 #[cfg(feature = "Win32_Foundation")]
965 #[inline]
ColorProfileGetDisplayList<'a, Param1: ::windows::runtime::IntoParam<'a, super::super::Foundation::LUID>>(scope: WCS_PROFILE_MANAGEMENT_SCOPE, targetadapterid: Param1, sourceid: u32, profilelist: *mut *mut super::super::Foundation::PWSTR, profilecount: *mut u32) -> ::windows::runtime::Result<()>966 pub unsafe fn ColorProfileGetDisplayList<'a, Param1: ::windows::runtime::IntoParam<'a, super::super::Foundation::LUID>>(scope: WCS_PROFILE_MANAGEMENT_SCOPE, targetadapterid: Param1, sourceid: u32, profilelist: *mut *mut super::super::Foundation::PWSTR, profilecount: *mut u32) -> ::windows::runtime::Result<()> {
967     #[cfg(windows)]
968     {
969         #[link(name = "windows")]
970         extern "system" {
971             fn ColorProfileGetDisplayList(scope: WCS_PROFILE_MANAGEMENT_SCOPE, targetadapterid: super::super::Foundation::LUID, sourceid: u32, profilelist: *mut *mut super::super::Foundation::PWSTR, profilecount: *mut u32) -> ::windows::runtime::HRESULT;
972         }
973         ColorProfileGetDisplayList(::std::mem::transmute(scope), targetadapterid.into_param().abi(), ::std::mem::transmute(sourceid), ::std::mem::transmute(profilelist), ::std::mem::transmute(profilecount)).ok()
974     }
975     #[cfg(not(windows))]
976     unimplemented!("Unsupported target OS");
977 }
978 #[cfg(feature = "Win32_Foundation")]
979 #[inline]
ColorProfileGetDisplayUserScope<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::LUID>>(targetadapterid: Param0, sourceid: u32) -> ::windows::runtime::Result<WCS_PROFILE_MANAGEMENT_SCOPE>980 pub unsafe fn ColorProfileGetDisplayUserScope<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::LUID>>(targetadapterid: Param0, sourceid: u32) -> ::windows::runtime::Result<WCS_PROFILE_MANAGEMENT_SCOPE> {
981     #[cfg(windows)]
982     {
983         #[link(name = "windows")]
984         extern "system" {
985             fn ColorProfileGetDisplayUserScope(targetadapterid: super::super::Foundation::LUID, sourceid: u32, scope: *mut WCS_PROFILE_MANAGEMENT_SCOPE) -> ::windows::runtime::HRESULT;
986         }
987         let mut result__: <WCS_PROFILE_MANAGEMENT_SCOPE as ::windows::runtime::Abi>::Abi = ::std::mem::zeroed();
988         ColorProfileGetDisplayUserScope(targetadapterid.into_param().abi(), ::std::mem::transmute(sourceid), &mut result__).from_abi::<WCS_PROFILE_MANAGEMENT_SCOPE>(result__)
989     }
990     #[cfg(not(windows))]
991     unimplemented!("Unsupported target OS");
992 }
993 #[cfg(feature = "Win32_Foundation")]
994 #[inline]
ColorProfileRemoveDisplayAssociation<'a, Param1: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>, Param2: ::windows::runtime::IntoParam<'a, super::super::Foundation::LUID>, Param4: ::windows::runtime::IntoParam<'a, super::super::Foundation::BOOL>>(scope: WCS_PROFILE_MANAGEMENT_SCOPE, profilename: Param1, targetadapterid: Param2, sourceid: u32, dissociateadvancedcolor: Param4) -> ::windows::runtime::Result<()>995 pub unsafe fn ColorProfileRemoveDisplayAssociation<'a, Param1: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>, Param2: ::windows::runtime::IntoParam<'a, super::super::Foundation::LUID>, Param4: ::windows::runtime::IntoParam<'a, super::super::Foundation::BOOL>>(scope: WCS_PROFILE_MANAGEMENT_SCOPE, profilename: Param1, targetadapterid: Param2, sourceid: u32, dissociateadvancedcolor: Param4) -> ::windows::runtime::Result<()> {
996     #[cfg(windows)]
997     {
998         #[link(name = "windows")]
999         extern "system" {
1000             fn ColorProfileRemoveDisplayAssociation(scope: WCS_PROFILE_MANAGEMENT_SCOPE, profilename: super::super::Foundation::PWSTR, targetadapterid: super::super::Foundation::LUID, sourceid: u32, dissociateadvancedcolor: super::super::Foundation::BOOL) -> ::windows::runtime::HRESULT;
1001         }
1002         ColorProfileRemoveDisplayAssociation(::std::mem::transmute(scope), profilename.into_param().abi(), targetadapterid.into_param().abi(), ::std::mem::transmute(sourceid), dissociateadvancedcolor.into_param().abi()).ok()
1003     }
1004     #[cfg(not(windows))]
1005     unimplemented!("Unsupported target OS");
1006 }
1007 #[cfg(feature = "Win32_Foundation")]
1008 #[inline]
ColorProfileSetDisplayDefaultAssociation<'a, Param1: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>, Param4: ::windows::runtime::IntoParam<'a, super::super::Foundation::LUID>>(scope: WCS_PROFILE_MANAGEMENT_SCOPE, profilename: Param1, profiletype: COLORPROFILETYPE, profilesubtype: COLORPROFILESUBTYPE, targetadapterid: Param4, sourceid: u32) -> ::windows::runtime::Result<()>1009 pub unsafe fn ColorProfileSetDisplayDefaultAssociation<'a, Param1: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>, Param4: ::windows::runtime::IntoParam<'a, super::super::Foundation::LUID>>(scope: WCS_PROFILE_MANAGEMENT_SCOPE, profilename: Param1, profiletype: COLORPROFILETYPE, profilesubtype: COLORPROFILESUBTYPE, targetadapterid: Param4, sourceid: u32) -> ::windows::runtime::Result<()> {
1010     #[cfg(windows)]
1011     {
1012         #[link(name = "windows")]
1013         extern "system" {
1014             fn ColorProfileSetDisplayDefaultAssociation(scope: WCS_PROFILE_MANAGEMENT_SCOPE, profilename: super::super::Foundation::PWSTR, profiletype: COLORPROFILETYPE, profilesubtype: COLORPROFILESUBTYPE, targetadapterid: super::super::Foundation::LUID, sourceid: u32) -> ::windows::runtime::HRESULT;
1015         }
1016         ColorProfileSetDisplayDefaultAssociation(::std::mem::transmute(scope), profilename.into_param().abi(), ::std::mem::transmute(profiletype), ::std::mem::transmute(profilesubtype), targetadapterid.into_param().abi(), ::std::mem::transmute(sourceid)).ok()
1017     }
1018     #[cfg(not(windows))]
1019     unimplemented!("Unsupported target OS");
1020 }
1021 #[cfg(feature = "Win32_Foundation")]
1022 #[inline]
ConvertColorNameToIndex(hprofile: isize, pacolorname: *const *const i8, paindex: *mut u32, dwcount: u32) -> super::super::Foundation::BOOL1023 pub unsafe fn ConvertColorNameToIndex(hprofile: isize, pacolorname: *const *const i8, paindex: *mut u32, dwcount: u32) -> super::super::Foundation::BOOL {
1024     #[cfg(windows)]
1025     {
1026         #[link(name = "windows")]
1027         extern "system" {
1028             fn ConvertColorNameToIndex(hprofile: isize, pacolorname: *const *const i8, paindex: *mut u32, dwcount: u32) -> super::super::Foundation::BOOL;
1029         }
1030         ::std::mem::transmute(ConvertColorNameToIndex(::std::mem::transmute(hprofile), ::std::mem::transmute(pacolorname), ::std::mem::transmute(paindex), ::std::mem::transmute(dwcount)))
1031     }
1032     #[cfg(not(windows))]
1033     unimplemented!("Unsupported target OS");
1034 }
1035 #[cfg(feature = "Win32_Foundation")]
1036 #[inline]
ConvertIndexToColorName(hprofile: isize, paindex: *const u32, pacolorname: *mut *mut i8, dwcount: u32) -> super::super::Foundation::BOOL1037 pub unsafe fn ConvertIndexToColorName(hprofile: isize, paindex: *const u32, pacolorname: *mut *mut i8, dwcount: u32) -> super::super::Foundation::BOOL {
1038     #[cfg(windows)]
1039     {
1040         #[link(name = "windows")]
1041         extern "system" {
1042             fn ConvertIndexToColorName(hprofile: isize, paindex: *const u32, pacolorname: *mut *mut i8, dwcount: u32) -> super::super::Foundation::BOOL;
1043         }
1044         ::std::mem::transmute(ConvertIndexToColorName(::std::mem::transmute(hprofile), ::std::mem::transmute(paindex), ::std::mem::transmute(pacolorname), ::std::mem::transmute(dwcount)))
1045     }
1046     #[cfg(not(windows))]
1047     unimplemented!("Unsupported target OS");
1048 }
1049 #[cfg(all(feature = "Win32_Foundation", feature = "Win32_Graphics_Gdi"))]
1050 #[inline]
CreateColorSpaceA(lplcs: *const LOGCOLORSPACEA) -> HCOLORSPACE1051 pub unsafe fn CreateColorSpaceA(lplcs: *const LOGCOLORSPACEA) -> HCOLORSPACE {
1052     #[cfg(windows)]
1053     {
1054         #[link(name = "windows")]
1055         extern "system" {
1056             fn CreateColorSpaceA(lplcs: *const LOGCOLORSPACEA) -> HCOLORSPACE;
1057         }
1058         ::std::mem::transmute(CreateColorSpaceA(::std::mem::transmute(lplcs)))
1059     }
1060     #[cfg(not(windows))]
1061     unimplemented!("Unsupported target OS");
1062 }
1063 #[cfg(feature = "Win32_Graphics_Gdi")]
1064 #[inline]
CreateColorSpaceW(lplcs: *const LOGCOLORSPACEW) -> HCOLORSPACE1065 pub unsafe fn CreateColorSpaceW(lplcs: *const LOGCOLORSPACEW) -> HCOLORSPACE {
1066     #[cfg(windows)]
1067     {
1068         #[link(name = "windows")]
1069         extern "system" {
1070             fn CreateColorSpaceW(lplcs: *const LOGCOLORSPACEW) -> HCOLORSPACE;
1071         }
1072         ::std::mem::transmute(CreateColorSpaceW(::std::mem::transmute(lplcs)))
1073     }
1074     #[cfg(not(windows))]
1075     unimplemented!("Unsupported target OS");
1076 }
1077 #[cfg(all(feature = "Win32_Foundation", feature = "Win32_Graphics_Gdi"))]
1078 #[inline]
CreateColorTransformA(plogcolorspace: *const LOGCOLORSPACEA, hdestprofile: isize, htargetprofile: isize, dwflags: u32) -> isize1079 pub unsafe fn CreateColorTransformA(plogcolorspace: *const LOGCOLORSPACEA, hdestprofile: isize, htargetprofile: isize, dwflags: u32) -> isize {
1080     #[cfg(windows)]
1081     {
1082         #[link(name = "windows")]
1083         extern "system" {
1084             fn CreateColorTransformA(plogcolorspace: *const LOGCOLORSPACEA, hdestprofile: isize, htargetprofile: isize, dwflags: u32) -> isize;
1085         }
1086         ::std::mem::transmute(CreateColorTransformA(::std::mem::transmute(plogcolorspace), ::std::mem::transmute(hdestprofile), ::std::mem::transmute(htargetprofile), ::std::mem::transmute(dwflags)))
1087     }
1088     #[cfg(not(windows))]
1089     unimplemented!("Unsupported target OS");
1090 }
1091 #[cfg(feature = "Win32_Graphics_Gdi")]
1092 #[inline]
CreateColorTransformW(plogcolorspace: *const LOGCOLORSPACEW, hdestprofile: isize, htargetprofile: isize, dwflags: u32) -> isize1093 pub unsafe fn CreateColorTransformW(plogcolorspace: *const LOGCOLORSPACEW, hdestprofile: isize, htargetprofile: isize, dwflags: u32) -> isize {
1094     #[cfg(windows)]
1095     {
1096         #[link(name = "windows")]
1097         extern "system" {
1098             fn CreateColorTransformW(plogcolorspace: *const LOGCOLORSPACEW, hdestprofile: isize, htargetprofile: isize, dwflags: u32) -> isize;
1099         }
1100         ::std::mem::transmute(CreateColorTransformW(::std::mem::transmute(plogcolorspace), ::std::mem::transmute(hdestprofile), ::std::mem::transmute(htargetprofile), ::std::mem::transmute(dwflags)))
1101     }
1102     #[cfg(not(windows))]
1103     unimplemented!("Unsupported target OS");
1104 }
1105 #[cfg(feature = "Win32_Foundation")]
1106 #[inline]
CreateDeviceLinkProfile(hprofile: *const isize, nprofiles: u32, padwintent: *const u32, nintents: u32, dwflags: u32, pprofiledata: *mut *mut u8, indexpreferredcmm: u32) -> super::super::Foundation::BOOL1107 pub unsafe fn CreateDeviceLinkProfile(hprofile: *const isize, nprofiles: u32, padwintent: *const u32, nintents: u32, dwflags: u32, pprofiledata: *mut *mut u8, indexpreferredcmm: u32) -> super::super::Foundation::BOOL {
1108     #[cfg(windows)]
1109     {
1110         #[link(name = "windows")]
1111         extern "system" {
1112             fn CreateDeviceLinkProfile(hprofile: *const isize, nprofiles: u32, padwintent: *const u32, nintents: u32, dwflags: u32, pprofiledata: *mut *mut u8, indexpreferredcmm: u32) -> super::super::Foundation::BOOL;
1113         }
1114         ::std::mem::transmute(CreateDeviceLinkProfile(::std::mem::transmute(hprofile), ::std::mem::transmute(nprofiles), ::std::mem::transmute(padwintent), ::std::mem::transmute(nintents), ::std::mem::transmute(dwflags), ::std::mem::transmute(pprofiledata), ::std::mem::transmute(indexpreferredcmm)))
1115     }
1116     #[cfg(not(windows))]
1117     unimplemented!("Unsupported target OS");
1118 }
1119 #[inline]
CreateMultiProfileTransform(pahprofiles: *const isize, nprofiles: u32, padwintent: *const u32, nintents: u32, dwflags: u32, indexpreferredcmm: u32) -> isize1120 pub unsafe fn CreateMultiProfileTransform(pahprofiles: *const isize, nprofiles: u32, padwintent: *const u32, nintents: u32, dwflags: u32, indexpreferredcmm: u32) -> isize {
1121     #[cfg(windows)]
1122     {
1123         #[link(name = "windows")]
1124         extern "system" {
1125             fn CreateMultiProfileTransform(pahprofiles: *const isize, nprofiles: u32, padwintent: *const u32, nintents: u32, dwflags: u32, indexpreferredcmm: u32) -> isize;
1126         }
1127         ::std::mem::transmute(CreateMultiProfileTransform(::std::mem::transmute(pahprofiles), ::std::mem::transmute(nprofiles), ::std::mem::transmute(padwintent), ::std::mem::transmute(nintents), ::std::mem::transmute(dwflags), ::std::mem::transmute(indexpreferredcmm)))
1128     }
1129     #[cfg(not(windows))]
1130     unimplemented!("Unsupported target OS");
1131 }
1132 #[cfg(all(feature = "Win32_Foundation", feature = "Win32_Graphics_Gdi"))]
1133 #[inline]
CreateProfileFromLogColorSpaceA(plogcolorspace: *const LOGCOLORSPACEA, pprofile: *mut *mut u8) -> super::super::Foundation::BOOL1134 pub unsafe fn CreateProfileFromLogColorSpaceA(plogcolorspace: *const LOGCOLORSPACEA, pprofile: *mut *mut u8) -> super::super::Foundation::BOOL {
1135     #[cfg(windows)]
1136     {
1137         #[link(name = "windows")]
1138         extern "system" {
1139             fn CreateProfileFromLogColorSpaceA(plogcolorspace: *const LOGCOLORSPACEA, pprofile: *mut *mut u8) -> super::super::Foundation::BOOL;
1140         }
1141         ::std::mem::transmute(CreateProfileFromLogColorSpaceA(::std::mem::transmute(plogcolorspace), ::std::mem::transmute(pprofile)))
1142     }
1143     #[cfg(not(windows))]
1144     unimplemented!("Unsupported target OS");
1145 }
1146 #[cfg(all(feature = "Win32_Foundation", feature = "Win32_Graphics_Gdi"))]
1147 #[inline]
CreateProfileFromLogColorSpaceW(plogcolorspace: *const LOGCOLORSPACEW, pprofile: *mut *mut u8) -> super::super::Foundation::BOOL1148 pub unsafe fn CreateProfileFromLogColorSpaceW(plogcolorspace: *const LOGCOLORSPACEW, pprofile: *mut *mut u8) -> super::super::Foundation::BOOL {
1149     #[cfg(windows)]
1150     {
1151         #[link(name = "windows")]
1152         extern "system" {
1153             fn CreateProfileFromLogColorSpaceW(plogcolorspace: *const LOGCOLORSPACEW, pprofile: *mut *mut u8) -> super::super::Foundation::BOOL;
1154         }
1155         ::std::mem::transmute(CreateProfileFromLogColorSpaceW(::std::mem::transmute(plogcolorspace), ::std::mem::transmute(pprofile)))
1156     }
1157     #[cfg(not(windows))]
1158     unimplemented!("Unsupported target OS");
1159 }
1160 pub const DONT_USE_EMBEDDED_WCS_PROFILES: i32 = 1i32;
1161 #[cfg(feature = "Win32_Foundation")]
1162 #[inline]
DeleteColorSpace<'a, Param0: ::windows::runtime::IntoParam<'a, HCOLORSPACE>>(hcs: Param0) -> super::super::Foundation::BOOL1163 pub unsafe fn DeleteColorSpace<'a, Param0: ::windows::runtime::IntoParam<'a, HCOLORSPACE>>(hcs: Param0) -> super::super::Foundation::BOOL {
1164     #[cfg(windows)]
1165     {
1166         #[link(name = "windows")]
1167         extern "system" {
1168             fn DeleteColorSpace(hcs: HCOLORSPACE) -> super::super::Foundation::BOOL;
1169         }
1170         ::std::mem::transmute(DeleteColorSpace(hcs.into_param().abi()))
1171     }
1172     #[cfg(not(windows))]
1173     unimplemented!("Unsupported target OS");
1174 }
1175 #[cfg(feature = "Win32_Foundation")]
1176 #[inline]
DeleteColorTransform(hxform: isize) -> super::super::Foundation::BOOL1177 pub unsafe fn DeleteColorTransform(hxform: isize) -> super::super::Foundation::BOOL {
1178     #[cfg(windows)]
1179     {
1180         #[link(name = "windows")]
1181         extern "system" {
1182             fn DeleteColorTransform(hxform: isize) -> super::super::Foundation::BOOL;
1183         }
1184         ::std::mem::transmute(DeleteColorTransform(::std::mem::transmute(hxform)))
1185     }
1186     #[cfg(not(windows))]
1187     unimplemented!("Unsupported target OS");
1188 }
1189 #[cfg(feature = "Win32_Foundation")]
1190 #[inline]
DisassociateColorProfileFromDeviceA<'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>>(pmachinename: Param0, pprofilename: Param1, pdevicename: Param2) -> super::super::Foundation::BOOL1191 pub unsafe fn DisassociateColorProfileFromDeviceA<'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>>(pmachinename: Param0, pprofilename: Param1, pdevicename: Param2) -> super::super::Foundation::BOOL {
1192     #[cfg(windows)]
1193     {
1194         #[link(name = "windows")]
1195         extern "system" {
1196             fn DisassociateColorProfileFromDeviceA(pmachinename: super::super::Foundation::PSTR, pprofilename: super::super::Foundation::PSTR, pdevicename: super::super::Foundation::PSTR) -> super::super::Foundation::BOOL;
1197         }
1198         ::std::mem::transmute(DisassociateColorProfileFromDeviceA(pmachinename.into_param().abi(), pprofilename.into_param().abi(), pdevicename.into_param().abi()))
1199     }
1200     #[cfg(not(windows))]
1201     unimplemented!("Unsupported target OS");
1202 }
1203 #[cfg(feature = "Win32_Foundation")]
1204 #[inline]
DisassociateColorProfileFromDeviceW<'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>>(pmachinename: Param0, pprofilename: Param1, pdevicename: Param2) -> super::super::Foundation::BOOL1205 pub unsafe fn DisassociateColorProfileFromDeviceW<'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>>(pmachinename: Param0, pprofilename: Param1, pdevicename: Param2) -> super::super::Foundation::BOOL {
1206     #[cfg(windows)]
1207     {
1208         #[link(name = "windows")]
1209         extern "system" {
1210             fn DisassociateColorProfileFromDeviceW(pmachinename: super::super::Foundation::PWSTR, pprofilename: super::super::Foundation::PWSTR, pdevicename: super::super::Foundation::PWSTR) -> super::super::Foundation::BOOL;
1211         }
1212         ::std::mem::transmute(DisassociateColorProfileFromDeviceW(pmachinename.into_param().abi(), pprofilename.into_param().abi(), pdevicename.into_param().abi()))
1213     }
1214     #[cfg(not(windows))]
1215     unimplemented!("Unsupported target OS");
1216 }
1217 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
1218 #[repr(C)]
1219 #[cfg(all(feature = "Win32_Foundation", feature = "Win32_Graphics_Gdi"))]
1220 pub struct EMRCREATECOLORSPACE {
1221     pub emr: super::super::Graphics::Gdi::EMR,
1222     pub ihCS: u32,
1223     pub lcs: LOGCOLORSPACEA,
1224 }
1225 #[cfg(all(feature = "Win32_Foundation", feature = "Win32_Graphics_Gdi"))]
1226 impl EMRCREATECOLORSPACE {}
1227 #[cfg(all(feature = "Win32_Foundation", feature = "Win32_Graphics_Gdi"))]
1228 impl ::std::default::Default for EMRCREATECOLORSPACE {
default() -> Self1229     fn default() -> Self {
1230         unsafe { ::std::mem::zeroed() }
1231     }
1232 }
1233 #[cfg(all(feature = "Win32_Foundation", feature = "Win32_Graphics_Gdi"))]
1234 impl ::std::fmt::Debug for EMRCREATECOLORSPACE {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result1235     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
1236         fmt.debug_struct("EMRCREATECOLORSPACE").field("emr", &self.emr).field("ihCS", &self.ihCS).field("lcs", &self.lcs).finish()
1237     }
1238 }
1239 #[cfg(all(feature = "Win32_Foundation", feature = "Win32_Graphics_Gdi"))]
1240 impl ::std::cmp::PartialEq for EMRCREATECOLORSPACE {
eq(&self, other: &Self) -> bool1241     fn eq(&self, other: &Self) -> bool {
1242         self.emr == other.emr && self.ihCS == other.ihCS && self.lcs == other.lcs
1243     }
1244 }
1245 #[cfg(all(feature = "Win32_Foundation", feature = "Win32_Graphics_Gdi"))]
1246 impl ::std::cmp::Eq for EMRCREATECOLORSPACE {}
1247 #[cfg(all(feature = "Win32_Foundation", feature = "Win32_Graphics_Gdi"))]
1248 unsafe impl ::windows::runtime::Abi for EMRCREATECOLORSPACE {
1249     type Abi = Self;
1250     type DefaultType = Self;
1251 }
1252 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
1253 #[repr(C)]
1254 #[cfg(feature = "Win32_Graphics_Gdi")]
1255 pub struct EMRCREATECOLORSPACEW {
1256     pub emr: super::super::Graphics::Gdi::EMR,
1257     pub ihCS: u32,
1258     pub lcs: LOGCOLORSPACEW,
1259     pub dwFlags: u32,
1260     pub cbData: u32,
1261     pub Data: [u8; 1],
1262 }
1263 #[cfg(feature = "Win32_Graphics_Gdi")]
1264 impl EMRCREATECOLORSPACEW {}
1265 #[cfg(feature = "Win32_Graphics_Gdi")]
1266 impl ::std::default::Default for EMRCREATECOLORSPACEW {
default() -> Self1267     fn default() -> Self {
1268         unsafe { ::std::mem::zeroed() }
1269     }
1270 }
1271 #[cfg(feature = "Win32_Graphics_Gdi")]
1272 impl ::std::fmt::Debug for EMRCREATECOLORSPACEW {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result1273     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
1274         fmt.debug_struct("EMRCREATECOLORSPACEW").field("emr", &self.emr).field("ihCS", &self.ihCS).field("lcs", &self.lcs).field("dwFlags", &self.dwFlags).field("cbData", &self.cbData).field("Data", &self.Data).finish()
1275     }
1276 }
1277 #[cfg(feature = "Win32_Graphics_Gdi")]
1278 impl ::std::cmp::PartialEq for EMRCREATECOLORSPACEW {
eq(&self, other: &Self) -> bool1279     fn eq(&self, other: &Self) -> bool {
1280         self.emr == other.emr && self.ihCS == other.ihCS && self.lcs == other.lcs && self.dwFlags == other.dwFlags && self.cbData == other.cbData && self.Data == other.Data
1281     }
1282 }
1283 #[cfg(feature = "Win32_Graphics_Gdi")]
1284 impl ::std::cmp::Eq for EMRCREATECOLORSPACEW {}
1285 #[cfg(feature = "Win32_Graphics_Gdi")]
1286 unsafe impl ::windows::runtime::Abi for EMRCREATECOLORSPACEW {
1287     type Abi = Self;
1288     type DefaultType = Self;
1289 }
1290 pub const ENABLE_GAMUT_CHECKING: u32 = 65536u32;
1291 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
1292 #[repr(C)]
1293 #[cfg(feature = "Win32_Foundation")]
1294 pub struct ENUMTYPEA {
1295     pub dwSize: u32,
1296     pub dwVersion: u32,
1297     pub dwFields: u32,
1298     pub pDeviceName: super::super::Foundation::PSTR,
1299     pub dwMediaType: u32,
1300     pub dwDitheringMode: u32,
1301     pub dwResolution: [u32; 2],
1302     pub dwCMMType: u32,
1303     pub dwClass: u32,
1304     pub dwDataColorSpace: u32,
1305     pub dwConnectionSpace: u32,
1306     pub dwSignature: u32,
1307     pub dwPlatform: u32,
1308     pub dwProfileFlags: u32,
1309     pub dwManufacturer: u32,
1310     pub dwModel: u32,
1311     pub dwAttributes: [u32; 2],
1312     pub dwRenderingIntent: u32,
1313     pub dwCreator: u32,
1314     pub dwDeviceClass: u32,
1315 }
1316 #[cfg(feature = "Win32_Foundation")]
1317 impl ENUMTYPEA {}
1318 #[cfg(feature = "Win32_Foundation")]
1319 impl ::std::default::Default for ENUMTYPEA {
default() -> Self1320     fn default() -> Self {
1321         unsafe { ::std::mem::zeroed() }
1322     }
1323 }
1324 #[cfg(feature = "Win32_Foundation")]
1325 impl ::std::fmt::Debug for ENUMTYPEA {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result1326     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
1327         fmt.debug_struct("ENUMTYPEA")
1328             .field("dwSize", &self.dwSize)
1329             .field("dwVersion", &self.dwVersion)
1330             .field("dwFields", &self.dwFields)
1331             .field("pDeviceName", &self.pDeviceName)
1332             .field("dwMediaType", &self.dwMediaType)
1333             .field("dwDitheringMode", &self.dwDitheringMode)
1334             .field("dwResolution", &self.dwResolution)
1335             .field("dwCMMType", &self.dwCMMType)
1336             .field("dwClass", &self.dwClass)
1337             .field("dwDataColorSpace", &self.dwDataColorSpace)
1338             .field("dwConnectionSpace", &self.dwConnectionSpace)
1339             .field("dwSignature", &self.dwSignature)
1340             .field("dwPlatform", &self.dwPlatform)
1341             .field("dwProfileFlags", &self.dwProfileFlags)
1342             .field("dwManufacturer", &self.dwManufacturer)
1343             .field("dwModel", &self.dwModel)
1344             .field("dwAttributes", &self.dwAttributes)
1345             .field("dwRenderingIntent", &self.dwRenderingIntent)
1346             .field("dwCreator", &self.dwCreator)
1347             .field("dwDeviceClass", &self.dwDeviceClass)
1348             .finish()
1349     }
1350 }
1351 #[cfg(feature = "Win32_Foundation")]
1352 impl ::std::cmp::PartialEq for ENUMTYPEA {
eq(&self, other: &Self) -> bool1353     fn eq(&self, other: &Self) -> bool {
1354         self.dwSize == other.dwSize
1355             && self.dwVersion == other.dwVersion
1356             && self.dwFields == other.dwFields
1357             && self.pDeviceName == other.pDeviceName
1358             && self.dwMediaType == other.dwMediaType
1359             && self.dwDitheringMode == other.dwDitheringMode
1360             && self.dwResolution == other.dwResolution
1361             && self.dwCMMType == other.dwCMMType
1362             && self.dwClass == other.dwClass
1363             && self.dwDataColorSpace == other.dwDataColorSpace
1364             && self.dwConnectionSpace == other.dwConnectionSpace
1365             && self.dwSignature == other.dwSignature
1366             && self.dwPlatform == other.dwPlatform
1367             && self.dwProfileFlags == other.dwProfileFlags
1368             && self.dwManufacturer == other.dwManufacturer
1369             && self.dwModel == other.dwModel
1370             && self.dwAttributes == other.dwAttributes
1371             && self.dwRenderingIntent == other.dwRenderingIntent
1372             && self.dwCreator == other.dwCreator
1373             && self.dwDeviceClass == other.dwDeviceClass
1374     }
1375 }
1376 #[cfg(feature = "Win32_Foundation")]
1377 impl ::std::cmp::Eq for ENUMTYPEA {}
1378 #[cfg(feature = "Win32_Foundation")]
1379 unsafe impl ::windows::runtime::Abi for ENUMTYPEA {
1380     type Abi = Self;
1381     type DefaultType = Self;
1382 }
1383 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
1384 #[repr(C)]
1385 #[cfg(feature = "Win32_Foundation")]
1386 pub struct ENUMTYPEW {
1387     pub dwSize: u32,
1388     pub dwVersion: u32,
1389     pub dwFields: u32,
1390     pub pDeviceName: super::super::Foundation::PWSTR,
1391     pub dwMediaType: u32,
1392     pub dwDitheringMode: u32,
1393     pub dwResolution: [u32; 2],
1394     pub dwCMMType: u32,
1395     pub dwClass: u32,
1396     pub dwDataColorSpace: u32,
1397     pub dwConnectionSpace: u32,
1398     pub dwSignature: u32,
1399     pub dwPlatform: u32,
1400     pub dwProfileFlags: u32,
1401     pub dwManufacturer: u32,
1402     pub dwModel: u32,
1403     pub dwAttributes: [u32; 2],
1404     pub dwRenderingIntent: u32,
1405     pub dwCreator: u32,
1406     pub dwDeviceClass: u32,
1407 }
1408 #[cfg(feature = "Win32_Foundation")]
1409 impl ENUMTYPEW {}
1410 #[cfg(feature = "Win32_Foundation")]
1411 impl ::std::default::Default for ENUMTYPEW {
default() -> Self1412     fn default() -> Self {
1413         unsafe { ::std::mem::zeroed() }
1414     }
1415 }
1416 #[cfg(feature = "Win32_Foundation")]
1417 impl ::std::fmt::Debug for ENUMTYPEW {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result1418     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
1419         fmt.debug_struct("ENUMTYPEW")
1420             .field("dwSize", &self.dwSize)
1421             .field("dwVersion", &self.dwVersion)
1422             .field("dwFields", &self.dwFields)
1423             .field("pDeviceName", &self.pDeviceName)
1424             .field("dwMediaType", &self.dwMediaType)
1425             .field("dwDitheringMode", &self.dwDitheringMode)
1426             .field("dwResolution", &self.dwResolution)
1427             .field("dwCMMType", &self.dwCMMType)
1428             .field("dwClass", &self.dwClass)
1429             .field("dwDataColorSpace", &self.dwDataColorSpace)
1430             .field("dwConnectionSpace", &self.dwConnectionSpace)
1431             .field("dwSignature", &self.dwSignature)
1432             .field("dwPlatform", &self.dwPlatform)
1433             .field("dwProfileFlags", &self.dwProfileFlags)
1434             .field("dwManufacturer", &self.dwManufacturer)
1435             .field("dwModel", &self.dwModel)
1436             .field("dwAttributes", &self.dwAttributes)
1437             .field("dwRenderingIntent", &self.dwRenderingIntent)
1438             .field("dwCreator", &self.dwCreator)
1439             .field("dwDeviceClass", &self.dwDeviceClass)
1440             .finish()
1441     }
1442 }
1443 #[cfg(feature = "Win32_Foundation")]
1444 impl ::std::cmp::PartialEq for ENUMTYPEW {
eq(&self, other: &Self) -> bool1445     fn eq(&self, other: &Self) -> bool {
1446         self.dwSize == other.dwSize
1447             && self.dwVersion == other.dwVersion
1448             && self.dwFields == other.dwFields
1449             && self.pDeviceName == other.pDeviceName
1450             && self.dwMediaType == other.dwMediaType
1451             && self.dwDitheringMode == other.dwDitheringMode
1452             && self.dwResolution == other.dwResolution
1453             && self.dwCMMType == other.dwCMMType
1454             && self.dwClass == other.dwClass
1455             && self.dwDataColorSpace == other.dwDataColorSpace
1456             && self.dwConnectionSpace == other.dwConnectionSpace
1457             && self.dwSignature == other.dwSignature
1458             && self.dwPlatform == other.dwPlatform
1459             && self.dwProfileFlags == other.dwProfileFlags
1460             && self.dwManufacturer == other.dwManufacturer
1461             && self.dwModel == other.dwModel
1462             && self.dwAttributes == other.dwAttributes
1463             && self.dwRenderingIntent == other.dwRenderingIntent
1464             && self.dwCreator == other.dwCreator
1465             && self.dwDeviceClass == other.dwDeviceClass
1466     }
1467 }
1468 #[cfg(feature = "Win32_Foundation")]
1469 impl ::std::cmp::Eq for ENUMTYPEW {}
1470 #[cfg(feature = "Win32_Foundation")]
1471 unsafe impl ::windows::runtime::Abi for ENUMTYPEW {
1472     type Abi = Self;
1473     type DefaultType = Self;
1474 }
1475 pub const ENUM_TYPE_VERSION: u32 = 768u32;
1476 pub const ET_ATTRIBUTES: u32 = 8192u32;
1477 pub const ET_CLASS: u32 = 32u32;
1478 pub const ET_CMMTYPE: u32 = 16u32;
1479 pub const ET_CONNECTIONSPACE: u32 = 128u32;
1480 pub const ET_CREATOR: u32 = 32768u32;
1481 pub const ET_DATACOLORSPACE: u32 = 64u32;
1482 pub const ET_DEVICECLASS: u32 = 65536u32;
1483 pub const ET_DEVICENAME: u32 = 1u32;
1484 pub const ET_DITHERMODE: u32 = 4u32;
1485 pub const ET_EXTENDEDDISPLAYCOLOR: u32 = 262144u32;
1486 pub const ET_MANUFACTURER: u32 = 2048u32;
1487 pub const ET_MEDIATYPE: u32 = 2u32;
1488 pub const ET_MODEL: u32 = 4096u32;
1489 pub const ET_PLATFORM: u32 = 512u32;
1490 pub const ET_PROFILEFLAGS: u32 = 1024u32;
1491 pub const ET_RENDERINGINTENT: u32 = 16384u32;
1492 pub const ET_RESOLUTION: u32 = 8u32;
1493 pub const ET_SIGNATURE: u32 = 256u32;
1494 pub const ET_STANDARDDISPLAYCOLOR: u32 = 131072u32;
1495 #[cfg(feature = "Win32_Foundation")]
1496 #[inline]
EnumColorProfilesA<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::PSTR>>(pmachinename: Param0, penumrecord: *const ENUMTYPEA, penumerationbuffer: *mut u8, pdwsizeofenumerationbuffer: *mut u32, pnprofiles: *mut u32) -> super::super::Foundation::BOOL1497 pub unsafe fn EnumColorProfilesA<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::PSTR>>(pmachinename: Param0, penumrecord: *const ENUMTYPEA, penumerationbuffer: *mut u8, pdwsizeofenumerationbuffer: *mut u32, pnprofiles: *mut u32) -> super::super::Foundation::BOOL {
1498     #[cfg(windows)]
1499     {
1500         #[link(name = "windows")]
1501         extern "system" {
1502             fn EnumColorProfilesA(pmachinename: super::super::Foundation::PSTR, penumrecord: *const ENUMTYPEA, penumerationbuffer: *mut u8, pdwsizeofenumerationbuffer: *mut u32, pnprofiles: *mut u32) -> super::super::Foundation::BOOL;
1503         }
1504         ::std::mem::transmute(EnumColorProfilesA(pmachinename.into_param().abi(), ::std::mem::transmute(penumrecord), ::std::mem::transmute(penumerationbuffer), ::std::mem::transmute(pdwsizeofenumerationbuffer), ::std::mem::transmute(pnprofiles)))
1505     }
1506     #[cfg(not(windows))]
1507     unimplemented!("Unsupported target OS");
1508 }
1509 #[cfg(feature = "Win32_Foundation")]
1510 #[inline]
EnumColorProfilesW<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>>(pmachinename: Param0, penumrecord: *const ENUMTYPEW, penumerationbuffer: *mut u8, pdwsizeofenumerationbuffer: *mut u32, pnprofiles: *mut u32) -> super::super::Foundation::BOOL1511 pub unsafe fn EnumColorProfilesW<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>>(pmachinename: Param0, penumrecord: *const ENUMTYPEW, penumerationbuffer: *mut u8, pdwsizeofenumerationbuffer: *mut u32, pnprofiles: *mut u32) -> super::super::Foundation::BOOL {
1512     #[cfg(windows)]
1513     {
1514         #[link(name = "windows")]
1515         extern "system" {
1516             fn EnumColorProfilesW(pmachinename: super::super::Foundation::PWSTR, penumrecord: *const ENUMTYPEW, penumerationbuffer: *mut u8, pdwsizeofenumerationbuffer: *mut u32, pnprofiles: *mut u32) -> super::super::Foundation::BOOL;
1517         }
1518         ::std::mem::transmute(EnumColorProfilesW(pmachinename.into_param().abi(), ::std::mem::transmute(penumrecord), ::std::mem::transmute(penumerationbuffer), ::std::mem::transmute(pdwsizeofenumerationbuffer), ::std::mem::transmute(pnprofiles)))
1519     }
1520     #[cfg(not(windows))]
1521     unimplemented!("Unsupported target OS");
1522 }
1523 #[cfg(all(feature = "Win32_Foundation", feature = "Win32_Graphics_Gdi"))]
1524 #[inline]
EnumICMProfilesA<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Graphics::Gdi::HDC>, Param2: ::windows::runtime::IntoParam<'a, super::super::Foundation::LPARAM>>(hdc: Param0, proc: ::std::option::Option<ICMENUMPROCA>, param2: Param2) -> i321525 pub unsafe fn EnumICMProfilesA<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Graphics::Gdi::HDC>, Param2: ::windows::runtime::IntoParam<'a, super::super::Foundation::LPARAM>>(hdc: Param0, proc: ::std::option::Option<ICMENUMPROCA>, param2: Param2) -> i32 {
1526     #[cfg(windows)]
1527     {
1528         #[link(name = "windows")]
1529         extern "system" {
1530             fn EnumICMProfilesA(hdc: super::super::Graphics::Gdi::HDC, proc: ::windows::runtime::RawPtr, param2: super::super::Foundation::LPARAM) -> i32;
1531         }
1532         ::std::mem::transmute(EnumICMProfilesA(hdc.into_param().abi(), ::std::mem::transmute(proc), param2.into_param().abi()))
1533     }
1534     #[cfg(not(windows))]
1535     unimplemented!("Unsupported target OS");
1536 }
1537 #[cfg(all(feature = "Win32_Foundation", feature = "Win32_Graphics_Gdi"))]
1538 #[inline]
EnumICMProfilesW<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Graphics::Gdi::HDC>, Param2: ::windows::runtime::IntoParam<'a, super::super::Foundation::LPARAM>>(hdc: Param0, proc: ::std::option::Option<ICMENUMPROCW>, param2: Param2) -> i321539 pub unsafe fn EnumICMProfilesW<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Graphics::Gdi::HDC>, Param2: ::windows::runtime::IntoParam<'a, super::super::Foundation::LPARAM>>(hdc: Param0, proc: ::std::option::Option<ICMENUMPROCW>, param2: Param2) -> i32 {
1540     #[cfg(windows)]
1541     {
1542         #[link(name = "windows")]
1543         extern "system" {
1544             fn EnumICMProfilesW(hdc: super::super::Graphics::Gdi::HDC, proc: ::windows::runtime::RawPtr, param2: super::super::Foundation::LPARAM) -> i32;
1545         }
1546         ::std::mem::transmute(EnumICMProfilesW(hdc.into_param().abi(), ::std::mem::transmute(proc), param2.into_param().abi()))
1547     }
1548     #[cfg(not(windows))]
1549     unimplemented!("Unsupported target OS");
1550 }
1551 pub const FAST_TRANSLATE: u32 = 262144u32;
1552 pub const FLAG_DEPENDENTONDATA: u32 = 2u32;
1553 pub const FLAG_EMBEDDEDPROFILE: u32 = 1u32;
1554 pub const FLAG_ENABLE_CHROMATIC_ADAPTATION: u32 = 33554432u32;
1555 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
1556 #[repr(C)]
1557 pub struct GENERIC3CHANNEL {
1558     pub ch1: u16,
1559     pub ch2: u16,
1560     pub ch3: u16,
1561 }
1562 impl GENERIC3CHANNEL {}
1563 impl ::std::default::Default for GENERIC3CHANNEL {
default() -> Self1564     fn default() -> Self {
1565         unsafe { ::std::mem::zeroed() }
1566     }
1567 }
1568 impl ::std::fmt::Debug for GENERIC3CHANNEL {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result1569     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
1570         fmt.debug_struct("GENERIC3CHANNEL").field("ch1", &self.ch1).field("ch2", &self.ch2).field("ch3", &self.ch3).finish()
1571     }
1572 }
1573 impl ::std::cmp::PartialEq for GENERIC3CHANNEL {
eq(&self, other: &Self) -> bool1574     fn eq(&self, other: &Self) -> bool {
1575         self.ch1 == other.ch1 && self.ch2 == other.ch2 && self.ch3 == other.ch3
1576     }
1577 }
1578 impl ::std::cmp::Eq for GENERIC3CHANNEL {}
1579 unsafe impl ::windows::runtime::Abi for GENERIC3CHANNEL {
1580     type Abi = Self;
1581     type DefaultType = Self;
1582 }
1583 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
1584 #[repr(C)]
1585 pub struct GRAYCOLOR {
1586     pub gray: u16,
1587 }
1588 impl GRAYCOLOR {}
1589 impl ::std::default::Default for GRAYCOLOR {
default() -> Self1590     fn default() -> Self {
1591         unsafe { ::std::mem::zeroed() }
1592     }
1593 }
1594 impl ::std::fmt::Debug for GRAYCOLOR {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result1595     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
1596         fmt.debug_struct("GRAYCOLOR").field("gray", &self.gray).finish()
1597     }
1598 }
1599 impl ::std::cmp::PartialEq for GRAYCOLOR {
eq(&self, other: &Self) -> bool1600     fn eq(&self, other: &Self) -> bool {
1601         self.gray == other.gray
1602     }
1603 }
1604 impl ::std::cmp::Eq for GRAYCOLOR {}
1605 unsafe impl ::windows::runtime::Abi for GRAYCOLOR {
1606     type Abi = Self;
1607     type DefaultType = Self;
1608 }
1609 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
1610 #[repr(C)]
1611 pub struct GamutBoundaryDescription {
1612     pub pPrimaries: *mut PrimaryJabColors,
1613     pub cNeutralSamples: u32,
1614     pub pNeutralSamples: *mut JabColorF,
1615     pub pReferenceShell: *mut GamutShell,
1616     pub pPlausibleShell: *mut GamutShell,
1617     pub pPossibleShell: *mut GamutShell,
1618 }
1619 impl GamutBoundaryDescription {}
1620 impl ::std::default::Default for GamutBoundaryDescription {
default() -> Self1621     fn default() -> Self {
1622         unsafe { ::std::mem::zeroed() }
1623     }
1624 }
1625 impl ::std::fmt::Debug for GamutBoundaryDescription {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result1626     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
1627         fmt.debug_struct("GamutBoundaryDescription")
1628             .field("pPrimaries", &self.pPrimaries)
1629             .field("cNeutralSamples", &self.cNeutralSamples)
1630             .field("pNeutralSamples", &self.pNeutralSamples)
1631             .field("pReferenceShell", &self.pReferenceShell)
1632             .field("pPlausibleShell", &self.pPlausibleShell)
1633             .field("pPossibleShell", &self.pPossibleShell)
1634             .finish()
1635     }
1636 }
1637 impl ::std::cmp::PartialEq for GamutBoundaryDescription {
eq(&self, other: &Self) -> bool1638     fn eq(&self, other: &Self) -> bool {
1639         self.pPrimaries == other.pPrimaries && self.cNeutralSamples == other.cNeutralSamples && self.pNeutralSamples == other.pNeutralSamples && self.pReferenceShell == other.pReferenceShell && self.pPlausibleShell == other.pPlausibleShell && self.pPossibleShell == other.pPossibleShell
1640     }
1641 }
1642 impl ::std::cmp::Eq for GamutBoundaryDescription {}
1643 unsafe impl ::windows::runtime::Abi for GamutBoundaryDescription {
1644     type Abi = Self;
1645     type DefaultType = Self;
1646 }
1647 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
1648 #[repr(C)]
1649 pub struct GamutShell {
1650     pub JMin: f32,
1651     pub JMax: f32,
1652     pub cVertices: u32,
1653     pub cTriangles: u32,
1654     pub pVertices: *mut JabColorF,
1655     pub pTriangles: *mut GamutShellTriangle,
1656 }
1657 impl GamutShell {}
1658 impl ::std::default::Default for GamutShell {
default() -> Self1659     fn default() -> Self {
1660         unsafe { ::std::mem::zeroed() }
1661     }
1662 }
1663 impl ::std::fmt::Debug for GamutShell {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result1664     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
1665         fmt.debug_struct("GamutShell").field("JMin", &self.JMin).field("JMax", &self.JMax).field("cVertices", &self.cVertices).field("cTriangles", &self.cTriangles).field("pVertices", &self.pVertices).field("pTriangles", &self.pTriangles).finish()
1666     }
1667 }
1668 impl ::std::cmp::PartialEq for GamutShell {
eq(&self, other: &Self) -> bool1669     fn eq(&self, other: &Self) -> bool {
1670         self.JMin == other.JMin && self.JMax == other.JMax && self.cVertices == other.cVertices && self.cTriangles == other.cTriangles && self.pVertices == other.pVertices && self.pTriangles == other.pTriangles
1671     }
1672 }
1673 impl ::std::cmp::Eq for GamutShell {}
1674 unsafe impl ::windows::runtime::Abi for GamutShell {
1675     type Abi = Self;
1676     type DefaultType = Self;
1677 }
1678 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
1679 #[repr(C)]
1680 pub struct GamutShellTriangle {
1681     pub aVertexIndex: [u32; 3],
1682 }
1683 impl GamutShellTriangle {}
1684 impl ::std::default::Default for GamutShellTriangle {
default() -> Self1685     fn default() -> Self {
1686         unsafe { ::std::mem::zeroed() }
1687     }
1688 }
1689 impl ::std::fmt::Debug for GamutShellTriangle {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result1690     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
1691         fmt.debug_struct("GamutShellTriangle").field("aVertexIndex", &self.aVertexIndex).finish()
1692     }
1693 }
1694 impl ::std::cmp::PartialEq for GamutShellTriangle {
eq(&self, other: &Self) -> bool1695     fn eq(&self, other: &Self) -> bool {
1696         self.aVertexIndex == other.aVertexIndex
1697     }
1698 }
1699 impl ::std::cmp::Eq for GamutShellTriangle {}
1700 unsafe impl ::windows::runtime::Abi for GamutShellTriangle {
1701     type Abi = Self;
1702     type DefaultType = Self;
1703 }
1704 #[inline]
GetCMMInfo(hcolortransform: isize, param1: u32) -> u321705 pub unsafe fn GetCMMInfo(hcolortransform: isize, param1: u32) -> u32 {
1706     #[cfg(windows)]
1707     {
1708         #[link(name = "windows")]
1709         extern "system" {
1710             fn GetCMMInfo(hcolortransform: isize, param1: u32) -> u32;
1711         }
1712         ::std::mem::transmute(GetCMMInfo(::std::mem::transmute(hcolortransform), ::std::mem::transmute(param1)))
1713     }
1714     #[cfg(not(windows))]
1715     unimplemented!("Unsupported target OS");
1716 }
1717 #[cfg(feature = "Win32_Foundation")]
1718 #[inline]
GetColorDirectoryA<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::PSTR>>(pmachinename: Param0, pbuffer: super::super::Foundation::PSTR, pdwsize: *mut u32) -> super::super::Foundation::BOOL1719 pub unsafe fn GetColorDirectoryA<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::PSTR>>(pmachinename: Param0, pbuffer: super::super::Foundation::PSTR, pdwsize: *mut u32) -> super::super::Foundation::BOOL {
1720     #[cfg(windows)]
1721     {
1722         #[link(name = "windows")]
1723         extern "system" {
1724             fn GetColorDirectoryA(pmachinename: super::super::Foundation::PSTR, pbuffer: super::super::Foundation::PSTR, pdwsize: *mut u32) -> super::super::Foundation::BOOL;
1725         }
1726         ::std::mem::transmute(GetColorDirectoryA(pmachinename.into_param().abi(), ::std::mem::transmute(pbuffer), ::std::mem::transmute(pdwsize)))
1727     }
1728     #[cfg(not(windows))]
1729     unimplemented!("Unsupported target OS");
1730 }
1731 #[cfg(feature = "Win32_Foundation")]
1732 #[inline]
GetColorDirectoryW<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>>(pmachinename: Param0, pbuffer: super::super::Foundation::PWSTR, pdwsize: *mut u32) -> super::super::Foundation::BOOL1733 pub unsafe fn GetColorDirectoryW<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>>(pmachinename: Param0, pbuffer: super::super::Foundation::PWSTR, pdwsize: *mut u32) -> super::super::Foundation::BOOL {
1734     #[cfg(windows)]
1735     {
1736         #[link(name = "windows")]
1737         extern "system" {
1738             fn GetColorDirectoryW(pmachinename: super::super::Foundation::PWSTR, pbuffer: super::super::Foundation::PWSTR, pdwsize: *mut u32) -> super::super::Foundation::BOOL;
1739         }
1740         ::std::mem::transmute(GetColorDirectoryW(pmachinename.into_param().abi(), ::std::mem::transmute(pbuffer), ::std::mem::transmute(pdwsize)))
1741     }
1742     #[cfg(not(windows))]
1743     unimplemented!("Unsupported target OS");
1744 }
1745 #[cfg(feature = "Win32_Foundation")]
1746 #[inline]
GetColorProfileElement(hprofile: isize, tag: u32, dwoffset: u32, pcbelement: *mut u32, pelement: *mut ::std::ffi::c_void, pbreference: *mut super::super::Foundation::BOOL) -> super::super::Foundation::BOOL1747 pub unsafe fn GetColorProfileElement(hprofile: isize, tag: u32, dwoffset: u32, pcbelement: *mut u32, pelement: *mut ::std::ffi::c_void, pbreference: *mut super::super::Foundation::BOOL) -> super::super::Foundation::BOOL {
1748     #[cfg(windows)]
1749     {
1750         #[link(name = "windows")]
1751         extern "system" {
1752             fn GetColorProfileElement(hprofile: isize, tag: u32, dwoffset: u32, pcbelement: *mut u32, pelement: *mut ::std::ffi::c_void, pbreference: *mut super::super::Foundation::BOOL) -> super::super::Foundation::BOOL;
1753         }
1754         ::std::mem::transmute(GetColorProfileElement(::std::mem::transmute(hprofile), ::std::mem::transmute(tag), ::std::mem::transmute(dwoffset), ::std::mem::transmute(pcbelement), ::std::mem::transmute(pelement), ::std::mem::transmute(pbreference)))
1755     }
1756     #[cfg(not(windows))]
1757     unimplemented!("Unsupported target OS");
1758 }
1759 #[cfg(feature = "Win32_Foundation")]
1760 #[inline]
GetColorProfileElementTag(hprofile: isize, dwindex: u32, ptag: *mut u32) -> super::super::Foundation::BOOL1761 pub unsafe fn GetColorProfileElementTag(hprofile: isize, dwindex: u32, ptag: *mut u32) -> super::super::Foundation::BOOL {
1762     #[cfg(windows)]
1763     {
1764         #[link(name = "windows")]
1765         extern "system" {
1766             fn GetColorProfileElementTag(hprofile: isize, dwindex: u32, ptag: *mut u32) -> super::super::Foundation::BOOL;
1767         }
1768         ::std::mem::transmute(GetColorProfileElementTag(::std::mem::transmute(hprofile), ::std::mem::transmute(dwindex), ::std::mem::transmute(ptag)))
1769     }
1770     #[cfg(not(windows))]
1771     unimplemented!("Unsupported target OS");
1772 }
1773 #[cfg(feature = "Win32_Foundation")]
1774 #[inline]
GetColorProfileFromHandle(hprofile: isize, pprofile: *mut u8, pcbprofile: *mut u32) -> super::super::Foundation::BOOL1775 pub unsafe fn GetColorProfileFromHandle(hprofile: isize, pprofile: *mut u8, pcbprofile: *mut u32) -> super::super::Foundation::BOOL {
1776     #[cfg(windows)]
1777     {
1778         #[link(name = "windows")]
1779         extern "system" {
1780             fn GetColorProfileFromHandle(hprofile: isize, pprofile: *mut u8, pcbprofile: *mut u32) -> super::super::Foundation::BOOL;
1781         }
1782         ::std::mem::transmute(GetColorProfileFromHandle(::std::mem::transmute(hprofile), ::std::mem::transmute(pprofile), ::std::mem::transmute(pcbprofile)))
1783     }
1784     #[cfg(not(windows))]
1785     unimplemented!("Unsupported target OS");
1786 }
1787 #[cfg(all(feature = "Win32_Foundation", feature = "Win32_Graphics_Gdi"))]
1788 #[inline]
GetColorProfileHeader(hprofile: isize, pheader: *mut PROFILEHEADER) -> super::super::Foundation::BOOL1789 pub unsafe fn GetColorProfileHeader(hprofile: isize, pheader: *mut PROFILEHEADER) -> super::super::Foundation::BOOL {
1790     #[cfg(windows)]
1791     {
1792         #[link(name = "windows")]
1793         extern "system" {
1794             fn GetColorProfileHeader(hprofile: isize, pheader: *mut PROFILEHEADER) -> super::super::Foundation::BOOL;
1795         }
1796         ::std::mem::transmute(GetColorProfileHeader(::std::mem::transmute(hprofile), ::std::mem::transmute(pheader)))
1797     }
1798     #[cfg(not(windows))]
1799     unimplemented!("Unsupported target OS");
1800 }
1801 #[cfg(feature = "Win32_Graphics_Gdi")]
1802 #[inline]
GetColorSpace<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Graphics::Gdi::HDC>>(hdc: Param0) -> HCOLORSPACE1803 pub unsafe fn GetColorSpace<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Graphics::Gdi::HDC>>(hdc: Param0) -> HCOLORSPACE {
1804     #[cfg(windows)]
1805     {
1806         #[link(name = "windows")]
1807         extern "system" {
1808             fn GetColorSpace(hdc: super::super::Graphics::Gdi::HDC) -> HCOLORSPACE;
1809         }
1810         ::std::mem::transmute(GetColorSpace(hdc.into_param().abi()))
1811     }
1812     #[cfg(not(windows))]
1813     unimplemented!("Unsupported target OS");
1814 }
1815 #[cfg(feature = "Win32_Foundation")]
1816 #[inline]
GetCountColorProfileElements(hprofile: isize, pnelementcount: *mut u32) -> super::super::Foundation::BOOL1817 pub unsafe fn GetCountColorProfileElements(hprofile: isize, pnelementcount: *mut u32) -> super::super::Foundation::BOOL {
1818     #[cfg(windows)]
1819     {
1820         #[link(name = "windows")]
1821         extern "system" {
1822             fn GetCountColorProfileElements(hprofile: isize, pnelementcount: *mut u32) -> super::super::Foundation::BOOL;
1823         }
1824         ::std::mem::transmute(GetCountColorProfileElements(::std::mem::transmute(hprofile), ::std::mem::transmute(pnelementcount)))
1825     }
1826     #[cfg(not(windows))]
1827     unimplemented!("Unsupported target OS");
1828 }
1829 #[cfg(all(feature = "Win32_Foundation", feature = "Win32_Graphics_Gdi"))]
1830 #[inline]
GetDeviceGammaRamp<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Graphics::Gdi::HDC>>(hdc: Param0, lpramp: *mut ::std::ffi::c_void) -> super::super::Foundation::BOOL1831 pub unsafe fn GetDeviceGammaRamp<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Graphics::Gdi::HDC>>(hdc: Param0, lpramp: *mut ::std::ffi::c_void) -> super::super::Foundation::BOOL {
1832     #[cfg(windows)]
1833     {
1834         #[link(name = "windows")]
1835         extern "system" {
1836             fn GetDeviceGammaRamp(hdc: super::super::Graphics::Gdi::HDC, lpramp: *mut ::std::ffi::c_void) -> super::super::Foundation::BOOL;
1837         }
1838         ::std::mem::transmute(GetDeviceGammaRamp(hdc.into_param().abi(), ::std::mem::transmute(lpramp)))
1839     }
1840     #[cfg(not(windows))]
1841     unimplemented!("Unsupported target OS");
1842 }
1843 #[cfg(all(feature = "Win32_Foundation", feature = "Win32_Graphics_Gdi"))]
1844 #[inline]
GetICMProfileA<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Graphics::Gdi::HDC>>(hdc: Param0, pbufsize: *mut u32, pszfilename: super::super::Foundation::PSTR) -> super::super::Foundation::BOOL1845 pub unsafe fn GetICMProfileA<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Graphics::Gdi::HDC>>(hdc: Param0, pbufsize: *mut u32, pszfilename: super::super::Foundation::PSTR) -> super::super::Foundation::BOOL {
1846     #[cfg(windows)]
1847     {
1848         #[link(name = "windows")]
1849         extern "system" {
1850             fn GetICMProfileA(hdc: super::super::Graphics::Gdi::HDC, pbufsize: *mut u32, pszfilename: super::super::Foundation::PSTR) -> super::super::Foundation::BOOL;
1851         }
1852         ::std::mem::transmute(GetICMProfileA(hdc.into_param().abi(), ::std::mem::transmute(pbufsize), ::std::mem::transmute(pszfilename)))
1853     }
1854     #[cfg(not(windows))]
1855     unimplemented!("Unsupported target OS");
1856 }
1857 #[cfg(all(feature = "Win32_Foundation", feature = "Win32_Graphics_Gdi"))]
1858 #[inline]
GetICMProfileW<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Graphics::Gdi::HDC>>(hdc: Param0, pbufsize: *mut u32, pszfilename: super::super::Foundation::PWSTR) -> super::super::Foundation::BOOL1859 pub unsafe fn GetICMProfileW<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Graphics::Gdi::HDC>>(hdc: Param0, pbufsize: *mut u32, pszfilename: super::super::Foundation::PWSTR) -> super::super::Foundation::BOOL {
1860     #[cfg(windows)]
1861     {
1862         #[link(name = "windows")]
1863         extern "system" {
1864             fn GetICMProfileW(hdc: super::super::Graphics::Gdi::HDC, pbufsize: *mut u32, pszfilename: super::super::Foundation::PWSTR) -> super::super::Foundation::BOOL;
1865         }
1866         ::std::mem::transmute(GetICMProfileW(hdc.into_param().abi(), ::std::mem::transmute(pbufsize), ::std::mem::transmute(pszfilename)))
1867     }
1868     #[cfg(not(windows))]
1869     unimplemented!("Unsupported target OS");
1870 }
1871 #[cfg(all(feature = "Win32_Foundation", feature = "Win32_Graphics_Gdi"))]
1872 #[inline]
GetLogColorSpaceA<'a, Param0: ::windows::runtime::IntoParam<'a, HCOLORSPACE>>(hcolorspace: Param0, lpbuffer: *mut LOGCOLORSPACEA, nsize: u32) -> super::super::Foundation::BOOL1873 pub unsafe fn GetLogColorSpaceA<'a, Param0: ::windows::runtime::IntoParam<'a, HCOLORSPACE>>(hcolorspace: Param0, lpbuffer: *mut LOGCOLORSPACEA, nsize: u32) -> super::super::Foundation::BOOL {
1874     #[cfg(windows)]
1875     {
1876         #[link(name = "windows")]
1877         extern "system" {
1878             fn GetLogColorSpaceA(hcolorspace: HCOLORSPACE, lpbuffer: *mut LOGCOLORSPACEA, nsize: u32) -> super::super::Foundation::BOOL;
1879         }
1880         ::std::mem::transmute(GetLogColorSpaceA(hcolorspace.into_param().abi(), ::std::mem::transmute(lpbuffer), ::std::mem::transmute(nsize)))
1881     }
1882     #[cfg(not(windows))]
1883     unimplemented!("Unsupported target OS");
1884 }
1885 #[cfg(all(feature = "Win32_Foundation", feature = "Win32_Graphics_Gdi"))]
1886 #[inline]
GetLogColorSpaceW<'a, Param0: ::windows::runtime::IntoParam<'a, HCOLORSPACE>>(hcolorspace: Param0, lpbuffer: *mut LOGCOLORSPACEW, nsize: u32) -> super::super::Foundation::BOOL1887 pub unsafe fn GetLogColorSpaceW<'a, Param0: ::windows::runtime::IntoParam<'a, HCOLORSPACE>>(hcolorspace: Param0, lpbuffer: *mut LOGCOLORSPACEW, nsize: u32) -> super::super::Foundation::BOOL {
1888     #[cfg(windows)]
1889     {
1890         #[link(name = "windows")]
1891         extern "system" {
1892             fn GetLogColorSpaceW(hcolorspace: HCOLORSPACE, lpbuffer: *mut LOGCOLORSPACEW, nsize: u32) -> super::super::Foundation::BOOL;
1893         }
1894         ::std::mem::transmute(GetLogColorSpaceW(hcolorspace.into_param().abi(), ::std::mem::transmute(lpbuffer), ::std::mem::transmute(nsize)))
1895     }
1896     #[cfg(not(windows))]
1897     unimplemented!("Unsupported target OS");
1898 }
1899 #[cfg(feature = "Win32_Foundation")]
1900 #[inline]
GetNamedProfileInfo(hprofile: isize, pnamedprofileinfo: *mut NAMED_PROFILE_INFO) -> super::super::Foundation::BOOL1901 pub unsafe fn GetNamedProfileInfo(hprofile: isize, pnamedprofileinfo: *mut NAMED_PROFILE_INFO) -> super::super::Foundation::BOOL {
1902     #[cfg(windows)]
1903     {
1904         #[link(name = "windows")]
1905         extern "system" {
1906             fn GetNamedProfileInfo(hprofile: isize, pnamedprofileinfo: *mut NAMED_PROFILE_INFO) -> super::super::Foundation::BOOL;
1907         }
1908         ::std::mem::transmute(GetNamedProfileInfo(::std::mem::transmute(hprofile), ::std::mem::transmute(pnamedprofileinfo)))
1909     }
1910     #[cfg(not(windows))]
1911     unimplemented!("Unsupported target OS");
1912 }
1913 #[cfg(feature = "Win32_Foundation")]
1914 #[inline]
GetPS2ColorRenderingDictionary(hprofile: isize, dwintent: u32, pps2colorrenderingdictionary: *mut u8, pcbps2colorrenderingdictionary: *mut u32, pbbinary: *mut super::super::Foundation::BOOL) -> super::super::Foundation::BOOL1915 pub unsafe fn GetPS2ColorRenderingDictionary(hprofile: isize, dwintent: u32, pps2colorrenderingdictionary: *mut u8, pcbps2colorrenderingdictionary: *mut u32, pbbinary: *mut super::super::Foundation::BOOL) -> super::super::Foundation::BOOL {
1916     #[cfg(windows)]
1917     {
1918         #[link(name = "windows")]
1919         extern "system" {
1920             fn GetPS2ColorRenderingDictionary(hprofile: isize, dwintent: u32, pps2colorrenderingdictionary: *mut u8, pcbps2colorrenderingdictionary: *mut u32, pbbinary: *mut super::super::Foundation::BOOL) -> super::super::Foundation::BOOL;
1921         }
1922         ::std::mem::transmute(GetPS2ColorRenderingDictionary(::std::mem::transmute(hprofile), ::std::mem::transmute(dwintent), ::std::mem::transmute(pps2colorrenderingdictionary), ::std::mem::transmute(pcbps2colorrenderingdictionary), ::std::mem::transmute(pbbinary)))
1923     }
1924     #[cfg(not(windows))]
1925     unimplemented!("Unsupported target OS");
1926 }
1927 #[cfg(feature = "Win32_Foundation")]
1928 #[inline]
GetPS2ColorRenderingIntent(hprofile: isize, dwintent: u32, pbuffer: *mut u8, pcbps2colorrenderingintent: *mut u32) -> super::super::Foundation::BOOL1929 pub unsafe fn GetPS2ColorRenderingIntent(hprofile: isize, dwintent: u32, pbuffer: *mut u8, pcbps2colorrenderingintent: *mut u32) -> super::super::Foundation::BOOL {
1930     #[cfg(windows)]
1931     {
1932         #[link(name = "windows")]
1933         extern "system" {
1934             fn GetPS2ColorRenderingIntent(hprofile: isize, dwintent: u32, pbuffer: *mut u8, pcbps2colorrenderingintent: *mut u32) -> super::super::Foundation::BOOL;
1935         }
1936         ::std::mem::transmute(GetPS2ColorRenderingIntent(::std::mem::transmute(hprofile), ::std::mem::transmute(dwintent), ::std::mem::transmute(pbuffer), ::std::mem::transmute(pcbps2colorrenderingintent)))
1937     }
1938     #[cfg(not(windows))]
1939     unimplemented!("Unsupported target OS");
1940 }
1941 #[cfg(feature = "Win32_Foundation")]
1942 #[inline]
GetPS2ColorSpaceArray(hprofile: isize, dwintent: u32, dwcsatype: u32, pps2colorspacearray: *mut u8, pcbps2colorspacearray: *mut u32, pbbinary: *mut super::super::Foundation::BOOL) -> super::super::Foundation::BOOL1943 pub unsafe fn GetPS2ColorSpaceArray(hprofile: isize, dwintent: u32, dwcsatype: u32, pps2colorspacearray: *mut u8, pcbps2colorspacearray: *mut u32, pbbinary: *mut super::super::Foundation::BOOL) -> super::super::Foundation::BOOL {
1944     #[cfg(windows)]
1945     {
1946         #[link(name = "windows")]
1947         extern "system" {
1948             fn GetPS2ColorSpaceArray(hprofile: isize, dwintent: u32, dwcsatype: u32, pps2colorspacearray: *mut u8, pcbps2colorspacearray: *mut u32, pbbinary: *mut super::super::Foundation::BOOL) -> super::super::Foundation::BOOL;
1949         }
1950         ::std::mem::transmute(GetPS2ColorSpaceArray(::std::mem::transmute(hprofile), ::std::mem::transmute(dwintent), ::std::mem::transmute(dwcsatype), ::std::mem::transmute(pps2colorspacearray), ::std::mem::transmute(pcbps2colorspacearray), ::std::mem::transmute(pbbinary)))
1951     }
1952     #[cfg(not(windows))]
1953     unimplemented!("Unsupported target OS");
1954 }
1955 #[cfg(feature = "Win32_Foundation")]
1956 #[inline]
GetStandardColorSpaceProfileA<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::PSTR>>(pmachinename: Param0, dwscs: u32, pbuffer: super::super::Foundation::PSTR, pcbsize: *mut u32) -> super::super::Foundation::BOOL1957 pub unsafe fn GetStandardColorSpaceProfileA<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::PSTR>>(pmachinename: Param0, dwscs: u32, pbuffer: super::super::Foundation::PSTR, pcbsize: *mut u32) -> super::super::Foundation::BOOL {
1958     #[cfg(windows)]
1959     {
1960         #[link(name = "windows")]
1961         extern "system" {
1962             fn GetStandardColorSpaceProfileA(pmachinename: super::super::Foundation::PSTR, dwscs: u32, pbuffer: super::super::Foundation::PSTR, pcbsize: *mut u32) -> super::super::Foundation::BOOL;
1963         }
1964         ::std::mem::transmute(GetStandardColorSpaceProfileA(pmachinename.into_param().abi(), ::std::mem::transmute(dwscs), ::std::mem::transmute(pbuffer), ::std::mem::transmute(pcbsize)))
1965     }
1966     #[cfg(not(windows))]
1967     unimplemented!("Unsupported target OS");
1968 }
1969 #[cfg(feature = "Win32_Foundation")]
1970 #[inline]
GetStandardColorSpaceProfileW<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>>(pmachinename: Param0, dwscs: u32, pbuffer: super::super::Foundation::PWSTR, pcbsize: *mut u32) -> super::super::Foundation::BOOL1971 pub unsafe fn GetStandardColorSpaceProfileW<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>>(pmachinename: Param0, dwscs: u32, pbuffer: super::super::Foundation::PWSTR, pcbsize: *mut u32) -> super::super::Foundation::BOOL {
1972     #[cfg(windows)]
1973     {
1974         #[link(name = "windows")]
1975         extern "system" {
1976             fn GetStandardColorSpaceProfileW(pmachinename: super::super::Foundation::PWSTR, dwscs: u32, pbuffer: super::super::Foundation::PWSTR, pcbsize: *mut u32) -> super::super::Foundation::BOOL;
1977         }
1978         ::std::mem::transmute(GetStandardColorSpaceProfileW(pmachinename.into_param().abi(), ::std::mem::transmute(dwscs), ::std::mem::transmute(pbuffer), ::std::mem::transmute(pcbsize)))
1979     }
1980     #[cfg(not(windows))]
1981     unimplemented!("Unsupported target OS");
1982 }
1983 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy, :: std :: fmt :: Debug, :: std :: cmp :: PartialEq, :: std :: cmp :: Eq)]
1984 #[repr(transparent)]
1985 pub struct HCOLORSPACE(pub isize);
1986 impl ::std::default::Default for HCOLORSPACE {
default() -> Self1987     fn default() -> Self {
1988         unsafe { ::std::mem::zeroed() }
1989     }
1990 }
1991 unsafe impl ::windows::runtime::Handle for HCOLORSPACE {}
1992 unsafe impl ::windows::runtime::Abi for HCOLORSPACE {
1993     type Abi = Self;
1994     type DefaultType = Self;
1995 }
1996 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
1997 #[repr(C)]
1998 pub struct HiFiCOLOR {
1999     pub channel: [u8; 8],
2000 }
2001 impl HiFiCOLOR {}
2002 impl ::std::default::Default for HiFiCOLOR {
default() -> Self2003     fn default() -> Self {
2004         unsafe { ::std::mem::zeroed() }
2005     }
2006 }
2007 impl ::std::fmt::Debug for HiFiCOLOR {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result2008     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
2009         fmt.debug_struct("HiFiCOLOR").field("channel", &self.channel).finish()
2010     }
2011 }
2012 impl ::std::cmp::PartialEq for HiFiCOLOR {
eq(&self, other: &Self) -> bool2013     fn eq(&self, other: &Self) -> bool {
2014         self.channel == other.channel
2015     }
2016 }
2017 impl ::std::cmp::Eq for HiFiCOLOR {}
2018 unsafe impl ::windows::runtime::Abi for HiFiCOLOR {
2019     type Abi = Self;
2020     type DefaultType = Self;
2021 }
2022 #[cfg(feature = "Win32_Foundation")]
2023 pub type ICMENUMPROCA = unsafe extern "system" fn(param0: super::super::Foundation::PSTR, param1: super::super::Foundation::LPARAM) -> i32;
2024 #[cfg(feature = "Win32_Foundation")]
2025 pub type ICMENUMPROCW = unsafe extern "system" fn(param0: super::super::Foundation::PWSTR, param1: super::super::Foundation::LPARAM) -> i32;
2026 #[derive(:: std :: cmp :: PartialEq, :: std :: cmp :: Eq, :: std :: marker :: Copy, :: std :: clone :: Clone, :: std :: default :: Default, :: std :: fmt :: Debug)]
2027 #[repr(transparent)]
2028 pub struct ICM_COMMAND(pub u32);
2029 pub const ICM_ADDPROFILE: ICM_COMMAND = ICM_COMMAND(1u32);
2030 pub const ICM_DELETEPROFILE: ICM_COMMAND = ICM_COMMAND(2u32);
2031 pub const ICM_QUERYPROFILE: ICM_COMMAND = ICM_COMMAND(3u32);
2032 pub const ICM_SETDEFAULTPROFILE: ICM_COMMAND = ICM_COMMAND(4u32);
2033 pub const ICM_REGISTERICMATCHER: ICM_COMMAND = ICM_COMMAND(5u32);
2034 pub const ICM_UNREGISTERICMATCHER: ICM_COMMAND = ICM_COMMAND(6u32);
2035 pub const ICM_QUERYMATCH: ICM_COMMAND = ICM_COMMAND(7u32);
2036 impl ::std::convert::From<u32> for ICM_COMMAND {
from(value: u32) -> Self2037     fn from(value: u32) -> Self {
2038         Self(value)
2039     }
2040 }
2041 unsafe impl ::windows::runtime::Abi for ICM_COMMAND {
2042     type Abi = Self;
2043     type DefaultType = Self;
2044 }
2045 impl ::std::ops::BitOr for ICM_COMMAND {
2046     type Output = Self;
bitor(self, rhs: Self) -> Self2047     fn bitor(self, rhs: Self) -> Self {
2048         Self(self.0 | rhs.0)
2049     }
2050 }
2051 impl ::std::ops::BitAnd for ICM_COMMAND {
2052     type Output = Self;
bitand(self, rhs: Self) -> Self2053     fn bitand(self, rhs: Self) -> Self {
2054         Self(self.0 & rhs.0)
2055     }
2056 }
2057 impl ::std::ops::BitOrAssign for ICM_COMMAND {
bitor_assign(&mut self, rhs: Self)2058     fn bitor_assign(&mut self, rhs: Self) {
2059         self.0.bitor_assign(rhs.0)
2060     }
2061 }
2062 impl ::std::ops::BitAndAssign for ICM_COMMAND {
bitand_assign(&mut self, rhs: Self)2063     fn bitand_assign(&mut self, rhs: Self) {
2064         self.0.bitand_assign(rhs.0)
2065     }
2066 }
2067 impl ::std::ops::Not for ICM_COMMAND {
2068     type Output = Self;
not(self) -> Self2069     fn not(self) -> Self {
2070         Self(self.0.not())
2071     }
2072 }
2073 #[repr(transparent)]
2074 #[derive(:: std :: cmp :: PartialEq, :: std :: cmp :: Eq, :: std :: clone :: Clone, :: std :: fmt :: Debug)]
2075 pub struct IDeviceModelPlugIn(::windows::runtime::IUnknown);
2076 impl IDeviceModelPlugIn {
2077     #[cfg(feature = "Win32_Foundation")]
Initialize<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::BSTR>>(&self, bstrxml: Param0, cnummodels: u32, imodelposition: u32) -> ::windows::runtime::Result<()>2078     pub unsafe fn Initialize<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::BSTR>>(&self, bstrxml: Param0, cnummodels: u32, imodelposition: u32) -> ::windows::runtime::Result<()> {
2079         (::windows::runtime::Interface::vtable(self).3)(::std::mem::transmute_copy(self), bstrxml.into_param().abi(), ::std::mem::transmute(cnummodels), ::std::mem::transmute(imodelposition)).ok()
2080     }
GetNumChannels(&self) -> ::windows::runtime::Result<u32>2081     pub unsafe fn GetNumChannels(&self) -> ::windows::runtime::Result<u32> {
2082         let mut result__: <u32 as ::windows::runtime::Abi>::Abi = ::std::mem::zeroed();
2083         (::windows::runtime::Interface::vtable(self).4)(::std::mem::transmute_copy(self), &mut result__).from_abi::<u32>(result__)
2084     }
DeviceToColorimetricColors(&self, ccolors: u32, cchannels: u32, pdevicevalues: *const f32, pxyzcolors: *mut XYZColorF) -> ::windows::runtime::Result<()>2085     pub unsafe fn DeviceToColorimetricColors(&self, ccolors: u32, cchannels: u32, pdevicevalues: *const f32, pxyzcolors: *mut XYZColorF) -> ::windows::runtime::Result<()> {
2086         (::windows::runtime::Interface::vtable(self).5)(::std::mem::transmute_copy(self), ::std::mem::transmute(ccolors), ::std::mem::transmute(cchannels), ::std::mem::transmute(pdevicevalues), ::std::mem::transmute(pxyzcolors)).ok()
2087     }
ColorimetricToDeviceColors(&self, ccolors: u32, cchannels: u32, pxyzcolors: *const XYZColorF) -> ::windows::runtime::Result<f32>2088     pub unsafe fn ColorimetricToDeviceColors(&self, ccolors: u32, cchannels: u32, pxyzcolors: *const XYZColorF) -> ::windows::runtime::Result<f32> {
2089         let mut result__: <f32 as ::windows::runtime::Abi>::Abi = ::std::mem::zeroed();
2090         (::windows::runtime::Interface::vtable(self).6)(::std::mem::transmute_copy(self), ::std::mem::transmute(ccolors), ::std::mem::transmute(cchannels), ::std::mem::transmute(pxyzcolors), &mut result__).from_abi::<f32>(result__)
2091     }
2092     #[cfg(feature = "Win32_Foundation")]
ColorimetricToDeviceColorsWithBlack(&self, ccolors: u32, cchannels: u32, pxyzcolors: *const XYZColorF, pblackinformation: *const BlackInformation) -> ::windows::runtime::Result<f32>2093     pub unsafe fn ColorimetricToDeviceColorsWithBlack(&self, ccolors: u32, cchannels: u32, pxyzcolors: *const XYZColorF, pblackinformation: *const BlackInformation) -> ::windows::runtime::Result<f32> {
2094         let mut result__: <f32 as ::windows::runtime::Abi>::Abi = ::std::mem::zeroed();
2095         (::windows::runtime::Interface::vtable(self).7)(::std::mem::transmute_copy(self), ::std::mem::transmute(ccolors), ::std::mem::transmute(cchannels), ::std::mem::transmute(pxyzcolors), ::std::mem::transmute(pblackinformation), &mut result__).from_abi::<f32>(result__)
2096     }
SetTransformDeviceModelInfo<'a, Param1: ::windows::runtime::IntoParam<'a, IDeviceModelPlugIn>>(&self, imodelposition: u32, pidevicemodelother: Param1) -> ::windows::runtime::Result<()>2097     pub unsafe fn SetTransformDeviceModelInfo<'a, Param1: ::windows::runtime::IntoParam<'a, IDeviceModelPlugIn>>(&self, imodelposition: u32, pidevicemodelother: Param1) -> ::windows::runtime::Result<()> {
2098         (::windows::runtime::Interface::vtable(self).8)(::std::mem::transmute_copy(self), ::std::mem::transmute(imodelposition), pidevicemodelother.into_param().abi()).ok()
2099     }
GetPrimarySamples(&self) -> ::windows::runtime::Result<PrimaryXYZColors>2100     pub unsafe fn GetPrimarySamples(&self) -> ::windows::runtime::Result<PrimaryXYZColors> {
2101         let mut result__: <PrimaryXYZColors as ::windows::runtime::Abi>::Abi = ::std::mem::zeroed();
2102         (::windows::runtime::Interface::vtable(self).9)(::std::mem::transmute_copy(self), &mut result__).from_abi::<PrimaryXYZColors>(result__)
2103     }
GetGamutBoundaryMeshSize(&self, pnumvertices: *mut u32, pnumtriangles: *mut u32) -> ::windows::runtime::Result<()>2104     pub unsafe fn GetGamutBoundaryMeshSize(&self, pnumvertices: *mut u32, pnumtriangles: *mut u32) -> ::windows::runtime::Result<()> {
2105         (::windows::runtime::Interface::vtable(self).10)(::std::mem::transmute_copy(self), ::std::mem::transmute(pnumvertices), ::std::mem::transmute(pnumtriangles)).ok()
2106     }
GetGamutBoundaryMesh(&self, cchannels: u32, cvertices: u32, ctriangles: u32, pvertices: *mut f32, ptriangles: *mut GamutShellTriangle) -> ::windows::runtime::Result<()>2107     pub unsafe fn GetGamutBoundaryMesh(&self, cchannels: u32, cvertices: u32, ctriangles: u32, pvertices: *mut f32, ptriangles: *mut GamutShellTriangle) -> ::windows::runtime::Result<()> {
2108         (::windows::runtime::Interface::vtable(self).11)(::std::mem::transmute_copy(self), ::std::mem::transmute(cchannels), ::std::mem::transmute(cvertices), ::std::mem::transmute(ctriangles), ::std::mem::transmute(pvertices), ::std::mem::transmute(ptriangles)).ok()
2109     }
GetNeutralAxisSize(&self) -> ::windows::runtime::Result<u32>2110     pub unsafe fn GetNeutralAxisSize(&self) -> ::windows::runtime::Result<u32> {
2111         let mut result__: <u32 as ::windows::runtime::Abi>::Abi = ::std::mem::zeroed();
2112         (::windows::runtime::Interface::vtable(self).12)(::std::mem::transmute_copy(self), &mut result__).from_abi::<u32>(result__)
2113     }
GetNeutralAxis(&self, ccolors: u32, pxyzcolors: *mut XYZColorF) -> ::windows::runtime::Result<()>2114     pub unsafe fn GetNeutralAxis(&self, ccolors: u32, pxyzcolors: *mut XYZColorF) -> ::windows::runtime::Result<()> {
2115         (::windows::runtime::Interface::vtable(self).13)(::std::mem::transmute_copy(self), ::std::mem::transmute(ccolors), ::std::mem::transmute(pxyzcolors)).ok()
2116     }
2117 }
2118 unsafe impl ::windows::runtime::Interface for IDeviceModelPlugIn {
2119     type Vtable = IDeviceModelPlugIn_abi;
2120     const IID: ::windows::runtime::GUID = ::windows::runtime::GUID::from_values(483800181, 1988, 18174, [169, 3, 214, 85, 49, 109, 17, 253]);
2121 }
2122 impl ::std::convert::From<IDeviceModelPlugIn> for ::windows::runtime::IUnknown {
from(value: IDeviceModelPlugIn) -> Self2123     fn from(value: IDeviceModelPlugIn) -> Self {
2124         unsafe { ::std::mem::transmute(value) }
2125     }
2126 }
2127 impl ::std::convert::From<&IDeviceModelPlugIn> for ::windows::runtime::IUnknown {
from(value: &IDeviceModelPlugIn) -> Self2128     fn from(value: &IDeviceModelPlugIn) -> Self {
2129         ::std::convert::From::from(::std::clone::Clone::clone(value))
2130     }
2131 }
2132 impl<'a> ::windows::runtime::IntoParam<'a, ::windows::runtime::IUnknown> for IDeviceModelPlugIn {
into_param(self) -> ::windows::runtime::Param<'a, ::windows::runtime::IUnknown>2133     fn into_param(self) -> ::windows::runtime::Param<'a, ::windows::runtime::IUnknown> {
2134         ::windows::runtime::Param::Owned(::std::convert::Into::<::windows::runtime::IUnknown>::into(self))
2135     }
2136 }
2137 impl<'a> ::windows::runtime::IntoParam<'a, ::windows::runtime::IUnknown> for &IDeviceModelPlugIn {
into_param(self) -> ::windows::runtime::Param<'a, ::windows::runtime::IUnknown>2138     fn into_param(self) -> ::windows::runtime::Param<'a, ::windows::runtime::IUnknown> {
2139         ::windows::runtime::Param::Owned(::std::convert::Into::<::windows::runtime::IUnknown>::into(::std::clone::Clone::clone(self)))
2140     }
2141 }
2142 #[repr(C)]
2143 #[doc(hidden)]
2144 pub struct IDeviceModelPlugIn_abi(
2145     pub unsafe extern "system" fn(this: ::windows::runtime::RawPtr, iid: &::windows::runtime::GUID, interface: *mut ::windows::runtime::RawPtr) -> ::windows::runtime::HRESULT,
2146     pub unsafe extern "system" fn(this: ::windows::runtime::RawPtr) -> u32,
2147     pub unsafe extern "system" fn(this: ::windows::runtime::RawPtr) -> u32,
2148     #[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::runtime::RawPtr, bstrxml: ::std::mem::ManuallyDrop<super::super::Foundation::BSTR>, cnummodels: u32, imodelposition: u32) -> ::windows::runtime::HRESULT,
2149     #[cfg(not(feature = "Win32_Foundation"))] usize,
2150     pub unsafe extern "system" fn(this: ::windows::runtime::RawPtr, pnumchannels: *mut u32) -> ::windows::runtime::HRESULT,
2151     pub unsafe extern "system" fn(this: ::windows::runtime::RawPtr, ccolors: u32, cchannels: u32, pdevicevalues: *const f32, pxyzcolors: *mut XYZColorF) -> ::windows::runtime::HRESULT,
2152     pub unsafe extern "system" fn(this: ::windows::runtime::RawPtr, ccolors: u32, cchannels: u32, pxyzcolors: *const XYZColorF, pdevicevalues: *mut f32) -> ::windows::runtime::HRESULT,
2153     #[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::runtime::RawPtr, ccolors: u32, cchannels: u32, pxyzcolors: *const XYZColorF, pblackinformation: *const BlackInformation, pdevicevalues: *mut f32) -> ::windows::runtime::HRESULT,
2154     #[cfg(not(feature = "Win32_Foundation"))] usize,
2155     pub unsafe extern "system" fn(this: ::windows::runtime::RawPtr, imodelposition: u32, pidevicemodelother: ::windows::runtime::RawPtr) -> ::windows::runtime::HRESULT,
2156     pub unsafe extern "system" fn(this: ::windows::runtime::RawPtr, pprimarycolor: *mut PrimaryXYZColors) -> ::windows::runtime::HRESULT,
2157     pub unsafe extern "system" fn(this: ::windows::runtime::RawPtr, pnumvertices: *mut u32, pnumtriangles: *mut u32) -> ::windows::runtime::HRESULT,
2158     pub unsafe extern "system" fn(this: ::windows::runtime::RawPtr, cchannels: u32, cvertices: u32, ctriangles: u32, pvertices: *mut f32, ptriangles: *mut GamutShellTriangle) -> ::windows::runtime::HRESULT,
2159     pub unsafe extern "system" fn(this: ::windows::runtime::RawPtr, pccolors: *mut u32) -> ::windows::runtime::HRESULT,
2160     pub unsafe extern "system" fn(this: ::windows::runtime::RawPtr, ccolors: u32, pxyzcolors: *mut XYZColorF) -> ::windows::runtime::HRESULT,
2161 );
2162 #[repr(transparent)]
2163 #[derive(:: std :: cmp :: PartialEq, :: std :: cmp :: Eq, :: std :: clone :: Clone, :: std :: fmt :: Debug)]
2164 pub struct IGamutMapModelPlugIn(::windows::runtime::IUnknown);
2165 impl IGamutMapModelPlugIn {
2166     #[cfg(feature = "Win32_Foundation")]
Initialize<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::BSTR>, Param1: ::windows::runtime::IntoParam<'a, IDeviceModelPlugIn>, Param2: ::windows::runtime::IntoParam<'a, IDeviceModelPlugIn>>(&self, bstrxml: Param0, psrcplugin: Param1, pdestplugin: Param2, psrcgbd: *const GamutBoundaryDescription, pdestgbd: *const GamutBoundaryDescription) -> ::windows::runtime::Result<()>2167     pub unsafe fn Initialize<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::BSTR>, Param1: ::windows::runtime::IntoParam<'a, IDeviceModelPlugIn>, Param2: ::windows::runtime::IntoParam<'a, IDeviceModelPlugIn>>(&self, bstrxml: Param0, psrcplugin: Param1, pdestplugin: Param2, psrcgbd: *const GamutBoundaryDescription, pdestgbd: *const GamutBoundaryDescription) -> ::windows::runtime::Result<()> {
2168         (::windows::runtime::Interface::vtable(self).3)(::std::mem::transmute_copy(self), bstrxml.into_param().abi(), psrcplugin.into_param().abi(), pdestplugin.into_param().abi(), ::std::mem::transmute(psrcgbd), ::std::mem::transmute(pdestgbd)).ok()
2169     }
SourceToDestinationAppearanceColors(&self, ccolors: u32, pinputcolors: *const JChColorF, poutputcolors: *mut JChColorF) -> ::windows::runtime::Result<()>2170     pub unsafe fn SourceToDestinationAppearanceColors(&self, ccolors: u32, pinputcolors: *const JChColorF, poutputcolors: *mut JChColorF) -> ::windows::runtime::Result<()> {
2171         (::windows::runtime::Interface::vtable(self).4)(::std::mem::transmute_copy(self), ::std::mem::transmute(ccolors), ::std::mem::transmute(pinputcolors), ::std::mem::transmute(poutputcolors)).ok()
2172     }
2173 }
2174 unsafe impl ::windows::runtime::Interface for IGamutMapModelPlugIn {
2175     type Vtable = IGamutMapModelPlugIn_abi;
2176     const IID: ::windows::runtime::GUID = ::windows::runtime::GUID::from_values(769130773, 44318, 16886, [162, 25, 164, 244, 181, 131, 209, 249]);
2177 }
2178 impl ::std::convert::From<IGamutMapModelPlugIn> for ::windows::runtime::IUnknown {
from(value: IGamutMapModelPlugIn) -> Self2179     fn from(value: IGamutMapModelPlugIn) -> Self {
2180         unsafe { ::std::mem::transmute(value) }
2181     }
2182 }
2183 impl ::std::convert::From<&IGamutMapModelPlugIn> for ::windows::runtime::IUnknown {
from(value: &IGamutMapModelPlugIn) -> Self2184     fn from(value: &IGamutMapModelPlugIn) -> Self {
2185         ::std::convert::From::from(::std::clone::Clone::clone(value))
2186     }
2187 }
2188 impl<'a> ::windows::runtime::IntoParam<'a, ::windows::runtime::IUnknown> for IGamutMapModelPlugIn {
into_param(self) -> ::windows::runtime::Param<'a, ::windows::runtime::IUnknown>2189     fn into_param(self) -> ::windows::runtime::Param<'a, ::windows::runtime::IUnknown> {
2190         ::windows::runtime::Param::Owned(::std::convert::Into::<::windows::runtime::IUnknown>::into(self))
2191     }
2192 }
2193 impl<'a> ::windows::runtime::IntoParam<'a, ::windows::runtime::IUnknown> for &IGamutMapModelPlugIn {
into_param(self) -> ::windows::runtime::Param<'a, ::windows::runtime::IUnknown>2194     fn into_param(self) -> ::windows::runtime::Param<'a, ::windows::runtime::IUnknown> {
2195         ::windows::runtime::Param::Owned(::std::convert::Into::<::windows::runtime::IUnknown>::into(::std::clone::Clone::clone(self)))
2196     }
2197 }
2198 #[repr(C)]
2199 #[doc(hidden)]
2200 pub struct IGamutMapModelPlugIn_abi(
2201     pub unsafe extern "system" fn(this: ::windows::runtime::RawPtr, iid: &::windows::runtime::GUID, interface: *mut ::windows::runtime::RawPtr) -> ::windows::runtime::HRESULT,
2202     pub unsafe extern "system" fn(this: ::windows::runtime::RawPtr) -> u32,
2203     pub unsafe extern "system" fn(this: ::windows::runtime::RawPtr) -> u32,
2204     #[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::runtime::RawPtr, bstrxml: ::std::mem::ManuallyDrop<super::super::Foundation::BSTR>, psrcplugin: ::windows::runtime::RawPtr, pdestplugin: ::windows::runtime::RawPtr, psrcgbd: *const GamutBoundaryDescription, pdestgbd: *const GamutBoundaryDescription) -> ::windows::runtime::HRESULT,
2205     #[cfg(not(feature = "Win32_Foundation"))] usize,
2206     pub unsafe extern "system" fn(this: ::windows::runtime::RawPtr, ccolors: u32, pinputcolors: *const JChColorF, poutputcolors: *mut JChColorF) -> ::windows::runtime::HRESULT,
2207 );
2208 pub const INDEX_DONT_CARE: u32 = 0u32;
2209 pub const INTENT_ABSOLUTE_COLORIMETRIC: u32 = 3u32;
2210 pub const INTENT_PERCEPTUAL: u32 = 0u32;
2211 pub const INTENT_RELATIVE_COLORIMETRIC: u32 = 1u32;
2212 pub const INTENT_SATURATION: u32 = 2u32;
2213 #[cfg(feature = "Win32_Foundation")]
2214 #[inline]
InstallColorProfileA<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::PSTR>, Param1: ::windows::runtime::IntoParam<'a, super::super::Foundation::PSTR>>(pmachinename: Param0, pprofilename: Param1) -> super::super::Foundation::BOOL2215 pub unsafe fn InstallColorProfileA<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::PSTR>, Param1: ::windows::runtime::IntoParam<'a, super::super::Foundation::PSTR>>(pmachinename: Param0, pprofilename: Param1) -> super::super::Foundation::BOOL {
2216     #[cfg(windows)]
2217     {
2218         #[link(name = "windows")]
2219         extern "system" {
2220             fn InstallColorProfileA(pmachinename: super::super::Foundation::PSTR, pprofilename: super::super::Foundation::PSTR) -> super::super::Foundation::BOOL;
2221         }
2222         ::std::mem::transmute(InstallColorProfileA(pmachinename.into_param().abi(), pprofilename.into_param().abi()))
2223     }
2224     #[cfg(not(windows))]
2225     unimplemented!("Unsupported target OS");
2226 }
2227 #[cfg(feature = "Win32_Foundation")]
2228 #[inline]
InstallColorProfileW<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>, Param1: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>>(pmachinename: Param0, pprofilename: Param1) -> super::super::Foundation::BOOL2229 pub unsafe fn InstallColorProfileW<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>, Param1: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>>(pmachinename: Param0, pprofilename: Param1) -> super::super::Foundation::BOOL {
2230     #[cfg(windows)]
2231     {
2232         #[link(name = "windows")]
2233         extern "system" {
2234             fn InstallColorProfileW(pmachinename: super::super::Foundation::PWSTR, pprofilename: super::super::Foundation::PWSTR) -> super::super::Foundation::BOOL;
2235         }
2236         ::std::mem::transmute(InstallColorProfileW(pmachinename.into_param().abi(), pprofilename.into_param().abi()))
2237     }
2238     #[cfg(not(windows))]
2239     unimplemented!("Unsupported target OS");
2240 }
2241 #[cfg(feature = "Win32_Foundation")]
2242 #[inline]
IsColorProfileTagPresent(hprofile: isize, tag: u32, pbpresent: *mut super::super::Foundation::BOOL) -> super::super::Foundation::BOOL2243 pub unsafe fn IsColorProfileTagPresent(hprofile: isize, tag: u32, pbpresent: *mut super::super::Foundation::BOOL) -> super::super::Foundation::BOOL {
2244     #[cfg(windows)]
2245     {
2246         #[link(name = "windows")]
2247         extern "system" {
2248             fn IsColorProfileTagPresent(hprofile: isize, tag: u32, pbpresent: *mut super::super::Foundation::BOOL) -> super::super::Foundation::BOOL;
2249         }
2250         ::std::mem::transmute(IsColorProfileTagPresent(::std::mem::transmute(hprofile), ::std::mem::transmute(tag), ::std::mem::transmute(pbpresent)))
2251     }
2252     #[cfg(not(windows))]
2253     unimplemented!("Unsupported target OS");
2254 }
2255 #[cfg(feature = "Win32_Foundation")]
2256 #[inline]
IsColorProfileValid(hprofile: isize, pbvalid: *mut super::super::Foundation::BOOL) -> super::super::Foundation::BOOL2257 pub unsafe fn IsColorProfileValid(hprofile: isize, pbvalid: *mut super::super::Foundation::BOOL) -> super::super::Foundation::BOOL {
2258     #[cfg(windows)]
2259     {
2260         #[link(name = "windows")]
2261         extern "system" {
2262             fn IsColorProfileValid(hprofile: isize, pbvalid: *mut super::super::Foundation::BOOL) -> super::super::Foundation::BOOL;
2263         }
2264         ::std::mem::transmute(IsColorProfileValid(::std::mem::transmute(hprofile), ::std::mem::transmute(pbvalid)))
2265     }
2266     #[cfg(not(windows))]
2267     unimplemented!("Unsupported target OS");
2268 }
2269 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
2270 #[repr(C)]
2271 pub struct JChColorF {
2272     pub J: f32,
2273     pub C: f32,
2274     pub h: f32,
2275 }
2276 impl JChColorF {}
2277 impl ::std::default::Default for JChColorF {
default() -> Self2278     fn default() -> Self {
2279         unsafe { ::std::mem::zeroed() }
2280     }
2281 }
2282 impl ::std::fmt::Debug for JChColorF {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result2283     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
2284         fmt.debug_struct("JChColorF").field("J", &self.J).field("C", &self.C).field("h", &self.h).finish()
2285     }
2286 }
2287 impl ::std::cmp::PartialEq for JChColorF {
eq(&self, other: &Self) -> bool2288     fn eq(&self, other: &Self) -> bool {
2289         self.J == other.J && self.C == other.C && self.h == other.h
2290     }
2291 }
2292 impl ::std::cmp::Eq for JChColorF {}
2293 unsafe impl ::windows::runtime::Abi for JChColorF {
2294     type Abi = Self;
2295     type DefaultType = Self;
2296 }
2297 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
2298 #[repr(C)]
2299 pub struct JabColorF {
2300     pub J: f32,
2301     pub a: f32,
2302     pub b: f32,
2303 }
2304 impl JabColorF {}
2305 impl ::std::default::Default for JabColorF {
default() -> Self2306     fn default() -> Self {
2307         unsafe { ::std::mem::zeroed() }
2308     }
2309 }
2310 impl ::std::fmt::Debug for JabColorF {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result2311     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
2312         fmt.debug_struct("JabColorF").field("J", &self.J).field("a", &self.a).field("b", &self.b).finish()
2313     }
2314 }
2315 impl ::std::cmp::PartialEq for JabColorF {
eq(&self, other: &Self) -> bool2316     fn eq(&self, other: &Self) -> bool {
2317         self.J == other.J && self.a == other.a && self.b == other.b
2318     }
2319 }
2320 impl ::std::cmp::Eq for JabColorF {}
2321 unsafe impl ::windows::runtime::Abi for JabColorF {
2322     type Abi = Self;
2323     type DefaultType = Self;
2324 }
2325 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
2326 #[repr(C)]
2327 #[cfg(all(feature = "Win32_Foundation", feature = "Win32_Graphics_Gdi"))]
2328 pub struct LOGCOLORSPACEA {
2329     pub lcsSignature: u32,
2330     pub lcsVersion: u32,
2331     pub lcsSize: u32,
2332     pub lcsCSType: i32,
2333     pub lcsIntent: i32,
2334     pub lcsEndpoints: super::super::Graphics::Gdi::CIEXYZTRIPLE,
2335     pub lcsGammaRed: u32,
2336     pub lcsGammaGreen: u32,
2337     pub lcsGammaBlue: u32,
2338     pub lcsFilename: [super::super::Foundation::CHAR; 260],
2339 }
2340 #[cfg(all(feature = "Win32_Foundation", feature = "Win32_Graphics_Gdi"))]
2341 impl LOGCOLORSPACEA {}
2342 #[cfg(all(feature = "Win32_Foundation", feature = "Win32_Graphics_Gdi"))]
2343 impl ::std::default::Default for LOGCOLORSPACEA {
default() -> Self2344     fn default() -> Self {
2345         unsafe { ::std::mem::zeroed() }
2346     }
2347 }
2348 #[cfg(all(feature = "Win32_Foundation", feature = "Win32_Graphics_Gdi"))]
2349 impl ::std::fmt::Debug for LOGCOLORSPACEA {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result2350     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
2351         fmt.debug_struct("LOGCOLORSPACEA")
2352             .field("lcsSignature", &self.lcsSignature)
2353             .field("lcsVersion", &self.lcsVersion)
2354             .field("lcsSize", &self.lcsSize)
2355             .field("lcsCSType", &self.lcsCSType)
2356             .field("lcsIntent", &self.lcsIntent)
2357             .field("lcsEndpoints", &self.lcsEndpoints)
2358             .field("lcsGammaRed", &self.lcsGammaRed)
2359             .field("lcsGammaGreen", &self.lcsGammaGreen)
2360             .field("lcsGammaBlue", &self.lcsGammaBlue)
2361             .field("lcsFilename", &self.lcsFilename)
2362             .finish()
2363     }
2364 }
2365 #[cfg(all(feature = "Win32_Foundation", feature = "Win32_Graphics_Gdi"))]
2366 impl ::std::cmp::PartialEq for LOGCOLORSPACEA {
eq(&self, other: &Self) -> bool2367     fn eq(&self, other: &Self) -> bool {
2368         self.lcsSignature == other.lcsSignature && self.lcsVersion == other.lcsVersion && self.lcsSize == other.lcsSize && self.lcsCSType == other.lcsCSType && self.lcsIntent == other.lcsIntent && self.lcsEndpoints == other.lcsEndpoints && self.lcsGammaRed == other.lcsGammaRed && self.lcsGammaGreen == other.lcsGammaGreen && self.lcsGammaBlue == other.lcsGammaBlue && self.lcsFilename == other.lcsFilename
2369     }
2370 }
2371 #[cfg(all(feature = "Win32_Foundation", feature = "Win32_Graphics_Gdi"))]
2372 impl ::std::cmp::Eq for LOGCOLORSPACEA {}
2373 #[cfg(all(feature = "Win32_Foundation", feature = "Win32_Graphics_Gdi"))]
2374 unsafe impl ::windows::runtime::Abi for LOGCOLORSPACEA {
2375     type Abi = Self;
2376     type DefaultType = Self;
2377 }
2378 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
2379 #[repr(C)]
2380 #[cfg(feature = "Win32_Graphics_Gdi")]
2381 pub struct LOGCOLORSPACEW {
2382     pub lcsSignature: u32,
2383     pub lcsVersion: u32,
2384     pub lcsSize: u32,
2385     pub lcsCSType: i32,
2386     pub lcsIntent: i32,
2387     pub lcsEndpoints: super::super::Graphics::Gdi::CIEXYZTRIPLE,
2388     pub lcsGammaRed: u32,
2389     pub lcsGammaGreen: u32,
2390     pub lcsGammaBlue: u32,
2391     pub lcsFilename: [u16; 260],
2392 }
2393 #[cfg(feature = "Win32_Graphics_Gdi")]
2394 impl LOGCOLORSPACEW {}
2395 #[cfg(feature = "Win32_Graphics_Gdi")]
2396 impl ::std::default::Default for LOGCOLORSPACEW {
default() -> Self2397     fn default() -> Self {
2398         unsafe { ::std::mem::zeroed() }
2399     }
2400 }
2401 #[cfg(feature = "Win32_Graphics_Gdi")]
2402 impl ::std::fmt::Debug for LOGCOLORSPACEW {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result2403     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
2404         fmt.debug_struct("LOGCOLORSPACEW")
2405             .field("lcsSignature", &self.lcsSignature)
2406             .field("lcsVersion", &self.lcsVersion)
2407             .field("lcsSize", &self.lcsSize)
2408             .field("lcsCSType", &self.lcsCSType)
2409             .field("lcsIntent", &self.lcsIntent)
2410             .field("lcsEndpoints", &self.lcsEndpoints)
2411             .field("lcsGammaRed", &self.lcsGammaRed)
2412             .field("lcsGammaGreen", &self.lcsGammaGreen)
2413             .field("lcsGammaBlue", &self.lcsGammaBlue)
2414             .field("lcsFilename", &self.lcsFilename)
2415             .finish()
2416     }
2417 }
2418 #[cfg(feature = "Win32_Graphics_Gdi")]
2419 impl ::std::cmp::PartialEq for LOGCOLORSPACEW {
eq(&self, other: &Self) -> bool2420     fn eq(&self, other: &Self) -> bool {
2421         self.lcsSignature == other.lcsSignature && self.lcsVersion == other.lcsVersion && self.lcsSize == other.lcsSize && self.lcsCSType == other.lcsCSType && self.lcsIntent == other.lcsIntent && self.lcsEndpoints == other.lcsEndpoints && self.lcsGammaRed == other.lcsGammaRed && self.lcsGammaGreen == other.lcsGammaGreen && self.lcsGammaBlue == other.lcsGammaBlue && self.lcsFilename == other.lcsFilename
2422     }
2423 }
2424 #[cfg(feature = "Win32_Graphics_Gdi")]
2425 impl ::std::cmp::Eq for LOGCOLORSPACEW {}
2426 #[cfg(feature = "Win32_Graphics_Gdi")]
2427 unsafe impl ::windows::runtime::Abi for LOGCOLORSPACEW {
2428     type Abi = Self;
2429     type DefaultType = Self;
2430 }
2431 #[cfg(feature = "Win32_Foundation")]
2432 pub type LPBMCALLBACKFN = unsafe extern "system" fn(param0: u32, param1: u32, param2: super::super::Foundation::LPARAM) -> super::super::Foundation::BOOL;
2433 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
2434 #[repr(C)]
2435 pub struct LabCOLOR {
2436     pub L: u16,
2437     pub a: u16,
2438     pub b: u16,
2439 }
2440 impl LabCOLOR {}
2441 impl ::std::default::Default for LabCOLOR {
default() -> Self2442     fn default() -> Self {
2443         unsafe { ::std::mem::zeroed() }
2444     }
2445 }
2446 impl ::std::fmt::Debug for LabCOLOR {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result2447     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
2448         fmt.debug_struct("LabCOLOR").field("L", &self.L).field("a", &self.a).field("b", &self.b).finish()
2449     }
2450 }
2451 impl ::std::cmp::PartialEq for LabCOLOR {
eq(&self, other: &Self) -> bool2452     fn eq(&self, other: &Self) -> bool {
2453         self.L == other.L && self.a == other.a && self.b == other.b
2454     }
2455 }
2456 impl ::std::cmp::Eq for LabCOLOR {}
2457 unsafe impl ::windows::runtime::Abi for LabCOLOR {
2458     type Abi = Self;
2459     type DefaultType = Self;
2460 }
2461 pub const MAX_COLOR_CHANNELS: u32 = 8u32;
2462 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
2463 #[repr(C)]
2464 pub struct NAMEDCOLOR {
2465     pub dwIndex: u32,
2466 }
2467 impl NAMEDCOLOR {}
2468 impl ::std::default::Default for NAMEDCOLOR {
default() -> Self2469     fn default() -> Self {
2470         unsafe { ::std::mem::zeroed() }
2471     }
2472 }
2473 impl ::std::fmt::Debug for NAMEDCOLOR {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result2474     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
2475         fmt.debug_struct("NAMEDCOLOR").field("dwIndex", &self.dwIndex).finish()
2476     }
2477 }
2478 impl ::std::cmp::PartialEq for NAMEDCOLOR {
eq(&self, other: &Self) -> bool2479     fn eq(&self, other: &Self) -> bool {
2480         self.dwIndex == other.dwIndex
2481     }
2482 }
2483 impl ::std::cmp::Eq for NAMEDCOLOR {}
2484 unsafe impl ::windows::runtime::Abi for NAMEDCOLOR {
2485     type Abi = Self;
2486     type DefaultType = Self;
2487 }
2488 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
2489 #[repr(C)]
2490 pub struct NAMED_PROFILE_INFO {
2491     pub dwFlags: u32,
2492     pub dwCount: u32,
2493     pub dwCountDevCoordinates: u32,
2494     pub szPrefix: [i8; 32],
2495     pub szSuffix: [i8; 32],
2496 }
2497 impl NAMED_PROFILE_INFO {}
2498 impl ::std::default::Default for NAMED_PROFILE_INFO {
default() -> Self2499     fn default() -> Self {
2500         unsafe { ::std::mem::zeroed() }
2501     }
2502 }
2503 impl ::std::fmt::Debug for NAMED_PROFILE_INFO {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result2504     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
2505         fmt.debug_struct("NAMED_PROFILE_INFO").field("dwFlags", &self.dwFlags).field("dwCount", &self.dwCount).field("dwCountDevCoordinates", &self.dwCountDevCoordinates).field("szPrefix", &self.szPrefix).field("szSuffix", &self.szSuffix).finish()
2506     }
2507 }
2508 impl ::std::cmp::PartialEq for NAMED_PROFILE_INFO {
eq(&self, other: &Self) -> bool2509     fn eq(&self, other: &Self) -> bool {
2510         self.dwFlags == other.dwFlags && self.dwCount == other.dwCount && self.dwCountDevCoordinates == other.dwCountDevCoordinates && self.szPrefix == other.szPrefix && self.szSuffix == other.szSuffix
2511     }
2512 }
2513 impl ::std::cmp::Eq for NAMED_PROFILE_INFO {}
2514 unsafe impl ::windows::runtime::Abi for NAMED_PROFILE_INFO {
2515     type Abi = Self;
2516     type DefaultType = Self;
2517 }
2518 pub const NORMAL_MODE: u32 = 2u32;
2519 #[inline]
OpenColorProfileA(pprofile: *const PROFILE, dwdesiredaccess: u32, dwsharemode: u32, dwcreationmode: u32) -> isize2520 pub unsafe fn OpenColorProfileA(pprofile: *const PROFILE, dwdesiredaccess: u32, dwsharemode: u32, dwcreationmode: u32) -> isize {
2521     #[cfg(windows)]
2522     {
2523         #[link(name = "windows")]
2524         extern "system" {
2525             fn OpenColorProfileA(pprofile: *const PROFILE, dwdesiredaccess: u32, dwsharemode: u32, dwcreationmode: u32) -> isize;
2526         }
2527         ::std::mem::transmute(OpenColorProfileA(::std::mem::transmute(pprofile), ::std::mem::transmute(dwdesiredaccess), ::std::mem::transmute(dwsharemode), ::std::mem::transmute(dwcreationmode)))
2528     }
2529     #[cfg(not(windows))]
2530     unimplemented!("Unsupported target OS");
2531 }
2532 #[inline]
OpenColorProfileW(pprofile: *const PROFILE, dwdesiredaccess: u32, dwsharemode: u32, dwcreationmode: u32) -> isize2533 pub unsafe fn OpenColorProfileW(pprofile: *const PROFILE, dwdesiredaccess: u32, dwsharemode: u32, dwcreationmode: u32) -> isize {
2534     #[cfg(windows)]
2535     {
2536         #[link(name = "windows")]
2537         extern "system" {
2538             fn OpenColorProfileW(pprofile: *const PROFILE, dwdesiredaccess: u32, dwsharemode: u32, dwcreationmode: u32) -> isize;
2539         }
2540         ::std::mem::transmute(OpenColorProfileW(::std::mem::transmute(pprofile), ::std::mem::transmute(dwdesiredaccess), ::std::mem::transmute(dwsharemode), ::std::mem::transmute(dwcreationmode)))
2541     }
2542     #[cfg(not(windows))]
2543     unimplemented!("Unsupported target OS");
2544 }
2545 #[cfg(all(feature = "Win32_Foundation", feature = "Win32_UI_WindowsAndMessaging"))]
2546 pub type PCMSCALLBACKA = unsafe extern "system" fn(param0: *mut ::std::mem::ManuallyDrop<COLORMATCHSETUPA>, param1: super::super::Foundation::LPARAM) -> super::super::Foundation::BOOL;
2547 #[cfg(all(feature = "Win32_Foundation", feature = "Win32_UI_WindowsAndMessaging"))]
2548 pub type PCMSCALLBACKW = unsafe extern "system" fn(param0: *mut ::std::mem::ManuallyDrop<COLORMATCHSETUPW>, param1: super::super::Foundation::LPARAM) -> super::super::Foundation::BOOL;
2549 pub const PRESERVEBLACK: u32 = 1048576u32;
2550 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
2551 #[repr(C)]
2552 pub struct PROFILE {
2553     pub dwType: u32,
2554     pub pProfileData: *mut ::std::ffi::c_void,
2555     pub cbDataSize: u32,
2556 }
2557 impl PROFILE {}
2558 impl ::std::default::Default for PROFILE {
default() -> Self2559     fn default() -> Self {
2560         unsafe { ::std::mem::zeroed() }
2561     }
2562 }
2563 impl ::std::fmt::Debug for PROFILE {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result2564     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
2565         fmt.debug_struct("PROFILE").field("dwType", &self.dwType).field("pProfileData", &self.pProfileData).field("cbDataSize", &self.cbDataSize).finish()
2566     }
2567 }
2568 impl ::std::cmp::PartialEq for PROFILE {
eq(&self, other: &Self) -> bool2569     fn eq(&self, other: &Self) -> bool {
2570         self.dwType == other.dwType && self.pProfileData == other.pProfileData && self.cbDataSize == other.cbDataSize
2571     }
2572 }
2573 impl ::std::cmp::Eq for PROFILE {}
2574 unsafe impl ::windows::runtime::Abi for PROFILE {
2575     type Abi = Self;
2576     type DefaultType = Self;
2577 }
2578 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
2579 #[repr(C)]
2580 #[cfg(feature = "Win32_Graphics_Gdi")]
2581 pub struct PROFILEHEADER {
2582     pub phSize: u32,
2583     pub phCMMType: u32,
2584     pub phVersion: u32,
2585     pub phClass: u32,
2586     pub phDataColorSpace: u32,
2587     pub phConnectionSpace: u32,
2588     pub phDateTime: [u32; 3],
2589     pub phSignature: u32,
2590     pub phPlatform: u32,
2591     pub phProfileFlags: u32,
2592     pub phManufacturer: u32,
2593     pub phModel: u32,
2594     pub phAttributes: [u32; 2],
2595     pub phRenderingIntent: u32,
2596     pub phIlluminant: super::super::Graphics::Gdi::CIEXYZ,
2597     pub phCreator: u32,
2598     pub phReserved: [u8; 44],
2599 }
2600 #[cfg(feature = "Win32_Graphics_Gdi")]
2601 impl PROFILEHEADER {}
2602 #[cfg(feature = "Win32_Graphics_Gdi")]
2603 impl ::std::default::Default for PROFILEHEADER {
default() -> Self2604     fn default() -> Self {
2605         unsafe { ::std::mem::zeroed() }
2606     }
2607 }
2608 #[cfg(feature = "Win32_Graphics_Gdi")]
2609 impl ::std::fmt::Debug for PROFILEHEADER {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result2610     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
2611         fmt.debug_struct("PROFILEHEADER")
2612             .field("phSize", &self.phSize)
2613             .field("phCMMType", &self.phCMMType)
2614             .field("phVersion", &self.phVersion)
2615             .field("phClass", &self.phClass)
2616             .field("phDataColorSpace", &self.phDataColorSpace)
2617             .field("phConnectionSpace", &self.phConnectionSpace)
2618             .field("phDateTime", &self.phDateTime)
2619             .field("phSignature", &self.phSignature)
2620             .field("phPlatform", &self.phPlatform)
2621             .field("phProfileFlags", &self.phProfileFlags)
2622             .field("phManufacturer", &self.phManufacturer)
2623             .field("phModel", &self.phModel)
2624             .field("phAttributes", &self.phAttributes)
2625             .field("phRenderingIntent", &self.phRenderingIntent)
2626             .field("phIlluminant", &self.phIlluminant)
2627             .field("phCreator", &self.phCreator)
2628             .field("phReserved", &self.phReserved)
2629             .finish()
2630     }
2631 }
2632 #[cfg(feature = "Win32_Graphics_Gdi")]
2633 impl ::std::cmp::PartialEq for PROFILEHEADER {
eq(&self, other: &Self) -> bool2634     fn eq(&self, other: &Self) -> bool {
2635         self.phSize == other.phSize
2636             && self.phCMMType == other.phCMMType
2637             && self.phVersion == other.phVersion
2638             && self.phClass == other.phClass
2639             && self.phDataColorSpace == other.phDataColorSpace
2640             && self.phConnectionSpace == other.phConnectionSpace
2641             && self.phDateTime == other.phDateTime
2642             && self.phSignature == other.phSignature
2643             && self.phPlatform == other.phPlatform
2644             && self.phProfileFlags == other.phProfileFlags
2645             && self.phManufacturer == other.phManufacturer
2646             && self.phModel == other.phModel
2647             && self.phAttributes == other.phAttributes
2648             && self.phRenderingIntent == other.phRenderingIntent
2649             && self.phIlluminant == other.phIlluminant
2650             && self.phCreator == other.phCreator
2651             && self.phReserved == other.phReserved
2652     }
2653 }
2654 #[cfg(feature = "Win32_Graphics_Gdi")]
2655 impl ::std::cmp::Eq for PROFILEHEADER {}
2656 #[cfg(feature = "Win32_Graphics_Gdi")]
2657 unsafe impl ::windows::runtime::Abi for PROFILEHEADER {
2658     type Abi = Self;
2659     type DefaultType = Self;
2660 }
2661 pub const PROFILE_FILENAME: u32 = 1u32;
2662 pub const PROFILE_MEMBUFFER: u32 = 2u32;
2663 pub const PROFILE_READ: u32 = 1u32;
2664 pub const PROFILE_READWRITE: u32 = 2u32;
2665 pub const PROOF_MODE: u32 = 1u32;
2666 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
2667 #[repr(C)]
2668 pub struct PrimaryJabColors {
2669     pub red: JabColorF,
2670     pub yellow: JabColorF,
2671     pub green: JabColorF,
2672     pub cyan: JabColorF,
2673     pub blue: JabColorF,
2674     pub magenta: JabColorF,
2675     pub black: JabColorF,
2676     pub white: JabColorF,
2677 }
2678 impl PrimaryJabColors {}
2679 impl ::std::default::Default for PrimaryJabColors {
default() -> Self2680     fn default() -> Self {
2681         unsafe { ::std::mem::zeroed() }
2682     }
2683 }
2684 impl ::std::fmt::Debug for PrimaryJabColors {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result2685     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
2686         fmt.debug_struct("PrimaryJabColors").field("red", &self.red).field("yellow", &self.yellow).field("green", &self.green).field("cyan", &self.cyan).field("blue", &self.blue).field("magenta", &self.magenta).field("black", &self.black).field("white", &self.white).finish()
2687     }
2688 }
2689 impl ::std::cmp::PartialEq for PrimaryJabColors {
eq(&self, other: &Self) -> bool2690     fn eq(&self, other: &Self) -> bool {
2691         self.red == other.red && self.yellow == other.yellow && self.green == other.green && self.cyan == other.cyan && self.blue == other.blue && self.magenta == other.magenta && self.black == other.black && self.white == other.white
2692     }
2693 }
2694 impl ::std::cmp::Eq for PrimaryJabColors {}
2695 unsafe impl ::windows::runtime::Abi for PrimaryJabColors {
2696     type Abi = Self;
2697     type DefaultType = Self;
2698 }
2699 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
2700 #[repr(C)]
2701 pub struct PrimaryXYZColors {
2702     pub red: XYZColorF,
2703     pub yellow: XYZColorF,
2704     pub green: XYZColorF,
2705     pub cyan: XYZColorF,
2706     pub blue: XYZColorF,
2707     pub magenta: XYZColorF,
2708     pub black: XYZColorF,
2709     pub white: XYZColorF,
2710 }
2711 impl PrimaryXYZColors {}
2712 impl ::std::default::Default for PrimaryXYZColors {
default() -> Self2713     fn default() -> Self {
2714         unsafe { ::std::mem::zeroed() }
2715     }
2716 }
2717 impl ::std::fmt::Debug for PrimaryXYZColors {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result2718     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
2719         fmt.debug_struct("PrimaryXYZColors").field("red", &self.red).field("yellow", &self.yellow).field("green", &self.green).field("cyan", &self.cyan).field("blue", &self.blue).field("magenta", &self.magenta).field("black", &self.black).field("white", &self.white).finish()
2720     }
2721 }
2722 impl ::std::cmp::PartialEq for PrimaryXYZColors {
eq(&self, other: &Self) -> bool2723     fn eq(&self, other: &Self) -> bool {
2724         self.red == other.red && self.yellow == other.yellow && self.green == other.green && self.cyan == other.cyan && self.blue == other.blue && self.magenta == other.magenta && self.black == other.black && self.white == other.white
2725     }
2726 }
2727 impl ::std::cmp::Eq for PrimaryXYZColors {}
2728 unsafe impl ::windows::runtime::Abi for PrimaryXYZColors {
2729     type Abi = Self;
2730     type DefaultType = Self;
2731 }
2732 pub const RESERVED: u32 = 2147483648u32;
2733 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
2734 #[repr(C)]
2735 pub struct RGBCOLOR {
2736     pub red: u16,
2737     pub green: u16,
2738     pub blue: u16,
2739 }
2740 impl RGBCOLOR {}
2741 impl ::std::default::Default for RGBCOLOR {
default() -> Self2742     fn default() -> Self {
2743         unsafe { ::std::mem::zeroed() }
2744     }
2745 }
2746 impl ::std::fmt::Debug for RGBCOLOR {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result2747     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
2748         fmt.debug_struct("RGBCOLOR").field("red", &self.red).field("green", &self.green).field("blue", &self.blue).finish()
2749     }
2750 }
2751 impl ::std::cmp::PartialEq for RGBCOLOR {
eq(&self, other: &Self) -> bool2752     fn eq(&self, other: &Self) -> bool {
2753         self.red == other.red && self.green == other.green && self.blue == other.blue
2754     }
2755 }
2756 impl ::std::cmp::Eq for RGBCOLOR {}
2757 unsafe impl ::windows::runtime::Abi for RGBCOLOR {
2758     type Abi = Self;
2759     type DefaultType = Self;
2760 }
2761 #[cfg(feature = "Win32_Foundation")]
2762 #[inline]
RegisterCMMA<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::PSTR>, Param2: ::windows::runtime::IntoParam<'a, super::super::Foundation::PSTR>>(pmachinename: Param0, cmmid: u32, pcmmdll: Param2) -> super::super::Foundation::BOOL2763 pub unsafe fn RegisterCMMA<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::PSTR>, Param2: ::windows::runtime::IntoParam<'a, super::super::Foundation::PSTR>>(pmachinename: Param0, cmmid: u32, pcmmdll: Param2) -> super::super::Foundation::BOOL {
2764     #[cfg(windows)]
2765     {
2766         #[link(name = "windows")]
2767         extern "system" {
2768             fn RegisterCMMA(pmachinename: super::super::Foundation::PSTR, cmmid: u32, pcmmdll: super::super::Foundation::PSTR) -> super::super::Foundation::BOOL;
2769         }
2770         ::std::mem::transmute(RegisterCMMA(pmachinename.into_param().abi(), ::std::mem::transmute(cmmid), pcmmdll.into_param().abi()))
2771     }
2772     #[cfg(not(windows))]
2773     unimplemented!("Unsupported target OS");
2774 }
2775 #[cfg(feature = "Win32_Foundation")]
2776 #[inline]
RegisterCMMW<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>, Param2: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>>(pmachinename: Param0, cmmid: u32, pcmmdll: Param2) -> super::super::Foundation::BOOL2777 pub unsafe fn RegisterCMMW<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>, Param2: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>>(pmachinename: Param0, cmmid: u32, pcmmdll: Param2) -> super::super::Foundation::BOOL {
2778     #[cfg(windows)]
2779     {
2780         #[link(name = "windows")]
2781         extern "system" {
2782             fn RegisterCMMW(pmachinename: super::super::Foundation::PWSTR, cmmid: u32, pcmmdll: super::super::Foundation::PWSTR) -> super::super::Foundation::BOOL;
2783         }
2784         ::std::mem::transmute(RegisterCMMW(pmachinename.into_param().abi(), ::std::mem::transmute(cmmid), pcmmdll.into_param().abi()))
2785     }
2786     #[cfg(not(windows))]
2787     unimplemented!("Unsupported target OS");
2788 }
2789 pub const SEQUENTIAL_TRANSFORM: u32 = 2155872256u32;
2790 #[cfg(feature = "Win32_Foundation")]
2791 #[inline]
SelectCMM(dwcmmtype: u32) -> super::super::Foundation::BOOL2792 pub unsafe fn SelectCMM(dwcmmtype: u32) -> super::super::Foundation::BOOL {
2793     #[cfg(windows)]
2794     {
2795         #[link(name = "windows")]
2796         extern "system" {
2797             fn SelectCMM(dwcmmtype: u32) -> super::super::Foundation::BOOL;
2798         }
2799         ::std::mem::transmute(SelectCMM(::std::mem::transmute(dwcmmtype)))
2800     }
2801     #[cfg(not(windows))]
2802     unimplemented!("Unsupported target OS");
2803 }
2804 #[cfg(feature = "Win32_Foundation")]
2805 #[inline]
SetColorProfileElement(hprofile: isize, tag: u32, dwoffset: u32, pcbelement: *const u32, pelement: *const ::std::ffi::c_void) -> super::super::Foundation::BOOL2806 pub unsafe fn SetColorProfileElement(hprofile: isize, tag: u32, dwoffset: u32, pcbelement: *const u32, pelement: *const ::std::ffi::c_void) -> super::super::Foundation::BOOL {
2807     #[cfg(windows)]
2808     {
2809         #[link(name = "windows")]
2810         extern "system" {
2811             fn SetColorProfileElement(hprofile: isize, tag: u32, dwoffset: u32, pcbelement: *const u32, pelement: *const ::std::ffi::c_void) -> super::super::Foundation::BOOL;
2812         }
2813         ::std::mem::transmute(SetColorProfileElement(::std::mem::transmute(hprofile), ::std::mem::transmute(tag), ::std::mem::transmute(dwoffset), ::std::mem::transmute(pcbelement), ::std::mem::transmute(pelement)))
2814     }
2815     #[cfg(not(windows))]
2816     unimplemented!("Unsupported target OS");
2817 }
2818 #[cfg(feature = "Win32_Foundation")]
2819 #[inline]
SetColorProfileElementReference(hprofile: isize, newtag: u32, reftag: u32) -> super::super::Foundation::BOOL2820 pub unsafe fn SetColorProfileElementReference(hprofile: isize, newtag: u32, reftag: u32) -> super::super::Foundation::BOOL {
2821     #[cfg(windows)]
2822     {
2823         #[link(name = "windows")]
2824         extern "system" {
2825             fn SetColorProfileElementReference(hprofile: isize, newtag: u32, reftag: u32) -> super::super::Foundation::BOOL;
2826         }
2827         ::std::mem::transmute(SetColorProfileElementReference(::std::mem::transmute(hprofile), ::std::mem::transmute(newtag), ::std::mem::transmute(reftag)))
2828     }
2829     #[cfg(not(windows))]
2830     unimplemented!("Unsupported target OS");
2831 }
2832 #[cfg(feature = "Win32_Foundation")]
2833 #[inline]
SetColorProfileElementSize(hprofile: isize, tagtype: u32, pcbelement: u32) -> super::super::Foundation::BOOL2834 pub unsafe fn SetColorProfileElementSize(hprofile: isize, tagtype: u32, pcbelement: u32) -> super::super::Foundation::BOOL {
2835     #[cfg(windows)]
2836     {
2837         #[link(name = "windows")]
2838         extern "system" {
2839             fn SetColorProfileElementSize(hprofile: isize, tagtype: u32, pcbelement: u32) -> super::super::Foundation::BOOL;
2840         }
2841         ::std::mem::transmute(SetColorProfileElementSize(::std::mem::transmute(hprofile), ::std::mem::transmute(tagtype), ::std::mem::transmute(pcbelement)))
2842     }
2843     #[cfg(not(windows))]
2844     unimplemented!("Unsupported target OS");
2845 }
2846 #[cfg(all(feature = "Win32_Foundation", feature = "Win32_Graphics_Gdi"))]
2847 #[inline]
SetColorProfileHeader(hprofile: isize, pheader: *const PROFILEHEADER) -> super::super::Foundation::BOOL2848 pub unsafe fn SetColorProfileHeader(hprofile: isize, pheader: *const PROFILEHEADER) -> super::super::Foundation::BOOL {
2849     #[cfg(windows)]
2850     {
2851         #[link(name = "windows")]
2852         extern "system" {
2853             fn SetColorProfileHeader(hprofile: isize, pheader: *const PROFILEHEADER) -> super::super::Foundation::BOOL;
2854         }
2855         ::std::mem::transmute(SetColorProfileHeader(::std::mem::transmute(hprofile), ::std::mem::transmute(pheader)))
2856     }
2857     #[cfg(not(windows))]
2858     unimplemented!("Unsupported target OS");
2859 }
2860 #[cfg(feature = "Win32_Graphics_Gdi")]
2861 #[inline]
SetColorSpace<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Graphics::Gdi::HDC>, Param1: ::windows::runtime::IntoParam<'a, HCOLORSPACE>>(hdc: Param0, hcs: Param1) -> HCOLORSPACE2862 pub unsafe fn SetColorSpace<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Graphics::Gdi::HDC>, Param1: ::windows::runtime::IntoParam<'a, HCOLORSPACE>>(hdc: Param0, hcs: Param1) -> HCOLORSPACE {
2863     #[cfg(windows)]
2864     {
2865         #[link(name = "windows")]
2866         extern "system" {
2867             fn SetColorSpace(hdc: super::super::Graphics::Gdi::HDC, hcs: HCOLORSPACE) -> HCOLORSPACE;
2868         }
2869         ::std::mem::transmute(SetColorSpace(hdc.into_param().abi(), hcs.into_param().abi()))
2870     }
2871     #[cfg(not(windows))]
2872     unimplemented!("Unsupported target OS");
2873 }
2874 #[cfg(all(feature = "Win32_Foundation", feature = "Win32_Graphics_Gdi"))]
2875 #[inline]
SetDeviceGammaRamp<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Graphics::Gdi::HDC>>(hdc: Param0, lpramp: *const ::std::ffi::c_void) -> super::super::Foundation::BOOL2876 pub unsafe fn SetDeviceGammaRamp<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Graphics::Gdi::HDC>>(hdc: Param0, lpramp: *const ::std::ffi::c_void) -> super::super::Foundation::BOOL {
2877     #[cfg(windows)]
2878     {
2879         #[link(name = "windows")]
2880         extern "system" {
2881             fn SetDeviceGammaRamp(hdc: super::super::Graphics::Gdi::HDC, lpramp: *const ::std::ffi::c_void) -> super::super::Foundation::BOOL;
2882         }
2883         ::std::mem::transmute(SetDeviceGammaRamp(hdc.into_param().abi(), ::std::mem::transmute(lpramp)))
2884     }
2885     #[cfg(not(windows))]
2886     unimplemented!("Unsupported target OS");
2887 }
2888 #[cfg(feature = "Win32_Graphics_Gdi")]
2889 #[inline]
SetICMMode<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Graphics::Gdi::HDC>>(hdc: Param0, mode: i32) -> i322890 pub unsafe fn SetICMMode<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Graphics::Gdi::HDC>>(hdc: Param0, mode: i32) -> i32 {
2891     #[cfg(windows)]
2892     {
2893         #[link(name = "windows")]
2894         extern "system" {
2895             fn SetICMMode(hdc: super::super::Graphics::Gdi::HDC, mode: i32) -> i32;
2896         }
2897         ::std::mem::transmute(SetICMMode(hdc.into_param().abi(), ::std::mem::transmute(mode)))
2898     }
2899     #[cfg(not(windows))]
2900     unimplemented!("Unsupported target OS");
2901 }
2902 #[cfg(all(feature = "Win32_Foundation", feature = "Win32_Graphics_Gdi"))]
2903 #[inline]
SetICMProfileA<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Graphics::Gdi::HDC>, Param1: ::windows::runtime::IntoParam<'a, super::super::Foundation::PSTR>>(hdc: Param0, lpfilename: Param1) -> super::super::Foundation::BOOL2904 pub unsafe fn SetICMProfileA<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Graphics::Gdi::HDC>, Param1: ::windows::runtime::IntoParam<'a, super::super::Foundation::PSTR>>(hdc: Param0, lpfilename: Param1) -> super::super::Foundation::BOOL {
2905     #[cfg(windows)]
2906     {
2907         #[link(name = "windows")]
2908         extern "system" {
2909             fn SetICMProfileA(hdc: super::super::Graphics::Gdi::HDC, lpfilename: super::super::Foundation::PSTR) -> super::super::Foundation::BOOL;
2910         }
2911         ::std::mem::transmute(SetICMProfileA(hdc.into_param().abi(), lpfilename.into_param().abi()))
2912     }
2913     #[cfg(not(windows))]
2914     unimplemented!("Unsupported target OS");
2915 }
2916 #[cfg(all(feature = "Win32_Foundation", feature = "Win32_Graphics_Gdi"))]
2917 #[inline]
SetICMProfileW<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Graphics::Gdi::HDC>, Param1: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>>(hdc: Param0, lpfilename: Param1) -> super::super::Foundation::BOOL2918 pub unsafe fn SetICMProfileW<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Graphics::Gdi::HDC>, Param1: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>>(hdc: Param0, lpfilename: Param1) -> super::super::Foundation::BOOL {
2919     #[cfg(windows)]
2920     {
2921         #[link(name = "windows")]
2922         extern "system" {
2923             fn SetICMProfileW(hdc: super::super::Graphics::Gdi::HDC, lpfilename: super::super::Foundation::PWSTR) -> super::super::Foundation::BOOL;
2924         }
2925         ::std::mem::transmute(SetICMProfileW(hdc.into_param().abi(), lpfilename.into_param().abi()))
2926     }
2927     #[cfg(not(windows))]
2928     unimplemented!("Unsupported target OS");
2929 }
2930 #[cfg(feature = "Win32_Foundation")]
2931 #[inline]
SetStandardColorSpaceProfileA<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::PSTR>, Param2: ::windows::runtime::IntoParam<'a, super::super::Foundation::PSTR>>(pmachinename: Param0, dwprofileid: u32, pprofilename: Param2) -> super::super::Foundation::BOOL2932 pub unsafe fn SetStandardColorSpaceProfileA<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::PSTR>, Param2: ::windows::runtime::IntoParam<'a, super::super::Foundation::PSTR>>(pmachinename: Param0, dwprofileid: u32, pprofilename: Param2) -> super::super::Foundation::BOOL {
2933     #[cfg(windows)]
2934     {
2935         #[link(name = "windows")]
2936         extern "system" {
2937             fn SetStandardColorSpaceProfileA(pmachinename: super::super::Foundation::PSTR, dwprofileid: u32, pprofilename: super::super::Foundation::PSTR) -> super::super::Foundation::BOOL;
2938         }
2939         ::std::mem::transmute(SetStandardColorSpaceProfileA(pmachinename.into_param().abi(), ::std::mem::transmute(dwprofileid), pprofilename.into_param().abi()))
2940     }
2941     #[cfg(not(windows))]
2942     unimplemented!("Unsupported target OS");
2943 }
2944 #[cfg(feature = "Win32_Foundation")]
2945 #[inline]
SetStandardColorSpaceProfileW<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>, Param2: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>>(pmachinename: Param0, dwprofileid: u32, pprofilename: Param2) -> super::super::Foundation::BOOL2946 pub unsafe fn SetStandardColorSpaceProfileW<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>, Param2: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>>(pmachinename: Param0, dwprofileid: u32, pprofilename: Param2) -> super::super::Foundation::BOOL {
2947     #[cfg(windows)]
2948     {
2949         #[link(name = "windows")]
2950         extern "system" {
2951             fn SetStandardColorSpaceProfileW(pmachinename: super::super::Foundation::PWSTR, dwprofileid: u32, pprofilename: super::super::Foundation::PWSTR) -> super::super::Foundation::BOOL;
2952         }
2953         ::std::mem::transmute(SetStandardColorSpaceProfileW(pmachinename.into_param().abi(), ::std::mem::transmute(dwprofileid), pprofilename.into_param().abi()))
2954     }
2955     #[cfg(not(windows))]
2956     unimplemented!("Unsupported target OS");
2957 }
2958 #[cfg(all(feature = "Win32_Foundation", feature = "Win32_UI_WindowsAndMessaging"))]
2959 #[inline]
SetupColorMatchingA(pcms: *mut COLORMATCHSETUPA) -> super::super::Foundation::BOOL2960 pub unsafe fn SetupColorMatchingA(pcms: *mut COLORMATCHSETUPA) -> super::super::Foundation::BOOL {
2961     #[cfg(windows)]
2962     {
2963         #[link(name = "windows")]
2964         extern "system" {
2965             fn SetupColorMatchingA(pcms: *mut ::std::mem::ManuallyDrop<COLORMATCHSETUPA>) -> super::super::Foundation::BOOL;
2966         }
2967         ::std::mem::transmute(SetupColorMatchingA(::std::mem::transmute(pcms)))
2968     }
2969     #[cfg(not(windows))]
2970     unimplemented!("Unsupported target OS");
2971 }
2972 #[cfg(all(feature = "Win32_Foundation", feature = "Win32_UI_WindowsAndMessaging"))]
2973 #[inline]
SetupColorMatchingW(pcms: *mut COLORMATCHSETUPW) -> super::super::Foundation::BOOL2974 pub unsafe fn SetupColorMatchingW(pcms: *mut COLORMATCHSETUPW) -> super::super::Foundation::BOOL {
2975     #[cfg(windows)]
2976     {
2977         #[link(name = "windows")]
2978         extern "system" {
2979             fn SetupColorMatchingW(pcms: *mut ::std::mem::ManuallyDrop<COLORMATCHSETUPW>) -> super::super::Foundation::BOOL;
2980         }
2981         ::std::mem::transmute(SetupColorMatchingW(::std::mem::transmute(pcms)))
2982     }
2983     #[cfg(not(windows))]
2984     unimplemented!("Unsupported target OS");
2985 }
2986 #[cfg(feature = "Win32_Foundation")]
2987 #[inline]
TranslateBitmapBits<'a, Param10: ::windows::runtime::IntoParam<'a, super::super::Foundation::LPARAM>>(hcolortransform: isize, psrcbits: *const ::std::ffi::c_void, bminput: BMFORMAT, dwwidth: u32, dwheight: u32, dwinputstride: u32, pdestbits: *mut ::std::ffi::c_void, bmoutput: BMFORMAT, dwoutputstride: u32, pfncallback: ::std::option::Option<LPBMCALLBACKFN>, ulcallbackdata: Param10) -> super::super::Foundation::BOOL2988 pub unsafe fn TranslateBitmapBits<'a, Param10: ::windows::runtime::IntoParam<'a, super::super::Foundation::LPARAM>>(hcolortransform: isize, psrcbits: *const ::std::ffi::c_void, bminput: BMFORMAT, dwwidth: u32, dwheight: u32, dwinputstride: u32, pdestbits: *mut ::std::ffi::c_void, bmoutput: BMFORMAT, dwoutputstride: u32, pfncallback: ::std::option::Option<LPBMCALLBACKFN>, ulcallbackdata: Param10) -> super::super::Foundation::BOOL {
2989     #[cfg(windows)]
2990     {
2991         #[link(name = "windows")]
2992         extern "system" {
2993             fn TranslateBitmapBits(hcolortransform: isize, psrcbits: *const ::std::ffi::c_void, bminput: BMFORMAT, dwwidth: u32, dwheight: u32, dwinputstride: u32, pdestbits: *mut ::std::ffi::c_void, bmoutput: BMFORMAT, dwoutputstride: u32, pfncallback: ::windows::runtime::RawPtr, ulcallbackdata: super::super::Foundation::LPARAM) -> super::super::Foundation::BOOL;
2994         }
2995         ::std::mem::transmute(TranslateBitmapBits(
2996             ::std::mem::transmute(hcolortransform),
2997             ::std::mem::transmute(psrcbits),
2998             ::std::mem::transmute(bminput),
2999             ::std::mem::transmute(dwwidth),
3000             ::std::mem::transmute(dwheight),
3001             ::std::mem::transmute(dwinputstride),
3002             ::std::mem::transmute(pdestbits),
3003             ::std::mem::transmute(bmoutput),
3004             ::std::mem::transmute(dwoutputstride),
3005             ::std::mem::transmute(pfncallback),
3006             ulcallbackdata.into_param().abi(),
3007         ))
3008     }
3009     #[cfg(not(windows))]
3010     unimplemented!("Unsupported target OS");
3011 }
3012 #[cfg(feature = "Win32_Foundation")]
3013 #[inline]
TranslateColors(hcolortransform: isize, painputcolors: *const COLOR, ncolors: u32, ctinput: COLORTYPE, paoutputcolors: *mut COLOR, ctoutput: COLORTYPE) -> super::super::Foundation::BOOL3014 pub unsafe fn TranslateColors(hcolortransform: isize, painputcolors: *const COLOR, ncolors: u32, ctinput: COLORTYPE, paoutputcolors: *mut COLOR, ctoutput: COLORTYPE) -> super::super::Foundation::BOOL {
3015     #[cfg(windows)]
3016     {
3017         #[link(name = "windows")]
3018         extern "system" {
3019             fn TranslateColors(hcolortransform: isize, painputcolors: *const COLOR, ncolors: u32, ctinput: COLORTYPE, paoutputcolors: *mut COLOR, ctoutput: COLORTYPE) -> super::super::Foundation::BOOL;
3020         }
3021         ::std::mem::transmute(TranslateColors(::std::mem::transmute(hcolortransform), ::std::mem::transmute(painputcolors), ::std::mem::transmute(ncolors), ::std::mem::transmute(ctinput), ::std::mem::transmute(paoutputcolors), ::std::mem::transmute(ctoutput)))
3022     }
3023     #[cfg(not(windows))]
3024     unimplemented!("Unsupported target OS");
3025 }
3026 pub const USE_RELATIVE_COLORIMETRIC: u32 = 131072u32;
3027 #[cfg(feature = "Win32_Foundation")]
3028 #[inline]
UninstallColorProfileA<'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::BOOL>>(pmachinename: Param0, pprofilename: Param1, bdelete: Param2) -> super::super::Foundation::BOOL3029 pub unsafe fn UninstallColorProfileA<'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::BOOL>>(pmachinename: Param0, pprofilename: Param1, bdelete: Param2) -> super::super::Foundation::BOOL {
3030     #[cfg(windows)]
3031     {
3032         #[link(name = "windows")]
3033         extern "system" {
3034             fn UninstallColorProfileA(pmachinename: super::super::Foundation::PSTR, pprofilename: super::super::Foundation::PSTR, bdelete: super::super::Foundation::BOOL) -> super::super::Foundation::BOOL;
3035         }
3036         ::std::mem::transmute(UninstallColorProfileA(pmachinename.into_param().abi(), pprofilename.into_param().abi(), bdelete.into_param().abi()))
3037     }
3038     #[cfg(not(windows))]
3039     unimplemented!("Unsupported target OS");
3040 }
3041 #[cfg(feature = "Win32_Foundation")]
3042 #[inline]
UninstallColorProfileW<'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::BOOL>>(pmachinename: Param0, pprofilename: Param1, bdelete: Param2) -> super::super::Foundation::BOOL3043 pub unsafe fn UninstallColorProfileW<'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::BOOL>>(pmachinename: Param0, pprofilename: Param1, bdelete: Param2) -> super::super::Foundation::BOOL {
3044     #[cfg(windows)]
3045     {
3046         #[link(name = "windows")]
3047         extern "system" {
3048             fn UninstallColorProfileW(pmachinename: super::super::Foundation::PWSTR, pprofilename: super::super::Foundation::PWSTR, bdelete: super::super::Foundation::BOOL) -> super::super::Foundation::BOOL;
3049         }
3050         ::std::mem::transmute(UninstallColorProfileW(pmachinename.into_param().abi(), pprofilename.into_param().abi(), bdelete.into_param().abi()))
3051     }
3052     #[cfg(not(windows))]
3053     unimplemented!("Unsupported target OS");
3054 }
3055 #[cfg(feature = "Win32_Foundation")]
3056 #[inline]
UnregisterCMMA<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::PSTR>>(pmachinename: Param0, cmmid: u32) -> super::super::Foundation::BOOL3057 pub unsafe fn UnregisterCMMA<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::PSTR>>(pmachinename: Param0, cmmid: u32) -> super::super::Foundation::BOOL {
3058     #[cfg(windows)]
3059     {
3060         #[link(name = "windows")]
3061         extern "system" {
3062             fn UnregisterCMMA(pmachinename: super::super::Foundation::PSTR, cmmid: u32) -> super::super::Foundation::BOOL;
3063         }
3064         ::std::mem::transmute(UnregisterCMMA(pmachinename.into_param().abi(), ::std::mem::transmute(cmmid)))
3065     }
3066     #[cfg(not(windows))]
3067     unimplemented!("Unsupported target OS");
3068 }
3069 #[cfg(feature = "Win32_Foundation")]
3070 #[inline]
UnregisterCMMW<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>>(pmachinename: Param0, cmmid: u32) -> super::super::Foundation::BOOL3071 pub unsafe fn UnregisterCMMW<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>>(pmachinename: Param0, cmmid: u32) -> super::super::Foundation::BOOL {
3072     #[cfg(windows)]
3073     {
3074         #[link(name = "windows")]
3075         extern "system" {
3076             fn UnregisterCMMW(pmachinename: super::super::Foundation::PWSTR, cmmid: u32) -> super::super::Foundation::BOOL;
3077         }
3078         ::std::mem::transmute(UnregisterCMMW(pmachinename.into_param().abi(), ::std::mem::transmute(cmmid)))
3079     }
3080     #[cfg(not(windows))]
3081     unimplemented!("Unsupported target OS");
3082 }
3083 #[cfg(feature = "Win32_Foundation")]
3084 #[inline]
UpdateICMRegKeyA<'a, Param1: ::windows::runtime::IntoParam<'a, super::super::Foundation::PSTR>, Param2: ::windows::runtime::IntoParam<'a, super::super::Foundation::PSTR>>(reserved: u32, lpszcmid: Param1, lpszfilename: Param2, command: ICM_COMMAND) -> super::super::Foundation::BOOL3085 pub unsafe fn UpdateICMRegKeyA<'a, Param1: ::windows::runtime::IntoParam<'a, super::super::Foundation::PSTR>, Param2: ::windows::runtime::IntoParam<'a, super::super::Foundation::PSTR>>(reserved: u32, lpszcmid: Param1, lpszfilename: Param2, command: ICM_COMMAND) -> super::super::Foundation::BOOL {
3086     #[cfg(windows)]
3087     {
3088         #[link(name = "windows")]
3089         extern "system" {
3090             fn UpdateICMRegKeyA(reserved: u32, lpszcmid: super::super::Foundation::PSTR, lpszfilename: super::super::Foundation::PSTR, command: ICM_COMMAND) -> super::super::Foundation::BOOL;
3091         }
3092         ::std::mem::transmute(UpdateICMRegKeyA(::std::mem::transmute(reserved), lpszcmid.into_param().abi(), lpszfilename.into_param().abi(), ::std::mem::transmute(command)))
3093     }
3094     #[cfg(not(windows))]
3095     unimplemented!("Unsupported target OS");
3096 }
3097 #[cfg(feature = "Win32_Foundation")]
3098 #[inline]
UpdateICMRegKeyW<'a, Param1: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>, Param2: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>>(reserved: u32, lpszcmid: Param1, lpszfilename: Param2, command: ICM_COMMAND) -> super::super::Foundation::BOOL3099 pub unsafe fn UpdateICMRegKeyW<'a, Param1: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>, Param2: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>>(reserved: u32, lpszcmid: Param1, lpszfilename: Param2, command: ICM_COMMAND) -> super::super::Foundation::BOOL {
3100     #[cfg(windows)]
3101     {
3102         #[link(name = "windows")]
3103         extern "system" {
3104             fn UpdateICMRegKeyW(reserved: u32, lpszcmid: super::super::Foundation::PWSTR, lpszfilename: super::super::Foundation::PWSTR, command: ICM_COMMAND) -> super::super::Foundation::BOOL;
3105         }
3106         ::std::mem::transmute(UpdateICMRegKeyW(::std::mem::transmute(reserved), lpszcmid.into_param().abi(), lpszfilename.into_param().abi(), ::std::mem::transmute(command)))
3107     }
3108     #[cfg(not(windows))]
3109     unimplemented!("Unsupported target OS");
3110 }
3111 pub const WCS_ALWAYS: u32 = 2097152u32;
3112 pub const WCS_DEFAULT: i32 = 0i32;
3113 #[derive(:: std :: cmp :: PartialEq, :: std :: cmp :: Eq, :: std :: marker :: Copy, :: std :: clone :: Clone, :: std :: default :: Default, :: std :: fmt :: Debug)]
3114 #[repr(transparent)]
3115 pub struct WCS_DEVICE_CAPABILITIES_TYPE(pub i32);
3116 pub const VideoCardGammaTable: WCS_DEVICE_CAPABILITIES_TYPE = WCS_DEVICE_CAPABILITIES_TYPE(1i32);
3117 pub const MicrosoftHardwareColorV2: WCS_DEVICE_CAPABILITIES_TYPE = WCS_DEVICE_CAPABILITIES_TYPE(2i32);
3118 impl ::std::convert::From<i32> for WCS_DEVICE_CAPABILITIES_TYPE {
from(value: i32) -> Self3119     fn from(value: i32) -> Self {
3120         Self(value)
3121     }
3122 }
3123 unsafe impl ::windows::runtime::Abi for WCS_DEVICE_CAPABILITIES_TYPE {
3124     type Abi = Self;
3125     type DefaultType = Self;
3126 }
3127 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
3128 #[repr(C)]
3129 #[cfg(feature = "Win32_Foundation")]
3130 pub struct WCS_DEVICE_MHC2_CAPABILITIES {
3131     pub Size: u32,
3132     pub SupportsMhc2: super::super::Foundation::BOOL,
3133     pub RegammaLutEntryCount: u32,
3134     pub CscXyzMatrixRows: u32,
3135     pub CscXyzMatrixColumns: u32,
3136 }
3137 #[cfg(feature = "Win32_Foundation")]
3138 impl WCS_DEVICE_MHC2_CAPABILITIES {}
3139 #[cfg(feature = "Win32_Foundation")]
3140 impl ::std::default::Default for WCS_DEVICE_MHC2_CAPABILITIES {
default() -> Self3141     fn default() -> Self {
3142         unsafe { ::std::mem::zeroed() }
3143     }
3144 }
3145 #[cfg(feature = "Win32_Foundation")]
3146 impl ::std::fmt::Debug for WCS_DEVICE_MHC2_CAPABILITIES {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result3147     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
3148         fmt.debug_struct("WCS_DEVICE_MHC2_CAPABILITIES").field("Size", &self.Size).field("SupportsMhc2", &self.SupportsMhc2).field("RegammaLutEntryCount", &self.RegammaLutEntryCount).field("CscXyzMatrixRows", &self.CscXyzMatrixRows).field("CscXyzMatrixColumns", &self.CscXyzMatrixColumns).finish()
3149     }
3150 }
3151 #[cfg(feature = "Win32_Foundation")]
3152 impl ::std::cmp::PartialEq for WCS_DEVICE_MHC2_CAPABILITIES {
eq(&self, other: &Self) -> bool3153     fn eq(&self, other: &Self) -> bool {
3154         self.Size == other.Size && self.SupportsMhc2 == other.SupportsMhc2 && self.RegammaLutEntryCount == other.RegammaLutEntryCount && self.CscXyzMatrixRows == other.CscXyzMatrixRows && self.CscXyzMatrixColumns == other.CscXyzMatrixColumns
3155     }
3156 }
3157 #[cfg(feature = "Win32_Foundation")]
3158 impl ::std::cmp::Eq for WCS_DEVICE_MHC2_CAPABILITIES {}
3159 #[cfg(feature = "Win32_Foundation")]
3160 unsafe impl ::windows::runtime::Abi for WCS_DEVICE_MHC2_CAPABILITIES {
3161     type Abi = Self;
3162     type DefaultType = Self;
3163 }
3164 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
3165 #[repr(C)]
3166 #[cfg(feature = "Win32_Foundation")]
3167 pub struct WCS_DEVICE_VCGT_CAPABILITIES {
3168     pub Size: u32,
3169     pub SupportsVcgt: super::super::Foundation::BOOL,
3170 }
3171 #[cfg(feature = "Win32_Foundation")]
3172 impl WCS_DEVICE_VCGT_CAPABILITIES {}
3173 #[cfg(feature = "Win32_Foundation")]
3174 impl ::std::default::Default for WCS_DEVICE_VCGT_CAPABILITIES {
default() -> Self3175     fn default() -> Self {
3176         unsafe { ::std::mem::zeroed() }
3177     }
3178 }
3179 #[cfg(feature = "Win32_Foundation")]
3180 impl ::std::fmt::Debug for WCS_DEVICE_VCGT_CAPABILITIES {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result3181     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
3182         fmt.debug_struct("WCS_DEVICE_VCGT_CAPABILITIES").field("Size", &self.Size).field("SupportsVcgt", &self.SupportsVcgt).finish()
3183     }
3184 }
3185 #[cfg(feature = "Win32_Foundation")]
3186 impl ::std::cmp::PartialEq for WCS_DEVICE_VCGT_CAPABILITIES {
eq(&self, other: &Self) -> bool3187     fn eq(&self, other: &Self) -> bool {
3188         self.Size == other.Size && self.SupportsVcgt == other.SupportsVcgt
3189     }
3190 }
3191 #[cfg(feature = "Win32_Foundation")]
3192 impl ::std::cmp::Eq for WCS_DEVICE_VCGT_CAPABILITIES {}
3193 #[cfg(feature = "Win32_Foundation")]
3194 unsafe impl ::windows::runtime::Abi for WCS_DEVICE_VCGT_CAPABILITIES {
3195     type Abi = Self;
3196     type DefaultType = Self;
3197 }
3198 pub const WCS_ICCONLY: i32 = 65536i32;
3199 #[derive(:: std :: cmp :: PartialEq, :: std :: cmp :: Eq, :: std :: marker :: Copy, :: std :: clone :: Clone, :: std :: default :: Default, :: std :: fmt :: Debug)]
3200 #[repr(transparent)]
3201 pub struct WCS_PROFILE_MANAGEMENT_SCOPE(pub i32);
3202 pub const WCS_PROFILE_MANAGEMENT_SCOPE_SYSTEM_WIDE: WCS_PROFILE_MANAGEMENT_SCOPE = WCS_PROFILE_MANAGEMENT_SCOPE(0i32);
3203 pub const WCS_PROFILE_MANAGEMENT_SCOPE_CURRENT_USER: WCS_PROFILE_MANAGEMENT_SCOPE = WCS_PROFILE_MANAGEMENT_SCOPE(1i32);
3204 impl ::std::convert::From<i32> for WCS_PROFILE_MANAGEMENT_SCOPE {
from(value: i32) -> Self3205     fn from(value: i32) -> Self {
3206         Self(value)
3207     }
3208 }
3209 unsafe impl ::windows::runtime::Abi for WCS_PROFILE_MANAGEMENT_SCOPE {
3210     type Abi = Self;
3211     type DefaultType = Self;
3212 }
3213 #[cfg(feature = "Win32_Foundation")]
3214 #[inline]
WcsAssociateColorProfileWithDevice<'a, Param1: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>, Param2: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>>(scope: WCS_PROFILE_MANAGEMENT_SCOPE, pprofilename: Param1, pdevicename: Param2) -> super::super::Foundation::BOOL3215 pub unsafe fn WcsAssociateColorProfileWithDevice<'a, Param1: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>, Param2: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>>(scope: WCS_PROFILE_MANAGEMENT_SCOPE, pprofilename: Param1, pdevicename: Param2) -> super::super::Foundation::BOOL {
3216     #[cfg(windows)]
3217     {
3218         #[link(name = "windows")]
3219         extern "system" {
3220             fn WcsAssociateColorProfileWithDevice(scope: WCS_PROFILE_MANAGEMENT_SCOPE, pprofilename: super::super::Foundation::PWSTR, pdevicename: super::super::Foundation::PWSTR) -> super::super::Foundation::BOOL;
3221         }
3222         ::std::mem::transmute(WcsAssociateColorProfileWithDevice(::std::mem::transmute(scope), pprofilename.into_param().abi(), pdevicename.into_param().abi()))
3223     }
3224     #[cfg(not(windows))]
3225     unimplemented!("Unsupported target OS");
3226 }
3227 #[cfg(feature = "Win32_Foundation")]
3228 #[inline]
WcsCheckColors(hcolortransform: isize, ncolors: u32, ninputchannels: u32, cdtinput: COLORDATATYPE, cbinput: u32, pinputdata: *const ::std::ffi::c_void, paresult: *mut u8) -> super::super::Foundation::BOOL3229 pub unsafe fn WcsCheckColors(hcolortransform: isize, ncolors: u32, ninputchannels: u32, cdtinput: COLORDATATYPE, cbinput: u32, pinputdata: *const ::std::ffi::c_void, paresult: *mut u8) -> super::super::Foundation::BOOL {
3230     #[cfg(windows)]
3231     {
3232         #[link(name = "windows")]
3233         extern "system" {
3234             fn WcsCheckColors(hcolortransform: isize, ncolors: u32, ninputchannels: u32, cdtinput: COLORDATATYPE, cbinput: u32, pinputdata: *const ::std::ffi::c_void, paresult: *mut u8) -> super::super::Foundation::BOOL;
3235         }
3236         ::std::mem::transmute(WcsCheckColors(::std::mem::transmute(hcolortransform), ::std::mem::transmute(ncolors), ::std::mem::transmute(ninputchannels), ::std::mem::transmute(cdtinput), ::std::mem::transmute(cbinput), ::std::mem::transmute(pinputdata), ::std::mem::transmute(paresult)))
3237     }
3238     #[cfg(not(windows))]
3239     unimplemented!("Unsupported target OS");
3240 }
3241 #[inline]
WcsCreateIccProfile(hwcsprofile: isize, dwoptions: u32) -> isize3242 pub unsafe fn WcsCreateIccProfile(hwcsprofile: isize, dwoptions: u32) -> isize {
3243     #[cfg(windows)]
3244     {
3245         #[link(name = "windows")]
3246         extern "system" {
3247             fn WcsCreateIccProfile(hwcsprofile: isize, dwoptions: u32) -> isize;
3248         }
3249         ::std::mem::transmute(WcsCreateIccProfile(::std::mem::transmute(hwcsprofile), ::std::mem::transmute(dwoptions)))
3250     }
3251     #[cfg(not(windows))]
3252     unimplemented!("Unsupported target OS");
3253 }
3254 #[cfg(feature = "Win32_Foundation")]
3255 #[inline]
WcsDisassociateColorProfileFromDevice<'a, Param1: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>, Param2: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>>(scope: WCS_PROFILE_MANAGEMENT_SCOPE, pprofilename: Param1, pdevicename: Param2) -> super::super::Foundation::BOOL3256 pub unsafe fn WcsDisassociateColorProfileFromDevice<'a, Param1: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>, Param2: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>>(scope: WCS_PROFILE_MANAGEMENT_SCOPE, pprofilename: Param1, pdevicename: Param2) -> super::super::Foundation::BOOL {
3257     #[cfg(windows)]
3258     {
3259         #[link(name = "windows")]
3260         extern "system" {
3261             fn WcsDisassociateColorProfileFromDevice(scope: WCS_PROFILE_MANAGEMENT_SCOPE, pprofilename: super::super::Foundation::PWSTR, pdevicename: super::super::Foundation::PWSTR) -> super::super::Foundation::BOOL;
3262         }
3263         ::std::mem::transmute(WcsDisassociateColorProfileFromDevice(::std::mem::transmute(scope), pprofilename.into_param().abi(), pdevicename.into_param().abi()))
3264     }
3265     #[cfg(not(windows))]
3266     unimplemented!("Unsupported target OS");
3267 }
3268 #[cfg(feature = "Win32_Foundation")]
3269 #[inline]
WcsEnumColorProfiles(scope: WCS_PROFILE_MANAGEMENT_SCOPE, penumrecord: *const ENUMTYPEW, pbuffer: *mut u8, dwsize: u32, pnprofiles: *mut u32) -> super::super::Foundation::BOOL3270 pub unsafe fn WcsEnumColorProfiles(scope: WCS_PROFILE_MANAGEMENT_SCOPE, penumrecord: *const ENUMTYPEW, pbuffer: *mut u8, dwsize: u32, pnprofiles: *mut u32) -> super::super::Foundation::BOOL {
3271     #[cfg(windows)]
3272     {
3273         #[link(name = "windows")]
3274         extern "system" {
3275             fn WcsEnumColorProfiles(scope: WCS_PROFILE_MANAGEMENT_SCOPE, penumrecord: *const ENUMTYPEW, pbuffer: *mut u8, dwsize: u32, pnprofiles: *mut u32) -> super::super::Foundation::BOOL;
3276         }
3277         ::std::mem::transmute(WcsEnumColorProfiles(::std::mem::transmute(scope), ::std::mem::transmute(penumrecord), ::std::mem::transmute(pbuffer), ::std::mem::transmute(dwsize), ::std::mem::transmute(pnprofiles)))
3278     }
3279     #[cfg(not(windows))]
3280     unimplemented!("Unsupported target OS");
3281 }
3282 #[cfg(feature = "Win32_Foundation")]
3283 #[inline]
WcsEnumColorProfilesSize(scope: WCS_PROFILE_MANAGEMENT_SCOPE, penumrecord: *const ENUMTYPEW, pdwsize: *mut u32) -> super::super::Foundation::BOOL3284 pub unsafe fn WcsEnumColorProfilesSize(scope: WCS_PROFILE_MANAGEMENT_SCOPE, penumrecord: *const ENUMTYPEW, pdwsize: *mut u32) -> super::super::Foundation::BOOL {
3285     #[cfg(windows)]
3286     {
3287         #[link(name = "windows")]
3288         extern "system" {
3289             fn WcsEnumColorProfilesSize(scope: WCS_PROFILE_MANAGEMENT_SCOPE, penumrecord: *const ENUMTYPEW, pdwsize: *mut u32) -> super::super::Foundation::BOOL;
3290         }
3291         ::std::mem::transmute(WcsEnumColorProfilesSize(::std::mem::transmute(scope), ::std::mem::transmute(penumrecord), ::std::mem::transmute(pdwsize)))
3292     }
3293     #[cfg(not(windows))]
3294     unimplemented!("Unsupported target OS");
3295 }
3296 #[cfg(feature = "Win32_Foundation")]
3297 #[inline]
WcsGetCalibrationManagementState(pbisenabled: *mut super::super::Foundation::BOOL) -> super::super::Foundation::BOOL3298 pub unsafe fn WcsGetCalibrationManagementState(pbisenabled: *mut super::super::Foundation::BOOL) -> super::super::Foundation::BOOL {
3299     #[cfg(windows)]
3300     {
3301         #[link(name = "windows")]
3302         extern "system" {
3303             fn WcsGetCalibrationManagementState(pbisenabled: *mut super::super::Foundation::BOOL) -> super::super::Foundation::BOOL;
3304         }
3305         ::std::mem::transmute(WcsGetCalibrationManagementState(::std::mem::transmute(pbisenabled)))
3306     }
3307     #[cfg(not(windows))]
3308     unimplemented!("Unsupported target OS");
3309 }
3310 #[cfg(feature = "Win32_Foundation")]
3311 #[inline]
WcsGetDefaultColorProfile<'a, Param1: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>>(scope: WCS_PROFILE_MANAGEMENT_SCOPE, pdevicename: Param1, cptcolorprofiletype: COLORPROFILETYPE, cpstcolorprofilesubtype: COLORPROFILESUBTYPE, dwprofileid: u32, cbprofilename: u32, pprofilename: super::super::Foundation::PWSTR) -> super::super::Foundation::BOOL3312 pub unsafe fn WcsGetDefaultColorProfile<'a, Param1: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>>(scope: WCS_PROFILE_MANAGEMENT_SCOPE, pdevicename: Param1, cptcolorprofiletype: COLORPROFILETYPE, cpstcolorprofilesubtype: COLORPROFILESUBTYPE, dwprofileid: u32, cbprofilename: u32, pprofilename: super::super::Foundation::PWSTR) -> super::super::Foundation::BOOL {
3313     #[cfg(windows)]
3314     {
3315         #[link(name = "windows")]
3316         extern "system" {
3317             fn WcsGetDefaultColorProfile(scope: WCS_PROFILE_MANAGEMENT_SCOPE, pdevicename: super::super::Foundation::PWSTR, cptcolorprofiletype: COLORPROFILETYPE, cpstcolorprofilesubtype: COLORPROFILESUBTYPE, dwprofileid: u32, cbprofilename: u32, pprofilename: super::super::Foundation::PWSTR) -> super::super::Foundation::BOOL;
3318         }
3319         ::std::mem::transmute(WcsGetDefaultColorProfile(::std::mem::transmute(scope), pdevicename.into_param().abi(), ::std::mem::transmute(cptcolorprofiletype), ::std::mem::transmute(cpstcolorprofilesubtype), ::std::mem::transmute(dwprofileid), ::std::mem::transmute(cbprofilename), ::std::mem::transmute(pprofilename)))
3320     }
3321     #[cfg(not(windows))]
3322     unimplemented!("Unsupported target OS");
3323 }
3324 #[cfg(feature = "Win32_Foundation")]
3325 #[inline]
WcsGetDefaultColorProfileSize<'a, Param1: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>>(scope: WCS_PROFILE_MANAGEMENT_SCOPE, pdevicename: Param1, cptcolorprofiletype: COLORPROFILETYPE, cpstcolorprofilesubtype: COLORPROFILESUBTYPE, dwprofileid: u32, pcbprofilename: *mut u32) -> super::super::Foundation::BOOL3326 pub unsafe fn WcsGetDefaultColorProfileSize<'a, Param1: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>>(scope: WCS_PROFILE_MANAGEMENT_SCOPE, pdevicename: Param1, cptcolorprofiletype: COLORPROFILETYPE, cpstcolorprofilesubtype: COLORPROFILESUBTYPE, dwprofileid: u32, pcbprofilename: *mut u32) -> super::super::Foundation::BOOL {
3327     #[cfg(windows)]
3328     {
3329         #[link(name = "windows")]
3330         extern "system" {
3331             fn WcsGetDefaultColorProfileSize(scope: WCS_PROFILE_MANAGEMENT_SCOPE, pdevicename: super::super::Foundation::PWSTR, cptcolorprofiletype: COLORPROFILETYPE, cpstcolorprofilesubtype: COLORPROFILESUBTYPE, dwprofileid: u32, pcbprofilename: *mut u32) -> super::super::Foundation::BOOL;
3332         }
3333         ::std::mem::transmute(WcsGetDefaultColorProfileSize(::std::mem::transmute(scope), pdevicename.into_param().abi(), ::std::mem::transmute(cptcolorprofiletype), ::std::mem::transmute(cpstcolorprofilesubtype), ::std::mem::transmute(dwprofileid), ::std::mem::transmute(pcbprofilename)))
3334     }
3335     #[cfg(not(windows))]
3336     unimplemented!("Unsupported target OS");
3337 }
3338 #[cfg(feature = "Win32_Foundation")]
3339 #[inline]
WcsGetDefaultRenderingIntent(scope: WCS_PROFILE_MANAGEMENT_SCOPE, pdwrenderingintent: *mut u32) -> super::super::Foundation::BOOL3340 pub unsafe fn WcsGetDefaultRenderingIntent(scope: WCS_PROFILE_MANAGEMENT_SCOPE, pdwrenderingintent: *mut u32) -> super::super::Foundation::BOOL {
3341     #[cfg(windows)]
3342     {
3343         #[link(name = "windows")]
3344         extern "system" {
3345             fn WcsGetDefaultRenderingIntent(scope: WCS_PROFILE_MANAGEMENT_SCOPE, pdwrenderingintent: *mut u32) -> super::super::Foundation::BOOL;
3346         }
3347         ::std::mem::transmute(WcsGetDefaultRenderingIntent(::std::mem::transmute(scope), ::std::mem::transmute(pdwrenderingintent)))
3348     }
3349     #[cfg(not(windows))]
3350     unimplemented!("Unsupported target OS");
3351 }
3352 #[cfg(feature = "Win32_Foundation")]
3353 #[inline]
WcsGetUsePerUserProfiles<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>>(pdevicename: Param0, dwdeviceclass: u32, puseperuserprofiles: *mut super::super::Foundation::BOOL) -> super::super::Foundation::BOOL3354 pub unsafe fn WcsGetUsePerUserProfiles<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>>(pdevicename: Param0, dwdeviceclass: u32, puseperuserprofiles: *mut super::super::Foundation::BOOL) -> super::super::Foundation::BOOL {
3355     #[cfg(windows)]
3356     {
3357         #[link(name = "windows")]
3358         extern "system" {
3359             fn WcsGetUsePerUserProfiles(pdevicename: super::super::Foundation::PWSTR, dwdeviceclass: u32, puseperuserprofiles: *mut super::super::Foundation::BOOL) -> super::super::Foundation::BOOL;
3360         }
3361         ::std::mem::transmute(WcsGetUsePerUserProfiles(pdevicename.into_param().abi(), ::std::mem::transmute(dwdeviceclass), ::std::mem::transmute(puseperuserprofiles)))
3362     }
3363     #[cfg(not(windows))]
3364     unimplemented!("Unsupported target OS");
3365 }
3366 #[inline]
WcsOpenColorProfileA(pcdmpprofile: *const PROFILE, pcampprofile: *const PROFILE, pgmmpprofile: *const PROFILE, dwdesireaccess: u32, dwsharemode: u32, dwcreationmode: u32, dwflags: u32) -> isize3367 pub unsafe fn WcsOpenColorProfileA(pcdmpprofile: *const PROFILE, pcampprofile: *const PROFILE, pgmmpprofile: *const PROFILE, dwdesireaccess: u32, dwsharemode: u32, dwcreationmode: u32, dwflags: u32) -> isize {
3368     #[cfg(windows)]
3369     {
3370         #[link(name = "windows")]
3371         extern "system" {
3372             fn WcsOpenColorProfileA(pcdmpprofile: *const PROFILE, pcampprofile: *const PROFILE, pgmmpprofile: *const PROFILE, dwdesireaccess: u32, dwsharemode: u32, dwcreationmode: u32, dwflags: u32) -> isize;
3373         }
3374         ::std::mem::transmute(WcsOpenColorProfileA(::std::mem::transmute(pcdmpprofile), ::std::mem::transmute(pcampprofile), ::std::mem::transmute(pgmmpprofile), ::std::mem::transmute(dwdesireaccess), ::std::mem::transmute(dwsharemode), ::std::mem::transmute(dwcreationmode), ::std::mem::transmute(dwflags)))
3375     }
3376     #[cfg(not(windows))]
3377     unimplemented!("Unsupported target OS");
3378 }
3379 #[inline]
WcsOpenColorProfileW(pcdmpprofile: *const PROFILE, pcampprofile: *const PROFILE, pgmmpprofile: *const PROFILE, dwdesireaccess: u32, dwsharemode: u32, dwcreationmode: u32, dwflags: u32) -> isize3380 pub unsafe fn WcsOpenColorProfileW(pcdmpprofile: *const PROFILE, pcampprofile: *const PROFILE, pgmmpprofile: *const PROFILE, dwdesireaccess: u32, dwsharemode: u32, dwcreationmode: u32, dwflags: u32) -> isize {
3381     #[cfg(windows)]
3382     {
3383         #[link(name = "windows")]
3384         extern "system" {
3385             fn WcsOpenColorProfileW(pcdmpprofile: *const PROFILE, pcampprofile: *const PROFILE, pgmmpprofile: *const PROFILE, dwdesireaccess: u32, dwsharemode: u32, dwcreationmode: u32, dwflags: u32) -> isize;
3386         }
3387         ::std::mem::transmute(WcsOpenColorProfileW(::std::mem::transmute(pcdmpprofile), ::std::mem::transmute(pcampprofile), ::std::mem::transmute(pgmmpprofile), ::std::mem::transmute(dwdesireaccess), ::std::mem::transmute(dwsharemode), ::std::mem::transmute(dwcreationmode), ::std::mem::transmute(dwflags)))
3388     }
3389     #[cfg(not(windows))]
3390     unimplemented!("Unsupported target OS");
3391 }
3392 #[cfg(feature = "Win32_Foundation")]
3393 #[inline]
WcsSetCalibrationManagementState<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::BOOL>>(bisenabled: Param0) -> super::super::Foundation::BOOL3394 pub unsafe fn WcsSetCalibrationManagementState<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::BOOL>>(bisenabled: Param0) -> super::super::Foundation::BOOL {
3395     #[cfg(windows)]
3396     {
3397         #[link(name = "windows")]
3398         extern "system" {
3399             fn WcsSetCalibrationManagementState(bisenabled: super::super::Foundation::BOOL) -> super::super::Foundation::BOOL;
3400         }
3401         ::std::mem::transmute(WcsSetCalibrationManagementState(bisenabled.into_param().abi()))
3402     }
3403     #[cfg(not(windows))]
3404     unimplemented!("Unsupported target OS");
3405 }
3406 #[cfg(feature = "Win32_Foundation")]
3407 #[inline]
WcsSetDefaultColorProfile<'a, Param1: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>, Param5: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>>(scope: WCS_PROFILE_MANAGEMENT_SCOPE, pdevicename: Param1, cptcolorprofiletype: COLORPROFILETYPE, cpstcolorprofilesubtype: COLORPROFILESUBTYPE, dwprofileid: u32, pprofilename: Param5) -> super::super::Foundation::BOOL3408 pub unsafe fn WcsSetDefaultColorProfile<'a, Param1: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>, Param5: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>>(scope: WCS_PROFILE_MANAGEMENT_SCOPE, pdevicename: Param1, cptcolorprofiletype: COLORPROFILETYPE, cpstcolorprofilesubtype: COLORPROFILESUBTYPE, dwprofileid: u32, pprofilename: Param5) -> super::super::Foundation::BOOL {
3409     #[cfg(windows)]
3410     {
3411         #[link(name = "windows")]
3412         extern "system" {
3413             fn WcsSetDefaultColorProfile(scope: WCS_PROFILE_MANAGEMENT_SCOPE, pdevicename: super::super::Foundation::PWSTR, cptcolorprofiletype: COLORPROFILETYPE, cpstcolorprofilesubtype: COLORPROFILESUBTYPE, dwprofileid: u32, pprofilename: super::super::Foundation::PWSTR) -> super::super::Foundation::BOOL;
3414         }
3415         ::std::mem::transmute(WcsSetDefaultColorProfile(::std::mem::transmute(scope), pdevicename.into_param().abi(), ::std::mem::transmute(cptcolorprofiletype), ::std::mem::transmute(cpstcolorprofilesubtype), ::std::mem::transmute(dwprofileid), pprofilename.into_param().abi()))
3416     }
3417     #[cfg(not(windows))]
3418     unimplemented!("Unsupported target OS");
3419 }
3420 #[cfg(feature = "Win32_Foundation")]
3421 #[inline]
WcsSetDefaultRenderingIntent(scope: WCS_PROFILE_MANAGEMENT_SCOPE, dwrenderingintent: u32) -> super::super::Foundation::BOOL3422 pub unsafe fn WcsSetDefaultRenderingIntent(scope: WCS_PROFILE_MANAGEMENT_SCOPE, dwrenderingintent: u32) -> super::super::Foundation::BOOL {
3423     #[cfg(windows)]
3424     {
3425         #[link(name = "windows")]
3426         extern "system" {
3427             fn WcsSetDefaultRenderingIntent(scope: WCS_PROFILE_MANAGEMENT_SCOPE, dwrenderingintent: u32) -> super::super::Foundation::BOOL;
3428         }
3429         ::std::mem::transmute(WcsSetDefaultRenderingIntent(::std::mem::transmute(scope), ::std::mem::transmute(dwrenderingintent)))
3430     }
3431     #[cfg(not(windows))]
3432     unimplemented!("Unsupported target OS");
3433 }
3434 #[cfg(feature = "Win32_Foundation")]
3435 #[inline]
WcsSetUsePerUserProfiles<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>, Param2: ::windows::runtime::IntoParam<'a, super::super::Foundation::BOOL>>(pdevicename: Param0, dwdeviceclass: u32, useperuserprofiles: Param2) -> super::super::Foundation::BOOL3436 pub unsafe fn WcsSetUsePerUserProfiles<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>, Param2: ::windows::runtime::IntoParam<'a, super::super::Foundation::BOOL>>(pdevicename: Param0, dwdeviceclass: u32, useperuserprofiles: Param2) -> super::super::Foundation::BOOL {
3437     #[cfg(windows)]
3438     {
3439         #[link(name = "windows")]
3440         extern "system" {
3441             fn WcsSetUsePerUserProfiles(pdevicename: super::super::Foundation::PWSTR, dwdeviceclass: u32, useperuserprofiles: super::super::Foundation::BOOL) -> super::super::Foundation::BOOL;
3442         }
3443         ::std::mem::transmute(WcsSetUsePerUserProfiles(pdevicename.into_param().abi(), ::std::mem::transmute(dwdeviceclass), useperuserprofiles.into_param().abi()))
3444     }
3445     #[cfg(not(windows))]
3446     unimplemented!("Unsupported target OS");
3447 }
3448 #[cfg(feature = "Win32_Foundation")]
3449 #[inline]
WcsTranslateColors(hcolortransform: isize, ncolors: u32, ninputchannels: u32, cdtinput: COLORDATATYPE, cbinput: u32, pinputdata: *const ::std::ffi::c_void, noutputchannels: u32, cdtoutput: COLORDATATYPE, cboutput: u32, poutputdata: *mut ::std::ffi::c_void) -> super::super::Foundation::BOOL3450 pub unsafe fn WcsTranslateColors(hcolortransform: isize, ncolors: u32, ninputchannels: u32, cdtinput: COLORDATATYPE, cbinput: u32, pinputdata: *const ::std::ffi::c_void, noutputchannels: u32, cdtoutput: COLORDATATYPE, cboutput: u32, poutputdata: *mut ::std::ffi::c_void) -> super::super::Foundation::BOOL {
3451     #[cfg(windows)]
3452     {
3453         #[link(name = "windows")]
3454         extern "system" {
3455             fn WcsTranslateColors(hcolortransform: isize, ncolors: u32, ninputchannels: u32, cdtinput: COLORDATATYPE, cbinput: u32, pinputdata: *const ::std::ffi::c_void, noutputchannels: u32, cdtoutput: COLORDATATYPE, cboutput: u32, poutputdata: *mut ::std::ffi::c_void) -> super::super::Foundation::BOOL;
3456         }
3457         ::std::mem::transmute(WcsTranslateColors(
3458             ::std::mem::transmute(hcolortransform),
3459             ::std::mem::transmute(ncolors),
3460             ::std::mem::transmute(ninputchannels),
3461             ::std::mem::transmute(cdtinput),
3462             ::std::mem::transmute(cbinput),
3463             ::std::mem::transmute(pinputdata),
3464             ::std::mem::transmute(noutputchannels),
3465             ::std::mem::transmute(cdtoutput),
3466             ::std::mem::transmute(cboutput),
3467             ::std::mem::transmute(poutputdata),
3468         ))
3469     }
3470     #[cfg(not(windows))]
3471     unimplemented!("Unsupported target OS");
3472 }
3473 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
3474 #[repr(C)]
3475 pub struct XYZCOLOR {
3476     pub X: u16,
3477     pub Y: u16,
3478     pub Z: u16,
3479 }
3480 impl XYZCOLOR {}
3481 impl ::std::default::Default for XYZCOLOR {
default() -> Self3482     fn default() -> Self {
3483         unsafe { ::std::mem::zeroed() }
3484     }
3485 }
3486 impl ::std::fmt::Debug for XYZCOLOR {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result3487     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
3488         fmt.debug_struct("XYZCOLOR").field("X", &self.X).field("Y", &self.Y).field("Z", &self.Z).finish()
3489     }
3490 }
3491 impl ::std::cmp::PartialEq for XYZCOLOR {
eq(&self, other: &Self) -> bool3492     fn eq(&self, other: &Self) -> bool {
3493         self.X == other.X && self.Y == other.Y && self.Z == other.Z
3494     }
3495 }
3496 impl ::std::cmp::Eq for XYZCOLOR {}
3497 unsafe impl ::windows::runtime::Abi for XYZCOLOR {
3498     type Abi = Self;
3499     type DefaultType = Self;
3500 }
3501 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
3502 #[repr(C)]
3503 pub struct XYZColorF {
3504     pub X: f32,
3505     pub Y: f32,
3506     pub Z: f32,
3507 }
3508 impl XYZColorF {}
3509 impl ::std::default::Default for XYZColorF {
default() -> Self3510     fn default() -> Self {
3511         unsafe { ::std::mem::zeroed() }
3512     }
3513 }
3514 impl ::std::fmt::Debug for XYZColorF {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result3515     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
3516         fmt.debug_struct("XYZColorF").field("X", &self.X).field("Y", &self.Y).field("Z", &self.Z).finish()
3517     }
3518 }
3519 impl ::std::cmp::PartialEq for XYZColorF {
eq(&self, other: &Self) -> bool3520     fn eq(&self, other: &Self) -> bool {
3521         self.X == other.X && self.Y == other.Y && self.Z == other.Z
3522     }
3523 }
3524 impl ::std::cmp::Eq for XYZColorF {}
3525 unsafe impl ::windows::runtime::Abi for XYZColorF {
3526     type Abi = Self;
3527     type DefaultType = Self;
3528 }
3529 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
3530 #[repr(C)]
3531 pub struct YxyCOLOR {
3532     pub Y: u16,
3533     pub x: u16,
3534     pub y: u16,
3535 }
3536 impl YxyCOLOR {}
3537 impl ::std::default::Default for YxyCOLOR {
default() -> Self3538     fn default() -> Self {
3539         unsafe { ::std::mem::zeroed() }
3540     }
3541 }
3542 impl ::std::fmt::Debug for YxyCOLOR {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result3543     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
3544         fmt.debug_struct("YxyCOLOR").field("Y", &self.Y).field("x", &self.x).field("y", &self.y).finish()
3545     }
3546 }
3547 impl ::std::cmp::PartialEq for YxyCOLOR {
eq(&self, other: &Self) -> bool3548     fn eq(&self, other: &Self) -> bool {
3549         self.Y == other.Y && self.x == other.x && self.y == other.y
3550     }
3551 }
3552 impl ::std::cmp::Eq for YxyCOLOR {}
3553 unsafe impl ::windows::runtime::Abi for YxyCOLOR {
3554     type Abi = Self;
3555     type DefaultType = Self;
3556 }
3557