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 "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, ARRAY_SIZE( colordir ));
 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     static const WCHAR slash[] = {'\\',0};
 672     BOOL ret;
 673     PROFILE profile;
 674     WCHAR path[MAX_PATH];
 675     DWORD size = sizeof(path);
 676     HANDLE handle;
 677
 678     ret = GetColorDirectoryW( NULL, path, &size );
 679     if (!ret)
 680     {
 681         WARN( "Can't retrieve color directory\n" );
 682         return FALSE;
 683     }
 684     if (size + sizeof(slash) + sizeof(WCHAR) * lstrlenW( file ) > sizeof(path))
 685     {
 686         WARN( "Filename too long\n" );
 687         return FALSE;
 688     }
 689
 690     lstrcatW( path, slash );
 691     lstrcatW( path, file );
 692
 693     profile.dwType = PROFILE_FILENAME;
 694     profile.pProfileData = path;
 695     profile.cbDataSize = lstrlenW( path ) + 1;
 696
 697     handle = OpenColorProfileW( &profile, PROFILE_READ, FILE_SHARE_READ, OPEN_EXISTING );
 698     if (!handle)
 699     {
 700         WARN( "Can't open color profile\n" );
 701         return FALSE;
 702     }
 703
 704     ret = GetColorProfileHeader( handle, header );
 705     if (!ret)
 706         WARN( "Can't retrieve color profile header\n" );
 707
 708     CloseColorProfile( handle );
 709     return ret;
 710 }
 711
 712 static BOOL match_profile( PENUMTYPEW rec, PPROFILEHEADER hdr )
 713 {
 714     if (rec->dwFields & ET_DEVICENAME)
 715     {
 716         FIXME( "ET_DEVICENAME: %s\n", debugstr_w(rec->pDeviceName) );
 717     }
 718     if (rec->dwFields & ET_MEDIATYPE)
 719     {
 720         FIXME( "ET_MEDIATYPE: 0x%08x\n", rec->dwMediaType );
 721     }
 722     if (rec->dwFields & ET_DITHERMODE)
 723     {
 724         FIXME( "ET_DITHERMODE: 0x%08x\n", rec->dwDitheringMode );
 725     }
 726     if (rec->dwFields & ET_RESOLUTION)
 727     {
 728         FIXME( "ET_RESOLUTION: 0x%08x, 0x%08x\n",
 729                rec->dwResolution[0], rec->dwResolution[1] );
 730     }
 731     if (rec->dwFields & ET_DEVICECLASS)
 732     {
 733         FIXME( "ET_DEVICECLASS: %s\n", dbgstr_tag(rec->dwMediaType) );
 734     }
 735     if (rec->dwFields & ET_CMMTYPE)
 736     {
 737         TRACE( "ET_CMMTYPE: %s\n", dbgstr_tag(rec->dwCMMType) );
 738         if (rec->dwCMMType != hdr->phCMMType) return FALSE;
 739     }
 740     if (rec->dwFields & ET_CLASS)
 741     {
 742         TRACE( "ET_CLASS: %s\n", dbgstr_tag(rec->dwClass) );
 743         if (rec->dwClass != hdr->phClass) return FALSE;
 744     }
 745     if (rec->dwFields & ET_DATACOLORSPACE)
 746     {
 747         TRACE( "ET_DATACOLORSPACE: %s\n", dbgstr_tag(rec->dwDataColorSpace) );
 748         if (rec->dwDataColorSpace != hdr->phDataColorSpace) return FALSE;
 749     }
 750     if (rec->dwFields & ET_CONNECTIONSPACE)
 751     {
 752         TRACE( "ET_CONNECTIONSPACE: %s\n", dbgstr_tag(rec->dwConnectionSpace) );
 753         if (rec->dwConnectionSpace != hdr->phConnectionSpace) return FALSE;
 754     }
 755     if (rec->dwFields & ET_SIGNATURE)
 756     {
 757         TRACE( "ET_SIGNATURE: %s\n", dbgstr_tag(rec->dwSignature) );
 758         if (rec->dwSignature != hdr->phSignature) return FALSE;
 759     }
 760     if (rec->dwFields & ET_PLATFORM)
 761     {
 762         TRACE( "ET_PLATFORM: %s\n", dbgstr_tag(rec->dwPlatform) );
 763         if (rec->dwPlatform != hdr->phPlatform) return FALSE;
 764     }
 765     if (rec->dwFields & ET_PROFILEFLAGS)
 766     {
 767         TRACE( "ET_PROFILEFLAGS: 0x%08x\n", rec->dwProfileFlags );
 768         if (rec->dwProfileFlags != hdr->phProfileFlags) return FALSE;
 769     }
 770     if (rec->dwFields & ET_MANUFACTURER)
 771     {
 772         TRACE( "ET_MANUFACTURER: %s\n", dbgstr_tag(rec->dwManufacturer) );
 773         if (rec->dwManufacturer != hdr->phManufacturer) return FALSE;
 774     }
 775     if (rec->dwFields & ET_MODEL)
 776     {
 777         TRACE( "ET_MODEL: %s\n", dbgstr_tag(rec->dwModel) );
 778         if (rec->dwModel != hdr->phModel) return FALSE;
 779     }
 780     if (rec->dwFields & ET_ATTRIBUTES)
 781     {
 782         TRACE( "ET_ATTRIBUTES: 0x%08x, 0x%08x\n",
 783                rec->dwAttributes[0], rec->dwAttributes[1] );
 784         if (rec->dwAttributes[0] != hdr->phAttributes[0] ||
 785             rec->dwAttributes[1] != hdr->phAttributes[1]) return FALSE;
 786     }
 787     if (rec->dwFields & ET_RENDERINGINTENT)
 788     {
 789         TRACE( "ET_RENDERINGINTENT: 0x%08x\n", rec->dwRenderingIntent );
 790         if (rec->dwRenderingIntent != hdr->phRenderingIntent) return FALSE;
 791     }
 792     if (rec->dwFields & ET_CREATOR)
 793     {
 794         TRACE( "ET_CREATOR: %s\n", dbgstr_tag(rec->dwCreator) );
 795         if (rec->dwCreator != hdr->phCreator) return FALSE;
 796     }
 797     return TRUE;
 798 }
 799
 800 /******************************************************************************
 801  * EnumColorProfilesA               [MSCMS.@]
 802  *
 803  * See EnumColorProfilesW.
 804  */
 805 BOOL WINAPI EnumColorProfilesA( PCSTR machine, PENUMTYPEA record, PBYTE buffer,
 806                                 PDWORD size, PDWORD number )
 807 {
 808     BOOL match, ret = FALSE;
 809     char spec[] = "\\*.icm";
 810     char colordir[MAX_PATH], glob[MAX_PATH], **profiles = NULL;
 811     DWORD i, len = sizeof(colordir), count = 0, totalsize = 0;
 812     PROFILEHEADER header;
 813     WIN32_FIND_DATAA data;
 814     ENUMTYPEW recordW;
 815     WCHAR *fileW = NULL, *deviceW = NULL;
 816     HANDLE find;
 817
 818     TRACE( "( %p, %p, %p, %p, %p )\n", machine, record, buffer, size, number );
 819
 820     if (machine || !record || !size ||
 821         record->dwSize != sizeof(ENUMTYPEA) ||
 822         record->dwVersion != ENUM_TYPE_VERSION) return FALSE;
 823
 824     ret = GetColorDirectoryA( machine, colordir, &len );
 825     if (!ret || len + sizeof(spec) > MAX_PATH)
 826     {
 827         WARN( "can't retrieve color directory\n" );
 828         return FALSE;
 829     }
 830
 831     lstrcpyA( glob, colordir );
 832     lstrcatA( glob, spec );
 833
 834     find = FindFirstFileA( glob, &data );
 835     if (find == INVALID_HANDLE_VALUE) return FALSE;
 836
 837     profiles = HeapAlloc( GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(char *) + 1 );
 838     if (!profiles) goto exit;
 839
 840     memcpy( &recordW, record, sizeof(ENUMTYPEA) );
 841     if (record->pDeviceName)
 842     {
 843         deviceW = strdupW( record->pDeviceName );
 844         if (!(recordW.pDeviceName = deviceW)) goto exit;
 845     }
 846
 847     fileW = strdupW( data.cFileName );
 848     if (!fileW) goto exit;
 849
 850     ret = header_from_file( fileW, &header );
 851     if (ret)
 852     {
 853         match = match_profile( &recordW, &header );
 854         if (match)
 855         {
 856             len = sizeof(char) * (lstrlenA( data.cFileName ) + 1);
 857             profiles[count] = HeapAlloc( GetProcessHeap(), 0, len );
 858
 859             if (!profiles[count]) goto exit;
 860             else
 861             {
 862                 TRACE( "matching profile: %s\n", debugstr_a(data.cFileName) );
 863                 lstrcpyA( profiles[count], data.cFileName );
 864                 totalsize += len;
 865                 count++;
 866             }
 867         }
 868     }
 869     HeapFree( GetProcessHeap(), 0, fileW );
 870     fileW = NULL;
 871
 872     while (FindNextFileA( find, &data ))
 873     {
 874         fileW = strdupW( data.cFileName );
 875         if (!fileW) goto exit;
 876
 877         ret = header_from_file( fileW, &header );
 878         if (!ret)
 879         {
 880             HeapFree( GetProcessHeap(), 0, fileW );
 881             continue;
 882         }
 883
 884         match = match_profile( &recordW, &header );
 885         if (match)
 886         {
 887             char **tmp = HeapReAlloc( GetProcessHeap(), HEAP_ZERO_MEMORY,
 888                                       profiles, sizeof(char *) * (count + 1) );
 889             if (!tmp) goto exit;
 890             else profiles = tmp;
 891
 892             len = sizeof(char) * (lstrlenA( data.cFileName ) + 1);
 893             profiles[count] = HeapAlloc( GetProcessHeap(), 0, len );
 894
 895             if (!profiles[count]) goto exit;
 896             else
 897             {
 898                 TRACE( "matching profile: %s\n", debugstr_a(data.cFileName) );
 899                 lstrcpyA( profiles[count], data.cFileName );
 900                 totalsize += len;
 901                 count++;
 902             }
 903         }
 904         HeapFree( GetProcessHeap(), 0, fileW );
 905         fileW = NULL;
 906     }
 907
 908     totalsize++;
 909     if (buffer && *size >= totalsize)
 910     {
 911         char *p = (char *)buffer;
 912
 913         for (i = 0; i < count; i++)
 914         {
 915             lstrcpyA( p, profiles[i] );
 916             p += lstrlenA( profiles[i] ) + 1;
 917         }
 918         *p = 0;
 919         ret = TRUE;
 920     }
 921     else
 922     {
 923         SetLastError( ERROR_INSUFFICIENT_BUFFER );
 924         ret = FALSE;
 925     }
 926
 927     *size = totalsize;
 928     if (number) *number = count;
 929
 930 exit:
 931     for (i = 0; i < count; i++)
 932         HeapFree( GetProcessHeap(), 0, profiles[i] );
 933     HeapFree( GetProcessHeap(), 0, profiles );
 934     HeapFree( GetProcessHeap(), 0, deviceW );
 935     HeapFree( GetProcessHeap(), 0, fileW );
 936     FindClose( find );
 937
 938     return ret;
 939 }
 940
 941 /******************************************************************************
 942  * EnumColorProfilesW               [MSCMS.@]
 943  *
 944  * Enumerate profiles that match given criteria.
 945  *
 946  * PARAMS
 947  *  machine  [I]   Name of the machine for which to enumerate profiles.
 948  *                 Must be NULL, which indicates the local machine.
 949  *  record   [I]   Record of criteria that a profile must match.
 950  *  buffer   [O]   Buffer to receive a string array of profile filenames.
 951  *  size     [I/O] Size of the filename buffer in bytes.
 952  *  number   [O]   Number of filenames copied into buffer.
 953  *
 954  * RETURNS
 955  *  Success: TRUE
 956  *  Failure: FALSE
 957  */
 958 BOOL WINAPI EnumColorProfilesW( PCWSTR machine, PENUMTYPEW record, PBYTE buffer,
 959                                 PDWORD size, PDWORD number )
 960 {
 961     static const WCHAR spec[] = {'\\','*','i','c','m',0};
 962     BOOL match, ret = FALSE;
 963     WCHAR colordir[MAX_PATH], glob[MAX_PATH], **profiles = NULL;
 964     DWORD i, len = sizeof(colordir), count = 0, totalsize = 0;
 965     PROFILEHEADER header;
 966     WIN32_FIND_DATAW data;
 967     HANDLE find;
 968
 969     TRACE( "( %p, %p, %p, %p, %p )\n", machine, record, buffer, size, number );
 970
 971     if (machine || !record || !size ||
 972         record->dwSize != sizeof(ENUMTYPEW) ||
 973         record->dwVersion != ENUM_TYPE_VERSION) return FALSE;
 974
 975     ret = GetColorDirectoryW( machine, colordir, &len );
 976     if (!ret || len + sizeof(spec) > MAX_PATH)
 977     {
 978         WARN( "Can't retrieve color directory\n" );
 979         return FALSE;
 980     }
 981
 982     lstrcpyW( glob, colordir );
 983     lstrcatW( glob, spec );
 984
 985     find = FindFirstFileW( glob, &data );
 986     if (find == INVALID_HANDLE_VALUE) return FALSE;
 987
 988     profiles = HeapAlloc( GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(WCHAR *) + 1 );
 989     if (!profiles) goto exit;
 990
 991     ret = header_from_file( data.cFileName, &header );
 992     if (ret)
 993     {
 994         match = match_profile( record, &header );
 995         if (match)
 996         {
 997             len = sizeof(WCHAR) * (lstrlenW( data.cFileName ) + 1);
 998             profiles[count] = HeapAlloc( GetProcessHeap(), 0, len );
 999
1000             if (!profiles[count]) goto exit;
1001             else
1002             {
1003                 TRACE( "matching profile: %s\n", debugstr_w(data.cFileName) );
1004                 lstrcpyW( profiles[count], data.cFileName );
1005                 totalsize += len;
1006                 count++;
1007             }
1008         }
1009     }
1010
1011     while (FindNextFileW( find, &data ))
1012     {
1013         ret = header_from_file( data.cFileName, &header );
1014         if (!ret) continue;
1015
1016         match = match_profile( record, &header );
1017         if (match)
1018         {
1019             WCHAR **tmp = HeapReAlloc( GetProcessHeap(), HEAP_ZERO_MEMORY,
1020                                        profiles, sizeof(WCHAR *) * (count + 1) );
1021             if (!tmp) goto exit;
1022             else profiles = tmp;
1023
1024             len = sizeof(WCHAR) * (lstrlenW( data.cFileName ) + 1);
1025             profiles[count] = HeapAlloc( GetProcessHeap(), 0, len );
1026
1027             if (!profiles[count]) goto exit;
1028             else
1029             {
1030                 TRACE( "matching profile: %s\n", debugstr_w(data.cFileName) );
1031                 lstrcpyW( profiles[count], data.cFileName );
1032                 totalsize += len;
1033                 count++;
1034             }
1035         }
1036     }
1037
1038     totalsize++;
1039     if (buffer && *size >= totalsize)
1040     {
1041         WCHAR *p = (WCHAR *)buffer;
1042
1043         for (i = 0; i < count; i++)
1044         {
1045             lstrcpyW( p, profiles[i] );
1046             p += lstrlenW( profiles[i] ) + 1;
1047         }
1048         *p = 0;
1049         ret = TRUE;
1050     }
1051     else
1052     {
1053         SetLastError( ERROR_INSUFFICIENT_BUFFER );
1054         ret = FALSE;
1055     }
1056
1057     *size = totalsize;
1058     if (number) *number = count;
1059
1060 exit:
1061     for (i = 0; i < count; i++)
1062         HeapFree( GetProcessHeap(), 0, profiles[i] );
1063     HeapFree( GetProcessHeap(), 0, profiles );
1064     FindClose( find );
1065
1066     return ret;
1067 }
1068
1069 /******************************************************************************
1070  * InstallColorProfileA               [MSCMS.@]
1071  *
1072  * See InstallColorProfileW.
1073  */
1074 BOOL WINAPI InstallColorProfileA( PCSTR machine, PCSTR profile )
1075 {
1076     UINT len;
1077     LPWSTR profileW;
1078     BOOL ret = FALSE;
1079
1080     TRACE( "( %s )\n", debugstr_a(profile) );
1081
1082     if (machine || !profile) return FALSE;
1083
1084     len = MultiByteToWideChar( CP_ACP, 0, profile, -1, NULL, 0 );
1085     profileW = HeapAlloc( GetProcessHeap(), 0, len * sizeof(WCHAR) );
1086
1087     if (profileW)
1088     {
1089         MultiByteToWideChar( CP_ACP, 0, profile, -1, profileW, len );
1090
1091         ret = InstallColorProfileW( NULL, profileW );
1092         HeapFree( GetProcessHeap(), 0, profileW );
1093     }
1094     return ret;
1095 }
1096
1097 /******************************************************************************
1098  * InstallColorProfileW               [MSCMS.@]
1099  *
1100  * Install a color profile.
1101  *
1102  * PARAMS
1103  *  machine  [I] Name of the machine to install the profile on. Must be NULL,
1104  *               which indicates the local machine.
1105  *  profile  [I] Full path name of the profile to install.
1106  *
1107  * RETURNS
1108  *  Success: TRUE
1109  *  Failure: FALSE
1110  */
1111 BOOL WINAPI InstallColorProfileW( PCWSTR machine, PCWSTR profile )
1112 {
1113     WCHAR dest[MAX_PATH], base[MAX_PATH];
1114     DWORD size = sizeof(dest);
1115     static const WCHAR slash[] = { '\\', 0 };
1116
1117     TRACE( "( %s )\n", debugstr_w(profile) );
1118
1119     if (machine || !profile) return FALSE;
1120
1121     if (!GetColorDirectoryW( machine, dest, &size )) return FALSE;
1122
1123     basename( profile, base );
1124
1125     lstrcatW( dest, slash );
1126     lstrcatW( dest, base );
1127
1128     /* Is source equal to destination? */
1129     if (!lstrcmpW( profile, dest )) return TRUE;
1130
1131     return CopyFileW( profile, dest, TRUE );
1132 }
1133
1134 /******************************************************************************
1135  * IsColorProfileTagPresent               [MSCMS.@]
1136  *
1137  * Determine if a given ICC tag type is present in a color profile.
1138  *
1139  * PARAMS
1140  *  profile  [I] Color profile handle.
1141  *  tag      [I] ICC tag type.
1142  *  present  [O] Pointer to a BOOL variable. Set to TRUE if tag type is present,
1143  *               FALSE otherwise.
1144  *
1145  * RETURNS
1146  *  Success: TRUE
1147  *  Failure: FALSE
1148  */
1149 BOOL WINAPI IsColorProfileTagPresent( HPROFILE handle, TAGTYPE type, PBOOL present )
1150 {
1151     BOOL ret = FALSE;
1152 #ifdef HAVE_LCMS2
1153     struct profile *profile = grab_profile( handle );
1154
1155     TRACE( "( %p, 0x%08x, %p )\n", handle, type, present );
1156
1157     if (!profile) return FALSE;
1158
1159     if (!present)
1160     {
1161         release_profile( profile );
1162         return FALSE;
1163     }
1164     *present = (cmsIsTag( profile->cmsprofile, type ) != 0);
1165     release_profile( profile );
1166     ret = TRUE;
1167
1168 #endif /* HAVE_LCMS2 */
1169     return ret;
1170 }
1171
1172 /******************************************************************************
1173  * IsColorProfileValid               [MSCMS.@]
1174  *
1175  * Determine if a given color profile is valid.
1176  *
1177  * PARAMS
1178  *  profile  [I] Color profile handle.
1179  *  valid    [O] Pointer to a BOOL variable. Set to TRUE if profile is valid,
1180  *               FALSE otherwise.
1181  *
1182  * RETURNS
1183  *  Success: TRUE
1184  *  Failure: FALSE
1185  */
1186 BOOL WINAPI IsColorProfileValid( HPROFILE handle, PBOOL valid )
1187 {
1188     BOOL ret = FALSE;
1189 #ifdef HAVE_LCMS2
1190     struct profile *profile = grab_profile( handle );
1191
1192     TRACE( "( %p, %p )\n", handle, valid );
1193
1194     if (!profile) return FALSE;
1195
1196     if (!valid)
1197     {
1198         release_profile( profile );
1199         return FALSE;
1200     }
1201     if (profile->data) ret = *valid = TRUE;
1202     release_profile( profile );
1203
1204 #endif /* HAVE_LCMS2 */
1205     return ret;
1206 }
1207
1208 /******************************************************************************
1209  * SetColorProfileElement               [MSCMS.@]
1210  *
1211  * Set data for a specified tag type.
1212  *
1213  * PARAMS
1214  *  profile  [I]   Handle to a color profile.
1215  *  type     [I]   ICC tag type.
1216  *  offset   [I]   Offset in bytes to start copying to.
1217  *  size     [I/O] Size of the buffer in bytes. On return the variable holds the
1218  *                 number of bytes actually needed.
1219  *  buffer   [O]   Buffer holding the tag data.
1220  *
1221  * RETURNS
1222  *  Success: TRUE
1223  *  Failure: FALSE
1224  */
1225 BOOL WINAPI SetColorProfileElement( HPROFILE handle, TAGTYPE type, DWORD offset, PDWORD size,
1226                                     PVOID buffer )
1227 {
1228     BOOL ret = FALSE;
1229 #ifdef HAVE_LCMS2
1230     struct profile *profile = grab_profile( handle );
1231
1232     TRACE( "( %p, 0x%08x, %d, %p, %p )\n", handle, type, offset, size, buffer );
1233
1234     if (!profile) return FALSE;
1235
1236     if (!size || !buffer || !(profile->access & PROFILE_READWRITE))
1237     {
1238         release_profile( profile );
1239         return FALSE;
1240     }
1241     ret = set_tag_data( profile, type, offset, buffer, size );
1242     release_profile( profile );
1243 #endif /* HAVE_LCMS2 */
1244     return ret;
1245 }
1246
1247 /******************************************************************************
1248  * SetColorProfileHeader               [MSCMS.@]
1249  *
1250  * Set header data for a given profile.
1251  *
1252  * PARAMS
1253  *  profile  [I] Handle to a color profile.
1254  *  header   [I] Buffer holding the header data.
1255  *
1256  * RETURNS
1257  *  Success: TRUE
1258  *  Failure: FALSE
1259  */
1260 BOOL WINAPI SetColorProfileHeader( HPROFILE handle, PPROFILEHEADER header )
1261 {
1262 #ifdef HAVE_LCMS2
1263     struct profile *profile = grab_profile( handle );
1264
1265     TRACE( "( %p, %p )\n", handle, header );
1266
1267     if (!profile) return FALSE;
1268
1269     if (!header || !(profile->access & PROFILE_READWRITE))
1270     {
1271         release_profile( profile );
1272         return FALSE;
1273     }
1274     set_profile_header( profile, header );
1275     release_profile( profile );
1276     return TRUE;
1277
1278 #else
1279     return FALSE;
1280 #endif /* HAVE_LCMS2 */
1281 }
1282
1283 /******************************************************************************
1284  * UninstallColorProfileA               [MSCMS.@]
1285  *
1286  * See UninstallColorProfileW.
1287  */
1288 BOOL WINAPI UninstallColorProfileA( PCSTR machine, PCSTR profile, BOOL delete )
1289 {
1290     UINT len;
1291     LPWSTR profileW;
1292     BOOL ret = FALSE;
1293
1294     TRACE( "( %s, %x )\n", debugstr_a(profile), delete );
1295
1296     if (machine || !profile) return FALSE;
1297
1298     len = MultiByteToWideChar( CP_ACP, 0, profile, -1, NULL, 0 );
1299     profileW = HeapAlloc( GetProcessHeap(), 0, len * sizeof(WCHAR) );
1300
1301     if (profileW)
1302     {
1303         MultiByteToWideChar( CP_ACP, 0, profile, -1, profileW, len );
1304
1305         ret = UninstallColorProfileW( NULL, profileW , delete );
1306
1307         HeapFree( GetProcessHeap(), 0, profileW );
1308     }
1309     return ret;
1310 }
1311
1312 /******************************************************************************
1313  * UninstallColorProfileW               [MSCMS.@]
1314  *
1315  * Uninstall a color profile.
1316  *
1317  * PARAMS
1318  *  machine  [I] Name of the machine to uninstall the profile on. Must be NULL,
1319  *               which indicates the local machine.
1320  *  profile  [I] Full path name of the profile to uninstall.
1321  *  delete   [I] Bool that specifies whether the profile file should be deleted.
1322  *
1323  * RETURNS
1324  *  Success: TRUE
1325  *  Failure: FALSE
1326  */
1327 BOOL WINAPI UninstallColorProfileW( PCWSTR machine, PCWSTR profile, BOOL delete )
1328 {
1329     TRACE( "( %s, %x )\n", debugstr_w(profile), delete );
1330
1331     if (machine || !profile) return FALSE;
1332
1333     if (delete) return DeleteFileW( profile );
1334
1335     return TRUE;
1336 }
1337
1338 static BOOL profile_AtoW( const PROFILE *in, PROFILE *out )
1339 {
1340     int len;
1341     if (!in->pProfileData) return FALSE;
1342     len = MultiByteToWideChar( CP_ACP, 0, in->pProfileData, -1, NULL, 0 );
1343     if (!(out->pProfileData = HeapAlloc( GetProcessHeap(), 0, len * sizeof(WCHAR) ))) return FALSE;
1344     out->cbDataSize = len * sizeof(WCHAR);
1345     MultiByteToWideChar( CP_ACP, 0, in->pProfileData, -1, out->pProfileData, len );
1346     out->dwType = in->dwType;
1347     return TRUE;
1348 }
1349
1350 /******************************************************************************
1351  * OpenColorProfileA               [MSCMS.@]
1352  *
1353  * See OpenColorProfileW.
1354  */
1355 HPROFILE WINAPI OpenColorProfileA( PPROFILE profile, DWORD access, DWORD sharing, DWORD creation )
1356 {
1357     HPROFILE handle = NULL;
1358     PROFILE profileW;
1359
1360     TRACE( "( %p, 0x%08x, 0x%08x, 0x%08x )\n", profile, access, sharing, creation );
1361
1362     if (!profile || !profile->pProfileData) return NULL;
1363
1364     /* No AW conversion needed for memory based profiles */
1365     if (profile->dwType & PROFILE_MEMBUFFER)
1366         return OpenColorProfileW( profile, access, sharing, creation );
1367
1368     if (!profile_AtoW( profile, &profileW )) return FALSE;
1369     handle = OpenColorProfileW( &profileW, access, sharing, creation );
1370     HeapFree( GetProcessHeap(), 0, profileW.pProfileData );
1371     return handle;
1372 }
1373
1374 /******************************************************************************
1375  * OpenColorProfileW               [MSCMS.@]
1376  *
1377  * Open a color profile.
1378  *
1379  * PARAMS
1380  *  profile   [I] Pointer to a color profile structure.
1381  *  access    [I] Desired access.
1382  *  sharing   [I] Sharing mode.
1383  *  creation  [I] Creation mode.
1384  *
1385  * RETURNS
1386  *  Success: Handle to the opened profile.
1387  *  Failure: NULL
1388  *
1389  * NOTES
1390  *  Values for access:   PROFILE_READ or PROFILE_READWRITE.
1391  *  Values for sharing:  0 (no sharing), FILE_SHARE_READ and/or FILE_SHARE_WRITE.
1392  *  Values for creation: one of CREATE_NEW, CREATE_ALWAYS, OPEN_EXISTING,
1393  *                       OPEN_ALWAYS, TRUNCATE_EXISTING.
1394  *  Sharing and creation flags are ignored for memory based profiles.
1395  */
1396 HPROFILE WINAPI OpenColorProfileW( PPROFILE profile, DWORD access, DWORD sharing, DWORD creation )
1397 {
1398 #ifdef HAVE_LCMS2
1399     cmsHPROFILE cmsprofile = NULL;
1400     char *data = NULL;
1401     HANDLE handle = INVALID_HANDLE_VALUE;
1402     DWORD size;
1403
1404     TRACE( "( %p, 0x%08x, 0x%08x, 0x%08x )\n", profile, access, sharing, creation );
1405
1406     if (!profile || !profile->pProfileData) return NULL;
1407
1408     if (profile->dwType == PROFILE_MEMBUFFER)
1409     {
1410         /* FIXME: access flags not implemented for memory based profiles */
1411
1412         if (!(data = HeapAlloc( GetProcessHeap(), 0, profile->cbDataSize ))) return NULL;
1413         memcpy( data, profile->pProfileData, profile->cbDataSize );
1414
1415         if (!(cmsprofile = cmsOpenProfileFromMem( data, profile->cbDataSize )))
1416         {
1417             HeapFree( GetProcessHeap(), 0, data );
1418             return FALSE;
1419         }
1420         size = profile->cbDataSize;
1421     }
1422     else if (profile->dwType == PROFILE_FILENAME)
1423     {
1424         DWORD read, flags = 0;
1425
1426         TRACE( "profile file: %s\n", debugstr_w( profile->pProfileData ) );
1427
1428         if (access & PROFILE_READ) flags = GENERIC_READ;
1429         if (access & PROFILE_READWRITE) flags = GENERIC_READ|GENERIC_WRITE;
1430
1431         if (!flags) return NULL;
1432         if (!sharing) sharing = FILE_SHARE_READ;
1433
1434         if (!PathIsRelativeW( profile->pProfileData ))
1435             handle = CreateFileW( profile->pProfileData, flags, sharing, NULL, creation, 0, NULL );
1436         else
1437         {
1438             WCHAR *path;
1439
1440             if (!GetColorDirectoryW( NULL, NULL, &size ) && GetLastError() == ERROR_MORE_DATA)
1441             {
1442                 size += (strlenW( profile->pProfileData ) + 2) * sizeof(WCHAR);
1443                 if (!(path = HeapAlloc( GetProcessHeap(), 0, size ))) return NULL;
1444                 GetColorDirectoryW( NULL, path, &size );
1445                 PathAddBackslashW( path );
1446                 strcatW( path, profile->pProfileData );
1447             }
1448             else return NULL;
1449             handle = CreateFileW( path, flags, sharing, NULL, creation, 0, NULL );
1450             HeapFree( GetProcessHeap(), 0, path );
1451         }
1452         if (handle == INVALID_HANDLE_VALUE)
1453         {
1454             WARN( "Unable to open color profile %u\n", GetLastError() );
1455             return NULL;
1456         }
1457         if ((size = GetFileSize( handle, NULL )) == INVALID_FILE_SIZE)
1458         {
1459             ERR( "Unable to retrieve size of color profile\n" );
1460             CloseHandle( handle );
1461             return NULL;
1462         }
1463         if (!(data = HeapAlloc( GetProcessHeap(), 0, size )))
1464         {
1465             ERR( "Unable to allocate memory for color profile\n" );
1466             CloseHandle( handle );
1467             return NULL;
1468         }
1469         if (!ReadFile( handle, data, size, &read, NULL ) || read != size)
1470         {
1471             ERR( "Unable to read color profile\n" );
1472
1473             CloseHandle( handle );
1474             HeapFree( GetProcessHeap(), 0, data );
1475             return NULL;
1476         }
1477         if (!(cmsprofile = cmsOpenProfileFromMem( data, size )))
1478         {
1479             CloseHandle( handle );
1480             HeapFree( GetProcessHeap(), 0, data );
1481             return NULL;
1482         }
1483     }
1484     else
1485     {
1486         ERR( "Invalid profile type %u\n", profile->dwType );
1487         return NULL;
1488     }
1489
1490     if (cmsprofile)
1491     {
1492         struct profile profile;
1493         HPROFILE hprof;
1494
1495         profile.file       = handle;
1496         profile.access     = access;
1497         profile.data       = data;
1498         profile.size       = size;
1499         profile.cmsprofile = cmsprofile;
1500
1501         if ((hprof = create_profile( &profile ))) return hprof;
1502         HeapFree( GetProcessHeap(), 0, data );
1503         cmsCloseProfile( cmsprofile );
1504     }
1505     CloseHandle( handle );
1506
1507 #endif /* HAVE_LCMS2 */
1508     return NULL;
1509 }
1510
1511 /******************************************************************************
1512  * CloseColorProfile               [MSCMS.@]
1513  *
1514  * Close a color profile.
1515  *
1516  * PARAMS
1517  *  profile  [I] Handle to the profile.
1518  *
1519  * RETURNS
1520  *  Success: TRUE
1521  *  Failure: FALSE
1522  */
1523 BOOL WINAPI CloseColorProfile( HPROFILE profile )
1524 {
1525     BOOL ret = FALSE;
1526 #ifdef HAVE_LCMS2
1527
1528     TRACE( "( %p )\n", profile );
1529     ret = close_profile( profile );
1530
1531 #endif /* HAVE_LCMS2 */
1532     return ret;
1533 }
1534
1535 /******************************************************************************
1536  * WcsGetUsePerUserProfiles               [MSCMS.@]
1537  */
1538 BOOL WINAPI WcsGetUsePerUserProfiles( const WCHAR* name, DWORD class, BOOL* use_per_user_profile )
1539 {
1540     FIXME( "%s %s %p\n", debugstr_w(name), dbgstr_tag(class), use_per_user_profile );
1541     SetLastError( ERROR_CALL_NOT_IMPLEMENTED );
1542     return FALSE;
1543 }
1544
1545 /******************************************************************************
1546  * WcsEnumColorProfilesSize               [MSCMS.@]
1547  */
1548 BOOL WINAPI WcsEnumColorProfilesSize( WCS_PROFILE_MANAGEMENT_SCOPE scope, ENUMTYPEW *record, DWORD *size )
1549 {
1550     FIXME( "%d %p %p\n", scope, record, size );
1551     SetLastError( ERROR_CALL_NOT_IMPLEMENTED );
1552     return FALSE;
1553 }
1554
1555 /******************************************************************************
1556  * WcsGetDefaultColorProfileSize     [MSCMS.@]
1557  */
1558 BOOL WINAPI WcsGetDefaultColorProfileSize( WCS_PROFILE_MANAGEMENT_SCOPE scope, PCWSTR device_name,
1559                                            COLORPROFILETYPE type, COLORPROFILESUBTYPE subtype,
1560                                            DWORD profile_id, PDWORD profile_size)
1561 {
1562     FIXME( "%d %s %d %d %d %p\n", scope, debugstr_w(device_name), type, subtype, profile_id, profile_size );
1563     SetLastError( ERROR_CALL_NOT_IMPLEMENTED );
1564     return FALSE;
1565 }
1566
1567 /******************************************************************************
1568  * WcsGetDefaultRednderingIntent      [MSCMS.@]
1569  */
1570 BOOL WINAPI WcsGetDefaultRenderingIntent( WCS_PROFILE_MANAGEMENT_SCOPE scope, PDWORD intent)
1571 {
1572     FIXME( "%d %p\n", scope, intent );
1573     SetLastError( ERROR_CALL_NOT_IMPLEMENTED );
1574     return FALSE;
1575 }
1576
1577 /******************************************************************************
1578  * WcsOpenColorProfileA               [MSCMS.@]
1579  */
1580 HPROFILE WINAPI WcsOpenColorProfileA( PROFILE *cdm, PROFILE *camp, PROFILE *gmmp, DWORD access, DWORD sharing,
1581                                       DWORD creation, DWORD flags )
1582 {
1583     PROFILE cdmW, campW = {0}, gmmpW = {0};
1584     HPROFILE ret = NULL;
1585
1586     TRACE( "%p, %p, %p, %08x, %08x, %08x, %08x\n", cdm, camp, gmmp, access, sharing, creation, flags );
1587
1588     if (!cdm || !profile_AtoW( cdm, &cdmW )) return NULL;
1589     if (camp && !profile_AtoW( camp, &campW )) goto done;
1590     if (gmmp && !profile_AtoW( gmmp, &gmmpW )) goto done;
1591
1592     ret = WcsOpenColorProfileW( &cdmW, &campW, &gmmpW, access, sharing, creation, flags );
1593
1594 done:
1595     HeapFree( GetProcessHeap(), 0, cdmW.pProfileData );
1596     HeapFree( GetProcessHeap(), 0, campW.pProfileData );
1597     HeapFree( GetProcessHeap(), 0, gmmpW.pProfileData );
1598     return ret;
1599 }
1600
1601 /******************************************************************************
1602  * WcsOpenColorProfileW               [MSCMS.@]
1603  */
1604 HPROFILE WINAPI WcsOpenColorProfileW( PROFILE *cdm, PROFILE *camp, PROFILE *gmmp, DWORD access, DWORD sharing,
1605                                       DWORD creation, DWORD flags )
1606 {
1607     TRACE( "%p, %p, %p, %08x, %08x, %08x, %08x\n", cdm, camp, gmmp, access, sharing, creation, flags );
1608     FIXME("no support for WCS profiles\n" );
1609
1610     return OpenColorProfileW( cdm, access, sharing, creation );
1611 }