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