dlls/mscms/profile.c

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