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