profile.c File Reference

#include "config.h"
#include "wine/debug.h"
#include "wine/unicode.h"
#include <stdarg.h>
#include "windef.h"
#include "winbase.h"
#include "winnls.h"
#include "wingdi.h"
#include "winuser.h"
#include "winreg.h"
#include "shlwapi.h"
#include "icm.h"
#include "mscms_priv.h"

Include dependency graph for profile.c:

Go to the source code of this file.

Functions
static void	basename (LPCWSTR path, LPWSTR name)
static LPWSTR	strdupW (LPCSTR str)
const char *	dbgstr_tag (DWORD tag)
	WINE_DEFAULT_DEBUG_CHANNEL (mscms)
BOOL WINAPI	AssociateColorProfileWithDeviceA (PCSTR machine, PCSTR profile, PCSTR device)
static BOOL	set_profile_device_key (PCWSTR file, const BYTE *value, DWORD size)
BOOL WINAPI	AssociateColorProfileWithDeviceW (PCWSTR machine, PCWSTR profile, PCWSTR device)
BOOL WINAPI	DisassociateColorProfileFromDeviceA (PCSTR machine, PCSTR profile, PCSTR device)
BOOL WINAPI	DisassociateColorProfileFromDeviceW (PCWSTR machine, PCWSTR profile, PCWSTR device)
BOOL WINAPI	GetColorDirectoryA (PCSTR machine, PSTR buffer, PDWORD size)
BOOL WINAPI	GetColorDirectoryW (PCWSTR machine, PWSTR buffer, PDWORD size)
BOOL WINAPI	GetColorProfileElement (HPROFILE handle, TAGTYPE type, DWORD offset, PDWORD size, PVOID buffer, PBOOL ref)
BOOL WINAPI	GetColorProfileElementTag (HPROFILE handle, DWORD index, PTAGTYPE type)
BOOL WINAPI	GetColorProfileFromHandle (HPROFILE handle, PBYTE buffer, PDWORD size)
BOOL WINAPI	GetColorProfileHeader (HPROFILE handle, PPROFILEHEADER header)
BOOL WINAPI	GetCountColorProfileElements (HPROFILE handle, PDWORD count)
BOOL WINAPI	GetStandardColorSpaceProfileA (PCSTR machine, DWORD id, PSTR profile, PDWORD size)
BOOL WINAPI	GetStandardColorSpaceProfileW (PCWSTR machine, DWORD id, PWSTR profile, PDWORD size)
static BOOL	header_from_file (LPCWSTR file, PPROFILEHEADER header)
static BOOL	match_profile (PENUMTYPEW rec, PPROFILEHEADER hdr)
BOOL WINAPI	EnumColorProfilesA (PCSTR machine, PENUMTYPEA record, PBYTE buffer, PDWORD size, PDWORD number)
BOOL WINAPI	EnumColorProfilesW (PCWSTR machine, PENUMTYPEW record, PBYTE buffer, PDWORD size, PDWORD number)
BOOL WINAPI	InstallColorProfileA (PCSTR machine, PCSTR profile)
BOOL WINAPI	InstallColorProfileW (PCWSTR machine, PCWSTR profile)
BOOL WINAPI	IsColorProfileTagPresent (HPROFILE handle, TAGTYPE type, PBOOL present)
BOOL WINAPI	IsColorProfileValid (HPROFILE handle, PBOOL valid)
BOOL WINAPI	SetColorProfileElement (HPROFILE handle, TAGTYPE type, DWORD offset, PDWORD size, PVOID buffer)
BOOL WINAPI	SetColorProfileHeader (HPROFILE handle, PPROFILEHEADER header)
BOOL WINAPI	UninstallColorProfileA (PCSTR machine, PCSTR profile, BOOL delete)
BOOL WINAPI	UninstallColorProfileW (PCWSTR machine, PCWSTR profile, BOOL delete)
static BOOL	profile_AtoW (const PROFILE *in, PROFILE *out)
HPROFILE WINAPI	OpenColorProfileA (PPROFILE profile, DWORD access, DWORD sharing, DWORD creation)
HPROFILE WINAPI	OpenColorProfileW (PPROFILE profile, DWORD access, DWORD sharing, DWORD creation)
BOOL WINAPI	CloseColorProfile (HPROFILE profile)
BOOL WINAPI	WcsGetUsePerUserProfiles (const WCHAR *name, DWORD class, BOOL *use_per_user_profile)
BOOL WINAPI	WcsEnumColorProfilesSize (WCS_PROFILE_MANAGEMENT_SCOPE scope, ENUMTYPEW *record, DWORD *size)
HPROFILE WINAPI	WcsOpenColorProfileA (PROFILE *cdm, PROFILE *camp, PROFILE *gmmp, DWORD access, DWORD sharing, DWORD creation, DWORD flags)
HPROFILE WINAPI	WcsOpenColorProfileW (PROFILE *cdm, PROFILE *camp, PROFILE *gmmp, DWORD access, DWORD sharing, DWORD creation, DWORD flags)

Function Documentation

AssociateColorProfileWithDeviceA()

BOOL WINAPI AssociateColorProfileWithDeviceA	(	PCSTR	machine,
		PCSTR	profile,
		PCSTR	device
	)

Definition at line 69 of file profile.c.

{
    int len;
    BOOL ret = FALSE;
    WCHAR *profileW, *deviceW;
 
    TRACE( "( %s, %s, %s )\n", debugstr_a(machine), debugstr_a(profile), debugstr_a(device) );
 
    if (!profile || !device)
    {
        SetLastError( ERROR_INVALID_PARAMETER );
        return FALSE;
    }
    if (machine)
    {
        SetLastError( ERROR_NOT_SUPPORTED );
        return FALSE;
    }
 
    len = MultiByteToWideChar( CP_ACP, 0, profile, -1, NULL, 0 );
    if (!(profileW = HeapAlloc( GetProcessHeap(), 0, len * sizeof(WCHAR) ))) return FALSE;
 
    MultiByteToWideChar( CP_ACP, 0, profile, -1, profileW, len );
 
    len = MultiByteToWideChar( CP_ACP, 0, device, -1, NULL, 0 );
    if ((deviceW = HeapAlloc( GetProcessHeap(), 0, len * sizeof(WCHAR) )))
    {
        MultiByteToWideChar( CP_ACP, 0, device, -1, deviceW, len );
        ret = AssociateColorProfileWithDeviceW( NULL, profileW, deviceW );
    }
 
    HeapFree( GetProcessHeap(), 0, profileW );
    HeapFree( GetProcessHeap(), 0, deviceW );
    return ret;
}

Referenced by init_function_ptrs().

AssociateColorProfileWithDeviceW()

BOOL WINAPI AssociateColorProfileWithDeviceW	(	PCWSTR	machine,
		PCWSTR	profile,
		PCWSTR	device
	)

Definition at line 154 of file profile.c.

{
    static const BYTE dummy_value[12];
 
    TRACE( "( %s, %s, %s )\n", debugstr_w(machine), debugstr_w(profile), debugstr_w(device) );
 
    if (!profile || !device)
    {
        SetLastError( ERROR_INVALID_PARAMETER );
        return FALSE;
    }
    if (machine)
    {
        SetLastError( ERROR_NOT_SUPPORTED );
        return FALSE;
    }
 
    return set_profile_device_key( profile, dummy_value, sizeof(dummy_value) );
}

Referenced by AssociateColorProfileWithDeviceA().

basename()

static void basename ( LPCWSTR  path, LPWSTR  name  )

static

Definition at line 38 of file profile.c.

{
    INT i = lstrlenW( path );
 
    while (i > 0 && path[i - 1] != '\\' && path[i - 1] != '/') i--;
    lstrcpyW( name, &path[i] );
}

Referenced by AddDelBackupEntryA(), cleanable(), create_cache(), DoGetNameInZip(), FileSaveRestoreA(), get_events(), hash_basename(), InstallCatalog(), InstallColorProfileW(), pSetupInstallCatalog(), set_outfile(), set_profile_device_key(), SHGetNewLinkInfoW(), test_AssociateColorProfileWithDeviceA(), test_CryptCATAdminAddRemoveCatalog(), and test_debug_heap().

CloseColorProfile()

BOOL WINAPI CloseColorProfile

(

HPROFILE

profile

)

Definition at line 1523 of file profile.c.

{
    BOOL ret = FALSE;
#ifdef HAVE_LCMS2
 
    TRACE( "( %p )\n", profile );
    ret = close_profile( profile );
 
#endif /* HAVE_LCMS2 */
    return ret;
}

Referenced by header_from_file(), init_function_ptrs(), and set_profile_device_key().

dbgstr_tag()

const char * dbgstr_tag

(

DWORD

tag

)

Definition at line 58 of file profile.c.

{
    return wine_dbg_sprintf( "'%c%c%c%c'",
        (char)(tag >> 24), (char)(tag >> 16), (char)(tag >> 8), (char)(tag) );
}

Referenced by CreateColorTransformW(), match_profile(), RegisterCMMA(), RegisterCMMW(), SelectCMM(), UnregisterCMMA(), UnregisterCMMW(), and WcsGetUsePerUserProfiles().

DisassociateColorProfileFromDeviceA()

BOOL WINAPI DisassociateColorProfileFromDeviceA	(	PCSTR	machine,
		PCSTR	profile,
		PCSTR	device
	)

Definition at line 177 of file profile.c.

{
    int len;
    BOOL ret = FALSE;
    WCHAR *profileW, *deviceW;
 
    TRACE( "( %s, %s, %s )\n", debugstr_a(machine), debugstr_a(profile), debugstr_a(device) );
 
    if (!profile || !device)
    {
        SetLastError( ERROR_INVALID_PARAMETER );
        return FALSE;
    }
    if (machine)
    {
        SetLastError( ERROR_NOT_SUPPORTED );
        return FALSE;
    }
 
    len = MultiByteToWideChar( CP_ACP, 0, profile, -1, NULL, 0 );
    if (!(profileW = HeapAlloc( GetProcessHeap(), 0, len * sizeof(WCHAR) ))) return FALSE;
 
    MultiByteToWideChar( CP_ACP, 0, profile, -1, profileW, len );
 
    len = MultiByteToWideChar( CP_ACP, 0, device, -1, NULL, 0 );
    if ((deviceW = HeapAlloc( GetProcessHeap(), 0, len * sizeof(WCHAR) )))
    {
        MultiByteToWideChar( CP_ACP, 0, device, -1, deviceW, len );
        ret = DisassociateColorProfileFromDeviceW( NULL, profileW, deviceW );
    }
 
    HeapFree( GetProcessHeap(), 0, profileW );
    HeapFree( GetProcessHeap(), 0, deviceW );
    return ret;
}

Referenced by init_function_ptrs().

DisassociateColorProfileFromDeviceW()

BOOL WINAPI DisassociateColorProfileFromDeviceW	(	PCWSTR	machine,
		PCWSTR	profile,
		PCWSTR	device
	)

Definition at line 216 of file profile.c.

{
    TRACE( "( %s, %s, %s )\n", debugstr_w(machine), debugstr_w(profile), debugstr_w(device) );
 
    if (!profile || !device)
    {
        SetLastError( ERROR_INVALID_PARAMETER );
        return FALSE;
    }
    if (machine)
    {
        SetLastError( ERROR_NOT_SUPPORTED );
        return FALSE;
    }
 
    return set_profile_device_key( profile, NULL, 0 );
}

Referenced by DisassociateColorProfileFromDeviceA().

EnumColorProfilesA()

BOOL WINAPI EnumColorProfilesA	(	PCSTR	machine,
		PENUMTYPEA	record,
		PBYTE	buffer,
		PDWORD	size,
		PDWORD	number
	)

Definition at line 805 of file profile.c.

{
    BOOL match, ret = FALSE;
    char spec[] = "\\*.icm";
    char colordir[MAX_PATH], glob[MAX_PATH], **profiles = NULL;
    DWORD i, len = sizeof(colordir), count = 0, totalsize = 0;
    PROFILEHEADER header;
    WIN32_FIND_DATAA data;
    ENUMTYPEW recordW;
    WCHAR *fileW = NULL, *deviceW = NULL;
    HANDLE find;
 
    TRACE( "( %p, %p, %p, %p, %p )\n", machine, record, buffer, size, number );
 
    if (machine || !record || !size ||
        record->dwSize != sizeof(ENUMTYPEA) ||
        record->dwVersion != ENUM_TYPE_VERSION) return FALSE;
 
    ret = GetColorDirectoryA( machine, colordir, &len );
    if (!ret || len + sizeof(spec) > MAX_PATH)
    {
        WARN( "can't retrieve color directory\n" );
        return FALSE;
    }
 
    lstrcpyA( glob, colordir );
    lstrcatA( glob, spec );
 
    find = FindFirstFileA( glob, &data );
    if (find == INVALID_HANDLE_VALUE) return FALSE;
 
    profiles = HeapAlloc( GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(char *) + 1 );
    if (!profiles) goto exit;
 
    memcpy( &recordW, record, sizeof(ENUMTYPEA) );
    if (record->pDeviceName)
    {
        deviceW = strdupW( record->pDeviceName );
        if (!(recordW.pDeviceName = deviceW)) goto exit;
    }
 
    fileW = strdupW( data.cFileName );
    if (!fileW) goto exit;
 
    ret = header_from_file( fileW, &header );
    if (ret)
    {
        match = match_profile( &recordW, &header );
        if (match)
        {
            len = sizeof(char) * (lstrlenA( data.cFileName ) + 1);
            profiles[count] = HeapAlloc( GetProcessHeap(), 0, len );
 
            if (!profiles[count]) goto exit;
            else
            {
                TRACE( "matching profile: %s\n", debugstr_a(data.cFileName) );
                lstrcpyA( profiles[count], data.cFileName );
                totalsize += len;
                count++;
            }
        }
    }
    HeapFree( GetProcessHeap(), 0, fileW );
    fileW = NULL;
 
    while (FindNextFileA( find, &data ))
    {
        fileW = strdupW( data.cFileName );
        if (!fileW) goto exit;
 
        ret = header_from_file( fileW, &header );
        if (!ret)
        {
            HeapFree( GetProcessHeap(), 0, fileW );
            continue;
        }
 
        match = match_profile( &recordW, &header );
        if (match)
        {
            char **tmp = HeapReAlloc( GetProcessHeap(), HEAP_ZERO_MEMORY,
                                      profiles, sizeof(char *) * (count + 1) );
            if (!tmp) goto exit;
            else profiles = tmp;
 
            len = sizeof(char) * (lstrlenA( data.cFileName ) + 1);
            profiles[count] = HeapAlloc( GetProcessHeap(), 0, len );
 
            if (!profiles[count]) goto exit;
            else
            {
                TRACE( "matching profile: %s\n", debugstr_a(data.cFileName) );
                lstrcpyA( profiles[count], data.cFileName );
                totalsize += len;
                count++;
            }
        }
        HeapFree( GetProcessHeap(), 0, fileW );
        fileW = NULL;
    }
 
    totalsize++;
    if (buffer && *size >= totalsize)
    {
        char *p = (char *)buffer;
 
        for (i = 0; i < count; i++)
        {
            lstrcpyA( p, profiles[i] );
            p += lstrlenA( profiles[i] ) + 1;
        }
        *p = 0;
        ret = TRUE;
    }
    else
    {
        SetLastError( ERROR_INSUFFICIENT_BUFFER );
        ret = FALSE;
    }
 
    *size = totalsize;
    if (number) *number = count;
 
exit:
    for (i = 0; i < count; i++)
        HeapFree( GetProcessHeap(), 0, profiles[i] );
    HeapFree( GetProcessHeap(), 0, profiles );
    HeapFree( GetProcessHeap(), 0, deviceW );
    HeapFree( GetProcessHeap(), 0, fileW );
    FindClose( find );
 
    return ret;
}

Referenced by init_function_ptrs().

EnumColorProfilesW()

BOOL WINAPI EnumColorProfilesW	(	PCWSTR	machine,
		PENUMTYPEW	record,
		PBYTE	buffer,
		PDWORD	size,
		PDWORD	number
	)

Definition at line 958 of file profile.c.

{
    static const WCHAR spec[] = {'\\','*','i','c','m',0};
    BOOL match, ret = FALSE;
    WCHAR colordir[MAX_PATH], glob[MAX_PATH], **profiles = NULL;
    DWORD i, len = sizeof(colordir), count = 0, totalsize = 0;
    PROFILEHEADER header;
    WIN32_FIND_DATAW data;
    HANDLE find;
 
    TRACE( "( %p, %p, %p, %p, %p )\n", machine, record, buffer, size, number );
 
    if (machine || !record || !size ||
        record->dwSize != sizeof(ENUMTYPEW) ||
        record->dwVersion != ENUM_TYPE_VERSION) return FALSE;
 
    ret = GetColorDirectoryW( machine, colordir, &len );
    if (!ret || len + sizeof(spec) > MAX_PATH)
    {
        WARN( "Can't retrieve color directory\n" );
        return FALSE;
    }
 
    lstrcpyW( glob, colordir );
    lstrcatW( glob, spec );
 
    find = FindFirstFileW( glob, &data );
    if (find == INVALID_HANDLE_VALUE) return FALSE;
 
    profiles = HeapAlloc( GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(WCHAR *) + 1 );
    if (!profiles) goto exit;
 
    ret = header_from_file( data.cFileName, &header );
    if (ret)
    {
        match = match_profile( record, &header );
        if (match)
        {
            len = sizeof(WCHAR) * (lstrlenW( data.cFileName ) + 1);
            profiles[count] = HeapAlloc( GetProcessHeap(), 0, len );
 
            if (!profiles[count]) goto exit;
            else
            {
                TRACE( "matching profile: %s\n", debugstr_w(data.cFileName) );
                lstrcpyW( profiles[count], data.cFileName );
                totalsize += len;
                count++;
            }
        }
    }
 
    while (FindNextFileW( find, &data ))
    {
        ret = header_from_file( data.cFileName, &header );
        if (!ret) continue;
 
        match = match_profile( record, &header );
        if (match)
        {
            WCHAR **tmp = HeapReAlloc( GetProcessHeap(), HEAP_ZERO_MEMORY,
                                       profiles, sizeof(WCHAR *) * (count + 1) );
            if (!tmp) goto exit;
            else profiles = tmp;
 
            len = sizeof(WCHAR) * (lstrlenW( data.cFileName ) + 1);
            profiles[count] = HeapAlloc( GetProcessHeap(), 0, len );
 
            if (!profiles[count]) goto exit;
            else
            {
                TRACE( "matching profile: %s\n", debugstr_w(data.cFileName) );
                lstrcpyW( profiles[count], data.cFileName );
                totalsize += len;
                count++;
            }
        }
    }
 
    totalsize++;
    if (buffer && *size >= totalsize)
    {
        WCHAR *p = (WCHAR *)buffer;
 
        for (i = 0; i < count; i++)
        {
            lstrcpyW( p, profiles[i] );
            p += lstrlenW( profiles[i] ) + 1;
        }
        *p = 0;
        ret = TRUE;
    }
    else
    {
        SetLastError( ERROR_INSUFFICIENT_BUFFER );
        ret = FALSE;
    }
 
    *size = totalsize;
    if (number) *number = count;
 
exit:
    for (i = 0; i < count; i++)
        HeapFree( GetProcessHeap(), 0, profiles[i] );
    HeapFree( GetProcessHeap(), 0, profiles );
    FindClose( find );
 
    return ret;
}

Referenced by init_function_ptrs().

GetColorDirectoryA()

BOOL WINAPI GetColorDirectoryA	(	PCSTR	machine,
		PSTR	buffer,
		PDWORD	size
	)

Definition at line 239 of file profile.c.

{
    INT len;
    LPWSTR bufferW;
    BOOL ret = FALSE;
    DWORD sizeW;
 
    TRACE( "( %p, %p )\n", buffer, size );
 
    if (machine || !size) return FALSE;
 
    if (!buffer)
    {
        ret = GetColorDirectoryW( NULL, NULL, &sizeW );
        *size = sizeW / sizeof(WCHAR);
        return ret;
    }
 
    sizeW = *size * sizeof(WCHAR);
 
    bufferW = HeapAlloc( GetProcessHeap(), 0, sizeW );
    if (bufferW)
    {
        if ((ret = GetColorDirectoryW( NULL, bufferW, &sizeW )))
        {
            *size = WideCharToMultiByte( CP_ACP, 0, bufferW, -1, NULL, 0, NULL, NULL );
            len = WideCharToMultiByte( CP_ACP, 0, bufferW, -1, buffer, *size, NULL, NULL );
            if (!len) ret = FALSE;
        }
        else *size = sizeW / sizeof(WCHAR);
 
        HeapFree( GetProcessHeap(), 0, bufferW );
    }
    return ret;
}

Referenced by EnumColorProfilesA(), and init_function_ptrs().

GetColorDirectoryW()

BOOL WINAPI GetColorDirectoryW	(	PCWSTR	machine,
		PWSTR	buffer,
		PDWORD	size
	)

Definition at line 287 of file profile.c.

{
    WCHAR colordir[MAX_PATH];
    static const WCHAR colorsubdir[] =
        {'\\','s','p','o','o','l','\\','d','r','i','v','e','r','s','\\','c','o','l','o','r',0};
    DWORD len;
 
    TRACE( "( %p, %p )\n", buffer, size );
 
    if (machine || !size) return FALSE;
 
    GetSystemDirectoryW( colordir, ARRAY_SIZE( colordir ));
    lstrcatW( colordir, colorsubdir );
 
    len = lstrlenW( colordir ) * sizeof(WCHAR);
 
    if (buffer && len <= *size)
    {
        lstrcpyW( buffer, colordir );
        *size = len;
        return TRUE;
    }
 
    SetLastError( ERROR_MORE_DATA );
    *size = len;
    return FALSE;
}

Referenced by EnumColorProfilesW(), GetColorDirectoryA(), GetStandardColorSpaceProfileW(), header_from_file(), init_function_ptrs(), InstallColorProfileW(), and OpenColorProfileW().

GetColorProfileElement()

BOOL WINAPI GetColorProfileElement	(	HPROFILE	handle,
		TAGTYPE	type,
		DWORD	offset,
		PDWORD	size,
		PVOID	buffer,
		PBOOL	ref
	)

Definition at line 334 of file profile.c.

{
    BOOL ret = FALSE;
#ifdef HAVE_LCMS2
    struct profile *profile = grab_profile( handle );
 
    TRACE( "( %p, 0x%08x, %d, %p, %p, %p )\n", handle, type, offset, size, buffer, ref );
 
    if (!profile) return FALSE;
 
    if (!size || !ref)
    {
        release_profile( profile );
        return FALSE;
    }
    if (!get_tag_data( profile, type, offset, buffer, size ))
    {
        release_profile( profile );
        return FALSE;
    }
    ret = get_tag_data( profile, type, offset, buffer, size );
    *ref = cmsTagLinkedTo( profile->cmsprofile, type ) != 0;
    release_profile( profile );
#endif /* HAVE_LCMS2 */
    return ret;
}

Referenced by init_function_ptrs().

GetColorProfileElementTag()

BOOL WINAPI GetColorProfileElementTag	(	HPROFILE	handle,
		DWORD	index,
		PTAGTYPE	type
	)

Definition at line 380 of file profile.c.

{
    BOOL ret = FALSE;
#ifdef HAVE_LCMS2
    struct profile *profile = grab_profile( handle );
    cmsInt32Number num_tags;
    cmsTagSignature sig;
 
    TRACE( "( %p, %d, %p )\n", handle, index, type );
 
    if (!profile) return FALSE;
 
    if (!type)
    {
        release_profile( profile );
        return FALSE;
    }
    num_tags = cmsGetTagCount( profile->cmsprofile );
    if (num_tags < 0 || index > num_tags || index < 1)
    {
        release_profile( profile );
        return FALSE;
    }
    if ((sig = cmsGetTagSignature( profile->cmsprofile, index - 1 )))
    {
        *type = sig;
        ret = TRUE;
    }
    release_profile( profile );
 
#endif /* HAVE_LCMS2 */
    return ret;
}

Referenced by init_function_ptrs().

GetColorProfileFromHandle()

BOOL WINAPI GetColorProfileFromHandle	(	HPROFILE	handle,
		PBYTE	buffer,
		PDWORD	size
	)

Definition at line 432 of file profile.c.

{
    BOOL ret = FALSE;
#ifdef HAVE_LCMS2
    struct profile *profile = grab_profile( handle );
    PROFILEHEADER header;
 
    TRACE( "( %p, %p, %p )\n", handle, buffer, size );
 
    if (!profile) return FALSE;
 
    if (!size)
    {
        release_profile( profile );
        return FALSE;
    }
    get_profile_header( profile, &header );
 
    if (!buffer || header.phSize > *size)
    {
        *size = header.phSize;
        release_profile( profile );
        return FALSE;
    }
 
    /* No endian conversion needed */
    memcpy( buffer, profile->data, profile->size );
    *size = profile->size;
 
    release_profile( profile );
    ret = TRUE;
 
#endif /* HAVE_LCMS2 */
    return ret;
}

Referenced by init_function_ptrs().

GetColorProfileHeader()

BOOL WINAPI GetColorProfileHeader	(	HPROFILE	handle,
		PPROFILEHEADER	header
	)

Definition at line 484 of file profile.c.

{
#ifdef HAVE_LCMS2
    struct profile *profile = grab_profile( handle );
 
    TRACE( "( %p, %p )\n", handle, header );
 
    if (!profile) return FALSE;
 
    if (!header)
    {
        release_profile( profile );
        return FALSE;
    }
    get_profile_header( profile, header );
    release_profile( profile );
    return TRUE;
 
#else
    return FALSE;
#endif /* HAVE_LCMS2 */
}

Referenced by header_from_file(), init_function_ptrs(), and set_profile_device_key().

GetCountColorProfileElements()

BOOL WINAPI GetCountColorProfileElements	(	HPROFILE	handle,
		PDWORD	count
	)

Definition at line 521 of file profile.c.

{
    BOOL ret = FALSE;
#ifdef HAVE_LCMS2
    struct profile *profile = grab_profile( handle );
    cmsInt32Number num_tags;
 
    TRACE( "( %p, %p )\n", handle, count );
 
    if (!profile) return FALSE;
 
    if (!count)
    {
        release_profile( profile );
        return FALSE;
    }
    if ((num_tags = cmsGetTagCount( profile->cmsprofile )) >= 0)
    {
        *count = num_tags;
        ret = TRUE;
    }
    release_profile( profile );
 
#endif /* HAVE_LCMS2 */
    return ret;
}

Referenced by init_function_ptrs().

GetStandardColorSpaceProfileA()

BOOL WINAPI GetStandardColorSpaceProfileA	(	PCSTR	machine,
		DWORD	id,
		PSTR	profile,
		PDWORD	size
	)

Definition at line 553 of file profile.c.

{
    INT len;
    LPWSTR profileW;
    BOOL ret = FALSE;
    DWORD sizeW;
 
    TRACE( "( 0x%08x, %p, %p )\n", id, profile, size );
 
    if (machine) 
    {
        SetLastError( ERROR_NOT_SUPPORTED );
        return FALSE;
    }
 
    if (!size) 
    {
        SetLastError( ERROR_INVALID_PARAMETER );
        return FALSE;
    }
 
    sizeW = *size * sizeof(WCHAR);
 
    if (!profile)
    {
        ret = GetStandardColorSpaceProfileW( NULL, id, NULL, &sizeW );
        *size = sizeW / sizeof(WCHAR);
        return ret;
    }
 
    profileW = HeapAlloc( GetProcessHeap(), 0, sizeW );
    if (profileW)
    {
        if ((ret = GetStandardColorSpaceProfileW( NULL, id, profileW, &sizeW )))
        {
            *size = WideCharToMultiByte( CP_ACP, 0, profileW, -1, NULL, 0, NULL, NULL );
            len = WideCharToMultiByte( CP_ACP, 0, profileW, -1, profile, *size, NULL, NULL );
            if (!len) ret = FALSE;
        }
        else *size = sizeW / sizeof(WCHAR);
 
        HeapFree( GetProcessHeap(), 0, profileW );
    }
    return ret;
}

Referenced by init_function_ptrs().

GetStandardColorSpaceProfileW()

BOOL WINAPI GetStandardColorSpaceProfileW	(	PCWSTR	machine,
		DWORD	id,
		PWSTR	profile,
		PDWORD	size
	)

Definition at line 615 of file profile.c.

{
    static const WCHAR rgbprofilefile[] =
        { '\\','s','r','g','b',' ','c','o','l','o','r',' ',
          's','p','a','c','e',' ','p','r','o','f','i','l','e','.','i','c','m',0 };
    WCHAR rgbprofile[MAX_PATH];
    DWORD len = sizeof(rgbprofile);
 
    TRACE( "( 0x%08x, %p, %p )\n", id, profile, size );
 
    if (machine) 
    {
        SetLastError( ERROR_NOT_SUPPORTED );
        return FALSE;
    }
 
    if (!size) 
    {
        SetLastError( ERROR_INVALID_PARAMETER );
        return FALSE;
    }
 
    if (!profile)
    {
        SetLastError( ERROR_INSUFFICIENT_BUFFER );
        return FALSE;
    }
 
    GetColorDirectoryW( machine, rgbprofile, &len );
 
    switch (id)
    {
        case LCS_sRGB:
        case LCS_WINDOWS_COLOR_SPACE: /* FIXME */
            lstrcatW( rgbprofile, rgbprofilefile );
            len = lstrlenW( rgbprofile ) * sizeof(WCHAR);
 
            if (*size < len)
            {
                *size = len;
                SetLastError( ERROR_MORE_DATA );
                return FALSE;
            }
 
            lstrcpyW( profile, rgbprofile );
            break;
 
        default:
            SetLastError( ERROR_FILE_NOT_FOUND );
            return FALSE;
    }
    return TRUE;
}

Referenced by GetStandardColorSpaceProfileA(), and init_function_ptrs().

header_from_file()

static BOOL header_from_file ( LPCWSTR  file, PPROFILEHEADER  header  )

static

Definition at line 669 of file profile.c.

{
    static const WCHAR slash[] = {'\\',0};
    BOOL ret;
    PROFILE profile;
    WCHAR path[MAX_PATH];
    DWORD size = sizeof(path);
    HANDLE handle;
 
    ret = GetColorDirectoryW( NULL, path, &size );
    if (!ret)
    {
        WARN( "Can't retrieve color directory\n" );
        return FALSE;
    }
    if (size + sizeof(slash) + sizeof(WCHAR) * lstrlenW( file ) > sizeof(path))
    {
        WARN( "Filename too long\n" );
        return FALSE;
    }
 
    lstrcatW( path, slash );
    lstrcatW( path, file );
 
    profile.dwType = PROFILE_FILENAME;
    profile.pProfileData = path;
    profile.cbDataSize = lstrlenW( path ) + 1;
 
    handle = OpenColorProfileW( &profile, PROFILE_READ, FILE_SHARE_READ, OPEN_EXISTING );
    if (!handle)
    {
        WARN( "Can't open color profile\n" );
        return FALSE;
    }
 
    ret = GetColorProfileHeader( handle, header );
    if (!ret)
        WARN( "Can't retrieve color profile header\n" );
 
    CloseColorProfile( handle );
    return ret;
}

Referenced by EnumColorProfilesA(), and EnumColorProfilesW().

InstallColorProfileA()

BOOL WINAPI InstallColorProfileA	(	PCSTR	machine,
		PCSTR	profile
	)

Definition at line 1074 of file profile.c.

{
    UINT len;
    LPWSTR profileW;
    BOOL ret = FALSE;
 
    TRACE( "( %s )\n", debugstr_a(profile) );
 
    if (machine || !profile) return FALSE;
 
    len = MultiByteToWideChar( CP_ACP, 0, profile, -1, NULL, 0 );
    profileW = HeapAlloc( GetProcessHeap(), 0, len * sizeof(WCHAR) );
 
    if (profileW)
    {
        MultiByteToWideChar( CP_ACP, 0, profile, -1, profileW, len );
 
        ret = InstallColorProfileW( NULL, profileW );
        HeapFree( GetProcessHeap(), 0, profileW );
    }
    return ret;
}

Referenced by init_function_ptrs().

InstallColorProfileW()

BOOL WINAPI InstallColorProfileW	(	PCWSTR	machine,
		PCWSTR	profile
	)

Definition at line 1111 of file profile.c.

{
    WCHAR dest[MAX_PATH], base[MAX_PATH];
    DWORD size = sizeof(dest);
    static const WCHAR slash[] = { '\\', 0 };
 
    TRACE( "( %s )\n", debugstr_w(profile) );
 
    if (machine || !profile) return FALSE;
 
    if (!GetColorDirectoryW( machine, dest, &size )) return FALSE;
 
    basename( profile, base );
 
    lstrcatW( dest, slash );
    lstrcatW( dest, base );
 
    /* Is source equal to destination? */
    if (!lstrcmpW( profile, dest )) return TRUE;
 
    return CopyFileW( profile, dest, TRUE );
}

Referenced by init_function_ptrs(), and InstallColorProfileA().

IsColorProfileTagPresent()

BOOL WINAPI IsColorProfileTagPresent	(	HPROFILE	handle,
		TAGTYPE	type,
		PBOOL	present
	)

Definition at line 1149 of file profile.c.

{
    BOOL ret = FALSE;
#ifdef HAVE_LCMS2
    struct profile *profile = grab_profile( handle );
 
    TRACE( "( %p, 0x%08x, %p )\n", handle, type, present );
 
    if (!profile) return FALSE;
 
    if (!present)
    {
        release_profile( profile );
        return FALSE;
    }
    *present = (cmsIsTag( profile->cmsprofile, type ) != 0);
    release_profile( profile );
    ret = TRUE;
 
#endif /* HAVE_LCMS2 */
    return ret;
}

Referenced by init_function_ptrs().

IsColorProfileValid()

BOOL WINAPI IsColorProfileValid	(	HPROFILE	handle,
		PBOOL	valid
	)

Definition at line 1186 of file profile.c.

{
    BOOL ret = FALSE;
#ifdef HAVE_LCMS2
    struct profile *profile = grab_profile( handle );
 
    TRACE( "( %p, %p )\n", handle, valid );
 
    if (!profile) return FALSE;
 
    if (!valid)
    {
        release_profile( profile );
        return FALSE;
    }
    if (profile->data) ret = *valid = TRUE;
    release_profile( profile );
 
#endif /* HAVE_LCMS2 */
    return ret;
}

match_profile()

static BOOL match_profile ( PENUMTYPEW  rec, PPROFILEHEADER  hdr  )

static

Definition at line 712 of file profile.c.

{
    if (rec->dwFields & ET_DEVICENAME)
    {
        FIXME( "ET_DEVICENAME: %s\n", debugstr_w(rec->pDeviceName) );
    }
    if (rec->dwFields & ET_MEDIATYPE)
    {
        FIXME( "ET_MEDIATYPE: 0x%08x\n", rec->dwMediaType );
    }
    if (rec->dwFields & ET_DITHERMODE)
    {
        FIXME( "ET_DITHERMODE: 0x%08x\n", rec->dwDitheringMode );
    }
    if (rec->dwFields & ET_RESOLUTION)
    {
        FIXME( "ET_RESOLUTION: 0x%08x, 0x%08x\n",
               rec->dwResolution[0], rec->dwResolution[1] );
    }
    if (rec->dwFields & ET_DEVICECLASS)
    {
        FIXME( "ET_DEVICECLASS: %s\n", dbgstr_tag(rec->dwMediaType) );
    }
    if (rec->dwFields & ET_CMMTYPE)
    {
        TRACE( "ET_CMMTYPE: %s\n", dbgstr_tag(rec->dwCMMType) );
        if (rec->dwCMMType != hdr->phCMMType) return FALSE;
    }
    if (rec->dwFields & ET_CLASS)
    {
        TRACE( "ET_CLASS: %s\n", dbgstr_tag(rec->dwClass) );
        if (rec->dwClass != hdr->phClass) return FALSE;
    }
    if (rec->dwFields & ET_DATACOLORSPACE)
    {
        TRACE( "ET_DATACOLORSPACE: %s\n", dbgstr_tag(rec->dwDataColorSpace) );
        if (rec->dwDataColorSpace != hdr->phDataColorSpace) return FALSE;
    }
    if (rec->dwFields & ET_CONNECTIONSPACE)
    {
        TRACE( "ET_CONNECTIONSPACE: %s\n", dbgstr_tag(rec->dwConnectionSpace) );
        if (rec->dwConnectionSpace != hdr->phConnectionSpace) return FALSE;
    }
    if (rec->dwFields & ET_SIGNATURE)
    {
        TRACE( "ET_SIGNATURE: %s\n", dbgstr_tag(rec->dwSignature) );
        if (rec->dwSignature != hdr->phSignature) return FALSE;
    }
    if (rec->dwFields & ET_PLATFORM)
    {
        TRACE( "ET_PLATFORM: %s\n", dbgstr_tag(rec->dwPlatform) );
        if (rec->dwPlatform != hdr->phPlatform) return FALSE;
    }
    if (rec->dwFields & ET_PROFILEFLAGS)
    {
        TRACE( "ET_PROFILEFLAGS: 0x%08x\n", rec->dwProfileFlags );
        if (rec->dwProfileFlags != hdr->phProfileFlags) return FALSE;
    }
    if (rec->dwFields & ET_MANUFACTURER)
    {
        TRACE( "ET_MANUFACTURER: %s\n", dbgstr_tag(rec->dwManufacturer) );
        if (rec->dwManufacturer != hdr->phManufacturer) return FALSE;
    }
    if (rec->dwFields & ET_MODEL)
    {
        TRACE( "ET_MODEL: %s\n", dbgstr_tag(rec->dwModel) );
        if (rec->dwModel != hdr->phModel) return FALSE;
    }
    if (rec->dwFields & ET_ATTRIBUTES)
    {
        TRACE( "ET_ATTRIBUTES: 0x%08x, 0x%08x\n",
               rec->dwAttributes[0], rec->dwAttributes[1] );
        if (rec->dwAttributes[0] != hdr->phAttributes[0] || 
            rec->dwAttributes[1] != hdr->phAttributes[1]) return FALSE;
    }
    if (rec->dwFields & ET_RENDERINGINTENT)
    {
        TRACE( "ET_RENDERINGINTENT: 0x%08x\n", rec->dwRenderingIntent );
        if (rec->dwRenderingIntent != hdr->phRenderingIntent) return FALSE;
    }
    if (rec->dwFields & ET_CREATOR)
    {
        TRACE( "ET_CREATOR: %s\n", dbgstr_tag(rec->dwCreator) );
        if (rec->dwCreator != hdr->phCreator) return FALSE;
    }
    return TRUE;
}

Referenced by EnumColorProfilesA(), and EnumColorProfilesW().

OpenColorProfileA()

HPROFILE WINAPI OpenColorProfileA	(	PPROFILE	profile,
		DWORD	access,
		DWORD	sharing,
		DWORD	creation
	)

Definition at line 1355 of file profile.c.

{
    HPROFILE handle = NULL;
    PROFILE profileW;
 
    TRACE( "( %p, 0x%08x, 0x%08x, 0x%08x )\n", profile, access, sharing, creation );
 
    if (!profile || !profile->pProfileData) return NULL;
 
    /* No AW conversion needed for memory based profiles */
    if (profile->dwType & PROFILE_MEMBUFFER)
        return OpenColorProfileW( profile, access, sharing, creation );
 
    if (!profile_AtoW( profile, &profileW )) return FALSE;
    handle = OpenColorProfileW( &profileW, access, sharing, creation );
    HeapFree( GetProcessHeap(), 0, profileW.pProfileData );
    return handle;
}

Referenced by init_function_ptrs().

OpenColorProfileW()

HPROFILE WINAPI OpenColorProfileW	(	PPROFILE	profile,
		DWORD	access,
		DWORD	sharing,
		DWORD	creation
	)

Definition at line 1396 of file profile.c.

{
#ifdef HAVE_LCMS2
    cmsHPROFILE cmsprofile = NULL;
    char *data = NULL;
    HANDLE handle = INVALID_HANDLE_VALUE;
    DWORD size;
 
    TRACE( "( %p, 0x%08x, 0x%08x, 0x%08x )\n", profile, access, sharing, creation );
 
    if (!profile || !profile->pProfileData) return NULL;
 
    if (profile->dwType == PROFILE_MEMBUFFER)
    {
        /* FIXME: access flags not implemented for memory based profiles */
 
        if (!(data = HeapAlloc( GetProcessHeap(), 0, profile->cbDataSize ))) return NULL;
        memcpy( data, profile->pProfileData, profile->cbDataSize );
 
        if (!(cmsprofile = cmsOpenProfileFromMem( data, profile->cbDataSize )))
        {
            HeapFree( GetProcessHeap(), 0, data );
            return FALSE;
        }
        size = profile->cbDataSize;
    }
    else if (profile->dwType == PROFILE_FILENAME)
    {
        DWORD read, flags = 0;
 
        TRACE( "profile file: %s\n", debugstr_w( profile->pProfileData ) );
 
        if (access & PROFILE_READ) flags = GENERIC_READ;
        if (access & PROFILE_READWRITE) flags = GENERIC_READ|GENERIC_WRITE;
 
        if (!flags) return NULL;
        if (!sharing) sharing = FILE_SHARE_READ;
 
        if (!PathIsRelativeW( profile->pProfileData ))
            handle = CreateFileW( profile->pProfileData, flags, sharing, NULL, creation, 0, NULL );
        else
        {
            WCHAR *path;
 
            if (!GetColorDirectoryW( NULL, NULL, &size ) && GetLastError() == ERROR_MORE_DATA)
            {
                size += (strlenW( profile->pProfileData ) + 2) * sizeof(WCHAR);
                if (!(path = HeapAlloc( GetProcessHeap(), 0, size ))) return NULL;
                GetColorDirectoryW( NULL, path, &size );
                PathAddBackslashW( path );
                strcatW( path, profile->pProfileData );
            }
            else return NULL;
            handle = CreateFileW( path, flags, sharing, NULL, creation, 0, NULL );
            HeapFree( GetProcessHeap(), 0, path );
        }
        if (handle == INVALID_HANDLE_VALUE)
        {
            WARN( "Unable to open color profile %u\n", GetLastError() );
            return NULL;
        }
        if ((size = GetFileSize( handle, NULL )) == INVALID_FILE_SIZE)
        {
            ERR( "Unable to retrieve size of color profile\n" );
            CloseHandle( handle );
            return NULL;
        }
        if (!(data = HeapAlloc( GetProcessHeap(), 0, size )))
        {
            ERR( "Unable to allocate memory for color profile\n" );
            CloseHandle( handle );
            return NULL;
        }
        if (!ReadFile( handle, data, size, &read, NULL ) || read != size)
        {
            ERR( "Unable to read color profile\n" );
 
            CloseHandle( handle );
            HeapFree( GetProcessHeap(), 0, data );
            return NULL;
        }
        if (!(cmsprofile = cmsOpenProfileFromMem( data, size )))
        {
            CloseHandle( handle );
            HeapFree( GetProcessHeap(), 0, data );
            return NULL;
        }
    }
    else
    {
        ERR( "Invalid profile type %u\n", profile->dwType );
        return NULL;
    }
 
    if (cmsprofile)
    {
        struct profile profile;
        HPROFILE hprof;
 
        profile.file       = handle;
        profile.access     = access;
        profile.data       = data;
        profile.size       = size;
        profile.cmsprofile = cmsprofile;
 
        if ((hprof = create_profile( &profile ))) return hprof;
        HeapFree( GetProcessHeap(), 0, data );
        cmsCloseProfile( cmsprofile );
    }
    CloseHandle( handle );
 
#endif /* HAVE_LCMS2 */
    return NULL;
}

Referenced by header_from_file(), init_function_ptrs(), OpenColorProfileA(), set_profile_device_key(), and WcsOpenColorProfileW().

profile_AtoW()

static BOOL profile_AtoW ( const PROFILE *  in, PROFILE *  out  )

static

Definition at line 1338 of file profile.c.

{
    int len;
    if (!in->pProfileData) return FALSE;
    len = MultiByteToWideChar( CP_ACP, 0, in->pProfileData, -1, NULL, 0 );
    if (!(out->pProfileData = HeapAlloc( GetProcessHeap(), 0, len * sizeof(WCHAR) ))) return FALSE;
    out->cbDataSize = len * sizeof(WCHAR);
    MultiByteToWideChar( CP_ACP, 0, in->pProfileData, -1, out->pProfileData, len );
    out->dwType = in->dwType;
    return TRUE;
}

Referenced by OpenColorProfileA(), and WcsOpenColorProfileA().

set_profile_device_key()

static BOOL set_profile_device_key ( PCWSTR  file, const BYTE *  value, DWORD  size  )

static

Definition at line 105 of file profile.c.

{
    static const WCHAR fmtW[] = {'%','c','%','c','%','c','%','c',0};
    static const WCHAR icmW[] = {'S','o','f','t','w','a','r','e','\\',
                                 'M','i','c','r','o','s','o','f','t','\\',
                                 'W','i','n','d','o','w','s',' ','N','T','\\',
                                 'C','u','r','r','e','n','t','V','e','r','s','i','o','n','\\',
                                 'I','C','M',0};
    PROFILEHEADER header;
    PROFILE profile;
    HPROFILE handle;
    HKEY icm_key, class_key;
    WCHAR basenameW[MAX_PATH], classW[5];
 
    profile.dwType = PROFILE_FILENAME;
    profile.pProfileData = (PVOID)file;
    profile.cbDataSize = (lstrlenW( file ) + 1) * sizeof(WCHAR);
 
    /* FIXME is the profile installed? */
    if (!(handle = OpenColorProfileW( &profile, PROFILE_READ, 0, OPEN_EXISTING )))
    {
        SetLastError( ERROR_INVALID_PROFILE );
        return FALSE;
    }
    if (!GetColorProfileHeader( handle, &header ))
    {
        CloseColorProfile( handle );
        SetLastError( ERROR_INVALID_PROFILE );
        return FALSE;
    }
    RegCreateKeyExW( HKEY_LOCAL_MACHINE, icmW, 0, NULL, 0, KEY_ALL_ACCESS, NULL, &icm_key, NULL );
 
    basename( file, basenameW );
    sprintfW( classW, fmtW, (header.phClass >> 24) & 0xff, (header.phClass >> 16) & 0xff,
                            (header.phClass >> 8) & 0xff,  header.phClass & 0xff );
 
    RegCreateKeyExW( icm_key, classW, 0, NULL, 0, KEY_ALL_ACCESS, NULL, &class_key, NULL );
    if (value) RegSetValueExW( class_key, basenameW, 0, REG_BINARY, value, size );
    else RegDeleteValueW( class_key, basenameW );
 
    RegCloseKey( class_key );
    RegCloseKey( icm_key );
    CloseColorProfile( handle );
    return TRUE;
}

Referenced by AssociateColorProfileWithDeviceW(), and DisassociateColorProfileFromDeviceW().

SetColorProfileElement()

BOOL WINAPI SetColorProfileElement	(	HPROFILE	handle,
		TAGTYPE	type,
		DWORD	offset,
		PDWORD	size,
		PVOID	buffer
	)

Definition at line 1225 of file profile.c.

{
    BOOL ret = FALSE;
#ifdef HAVE_LCMS2
    struct profile *profile = grab_profile( handle );
 
    TRACE( "( %p, 0x%08x, %d, %p, %p )\n", handle, type, offset, size, buffer );
 
    if (!profile) return FALSE;
 
    if (!size || !buffer || !(profile->access & PROFILE_READWRITE))
    {
        release_profile( profile );
        return FALSE;
    }
    ret = set_tag_data( profile, type, offset, buffer, size );
    release_profile( profile );
#endif /* HAVE_LCMS2 */
    return ret;
}

Referenced by init_function_ptrs().

SetColorProfileHeader()

BOOL WINAPI SetColorProfileHeader	(	HPROFILE	handle,
		PPROFILEHEADER	header
	)

Definition at line 1260 of file profile.c.

{
#ifdef HAVE_LCMS2
    struct profile *profile = grab_profile( handle );
 
    TRACE( "( %p, %p )\n", handle, header );
 
    if (!profile) return FALSE;
 
    if (!header || !(profile->access & PROFILE_READWRITE))
    {
        release_profile( profile );
        return FALSE;
    }
    set_profile_header( profile, header );
    release_profile( profile );
    return TRUE;
 
#else
    return FALSE;
#endif /* HAVE_LCMS2 */
}

Referenced by init_function_ptrs().

strdupW()

static LPWSTR strdupW ( LPCSTR  str )

inlinestatic

Definition at line 46 of file profile.c.

{
    LPWSTR ret = NULL;
    if (str)
    {
        DWORD len = MultiByteToWideChar( CP_ACP, 0, str, -1, NULL, 0 );
        if ((ret = HeapAlloc( GetProcessHeap(), 0, len * sizeof(WCHAR) )))
            MultiByteToWideChar( CP_ACP, 0, str, -1, ret, len );
    }
    return ret;
}

Referenced by EnumColorProfilesA().

UninstallColorProfileA()

BOOL WINAPI UninstallColorProfileA	(	PCSTR	machine,
		PCSTR	profile,
		BOOL	delete
	)

Definition at line 1288 of file profile.c.

{
    UINT len;
    LPWSTR profileW;
    BOOL ret = FALSE;
 
    TRACE( "( %s, %x )\n", debugstr_a(profile), delete );
 
    if (machine || !profile) return FALSE;
 
    len = MultiByteToWideChar( CP_ACP, 0, profile, -1, NULL, 0 );
    profileW = HeapAlloc( GetProcessHeap(), 0, len * sizeof(WCHAR) );
 
    if (profileW)
    {
        MultiByteToWideChar( CP_ACP, 0, profile, -1, profileW, len );
 
        ret = UninstallColorProfileW( NULL, profileW , delete );
 
        HeapFree( GetProcessHeap(), 0, profileW );
    }
    return ret;
}

Referenced by init_function_ptrs().

UninstallColorProfileW()

BOOL WINAPI UninstallColorProfileW	(	PCWSTR	machine,
		PCWSTR	profile,
		BOOL	delete
	)

Definition at line 1327 of file profile.c.

{
    TRACE( "( %s, %x )\n", debugstr_w(profile), delete );
 
    if (machine || !profile) return FALSE;
 
    if (delete) return DeleteFileW( profile );
 
    return TRUE;
}

Referenced by init_function_ptrs(), and UninstallColorProfileA().

WcsEnumColorProfilesSize()

BOOL WINAPI WcsEnumColorProfilesSize	(	WCS_PROFILE_MANAGEMENT_SCOPE	scope,
		ENUMTYPEW *	record,
		DWORD *	size
	)

Definition at line 1548 of file profile.c.

{
    FIXME( "%d %p %p\n", scope, record, size );
    SetLastError( ERROR_CALL_NOT_IMPLEMENTED );
    return FALSE;
}

WcsGetUsePerUserProfiles()

BOOL WINAPI WcsGetUsePerUserProfiles	(	const WCHAR *	name,
		DWORD	class,
		BOOL *	use_per_user_profile
	)

Definition at line 1538 of file profile.c.

{
    FIXME( "%s %s %p\n", debugstr_w(name), dbgstr_tag(class), use_per_user_profile );
    SetLastError( ERROR_CALL_NOT_IMPLEMENTED );
    return FALSE;
}

WcsOpenColorProfileA()

HPROFILE WINAPI WcsOpenColorProfileA	(	PROFILE *	cdm,
		PROFILE *	camp,
		PROFILE *	gmmp,
		DWORD	access,
		DWORD	sharing,
		DWORD	creation,
		DWORD	flags
	)

Definition at line 1558 of file profile.c.

{
    PROFILE cdmW, campW = {0}, gmmpW = {0};
    HPROFILE ret = NULL;
 
    TRACE( "%p, %p, %p, %08x, %08x, %08x, %08x\n", cdm, camp, gmmp, access, sharing, creation, flags );
 
    if (!cdm || !profile_AtoW( cdm, &cdmW )) return NULL;
    if (camp && !profile_AtoW( camp, &campW )) goto done;
    if (gmmp && !profile_AtoW( gmmp, &gmmpW )) goto done;
 
    ret = WcsOpenColorProfileW( &cdmW, &campW, &gmmpW, access, sharing, creation, flags );
 
done:
    HeapFree( GetProcessHeap(), 0, cdmW.pProfileData );
    HeapFree( GetProcessHeap(), 0, campW.pProfileData );
    HeapFree( GetProcessHeap(), 0, gmmpW.pProfileData );
    return ret;
}

WcsOpenColorProfileW()

HPROFILE WINAPI WcsOpenColorProfileW	(	PROFILE *	cdm,
		PROFILE *	camp,
		PROFILE *	gmmp,
		DWORD	access,
		DWORD	sharing,
		DWORD	creation,
		DWORD	flags
	)

Definition at line 1582 of file profile.c.

{
    TRACE( "%p, %p, %p, %08x, %08x, %08x, %08x\n", cdm, camp, gmmp, access, sharing, creation, flags );
    FIXME("no support for WCS profiles\n" );
 
    return OpenColorProfileW( cdm, access, sharing, creation );
}

Referenced by WcsOpenColorProfileA().

WINE_DEFAULT_DEBUG_CHANNEL()

WINE_DEFAULT_DEBUG_CHANNEL

(

mscms

)