f0c40877a17456c99ad4cd485e5a9d89e0b4ec26
[reactos.git] / dll / win32 / mscms / profile.c
1 /*
2 * MSCMS - Color Management System for Wine
3 *
4 * Copyright 2004, 2005, 2006, 2008 Hans Leidekker
5 *
6 * This library is free software; you can redistribute it and/or
7 * modify it under the terms of the GNU Lesser General Public
8 * License as published by the Free Software Foundation; either
9 * version 2.1 of the License, or (at your option) any later version.
10 *
11 * This library is distributed in the hope that it will be useful,
12 * but WITHOUT ANY WARRANTY; without even the implied warranty of
13 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
14 * Lesser General Public License for more details.
15 *
16 * You should have received a copy of the GNU Lesser General Public
17 * License along with this library; if not, write to the Free Software
18 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
19 */
20
21 #include "config.h"
22 #include "wine/debug.h"
23 #include "wine/unicode.h"
24
25 #include <stdarg.h>
26
27 #include "windef.h"
28 #include "winbase.h"
29 #include "winnls.h"
30 #include "wingdi.h"
31 #include "winuser.h"
32 #include "winreg.h"
33 #include "shlwapi.h"
34 #include "icm.h"
35
36 #include "mscms_priv.h"
37
38 static void basename( LPCWSTR path, LPWSTR name )
39 {
40 INT i = lstrlenW( path );
41
42 while (i > 0 && path[i - 1] != '\\' && path[i - 1] != '/') i--;
43 lstrcpyW( name, &path[i] );
44 }
45
46 static inline LPWSTR strdupW( LPCSTR str )
47 {
48 LPWSTR ret = NULL;
49 if (str)
50 {
51 DWORD len = MultiByteToWideChar( CP_ACP, 0, str, -1, NULL, 0 );
52 if ((ret = HeapAlloc( GetProcessHeap(), 0, len * sizeof(WCHAR) )))
53 MultiByteToWideChar( CP_ACP, 0, str, -1, ret, len );
54 }
55 return ret;
56 }
57
58 const char *dbgstr_tag( DWORD tag )
59 {
60 return wine_dbg_sprintf( "'%c%c%c%c'",
61 (char)(tag >> 24), (char)(tag >> 16), (char)(tag >> 8), (char)(tag) );
62 }
63
64 WINE_DEFAULT_DEBUG_CHANNEL(mscms);
65
66 /******************************************************************************
67 * AssociateColorProfileWithDeviceA [MSCMS.@]
68 */
69 BOOL WINAPI AssociateColorProfileWithDeviceA( PCSTR machine, PCSTR profile, PCSTR device )
70 {
71 int len;
72 BOOL ret = FALSE;
73 WCHAR *profileW, *deviceW;
74
75 TRACE( "( %s, %s, %s )\n", debugstr_a(machine), debugstr_a(profile), debugstr_a(device) );
76
77 if (!profile || !device)
78 {
79 SetLastError( ERROR_INVALID_PARAMETER );
80 return FALSE;
81 }
82 if (machine)
83 {
84 SetLastError( ERROR_NOT_SUPPORTED );
85 return FALSE;
86 }
87
88 len = MultiByteToWideChar( CP_ACP, 0, profile, -1, NULL, 0 );
89 if (!(profileW = HeapAlloc( GetProcessHeap(), 0, len * sizeof(WCHAR) ))) return FALSE;
90
91 MultiByteToWideChar( CP_ACP, 0, profile, -1, profileW, len );
92
93 len = MultiByteToWideChar( CP_ACP, 0, device, -1, NULL, 0 );
94 if ((deviceW = HeapAlloc( GetProcessHeap(), 0, len * sizeof(WCHAR) )))
95 {
96 MultiByteToWideChar( CP_ACP, 0, device, -1, deviceW, len );
97 ret = AssociateColorProfileWithDeviceW( NULL, profileW, deviceW );
98 }
99
100 HeapFree( GetProcessHeap(), 0, profileW );
101 HeapFree( GetProcessHeap(), 0, deviceW );
102 return ret;
103 }
104
105 static BOOL set_profile_device_key( PCWSTR file, const BYTE *value, DWORD size )
106 {
107 static const WCHAR fmtW[] = {'%','c','%','c','%','c','%','c',0};
108 static const WCHAR icmW[] = {'S','o','f','t','w','a','r','e','\\',
109 'M','i','c','r','o','s','o','f','t','\\',
110 'W','i','n','d','o','w','s',' ','N','T','\\',
111 'C','u','r','r','e','n','t','V','e','r','s','i','o','n','\\',
112 'I','C','M',0};
113 PROFILEHEADER header;
114 PROFILE profile;
115 HPROFILE handle;
116 HKEY icm_key, class_key;
117 WCHAR basenameW[MAX_PATH], classW[5];
118
119 profile.dwType = PROFILE_FILENAME;
120 profile.pProfileData = (PVOID)file;
121 profile.cbDataSize = (lstrlenW( file ) + 1) * sizeof(WCHAR);
122
123 /* FIXME is the profile installed? */
124 if (!(handle = OpenColorProfileW( &profile, PROFILE_READ, 0, OPEN_EXISTING )))
125 {
126 SetLastError( ERROR_INVALID_PROFILE );
127 return FALSE;
128 }
129 if (!GetColorProfileHeader( handle, &header ))
130 {
131 CloseColorProfile( handle );
132 SetLastError( ERROR_INVALID_PROFILE );
133 return FALSE;
134 }
135 RegCreateKeyExW( HKEY_LOCAL_MACHINE, icmW, 0, NULL, 0, KEY_ALL_ACCESS, NULL, &icm_key, NULL );
136
137 basename( file, basenameW );
138 sprintfW( classW, fmtW, (header.phClass >> 24) & 0xff, (header.phClass >> 16) & 0xff,
139 (header.phClass >> 8) & 0xff, header.phClass & 0xff );
140
141 RegCreateKeyExW( icm_key, classW, 0, NULL, 0, KEY_ALL_ACCESS, NULL, &class_key, NULL );
142 if (value) RegSetValueExW( class_key, basenameW, 0, REG_BINARY, value, size );
143 else RegDeleteValueW( class_key, basenameW );
144
145 RegCloseKey( class_key );
146 RegCloseKey( icm_key );
147 CloseColorProfile( handle );
148 return TRUE;
149 }
150
151 /******************************************************************************
152 * AssociateColorProfileWithDeviceW [MSCMS.@]
153 */
154 BOOL WINAPI AssociateColorProfileWithDeviceW( PCWSTR machine, PCWSTR profile, PCWSTR device )
155 {
156 static const BYTE dummy_value[12];
157
158 TRACE( "( %s, %s, %s )\n", debugstr_w(machine), debugstr_w(profile), debugstr_w(device) );
159
160 if (!profile || !device)
161 {
162 SetLastError( ERROR_INVALID_PARAMETER );
163 return FALSE;
164 }
165 if (machine)
166 {
167 SetLastError( ERROR_NOT_SUPPORTED );
168 return FALSE;
169 }
170
171 return set_profile_device_key( profile, dummy_value, sizeof(dummy_value) );
172 }
173
174 /******************************************************************************
175 * DisassociateColorProfileFromDeviceA [MSCMS.@]
176 */
177 BOOL WINAPI DisassociateColorProfileFromDeviceA( PCSTR machine, PCSTR profile, PCSTR device )
178 {
179 int len;
180 BOOL ret = FALSE;
181 WCHAR *profileW, *deviceW;
182
183 TRACE( "( %s, %s, %s )\n", debugstr_a(machine), debugstr_a(profile), debugstr_a(device) );
184
185 if (!profile || !device)
186 {
187 SetLastError( ERROR_INVALID_PARAMETER );
188 return FALSE;
189 }
190 if (machine)
191 {
192 SetLastError( ERROR_NOT_SUPPORTED );
193 return FALSE;
194 }
195
196 len = MultiByteToWideChar( CP_ACP, 0, profile, -1, NULL, 0 );
197 if (!(profileW = HeapAlloc( GetProcessHeap(), 0, len * sizeof(WCHAR) ))) return FALSE;
198
199 MultiByteToWideChar( CP_ACP, 0, profile, -1, profileW, len );
200
201 len = MultiByteToWideChar( CP_ACP, 0, device, -1, NULL, 0 );
202 if ((deviceW = HeapAlloc( GetProcessHeap(), 0, len * sizeof(WCHAR) )))
203 {
204 MultiByteToWideChar( CP_ACP, 0, device, -1, deviceW, len );
205 ret = DisassociateColorProfileFromDeviceW( NULL, profileW, deviceW );
206 }
207
208 HeapFree( GetProcessHeap(), 0, profileW );
209 HeapFree( GetProcessHeap(), 0, deviceW );
210 return ret;
211 }
212
213 /******************************************************************************
214 * DisassociateColorProfileFromDeviceW [MSCMS.@]
215 */
216 BOOL WINAPI DisassociateColorProfileFromDeviceW( PCWSTR machine, PCWSTR profile, PCWSTR device )
217 {
218 TRACE( "( %s, %s, %s )\n", debugstr_w(machine), debugstr_w(profile), debugstr_w(device) );
219
220 if (!profile || !device)
221 {
222 SetLastError( ERROR_INVALID_PARAMETER );
223 return FALSE;
224 }
225 if (machine)
226 {
227 SetLastError( ERROR_NOT_SUPPORTED );
228 return FALSE;
229 }
230
231 return set_profile_device_key( profile, NULL, 0 );
232 }
233
234 /******************************************************************************
235 * GetColorDirectoryA [MSCMS.@]
236 *
237 * See GetColorDirectoryW.
238 */
239 BOOL WINAPI GetColorDirectoryA( PCSTR machine, PSTR buffer, PDWORD size )
240 {
241 INT len;
242 LPWSTR bufferW;
243 BOOL ret = FALSE;
244 DWORD sizeW;
245
246 TRACE( "( %p, %p )\n", buffer, size );
247
248 if (machine || !size) return FALSE;
249
250 if (!buffer)
251 {
252 ret = GetColorDirectoryW( NULL, NULL, &sizeW );
253 *size = sizeW / sizeof(WCHAR);
254 return ret;
255 }
256
257 sizeW = *size * sizeof(WCHAR);
258
259 bufferW = HeapAlloc( GetProcessHeap(), 0, sizeW );
260 if (bufferW)
261 {
262 if ((ret = GetColorDirectoryW( NULL, bufferW, &sizeW )))
263 {
264 *size = WideCharToMultiByte( CP_ACP, 0, bufferW, -1, NULL, 0, NULL, NULL );
265 len = WideCharToMultiByte( CP_ACP, 0, bufferW, -1, buffer, *size, NULL, NULL );
266 if (!len) ret = FALSE;
267 }
268 else *size = sizeW / sizeof(WCHAR);
269
270 HeapFree( GetProcessHeap(), 0, bufferW );
271 }
272 return ret;
273 }
274
275 /******************************************************************************
276 * GetColorDirectoryW [MSCMS.@]
277 *
278 * Get the directory where color profiles are stored.
279 *
280 * PARAMS
281 * machine [I] Name of the machine for which to get the color directory.
282 * Must be NULL, which indicates the local machine.
283 * buffer [I] Buffer to receive the path name.
284 * size [I/O] Size of the buffer in bytes. On return the variable holds
285 * the number of bytes actually needed.
286 */
287 BOOL WINAPI GetColorDirectoryW( PCWSTR machine, PWSTR buffer, PDWORD size )
288 {
289 WCHAR colordir[MAX_PATH];
290 static const WCHAR colorsubdir[] =
291 {'\\','s','p','o','o','l','\\','d','r','i','v','e','r','s','\\','c','o','l','o','r',0};
292 DWORD len;
293
294 TRACE( "( %p, %p )\n", buffer, size );
295
296 if (machine || !size) return FALSE;
297
298 GetSystemDirectoryW( colordir, sizeof(colordir) / sizeof(WCHAR) );
299 lstrcatW( colordir, colorsubdir );
300
301 len = lstrlenW( colordir ) * sizeof(WCHAR);
302
303 if (buffer && len <= *size)
304 {
305 lstrcpyW( buffer, colordir );
306 *size = len;
307 return TRUE;
308 }
309
310 SetLastError( ERROR_MORE_DATA );
311 *size = len;
312 return FALSE;
313 }
314
315 /******************************************************************************
316 * GetColorProfileElement [MSCMS.@]
317 *
318 * Retrieve data for a specified tag type.
319 *
320 * PARAMS
321 * profile [I] Handle to a color profile.
322 * type [I] ICC tag type.
323 * offset [I] Offset in bytes to start copying from.
324 * size [I/O] Size of the buffer in bytes. On return the variable holds
325 * the number of bytes actually needed.
326 * buffer [O] Buffer to receive the tag data.
327 * ref [O] Pointer to a BOOL that specifies whether more than one tag
328 * references the data.
329 *
330 * RETURNS
331 * Success: TRUE
332 * Failure: FALSE
333 */
334 BOOL WINAPI GetColorProfileElement( HPROFILE handle, TAGTYPE type, DWORD offset, PDWORD size,
335 PVOID buffer, PBOOL ref )
336 {
337 BOOL ret = FALSE;
338 #ifdef HAVE_LCMS2
339 struct profile *profile = grab_profile( handle );
340
341 TRACE( "( %p, 0x%08x, %d, %p, %p, %p )\n", handle, type, offset, size, buffer, ref );
342
343 if (!profile) return FALSE;
344
345 if (!size || !ref)
346 {
347 release_profile( profile );
348 return FALSE;
349 }
350 if (!get_tag_data( profile, type, offset, buffer, size ))
351 {
352 release_profile( profile );
353 return FALSE;
354 }
355 ret = get_tag_data( profile, type, offset, buffer, size );
356 *ref = cmsTagLinkedTo( profile->cmsprofile, type ) != 0;
357 release_profile( profile );
358 #endif /* HAVE_LCMS2 */
359 return ret;
360 }
361
362 /******************************************************************************
363 * GetColorProfileElementTag [MSCMS.@]
364 *
365 * Get the tag type from a color profile by index.
366 *
367 * PARAMS
368 * profile [I] Handle to a color profile.
369 * index [I] Index into the tag table of the color profile.
370 * type [O] Pointer to a variable that holds the ICC tag type on return.
371 *
372 * RETURNS
373 * Success: TRUE
374 * Failure: FALSE
375 *
376 * NOTES
377 * The tag table index starts at 1.
378 * Use GetCountColorProfileElements to retrieve a count of tagged elements.
379 */
380 BOOL WINAPI GetColorProfileElementTag( HPROFILE handle, DWORD index, PTAGTYPE type )
381 {
382 BOOL ret = FALSE;
383 #ifdef HAVE_LCMS2
384 struct profile *profile = grab_profile( handle );
385 cmsInt32Number num_tags;
386 cmsTagSignature sig;
387
388 TRACE( "( %p, %d, %p )\n", handle, index, type );
389
390 if (!profile) return FALSE;
391
392 if (!type)
393 {
394 release_profile( profile );
395 return FALSE;
396 }
397 num_tags = cmsGetTagCount( profile->cmsprofile );
398 if (num_tags < 0 || index > num_tags || index < 1)
399 {
400 release_profile( profile );
401 return FALSE;
402 }
403 if ((sig = cmsGetTagSignature( profile->cmsprofile, index - 1 )))
404 {
405 *type = sig;
406 ret = TRUE;
407 }
408 release_profile( profile );
409
410 #endif /* HAVE_LCMS2 */
411 return ret;
412 }
413
414 /******************************************************************************
415 * GetColorProfileFromHandle [MSCMS.@]
416 *
417 * Retrieve an ICC color profile by handle.
418 *
419 * PARAMS
420 * profile [I] Handle to a color profile.
421 * buffer [O] Buffer to receive the ICC profile.
422 * size [I/O] Size of the buffer in bytes. On return the variable holds the
423 * number of bytes actually needed.
424 *
425 * RETURNS
426 * Success: TRUE
427 * Failure: FALSE
428 *
429 * NOTES
430 * The profile returned will be in big-endian format.
431 */
432 BOOL WINAPI GetColorProfileFromHandle( HPROFILE handle, PBYTE buffer, PDWORD size )
433 {
434 BOOL ret = FALSE;
435 #ifdef HAVE_LCMS2
436 struct profile *profile = grab_profile( handle );
437 PROFILEHEADER header;
438
439 TRACE( "( %p, %p, %p )\n", handle, buffer, size );
440
441 if (!profile) return FALSE;
442
443 if (!size)
444 {
445 release_profile( profile );
446 return FALSE;
447 }
448 get_profile_header( profile, &header );
449
450 if (!buffer || header.phSize > *size)
451 {
452 *size = header.phSize;
453 release_profile( profile );
454 return FALSE;
455 }
456
457 /* No endian conversion needed */
458 memcpy( buffer, profile->data, profile->size );
459 *size = profile->size;
460
461 release_profile( profile );
462 ret = TRUE;
463
464 #endif /* HAVE_LCMS2 */
465 return ret;
466 }
467
468 /******************************************************************************
469 * GetColorProfileHeader [MSCMS.@]
470 *
471 * Retrieve a color profile header by handle.
472 *
473 * PARAMS
474 * profile [I] Handle to a color profile.
475 * header [O] Buffer to receive the ICC profile header.
476 *
477 * RETURNS
478 * Success: TRUE
479 * Failure: FALSE
480 *
481 * NOTES
482 * The profile header returned will be adjusted for endianness.
483 */
484 BOOL WINAPI GetColorProfileHeader( HPROFILE handle, PPROFILEHEADER header )
485 {
486 #ifdef HAVE_LCMS2
487 struct profile *profile = grab_profile( handle );
488
489 TRACE( "( %p, %p )\n", handle, header );
490
491 if (!profile) return FALSE;
492
493 if (!header)
494 {
495 release_profile( profile );
496 return FALSE;
497 }
498 get_profile_header( profile, header );
499 release_profile( profile );
500 return TRUE;
501
502 #else
503 return FALSE;
504 #endif /* HAVE_LCMS2 */
505 }
506
507 /******************************************************************************
508 * GetCountColorProfileElements [MSCMS.@]
509 *
510 * Retrieve the number of elements in a color profile.
511 *
512 * PARAMS
513 * profile [I] Handle to a color profile.
514 * count [O] Pointer to a variable which is set to the number of elements
515 * in the color profile.
516 *
517 * RETURNS
518 * Success: TRUE
519 * Failure: FALSE
520 */
521 BOOL WINAPI GetCountColorProfileElements( HPROFILE handle, PDWORD count )
522 {
523 BOOL ret = FALSE;
524 #ifdef HAVE_LCMS2
525 struct profile *profile = grab_profile( handle );
526 cmsInt32Number num_tags;
527
528 TRACE( "( %p, %p )\n", handle, count );
529
530 if (!profile) return FALSE;
531
532 if (!count)
533 {
534 release_profile( profile );
535 return FALSE;
536 }
537 if ((num_tags = cmsGetTagCount( profile->cmsprofile )) >= 0)
538 {
539 *count = num_tags;
540 ret = TRUE;
541 }
542 release_profile( profile );
543
544 #endif /* HAVE_LCMS2 */
545 return ret;
546 }
547
548 /******************************************************************************
549 * GetStandardColorSpaceProfileA [MSCMS.@]
550 *
551 * See GetStandardColorSpaceProfileW.
552 */
553 BOOL WINAPI GetStandardColorSpaceProfileA( PCSTR machine, DWORD id, PSTR profile, PDWORD size )
554 {
555 INT len;
556 LPWSTR profileW;
557 BOOL ret = FALSE;
558 DWORD sizeW;
559
560 TRACE( "( 0x%08x, %p, %p )\n", id, profile, size );
561
562 if (machine)
563 {
564 SetLastError( ERROR_NOT_SUPPORTED );
565 return FALSE;
566 }
567
568 if (!size)
569 {
570 SetLastError( ERROR_INVALID_PARAMETER );
571 return FALSE;
572 }
573
574 sizeW = *size * sizeof(WCHAR);
575
576 if (!profile)
577 {
578 ret = GetStandardColorSpaceProfileW( NULL, id, NULL, &sizeW );
579 *size = sizeW / sizeof(WCHAR);
580 return ret;
581 }
582
583 profileW = HeapAlloc( GetProcessHeap(), 0, sizeW );
584 if (profileW)
585 {
586 if ((ret = GetStandardColorSpaceProfileW( NULL, id, profileW, &sizeW )))
587 {
588 *size = WideCharToMultiByte( CP_ACP, 0, profileW, -1, NULL, 0, NULL, NULL );
589 len = WideCharToMultiByte( CP_ACP, 0, profileW, -1, profile, *size, NULL, NULL );
590 if (!len) ret = FALSE;
591 }
592 else *size = sizeW / sizeof(WCHAR);
593
594 HeapFree( GetProcessHeap(), 0, profileW );
595 }
596 return ret;
597 }
598
599 /******************************************************************************
600 * GetStandardColorSpaceProfileW [MSCMS.@]
601 *
602 * Retrieve the profile filename for a given standard color space id.
603 *
604 * PARAMS
605 * machine [I] Name of the machine for which to get the standard color space.
606 * Must be NULL, which indicates the local machine.
607 * id [I] Id of a standard color space.
608 * profile [O] Buffer to receive the profile filename.
609 * size [I/O] Size of the filename buffer in bytes.
610 *
611 * RETURNS
612 * Success: TRUE
613 * Failure: FALSE
614 */
615 BOOL WINAPI GetStandardColorSpaceProfileW( PCWSTR machine, DWORD id, PWSTR profile, PDWORD size )
616 {
617 static const WCHAR rgbprofilefile[] =
618 { '\\','s','r','g','b',' ','c','o','l','o','r',' ',
619 's','p','a','c','e',' ','p','r','o','f','i','l','e','.','i','c','m',0 };
620 WCHAR rgbprofile[MAX_PATH];
621 DWORD len = sizeof(rgbprofile);
622
623 TRACE( "( 0x%08x, %p, %p )\n", id, profile, size );
624
625 if (machine)
626 {
627 SetLastError( ERROR_NOT_SUPPORTED );
628 return FALSE;
629 }
630
631 if (!size)
632 {
633 SetLastError( ERROR_INVALID_PARAMETER );
634 return FALSE;
635 }
636
637 if (!profile)
638 {
639 SetLastError( ERROR_INSUFFICIENT_BUFFER );
640 return FALSE;
641 }
642
643 GetColorDirectoryW( machine, rgbprofile, &len );
644
645 switch (id)
646 {
647 case LCS_sRGB:
648 case LCS_WINDOWS_COLOR_SPACE: /* FIXME */
649 lstrcatW( rgbprofile, rgbprofilefile );
650 len = lstrlenW( rgbprofile ) * sizeof(WCHAR);
651
652 if (*size < len)
653 {
654 *size = len;
655 SetLastError( ERROR_MORE_DATA );
656 return FALSE;
657 }
658
659 lstrcpyW( profile, rgbprofile );
660 break;
661
662 default:
663 SetLastError( ERROR_FILE_NOT_FOUND );
664 return FALSE;
665 }
666 return TRUE;
667 }
668
669 static BOOL header_from_file( LPCWSTR file, PPROFILEHEADER header )
670 {
671 BOOL ret;
672 PROFILE profile;
673 WCHAR path[MAX_PATH], slash[] = {'\\',0};
674 DWORD size = sizeof(path);
675 HANDLE handle;
676
677 ret = GetColorDirectoryW( NULL, path, &size );
678 if (!ret)
679 {
680 WARN( "Can't retrieve color directory\n" );
681 return FALSE;
682 }
683 if (size + sizeof(slash) + sizeof(WCHAR) * lstrlenW( file ) > sizeof(path))
684 {
685 WARN( "Filename too long\n" );
686 return FALSE;
687 }
688
689 lstrcatW( path, slash );
690 lstrcatW( path, file );
691
692 profile.dwType = PROFILE_FILENAME;
693 profile.pProfileData = path;
694 profile.cbDataSize = lstrlenW( path ) + 1;
695
696 handle = OpenColorProfileW( &profile, PROFILE_READ, FILE_SHARE_READ, OPEN_EXISTING );
697 if (!handle)
698 {
699 WARN( "Can't open color profile\n" );
700 return FALSE;
701 }
702
703 ret = GetColorProfileHeader( handle, header );
704 if (!ret)
705 WARN( "Can't retrieve color profile header\n" );
706
707 CloseColorProfile( handle );
708 return ret;
709 }
710
711 static BOOL match_profile( PENUMTYPEW rec, PPROFILEHEADER hdr )
712 {
713 if (rec->dwFields & ET_DEVICENAME)
714 {
715 FIXME( "ET_DEVICENAME: %s\n", debugstr_w(rec->pDeviceName) );
716 }
717 if (rec->dwFields & ET_MEDIATYPE)
718 {
719 FIXME( "ET_MEDIATYPE: 0x%08x\n", rec->dwMediaType );
720 }
721 if (rec->dwFields & ET_DITHERMODE)
722 {
723 FIXME( "ET_DITHERMODE: 0x%08x\n", rec->dwDitheringMode );
724 }
725 if (rec->dwFields & ET_RESOLUTION)
726 {
727 FIXME( "ET_RESOLUTION: 0x%08x, 0x%08x\n",
728 rec->dwResolution[0], rec->dwResolution[1] );
729 }
730 if (rec->dwFields & ET_DEVICECLASS)
731 {
732 FIXME( "ET_DEVICECLASS: %s\n", dbgstr_tag(rec->dwMediaType) );
733 }
734 if (rec->dwFields & ET_CMMTYPE)
735 {
736 TRACE( "ET_CMMTYPE: %s\n", dbgstr_tag(rec->dwCMMType) );
737 if (rec->dwCMMType != hdr->phCMMType) return FALSE;
738 }
739 if (rec->dwFields & ET_CLASS)
740 {
741 TRACE( "ET_CLASS: %s\n", dbgstr_tag(rec->dwClass) );
742 if (rec->dwClass != hdr->phClass) return FALSE;
743 }
744 if (rec->dwFields & ET_DATACOLORSPACE)
745 {
746 TRACE( "ET_DATACOLORSPACE: %s\n", dbgstr_tag(rec->dwDataColorSpace) );
747 if (rec->dwDataColorSpace != hdr->phDataColorSpace) return FALSE;
748 }
749 if (rec->dwFields & ET_CONNECTIONSPACE)
750 {
751 TRACE( "ET_CONNECTIONSPACE: %s\n", dbgstr_tag(rec->dwConnectionSpace) );
752 if (rec->dwConnectionSpace != hdr->phConnectionSpace) return FALSE;
753 }
754 if (rec->dwFields & ET_SIGNATURE)
755 {
756 TRACE( "ET_SIGNATURE: %s\n", dbgstr_tag(rec->dwSignature) );
757 if (rec->dwSignature != hdr->phSignature) return FALSE;
758 }
759 if (rec->dwFields & ET_PLATFORM)
760 {
761 TRACE( "ET_PLATFORM: %s\n", dbgstr_tag(rec->dwPlatform) );
762 if (rec->dwPlatform != hdr->phPlatform) return FALSE;
763 }
764 if (rec->dwFields & ET_PROFILEFLAGS)
765 {
766 TRACE( "ET_PROFILEFLAGS: 0x%08x\n", rec->dwProfileFlags );
767 if (rec->dwProfileFlags != hdr->phProfileFlags) return FALSE;
768 }
769 if (rec->dwFields & ET_MANUFACTURER)
770 {
771 TRACE( "ET_MANUFACTURER: %s\n", dbgstr_tag(rec->dwManufacturer) );
772 if (rec->dwManufacturer != hdr->phManufacturer) return FALSE;
773 }
774 if (rec->dwFields & ET_MODEL)
775 {
776 TRACE( "ET_MODEL: %s\n", dbgstr_tag(rec->dwModel) );
777 if (rec->dwModel != hdr->phModel) return FALSE;
778 }
779 if (rec->dwFields & ET_ATTRIBUTES)
780 {
781 TRACE( "ET_ATTRIBUTES: 0x%08x, 0x%08x\n",
782 rec->dwAttributes[0], rec->dwAttributes[1] );
783 if (rec->dwAttributes[0] != hdr->phAttributes[0] ||
784 rec->dwAttributes[1] != hdr->phAttributes[1]) return FALSE;
785 }
786 if (rec->dwFields & ET_RENDERINGINTENT)
787 {
788 TRACE( "ET_RENDERINGINTENT: 0x%08x\n", rec->dwRenderingIntent );
789 if (rec->dwRenderingIntent != hdr->phRenderingIntent) return FALSE;
790 }
791 if (rec->dwFields & ET_CREATOR)
792 {
793 TRACE( "ET_CREATOR: %s\n", dbgstr_tag(rec->dwCreator) );
794 if (rec->dwCreator != hdr->phCreator) return FALSE;
795 }
796 return TRUE;
797 }
798
799 /******************************************************************************
800 * EnumColorProfilesA [MSCMS.@]
801 *
802 * See EnumColorProfilesW.
803 */
804 BOOL WINAPI EnumColorProfilesA( PCSTR machine, PENUMTYPEA record, PBYTE buffer,
805 PDWORD size, PDWORD number )
806 {
807 BOOL match, ret = FALSE;
808 char spec[] = "\\*.icm";
809 char colordir[MAX_PATH], glob[MAX_PATH], **profiles = NULL;
810 DWORD i, len = sizeof(colordir), count = 0, totalsize = 0;
811 PROFILEHEADER header;
812 WIN32_FIND_DATAA data;
813 ENUMTYPEW recordW;
814 WCHAR *fileW = NULL, *deviceW = NULL;
815 HANDLE find;
816
817 TRACE( "( %p, %p, %p, %p, %p )\n", machine, record, buffer, size, number );
818
819 if (machine || !record || !size ||
820 record->dwSize != sizeof(ENUMTYPEA) ||
821 record->dwVersion != ENUM_TYPE_VERSION) return FALSE;
822
823 ret = GetColorDirectoryA( machine, colordir, &len );
824 if (!ret || len + sizeof(spec) > MAX_PATH)
825 {
826 WARN( "can't retrieve color directory\n" );
827 return FALSE;
828 }
829
830 lstrcpyA( glob, colordir );
831 lstrcatA( glob, spec );
832
833 find = FindFirstFileA( glob, &data );
834 if (find == INVALID_HANDLE_VALUE) return FALSE;
835
836 profiles = HeapAlloc( GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(char *) + 1 );
837 if (!profiles) goto exit;
838
839 memcpy( &recordW, record, sizeof(ENUMTYPEA) );
840 if (record->pDeviceName)
841 {
842 deviceW = strdupW( record->pDeviceName );
843 if (!(recordW.pDeviceName = deviceW)) goto exit;
844 }
845
846 fileW = strdupW( data.cFileName );
847 if (!fileW) goto exit;
848
849 ret = header_from_file( fileW, &header );
850 if (ret)
851 {
852 match = match_profile( &recordW, &header );
853 if (match)
854 {
855 len = sizeof(char) * (lstrlenA( data.cFileName ) + 1);
856 profiles[count] = HeapAlloc( GetProcessHeap(), 0, len );
857
858 if (!profiles[count]) goto exit;
859 else
860 {
861 TRACE( "matching profile: %s\n", debugstr_a(data.cFileName) );
862 lstrcpyA( profiles[count], data.cFileName );
863 totalsize += len;
864 count++;
865 }
866 }
867 }
868 HeapFree( GetProcessHeap(), 0, fileW );
869 fileW = NULL;
870
871 while (FindNextFileA( find, &data ))
872 {
873 fileW = strdupW( data.cFileName );
874 if (!fileW) goto exit;
875
876 ret = header_from_file( fileW, &header );
877 if (!ret)
878 {
879 HeapFree( GetProcessHeap(), 0, fileW );
880 continue;
881 }
882
883 match = match_profile( &recordW, &header );
884 if (match)
885 {
886 char **tmp = HeapReAlloc( GetProcessHeap(), HEAP_ZERO_MEMORY,
887 profiles, sizeof(char *) * (count + 1) );
888 if (!tmp) goto exit;
889 else profiles = tmp;
890
891 len = sizeof(char) * (lstrlenA( data.cFileName ) + 1);
892 profiles[count] = HeapAlloc( GetProcessHeap(), 0, len );
893
894 if (!profiles[count]) goto exit;
895 else
896 {
897 TRACE( "matching profile: %s\n", debugstr_a(data.cFileName) );
898 lstrcpyA( profiles[count], data.cFileName );
899 totalsize += len;
900 count++;
901 }
902 }
903 HeapFree( GetProcessHeap(), 0, fileW );
904 fileW = NULL;
905 }
906
907 totalsize++;
908 if (buffer && *size >= totalsize)
909 {
910 char *p = (char *)buffer;
911
912 for (i = 0; i < count; i++)
913 {
914 lstrcpyA( p, profiles[i] );
915 p += lstrlenA( profiles[i] ) + 1;
916 }
917 *p = 0;
918 ret = TRUE;
919 }
920 else ret = FALSE;
921
922 *size = totalsize;
923 if (number) *number = count;
924
925 exit:
926 for (i = 0; i < count; i++)
927 HeapFree( GetProcessHeap(), 0, profiles[i] );
928 HeapFree( GetProcessHeap(), 0, profiles );
929 HeapFree( GetProcessHeap(), 0, deviceW );
930 HeapFree( GetProcessHeap(), 0, fileW );
931 FindClose( find );
932
933 return ret;
934 }
935
936 /******************************************************************************
937 * EnumColorProfilesW [MSCMS.@]
938 *
939 * Enumerate profiles that match given criteria.
940 *
941 * PARAMS
942 * machine [I] Name of the machine for which to enumerate profiles.
943 * Must be NULL, which indicates the local machine.
944 * record [I] Record of criteria that a profile must match.
945 * buffer [O] Buffer to receive a string array of profile filenames.
946 * size [I/O] Size of the filename buffer in bytes.
947 * number [O] Number of filenames copied into buffer.
948 *
949 * RETURNS
950 * Success: TRUE
951 * Failure: FALSE
952 */
953 BOOL WINAPI EnumColorProfilesW( PCWSTR machine, PENUMTYPEW record, PBYTE buffer,
954 PDWORD size, PDWORD number )
955 {
956 BOOL match, ret = FALSE;
957 WCHAR spec[] = {'\\','*','i','c','m',0};
958 WCHAR colordir[MAX_PATH], glob[MAX_PATH], **profiles = NULL;
959 DWORD i, len = sizeof(colordir), count = 0, totalsize = 0;
960 PROFILEHEADER header;
961 WIN32_FIND_DATAW data;
962 HANDLE find;
963
964 TRACE( "( %p, %p, %p, %p, %p )\n", machine, record, buffer, size, number );
965
966 if (machine || !record || !size ||
967 record->dwSize != sizeof(ENUMTYPEW) ||
968 record->dwVersion != ENUM_TYPE_VERSION) return FALSE;
969
970 ret = GetColorDirectoryW( machine, colordir, &len );
971 if (!ret || len + sizeof(spec) > MAX_PATH)
972 {
973 WARN( "Can't retrieve color directory\n" );
974 return FALSE;
975 }
976
977 lstrcpyW( glob, colordir );
978 lstrcatW( glob, spec );
979
980 find = FindFirstFileW( glob, &data );
981 if (find == INVALID_HANDLE_VALUE) return FALSE;
982
983 profiles = HeapAlloc( GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(WCHAR *) + 1 );
984 if (!profiles) goto exit;
985
986 ret = header_from_file( data.cFileName, &header );
987 if (ret)
988 {
989 match = match_profile( record, &header );
990 if (match)
991 {
992 len = sizeof(WCHAR) * (lstrlenW( data.cFileName ) + 1);
993 profiles[count] = HeapAlloc( GetProcessHeap(), 0, len );
994
995 if (!profiles[count]) goto exit;
996 else
997 {
998 TRACE( "matching profile: %s\n", debugstr_w(data.cFileName) );
999 lstrcpyW( profiles[count], data.cFileName );
1000 totalsize += len;
1001 count++;
1002 }
1003 }
1004 }
1005
1006 while (FindNextFileW( find, &data ))
1007 {
1008 ret = header_from_file( data.cFileName, &header );
1009 if (!ret) continue;
1010
1011 match = match_profile( record, &header );
1012 if (match)
1013 {
1014 WCHAR **tmp = HeapReAlloc( GetProcessHeap(), HEAP_ZERO_MEMORY,
1015 profiles, sizeof(WCHAR *) * (count + 1) );
1016 if (!tmp) goto exit;
1017 else profiles = tmp;
1018
1019 len = sizeof(WCHAR) * (lstrlenW( data.cFileName ) + 1);
1020 profiles[count] = HeapAlloc( GetProcessHeap(), 0, len );
1021
1022 if (!profiles[count]) goto exit;
1023 else
1024 {
1025 TRACE( "matching profile: %s\n", debugstr_w(data.cFileName) );
1026 lstrcpyW( profiles[count], data.cFileName );
1027 totalsize += len;
1028 count++;
1029 }
1030 }
1031 }
1032
1033 totalsize++;
1034 if (buffer && *size >= totalsize)
1035 {
1036 WCHAR *p = (WCHAR *)buffer;
1037
1038 for (i = 0; i < count; i++)
1039 {
1040 lstrcpyW( p, profiles[i] );
1041 p += lstrlenW( profiles[i] ) + 1;
1042 }
1043 *p = 0;
1044 ret = TRUE;
1045 }
1046 else ret = FALSE;
1047
1048 *size = totalsize;
1049 if (number) *number = count;
1050
1051 exit:
1052 for (i = 0; i < count; i++)
1053 HeapFree( GetProcessHeap(), 0, profiles[i] );
1054 HeapFree( GetProcessHeap(), 0, profiles );
1055 FindClose( find );
1056
1057 return ret;
1058 }
1059
1060 /******************************************************************************
1061 * InstallColorProfileA [MSCMS.@]
1062 *
1063 * See InstallColorProfileW.
1064 */
1065 BOOL WINAPI InstallColorProfileA( PCSTR machine, PCSTR profile )
1066 {
1067 UINT len;
1068 LPWSTR profileW;
1069 BOOL ret = FALSE;
1070
1071 TRACE( "( %s )\n", debugstr_a(profile) );
1072
1073 if (machine || !profile) return FALSE;
1074
1075 len = MultiByteToWideChar( CP_ACP, 0, profile, -1, NULL, 0 );
1076 profileW = HeapAlloc( GetProcessHeap(), 0, len * sizeof(WCHAR) );
1077
1078 if (profileW)
1079 {
1080 MultiByteToWideChar( CP_ACP, 0, profile, -1, profileW, len );
1081
1082 ret = InstallColorProfileW( NULL, profileW );
1083 HeapFree( GetProcessHeap(), 0, profileW );
1084 }
1085 return ret;
1086 }
1087
1088 /******************************************************************************
1089 * InstallColorProfileW [MSCMS.@]
1090 *
1091 * Install a color profile.
1092 *
1093 * PARAMS
1094 * machine [I] Name of the machine to install the profile on. Must be NULL,
1095 * which indicates the local machine.
1096 * profile [I] Full path name of the profile to install.
1097 *
1098 * RETURNS
1099 * Success: TRUE
1100 * Failure: FALSE
1101 */
1102 BOOL WINAPI InstallColorProfileW( PCWSTR machine, PCWSTR profile )
1103 {
1104 WCHAR dest[MAX_PATH], base[MAX_PATH];
1105 DWORD size = sizeof(dest);
1106 static const WCHAR slash[] = { '\\', 0 };
1107
1108 TRACE( "( %s )\n", debugstr_w(profile) );
1109
1110 if (machine || !profile) return FALSE;
1111
1112 if (!GetColorDirectoryW( machine, dest, &size )) return FALSE;
1113
1114 basename( profile, base );
1115
1116 lstrcatW( dest, slash );
1117 lstrcatW( dest, base );
1118
1119 /* Is source equal to destination? */
1120 if (!lstrcmpW( profile, dest )) return TRUE;
1121
1122 return CopyFileW( profile, dest, TRUE );
1123 }
1124
1125 /******************************************************************************
1126 * IsColorProfileTagPresent [MSCMS.@]
1127 *
1128 * Determine if a given ICC tag type is present in a color profile.
1129 *
1130 * PARAMS
1131 * profile [I] Color profile handle.
1132 * tag [I] ICC tag type.
1133 * present [O] Pointer to a BOOL variable. Set to TRUE if tag type is present,
1134 * FALSE otherwise.
1135 *
1136 * RETURNS
1137 * Success: TRUE
1138 * Failure: FALSE
1139 */
1140 BOOL WINAPI IsColorProfileTagPresent( HPROFILE handle, TAGTYPE type, PBOOL present )
1141 {
1142 BOOL ret = FALSE;
1143 #ifdef HAVE_LCMS2
1144 struct profile *profile = grab_profile( handle );
1145
1146 TRACE( "( %p, 0x%08x, %p )\n", handle, type, present );
1147
1148 if (!profile) return FALSE;
1149
1150 if (!present)
1151 {
1152 release_profile( profile );
1153 return FALSE;
1154 }
1155 *present = (cmsIsTag( profile->cmsprofile, type ) != 0);
1156 release_profile( profile );
1157 ret = TRUE;
1158
1159 #endif /* HAVE_LCMS2 */
1160 return ret;
1161 }
1162
1163 /******************************************************************************
1164 * IsColorProfileValid [MSCMS.@]
1165 *
1166 * Determine if a given color profile is valid.
1167 *
1168 * PARAMS
1169 * profile [I] Color profile handle.
1170 * valid [O] Pointer to a BOOL variable. Set to TRUE if profile is valid,
1171 * FALSE otherwise.
1172 *
1173 * RETURNS
1174 * Success: TRUE
1175 * Failure: FALSE
1176 */
1177 BOOL WINAPI IsColorProfileValid( HPROFILE handle, PBOOL valid )
1178 {
1179 BOOL ret = FALSE;
1180 #ifdef HAVE_LCMS2
1181 struct profile *profile = grab_profile( handle );
1182
1183 TRACE( "( %p, %p )\n", handle, valid );
1184
1185 if (!profile) return FALSE;
1186
1187 if (!valid)
1188 {
1189 release_profile( profile );
1190 return FALSE;
1191 }
1192 if (profile->data) ret = *valid = TRUE;
1193 release_profile( profile );
1194
1195 #endif /* HAVE_LCMS2 */
1196 return ret;
1197 }
1198
1199 /******************************************************************************
1200 * SetColorProfileElement [MSCMS.@]
1201 *
1202 * Set data for a specified tag type.
1203 *
1204 * PARAMS
1205 * profile [I] Handle to a color profile.
1206 * type [I] ICC tag type.
1207 * offset [I] Offset in bytes to start copying to.
1208 * size [I/O] Size of the buffer in bytes. On return the variable holds the
1209 * number of bytes actually needed.
1210 * buffer [O] Buffer holding the tag data.
1211 *
1212 * RETURNS
1213 * Success: TRUE
1214 * Failure: FALSE
1215 */
1216 BOOL WINAPI SetColorProfileElement( HPROFILE handle, TAGTYPE type, DWORD offset, PDWORD size,
1217 PVOID buffer )
1218 {
1219 BOOL ret = FALSE;
1220 #ifdef HAVE_LCMS2
1221 struct profile *profile = grab_profile( handle );
1222
1223 TRACE( "( %p, 0x%08x, %d, %p, %p )\n", handle, type, offset, size, buffer );
1224
1225 if (!profile) return FALSE;
1226
1227 if (!size || !buffer || !(profile->access & PROFILE_READWRITE))
1228 {
1229 release_profile( profile );
1230 return FALSE;
1231 }
1232 ret = set_tag_data( profile, type, offset, buffer, size );
1233 release_profile( profile );
1234 #endif /* HAVE_LCMS2 */
1235 return ret;
1236 }
1237
1238 /******************************************************************************
1239 * SetColorProfileHeader [MSCMS.@]
1240 *
1241 * Set header data for a given profile.
1242 *
1243 * PARAMS
1244 * profile [I] Handle to a color profile.
1245 * header [I] Buffer holding the header data.
1246 *
1247 * RETURNS
1248 * Success: TRUE
1249 * Failure: FALSE
1250 */
1251 BOOL WINAPI SetColorProfileHeader( HPROFILE handle, PPROFILEHEADER header )
1252 {
1253 #ifdef HAVE_LCMS2
1254 struct profile *profile = grab_profile( handle );
1255
1256 TRACE( "( %p, %p )\n", handle, header );
1257
1258 if (!profile) return FALSE;
1259
1260 if (!header || !(profile->access & PROFILE_READWRITE))
1261 {
1262 release_profile( profile );
1263 return FALSE;
1264 }
1265 set_profile_header( profile, header );
1266 release_profile( profile );
1267 return TRUE;
1268
1269 #else
1270 return FALSE;
1271 #endif /* HAVE_LCMS2 */
1272 }
1273
1274 /******************************************************************************
1275 * UninstallColorProfileA [MSCMS.@]
1276 *
1277 * See UninstallColorProfileW.
1278 */
1279 BOOL WINAPI UninstallColorProfileA( PCSTR machine, PCSTR profile, BOOL delete )
1280 {
1281 UINT len;
1282 LPWSTR profileW;
1283 BOOL ret = FALSE;
1284
1285 TRACE( "( %s, %x )\n", debugstr_a(profile), delete );
1286
1287 if (machine || !profile) return FALSE;
1288
1289 len = MultiByteToWideChar( CP_ACP, 0, profile, -1, NULL, 0 );
1290 profileW = HeapAlloc( GetProcessHeap(), 0, len * sizeof(WCHAR) );
1291
1292 if (profileW)
1293 {
1294 MultiByteToWideChar( CP_ACP, 0, profile, -1, profileW, len );
1295
1296 ret = UninstallColorProfileW( NULL, profileW , delete );
1297
1298 HeapFree( GetProcessHeap(), 0, profileW );
1299 }
1300 return ret;
1301 }
1302
1303 /******************************************************************************
1304 * UninstallColorProfileW [MSCMS.@]
1305 *
1306 * Uninstall a color profile.
1307 *
1308 * PARAMS
1309 * machine [I] Name of the machine to uninstall the profile on. Must be NULL,
1310 * which indicates the local machine.
1311 * profile [I] Full path name of the profile to uninstall.
1312 * delete [I] Bool that specifies whether the profile file should be deleted.
1313 *
1314 * RETURNS
1315 * Success: TRUE
1316 * Failure: FALSE
1317 */
1318 BOOL WINAPI UninstallColorProfileW( PCWSTR machine, PCWSTR profile, BOOL delete )
1319 {
1320 TRACE( "( %s, %x )\n", debugstr_w(profile), delete );
1321
1322 if (machine || !profile) return FALSE;
1323
1324 if (delete) return DeleteFileW( profile );
1325
1326 return TRUE;
1327 }
1328
1329 /******************************************************************************
1330 * OpenColorProfileA [MSCMS.@]
1331 *
1332 * See OpenColorProfileW.
1333 */
1334 HPROFILE WINAPI OpenColorProfileA( PPROFILE profile, DWORD access, DWORD sharing, DWORD creation )
1335 {
1336 HPROFILE handle = NULL;
1337
1338 TRACE( "( %p, 0x%08x, 0x%08x, 0x%08x )\n", profile, access, sharing, creation );
1339
1340 if (!profile || !profile->pProfileData) return NULL;
1341
1342 /* No AW conversion needed for memory based profiles */
1343 if (profile->dwType & PROFILE_MEMBUFFER)
1344 return OpenColorProfileW( profile, access, sharing, creation );
1345
1346 if (profile->dwType & PROFILE_FILENAME)
1347 {
1348 UINT len;
1349 PROFILE profileW;
1350
1351 profileW.dwType = profile->dwType;
1352
1353 len = MultiByteToWideChar( CP_ACP, 0, profile->pProfileData, -1, NULL, 0 );
1354 profileW.pProfileData = HeapAlloc( GetProcessHeap(), 0, len * sizeof(WCHAR) );
1355
1356 if (profileW.pProfileData)
1357 {
1358 profileW.cbDataSize = len * sizeof(WCHAR);
1359 MultiByteToWideChar( CP_ACP, 0, profile->pProfileData, -1, profileW.pProfileData, len );
1360
1361 handle = OpenColorProfileW( &profileW, access, sharing, creation );
1362 HeapFree( GetProcessHeap(), 0, profileW.pProfileData );
1363 }
1364 }
1365 return handle;
1366 }
1367
1368 /******************************************************************************
1369 * OpenColorProfileW [MSCMS.@]
1370 *
1371 * Open a color profile.
1372 *
1373 * PARAMS
1374 * profile [I] Pointer to a color profile structure.
1375 * access [I] Desired access.
1376 * sharing [I] Sharing mode.
1377 * creation [I] Creation mode.
1378 *
1379 * RETURNS
1380 * Success: Handle to the opened profile.
1381 * Failure: NULL
1382 *
1383 * NOTES
1384 * Values for access: PROFILE_READ or PROFILE_READWRITE.
1385 * Values for sharing: 0 (no sharing), FILE_SHARE_READ and/or FILE_SHARE_WRITE.
1386 * Values for creation: one of CREATE_NEW, CREATE_ALWAYS, OPEN_EXISTING,
1387 * OPEN_ALWAYS, TRUNCATE_EXISTING.
1388 * Sharing and creation flags are ignored for memory based profiles.
1389 */
1390 HPROFILE WINAPI OpenColorProfileW( PPROFILE profile, DWORD access, DWORD sharing, DWORD creation )
1391 {
1392 #ifdef HAVE_LCMS2
1393 cmsHPROFILE cmsprofile = NULL;
1394 char *data = NULL;
1395 HANDLE handle = INVALID_HANDLE_VALUE;
1396 DWORD size;
1397
1398 TRACE( "( %p, 0x%08x, 0x%08x, 0x%08x )\n", profile, access, sharing, creation );
1399
1400 if (!profile || !profile->pProfileData) return NULL;
1401
1402 if (profile->dwType == PROFILE_MEMBUFFER)
1403 {
1404 /* FIXME: access flags not implemented for memory based profiles */
1405
1406 if (!(data = HeapAlloc( GetProcessHeap(), 0, profile->cbDataSize ))) return NULL;
1407 memcpy( data, profile->pProfileData, profile->cbDataSize );
1408
1409 if (!(cmsprofile = cmsOpenProfileFromMem( data, profile->cbDataSize )))
1410 {
1411 HeapFree( GetProcessHeap(), 0, data );
1412 return FALSE;
1413 }
1414 size = profile->cbDataSize;
1415 }
1416 else if (profile->dwType == PROFILE_FILENAME)
1417 {
1418 DWORD read, flags = 0;
1419
1420 TRACE( "profile file: %s\n", debugstr_w( profile->pProfileData ) );
1421
1422 if (access & PROFILE_READ) flags = GENERIC_READ;
1423 if (access & PROFILE_READWRITE) flags = GENERIC_READ|GENERIC_WRITE;
1424
1425 if (!flags) return NULL;
1426 if (!sharing) sharing = FILE_SHARE_READ;
1427
1428 if (!PathIsRelativeW( profile->pProfileData ))
1429 handle = CreateFileW( profile->pProfileData, flags, sharing, NULL, creation, 0, NULL );
1430 else
1431 {
1432 WCHAR *path;
1433
1434 if (!GetColorDirectoryW( NULL, NULL, &size ) && GetLastError() == ERROR_MORE_DATA)
1435 {
1436 size += (strlenW( profile->pProfileData ) + 2) * sizeof(WCHAR);
1437 if (!(path = HeapAlloc( GetProcessHeap(), 0, size ))) return NULL;
1438 GetColorDirectoryW( NULL, path, &size );
1439 PathAddBackslashW( path );
1440 strcatW( path, profile->pProfileData );
1441 }
1442 else return NULL;
1443 handle = CreateFileW( path, flags, sharing, NULL, creation, 0, NULL );
1444 HeapFree( GetProcessHeap(), 0, path );
1445 }
1446 if (handle == INVALID_HANDLE_VALUE)
1447 {
1448 WARN( "Unable to open color profile %u\n", GetLastError() );
1449 return NULL;
1450 }
1451 if ((size = GetFileSize( handle, NULL )) == INVALID_FILE_SIZE)
1452 {
1453 ERR( "Unable to retrieve size of color profile\n" );
1454 CloseHandle( handle );
1455 return NULL;
1456 }
1457 if (!(data = HeapAlloc( GetProcessHeap(), 0, size )))
1458 {
1459 ERR( "Unable to allocate memory for color profile\n" );
1460 CloseHandle( handle );
1461 return NULL;
1462 }
1463 if (!ReadFile( handle, data, size, &read, NULL ) || read != size)
1464 {
1465 ERR( "Unable to read color profile\n" );
1466
1467 CloseHandle( handle );
1468 HeapFree( GetProcessHeap(), 0, data );
1469 return NULL;
1470 }
1471 if (!(cmsprofile = cmsOpenProfileFromMem( data, size )))
1472 {
1473 CloseHandle( handle );
1474 HeapFree( GetProcessHeap(), 0, data );
1475 return NULL;
1476 }
1477 }
1478 else
1479 {
1480 ERR( "Invalid profile type %u\n", profile->dwType );
1481 return NULL;
1482 }
1483
1484 if (cmsprofile)
1485 {
1486 struct profile profile;
1487 HPROFILE hprof;
1488
1489 profile.file = handle;
1490 profile.access = access;
1491 profile.data = data;
1492 profile.size = size;
1493 profile.cmsprofile = cmsprofile;
1494
1495 if ((hprof = create_profile( &profile ))) return hprof;
1496 HeapFree( GetProcessHeap(), 0, data );
1497 cmsCloseProfile( cmsprofile );
1498 }
1499 CloseHandle( handle );
1500
1501 #endif /* HAVE_LCMS2 */
1502 return NULL;
1503 }
1504
1505 /******************************************************************************
1506 * CloseColorProfile [MSCMS.@]
1507 *
1508 * Close a color profile.
1509 *
1510 * PARAMS
1511 * profile [I] Handle to the profile.
1512 *
1513 * RETURNS
1514 * Success: TRUE
1515 * Failure: FALSE
1516 */
1517 BOOL WINAPI CloseColorProfile( HPROFILE profile )
1518 {
1519 BOOL ret = FALSE;
1520 #ifdef HAVE_LCMS2
1521
1522 TRACE( "( %p )\n", profile );
1523 ret = close_profile( profile );
1524
1525 #endif /* HAVE_LCMS2 */
1526 return ret;
1527 }