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