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