dlls/mscms/profile.c

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