/****************************Module*Header******************************\ * Module Name: PROFMAN.C * * Module Descripton: Profile management functions. * * Warnings: * * Issues: * * Public Routines: * * Created: 5 Nov 1996 * * Author: Srinivasan Chandrasekar [srinivac] * * Copyright (c) 1996, 1997 Microsoft Corporation \***********************************************************************/ #include "mscms.h" #include "objbase.h" #include "initguid.h" #include "devguid.h" #include "sti.h" #define TAG_DEVICESETTINGS 'devs' #define TAG_MS01 'MS01' #define TAG_MS02 'MS02' #define TAG_MS03 'MS03' #define ID_MSFT_REVERSED 'tfsm' #define ID_MEDIATYPE_REVERSED 'aidm' #define ID_DITHER_REVERSED 'ntfh' #define ID_RESLN_REVERSED 'nlsr' #define DEVICE_PROFILE_DATA 1 #define DEVICE_PROFILE_ENUMMODE 2 // // Local types // typedef enum { NOMATCH = 0, MATCH = 1, EXACT_MATCH = 2, } MATCHTYPE; typedef struct tagREGDATA { DWORD dwRefCount; DWORD dwManuID; DWORD dwModelID; } REGDATA, *PREGDATA; typedef struct tagSCANNERDATA { PWSTR pDeviceName; HINSTANCE hModule; PSTI pSti; } SCANNERDATA, *PSCANNERDATA; typedef BOOL (WINAPI *PFNOPENDEVICE)(PTSTR, LPHANDLE, PTSTR); typedef BOOL (WINAPI *PFNCLOSEDEVICE)(HANDLE); typedef DWORD (WINAPI *PFNGETDEVICEDATA)(HANDLE, PTSTR, PTSTR, PDWORD, PBYTE, DWORD, PDWORD); typedef DWORD (WINAPI *PFNSETDEVICEDATA)(HANDLE, PTSTR, PTSTR, DWORD, PBYTE, DWORD); typedef HRESULT (__stdcall *PFNSTICREATEINSTANCE)(HINSTANCE, DWORD, PSTI*, LPDWORD); // // Local functions // BOOL InternalGetColorDirectory(LPCTSTR, PTSTR, DWORD*); BOOL InternalInstallColorProfile(LPCTSTR, LPCTSTR); BOOL InternalUninstallColorProfile(LPCTSTR, LPCTSTR, BOOL); BOOL InternalAssociateColorProfileWithDevice(LPCTSTR, LPCTSTR, LPCTSTR); BOOL InternalDisassociateColorProfileFromDevice(LPCTSTR, LPCTSTR, LPCTSTR); BOOL InternalEnumColorProfiles(LPCTSTR, PENUMTYPE, PBYTE, PDWORD, PDWORD); BOOL InternalSetSCSProfile(LPCTSTR, DWORD, LPCTSTR); BOOL InternalGetSCSProfile(LPCTSTR, DWORD, PTSTR, PDWORD); VOID ConvertDwordToString(DWORD, PTSTR); PTSTR ConvertClassIdToClassString(DWORD); BOOL GetProfileClassString(LPCTSTR, PTSTR, PPROFILEHEADER); BOOL GetDeviceData(LPCTSTR, DWORD, DWORD, PVOID*, PDWORD, BOOL); BOOL SetDeviceData(LPCTSTR, DWORD, DWORD, PVOID, DWORD); BOOL IGetDeviceData(LPCTSTR, DWORD, DWORD, PVOID*, PDWORD, BOOL); BOOL ISetDeviceData(LPCTSTR, DWORD, DWORD, PVOID, DWORD); BOOL IsStringInMultiSz(PTSTR, PTSTR); DWORD RemoveStringFromMultiSz(PTSTR, PTSTR, DWORD); VOID InsertInBuffer(PBYTE, PBYTE, PTSTR); MATCHTYPE DoesProfileMatchEnumRecord(PTSTR, PENUMTYPE); MATCHTYPE CheckResMedHftnMatch(HPROFILE, PENUMTYPE); BOOL DwordMatches(PSETTINGS, DWORD); BOOL QwordMatches(PSETTINGS, PDWORD); BOOL WINAPI OpenPrtr(PTSTR, LPHANDLE, PTSTR); BOOL WINAPI ClosePrtr(HANDLE); DWORD WINAPI GetPrtrData(HANDLE, PTSTR, PTSTR, PDWORD, PBYTE, DWORD, PDWORD); DWORD WINAPI SetPrtrData(HANDLE, PTSTR, PTSTR, DWORD, PBYTE, DWORD); BOOL WINAPI OpenMonitor(PTSTR, LPHANDLE, PTSTR); BOOL WINAPI CloseMonitor(HANDLE); DWORD WINAPI GetMonitorData(HANDLE, PTSTR, PTSTR, PDWORD, PBYTE, DWORD, PDWORD); DWORD WINAPI SetMonitorData(HANDLE, PTSTR, PTSTR, DWORD, PBYTE, DWORD); BOOL WINAPI OpenScanner(PTSTR, LPHANDLE, PTSTR); BOOL WINAPI CloseScanner(HANDLE); DWORD WINAPI GetScannerData(HANDLE, PTSTR, PTSTR, PDWORD, PBYTE, DWORD, PDWORD); DWORD WINAPI SetScannerData(HANDLE, PTSTR, PTSTR, DWORD, PBYTE, DWORD); #ifdef _WIN95_ BOOL LoadSetupAPIDll(VOID); #else VOID ChangeICMSetting(LPCTSTR, LPCTSTR, DWORD); #endif // _WIN95_ // // SetupAPI function pointers // typedef WINSETUPAPI HKEY (WINAPI *FP_SetupDiOpenDevRegKey)( IN HDEVINFO DeviceInfoSet, IN PSP_DEVINFO_DATA DeviceInfoData, IN DWORD Scope, IN DWORD HwProfile, IN DWORD KeyType, IN REGSAM samDesired ); typedef WINSETUPAPI BOOL (WINAPI *FP_SetupDiDestroyDeviceInfoList)( IN HDEVINFO DeviceInfoSet ); typedef WINSETUPAPI BOOL (WINAPI *FP_SetupDiEnumDeviceInfo)( IN HDEVINFO DeviceInfoSet, IN DWORD MemberIndex, OUT PSP_DEVINFO_DATA DeviceInfoData ); #if !defined(_WIN95_) typedef WINSETUPAPI BOOL (WINAPI *FP_SetupDiGetDeviceInstanceId)( IN HDEVINFO DeviceInfoSet, IN PSP_DEVINFO_DATA DeviceInfoData, OUT PWSTR DeviceInstanceId, IN DWORD DeviceInstanceIdSize, OUT PDWORD RequiredSize OPTIONAL ); typedef WINSETUPAPI HDEVINFO (WINAPI *FP_SetupDiGetClassDevs)( IN LPGUID ClassGuid, OPTIONAL IN PCWSTR Enumerator, OPTIONAL IN HWND hwndParent, OPTIONAL IN DWORD Flags ); #else typedef WINSETUPAPI BOOL (WINAPI *FP_SetupDiGetDeviceInstanceId)( IN HDEVINFO DeviceInfoSet, IN PSP_DEVINFO_DATA DeviceInfoData, OUT PSTR DeviceInstanceId, IN DWORD DeviceInstanceIdSize, OUT PDWORD RequiredSize OPTIONAL ); typedef WINSETUPAPI HDEVINFO (WINAPI *FP_SetupDiGetClassDevs)( IN LPGUID ClassGuid, OPTIONAL IN PCSTR Enumerator, OPTIONAL IN HWND hwndParent, OPTIONAL IN DWORD Flags ); #endif HMODULE ghModSetupAPIDll = NULL; FP_SetupDiOpenDevRegKey fpSetupDiOpenDevRegKey = NULL; FP_SetupDiDestroyDeviceInfoList fpSetupDiDestroyDeviceInfoList = NULL; FP_SetupDiEnumDeviceInfo fpSetupDiEnumDeviceInfo = NULL; FP_SetupDiGetDeviceInstanceId fpSetupDiGetDeviceInstanceId = NULL; FP_SetupDiGetClassDevs fpSetupDiGetClassDevs = NULL; // // Predefined profiles in order - INF file has 1-based index into this list // TCHAR *gszDispProfiles[] = { __TEXT("mnB22G15.icm"), // 1 __TEXT("mnB22G18.icm"), // 2 __TEXT("mnB22G21.icm"), // 3 __TEXT("mnEBUG15.icm"), // 4 __TEXT("mnEBUG18.icm"), // 5 __TEXT("mnEBUG21.icm"), // 6 __TEXT("mnP22G15.icm"), // 7 __TEXT("mnP22G18.icm"), // 8 __TEXT("mnP22G21.icm"), // 9 __TEXT("Diamond Compatible 9300K G2.2.icm"), // 10 __TEXT("Hitachi Compatible 9300K G2.2.icm"), // 11 __TEXT("NEC Compatible 9300K G2.2.icm"), // 12 __TEXT("Trinitron Compatible 9300K G2.2.icm"), // 13 }; TCHAR *gpszClasses[] = { // different profile classes __TEXT("mntr"), // 0 __TEXT("prtr"), // 1 __TEXT("scnr"), // 2 __TEXT("link"), // 3 __TEXT("abst"), // 4 __TEXT("spac"), // 5 __TEXT("nmcl") // 6 }; #define INDEX_CLASS_MONITOR 0 #define INDEX_CLASS_PRINTER 1 #define INDEX_CLASS_SCANNER 2 #define INDEX_CLASS_LINK 3 #define INDEX_CLASS_ABSTRACT 4 #define INDEX_CLASS_COLORSPACE 5 #define INDEX_CLASS_NAMED 6 /****************************************************************************** * * GetColorDirectory * * Function: * These are the ANSI & Unicode wrappers for InternalGetColorDirectory. * Please see InternalGetColorDirectory for more details on this * function. * * Arguments: * pMachineName - name identifying machine on which the path * to the color directory is requested * pBuffer - pointer to buffer to receive pathname * pdwSize - pointer to size of buffer. On return it has size of * buffer needed if failure, and used on success * * Returns: * TRUE if successful, NULL otherwise * ******************************************************************************/ #ifdef UNICODE // Windows NT versions BOOL WINAPI GetColorDirectoryA( PCSTR pMachineName, PSTR pBuffer, PDWORD pdwSize ) { PWSTR pwszMachineName = NULL; // Unicode machine name PWSTR pwBuffer = NULL; // Unicode color directory path DWORD dwSize; // size of Unicode buffer DWORD dwErr = 0; // error code BOOL rc = TRUE; // return code TRACEAPI((__TEXT("GetColorDirectoryA\n"))); // // Validate parameters before we touch them // if (!pdwSize || IsBadWritePtr(pdwSize, sizeof(DWORD)) || (pBuffer && IsBadWritePtr(pBuffer, *pdwSize))) { WARNING((__TEXT("Invalid parameter to GetColorDirectory\n"))); SetLastError(ERROR_INVALID_PARAMETER); return FALSE; } // // Convert machine name to Unicode // if (pMachineName) { rc = ConvertToUnicode(pMachineName, &pwszMachineName, TRUE); } else pwszMachineName = NULL; dwSize = *pdwSize * sizeof(WCHAR); // // Create a buffer to get Unicode directory from system // if (pBuffer && dwSize) { pwBuffer = (PWSTR)MemAlloc(dwSize); if (! pwBuffer) { WARNING((__TEXT("Error allocating memory for Unicode string\n"))); SetLastError(ERROR_NOT_ENOUGH_MEMORY); rc = FALSE; goto EndGetColorDirectoryA; } } rc = rc && InternalGetColorDirectory(pwszMachineName, pwBuffer, &dwSize); *pdwSize = dwSize / sizeof(WCHAR); // // Convert Unicode path to Ansi // if (pwBuffer) { rc = rc && ConvertToAnsi(pwBuffer, &pBuffer, FALSE); } EndGetColorDirectoryA: if (pwszMachineName) { MemFree(pwszMachineName); } if (pwBuffer) { MemFree(pwBuffer); } return rc; } BOOL WINAPI GetColorDirectoryW( PCWSTR pMachineName, PWSTR pBuffer, PDWORD pdwSize ) { TRACEAPI((__TEXT("GetColorDirectoryW\n"))); // // Internal function is ANSI in Windows 95, call it directly. // return InternalGetColorDirectory(pMachineName, pBuffer, pdwSize); } #else // Windows 95 versions BOOL WINAPI GetColorDirectoryA( PCSTR pMachineName, PSTR pBuffer, PDWORD pdwSize ) { TRACEAPI((__TEXT("GetColorDirectoryA\n"))); // // Internal function is ANSI in Windows 95, call it directly. // return InternalGetColorDirectory(pMachineName, pBuffer, pdwSize); } BOOL WINAPI GetColorDirectoryW( PCWSTR pMachineName, PWSTR pBuffer, PDWORD pdwSize ) { PSTR pszMachineName = NULL; // Ansi machine name PSTR pszBuffer = NULL; // Ansi color directory path DWORD dwSize; // size of Ansi buffer BOOL rc = TRUE; // return code TRACEAPI((__TEXT("GetColorDirectoryW\n"))); // // Validate parameters before we touch them // if (!pdwSize || IsBadWritePtr(pdwSize, sizeof(DWORD)) || (pBuffer && IsBadWritePtr(pBuffer, *pdwSize))) { WARNING((__TEXT("Invalid parameter to GetColorDirectory\n"))); SetLastError(ERROR_INVALID_PARAMETER); return FALSE; } // // Convert machine name to Ansi // if (pMachineName) { rc = ConvertToAnsi(pMachineName, &pszMachineName, TRUE); } else pszMachineName = NULL; // // Create a buffer to get Ansi directory from system // dwSize = *pdwSize / sizeof(WCHAR); if (pBuffer && dwSize) { pszBuffer = (PSTR)MemAlloc(dwSize); if (! pszBuffer) { WARNING((__TEXT("Error allocating memory for Ansi string\n"))); SetLastError(ERROR_NOT_ENOUGH_MEMORY); rc = FALSE; goto EndGetColorDirectoryW; } } rc = rc && InternalGetColorDirectory(pszMachineName, pszBuffer, &dwSize); *pdwSize = dwSize * sizeof(WCHAR); // // Convert Ansi path to Unicode // if (pszBuffer) { rc = rc && ConvertToUnicode(pszBuffer, &pBuffer, FALSE); } EndGetColorDirectoryW: if (pszMachineName) { MemFree(pszMachineName); } if (pszBuffer) { MemFree(pszBuffer); } return rc; } #endif // ! UNICODE /****************************************************************************** * * InstallColorProfile * * Function: * These are the ANSI & Unicode wrappers for InternalInstallColorProfile. * Please see InternalInstallColorProfile for more details on this * function. * * Arguments: * pMachineName - name identifying machine on which the profile * should be installed. NULL implies local * pProfileName - pointer to filename of profile to install * * Returns: * TRUE if successful, NULL otherwise * ******************************************************************************/ #ifdef UNICODE // Windows NT versions BOOL WINAPI InstallColorProfileA( PCSTR pMachineName, PCSTR pProfileName ) { PWSTR pwszMachineName = NULL; // Unicode machine name PWSTR pwszProfileName = NULL; // Unicode profile name BOOL rc = TRUE; // return code TRACEAPI((__TEXT("InstallColorProfileA\n"))); // // Validate parameters before we touch them // if (!pProfileName) { WARNING((__TEXT("Invalid parameter to InstallColorProfile\n"))); SetLastError(ERROR_INVALID_PARAMETER); return FALSE; } // // Convert machine name to Unicode // if (pMachineName) { rc = ConvertToUnicode(pMachineName, &pwszMachineName, TRUE); } else pwszMachineName = NULL; // // Convert profile name to Unicode // rc = rc && ConvertToUnicode(pProfileName, &pwszProfileName, TRUE); // // Call the internal Unicode function // rc = rc && InternalInstallColorProfile(pwszMachineName, pwszProfileName); // // Free memory before leaving // if (pwszProfileName) { MemFree(pwszProfileName); } if (pwszMachineName) { MemFree(pwszMachineName); } return rc; } BOOL WINAPI InstallColorProfileW( PCWSTR pMachineName, PCWSTR pProfileName ) { TRACEAPI((__TEXT("InstallColorProfileW\n"))); // // Internal function is Unicode in Windows NT, call it directly. // return InternalInstallColorProfile(pMachineName, pProfileName); } #else // Windows 95 versions BOOL WINAPI InstallColorProfileA( PCSTR pMachineName, PCSTR pProfileName ) { TRACEAPI((__TEXT("InstallColorProfileA\n"))); // // Internal function is ANSI in Windows 95, call it directly. // return InternalInstallColorProfile(pMachineName, pProfileName); } BOOL WINAPI InstallColorProfileW( PCWSTR pMachineName, PCWSTR pProfileName ) { PSTR pszMachineName = NULL; // Ansi machine name PSTR pszProfileName = NULL; // Ansi profile name BOOL rc = TRUE; // return code TRACEAPI((__TEXT("InstallColorProfileW\n"))); // // Validate parameters before we touch them // if (!pProfileName) { WARNING((__TEXT("Invalid parameter to InstallColorProfile\n"))); SetLastError(ERROR_INVALID_PARAMETER); return FALSE; } // // Convert machine name to Ansi // if (pMachineName) { rc = ConvertToAnsi(pMachineName, &pszMachineName, TRUE); } else pszMachineName = NULL; // // Convert profile name to Ansi // rc = rc && ConvertToAnsi(pProfileName, &pszProfileName, TRUE); // // Call the internal Ansi function // rc = rc && InternalInstallColorProfile(pszMachineName, pszProfileName); // // Free memory before leaving // if (pszProfileName) { MemFree(pszProfileName); } if (pszMachineName) { MemFree(pszMachineName); } return rc; } #endif // ! UNICODE /****************************************************************************** * * UninstallColorProfile * * Function: * These are the ANSI & Unicode wrappers for InternalUninstallColorProfile. * Please see InternalUninstallColorProfile for more details on this * function. * * Arguments: * pMachineName - name identifying machine on which the profile * should be uninstalled. NULL implies local * pProfileName - pointer to filename of profile to uninstall * bDelete - TRUE if profile should be deleted in disk * * Returns: * TRUE if successful, NULL otherwise * ******************************************************************************/ #ifdef UNICODE // Windows NT versions BOOL WINAPI UninstallColorProfileA( PCSTR pMachineName, PCSTR pProfileName, BOOL bDelete ) { PWSTR pwszMachineName = NULL; // Unicode machine name PWSTR pwszProfileName = NULL; // Unicode profile name BOOL rc = TRUE; // return code TRACEAPI((__TEXT("UninstallColorProfileA\n"))); // // Validate parameters before we touch them // if (!pProfileName) { WARNING((__TEXT("Invalid parameter to UninstallColorProfile\n"))); SetLastError(ERROR_INVALID_PARAMETER); return FALSE; } // // Convert machine name to Unicode // if (pMachineName) { rc = ConvertToUnicode(pMachineName, &pwszMachineName, TRUE); } else pwszMachineName = NULL; // // Convert profile name to Unicode // rc = rc && ConvertToUnicode(pProfileName, &pwszProfileName, TRUE); // // Call the internal Unicode function // rc = rc && InternalUninstallColorProfile(pwszMachineName, pwszProfileName, bDelete); // // Free memory before leaving // if (pwszProfileName) { MemFree(pwszProfileName); } if (pwszMachineName) { MemFree(pwszMachineName); } return rc; } BOOL WINAPI UninstallColorProfileW( PCWSTR pMachineName, PCWSTR pProfileName, BOOL bDelete ) { TRACEAPI((__TEXT("UninstallColorProfileW\n"))); // // Internal function is Unicode in Windows NT, call it directly. // return InternalUninstallColorProfile(pMachineName, pProfileName, bDelete); } #else // Windows 95 versions BOOL WINAPI UninstallColorProfileA( PCSTR pMachineName, PCSTR pProfileName, BOOL bDelete ) { TRACEAPI((__TEXT("UninstallColorProfileA\n"))); // // Internal function is ANSI in Windows 95, call it directly. // return InternalUninstallColorProfile(pMachineName, pProfileName, bDelete); } BOOL WINAPI UninstallColorProfileW( PCWSTR pMachineName, PCWSTR pProfileName, BOOL bDelete ) { PSTR pszMachineName = NULL; // Ansi machine name PSTR pszProfileName = NULL; // Ansi profile name BOOL rc = TRUE; // return code TRACEAPI((__TEXT("UninstallColorProfileW\n"))); // // Validate parameters before we touch them // if (!pProfileName) { WARNING((__TEXT("Invalid parameter to UninstallColorProfile\n"))); SetLastError(ERROR_INVALID_PARAMETER); return FALSE; } // // Convert machine name to Ansi // if (pMachineName) { rc = ConvertToAnsi(pMachineName, &pszMachineName, TRUE); } else pszMachineName = NULL; // // Convert profile name to Ansi // rc = rc && ConvertToAnsi(pProfileName, &pszProfileName, TRUE); // // Call the internal Ansi function // rc = rc && InternalUninstallColorProfile(pszMachineName, pszProfileName, bDelete); // // Free memory before leaving // if (pszProfileName) { MemFree(pszProfileName); } if (pszMachineName) { MemFree(pszMachineName); } return rc; } #endif // ! UNICODE /****************************************************************************** * * AssociateColorProfileWithDevice * * Function: * These are the ANSI & Unicode wrappers for * InternalAssociateColorProfileWithDevice. Please see * InternalAssociateColorProfileWithDevice for more details * on this function. * * Arguments: * pMachineName - name identifying machine. NULL implies local * pProfileName - pointer to profile to associate * pDeviceName - pointer to device name * * Returns: * TRUE if successful, NULL otherwise * ******************************************************************************/ #ifdef UNICODE // Windows NT versions BOOL WINAPI AssociateColorProfileWithDeviceA( PCSTR pMachineName, PCSTR pProfileName, PCSTR pDeviceName ) { PWSTR pwszMachineName = NULL; // Unicode machine name PWSTR pwszProfileName = NULL; // Unicode profile name PWSTR pwszDeviceName = NULL; // Unicode device name BOOL rc = TRUE; // return code TRACEAPI((__TEXT("AssociateColorProfileWithDeviceA\n"))); // // Validate parameters before we touch them // if (! pProfileName || ! pDeviceName) { WARNING((__TEXT("Invalid parameter to AssociateColorProfileWithDevice\n"))); SetLastError(ERROR_INVALID_PARAMETER); return FALSE; } // // Convert machine name to Unicode // if (pMachineName) { rc = ConvertToUnicode(pMachineName, &pwszMachineName, TRUE); } else pwszMachineName = NULL; // // Convert profile name to Unicode // rc = rc && ConvertToUnicode(pProfileName, &pwszProfileName, TRUE); // // Convert device name to Unicode // rc = rc && ConvertToUnicode(pDeviceName, &pwszDeviceName, TRUE); // // Call the internal Unicode function // rc = rc && InternalAssociateColorProfileWithDevice(pwszMachineName, pwszProfileName, pwszDeviceName); // // Free memory before leaving // if (pwszProfileName) { MemFree(pwszProfileName); } if (pwszMachineName) { MemFree(pwszMachineName); } if (pwszDeviceName) { MemFree(pwszDeviceName); } return rc; } BOOL WINAPI AssociateColorProfileWithDeviceW( PCWSTR pMachineName, PCWSTR pProfileName, PCWSTR pDeviceName ) { TRACEAPI((__TEXT("AssociateColorProfileWithDeviceW\n"))); // // Internal function is Unicode in Windows NT, call it directly. // return InternalAssociateColorProfileWithDevice(pMachineName, pProfileName, pDeviceName); } #else // Windows 95 versions BOOL WINAPI AssociateColorProfileWithDeviceA( PCSTR pMachineName, PCSTR pProfileName, PCSTR pDeviceName ) { TRACEAPI((__TEXT("AssociateColorProfileWithDeviceA\n"))); // // Internal function is ANSI in Windows 95, call it directly. // return InternalAssociateColorProfileWithDevice(pMachineName, pProfileName, pDeviceName); } BOOL WINAPI AssociateColorProfileWithDeviceW( PCWSTR pMachineName, PCWSTR pProfileName, PCWSTR pDeviceName ) { PSTR pszMachineName = NULL; // Ansi machine name PSTR pszProfileName = NULL; // Ansi profile name PSTR pszDeviceName = NULL; // Ansi device name BOOL rc = TRUE; // return code TRACEAPI((__TEXT("AssociateColorProfileWithDeviceW\n"))); // // Validate parameters before we touch them // if (! pProfileName || ! pDeviceName) { WARNING((__TEXT("Invalid parameter to AssociateColorProfileWithDevice\n"))); SetLastError(ERROR_INVALID_PARAMETER); return FALSE; } // // Convert machine name to Ansi // if (pMachineName) { rc = ConvertToAnsi(pMachineName, &pszMachineName, TRUE); } else pszMachineName = NULL; // // Convert profile name to Ansi // rc = rc && ConvertToAnsi(pProfileName, &pszProfileName, TRUE); // // Convert device name to Ansi // rc = rc && ConvertToAnsi(pDeviceName, &pszDeviceName, TRUE); // // Call the internal Ansi function // rc = rc && InternalAssociateColorProfileWithDevice(pszMachineName, pszProfileName, pszDeviceName); // // Free memory before leaving // if (pszProfileName) { MemFree(pszProfileName); } if (pszMachineName) { MemFree(pszMachineName); } if (pszDeviceName) { MemFree(pszDeviceName); } return rc; } #endif // ! UNICODE /****************************************************************************** * * DisassociateColorProfileFromDevice * * Function: * These are the ANSI & Unicode wrappers for * InternalDisassociateColorProfileFromDevice. Please see * InternalDisassociateColorProfileFromDevice for more details * on this function. * * Arguments: * pMachineName - name identifying machine. NULL implies local * pProfileName - pointer to profile to disassiciate * pDeviceName - pointer to device name * * Returns: * TRUE if successful, NULL otherwise * ******************************************************************************/ #ifdef UNICODE // Windows NT versions BOOL WINAPI DisassociateColorProfileFromDeviceA( PCSTR pMachineName, PCSTR pProfileName, PCSTR pDeviceName ) { PWSTR pwszMachineName = NULL; // Unicode machine name PWSTR pwszProfileName = NULL; // Unicode profile name PWSTR pwszDeviceName = NULL; // Unicode device name BOOL rc = TRUE; // return code TRACEAPI((__TEXT("DisassociateColorProfileWithDeviceA\n"))); // // Validate parameters before we touch them // if (! pProfileName || ! pDeviceName) { WARNING((__TEXT("Invalid parameter to DisassociateColorProfileFromDevice\n"))); SetLastError(ERROR_INVALID_PARAMETER); return FALSE; } // // Convert machine name to Unicode // if (pMachineName) { rc = ConvertToUnicode(pMachineName, &pwszMachineName, TRUE); } else pwszMachineName = NULL; // // Convert profile name to Unicode // rc = rc && ConvertToUnicode(pProfileName, &pwszProfileName, TRUE); // // Convert device name to Unicode // rc = rc && ConvertToUnicode(pDeviceName, &pwszDeviceName, TRUE); // // Call the internal Unicode function // rc = rc && InternalDisassociateColorProfileFromDevice(pwszMachineName, pwszProfileName, pwszDeviceName); // // Free memory before leaving // if (pwszProfileName) { MemFree(pwszProfileName); } if (pwszMachineName) { MemFree(pwszMachineName); } if (pwszDeviceName) { MemFree(pwszDeviceName); } return rc; } BOOL WINAPI DisassociateColorProfileFromDeviceW( PCWSTR pMachineName, PCWSTR pProfileName, PCWSTR pDeviceName ) { TRACEAPI((__TEXT("DisassociateColorProfileWithDeviceW\n"))); // // Internal function is Unicode in Windows NT, call it directly. // return InternalDisassociateColorProfileFromDevice(pMachineName, pProfileName, pDeviceName); } #else // Windows 95 versions BOOL WINAPI DisassociateColorProfileFromDeviceA( PCSTR pMachineName, PCSTR pProfileName, PCSTR pDeviceName ) { TRACEAPI((__TEXT("DisassociateColorProfileWithDeviceA\n"))); // // Internal function is ANSI in Windows 95, call it directly. // return InternalDisassociateColorProfileFromDevice(pMachineName, pProfileName, pDeviceName); } BOOL WINAPI DisassociateColorProfileFromDeviceW( PCWSTR pMachineName, PCWSTR pProfileName, PCWSTR pDeviceName ) { PSTR pszMachineName = NULL; // Ansi machine name PSTR pszProfileName = NULL; // Ansi profile name PSTR pszDeviceName = NULL; // Ansi device name BOOL rc = TRUE; // return code TRACEAPI((__TEXT("DisassociateColorProfileWithDeviceW\n"))); // // Validate parameters before we touch them // if (! pProfileName || ! pDeviceName) { WARNING((__TEXT("Invalid parameter to AssociateColorProfileWithDevice\n"))); SetLastError(ERROR_INVALID_PARAMETER); return FALSE; } // // Convert machine name to Ansi // if (pMachineName) { rc = ConvertToAnsi(pMachineName, &pszMachineName, TRUE); } else pszMachineName = NULL; // // Convert profile name to Ansi // rc = rc && ConvertToAnsi(pProfileName, &pszProfileName, TRUE); // // Convert device name to Ansi // rc = rc && ConvertToAnsi(pDeviceName, &pszDeviceName, TRUE); // // Call the internal Ansi function // rc = rc && InternalDisassociateColorProfileFromDevice(pszMachineName, pszProfileName, pszDeviceName); // // Free memory before leaving // if (pszProfileName) { MemFree(pszProfileName); } if (pszMachineName) { MemFree(pszMachineName); } if (pszDeviceName) { MemFree(pszDeviceName); } return rc; } #endif // ! UNICODE /****************************************************************************** * * EnumColorProfiles * * Function: * These are the ANSI & Unicode wrappers for InternalEnumColorProfile. * Please see InternalEnumColorProfile for more details on this * function. * * Arguments: * pMachineName - name identifying machine on which the enumeration * needs to be done * pEnumRecord - pointer to enumeration criteria * pBuffer - pointer to buffer to receive result, can be NULL * pdwSize - pointer to buffer size. On return it is actual number * of bytes copied/needed. * pnProfiles - pointer to DWORD. On return, it is number of profiles * copied to pBuffer. * * Returns: * TRUE if successful, NULL otherwise * ******************************************************************************/ #ifdef UNICODE // Windows NT versions BOOL WINAPI EnumColorProfilesA( PCSTR pMachineName, PENUMTYPEA pEnumRecord, PBYTE pBuffer, PDWORD pdwSize, PDWORD pnProfiles ) { PWSTR pwszMachineName = NULL; // Unicode machine name PWSTR pwszDeviceName = NULL; // Unicode device name PSTR pAnsiDeviceName = NULL; // incoming Ansi device name PWSTR pwBuffer = NULL; // buffer to receive data PWSTR pwTempBuffer = NULL; // temporary pointer to buffer DWORD dwSize; // size of buffer DWORD dwSizeOfStruct; // size of ENUMTYPE structure DWORD dwVersion; // ENUMTYPE structure version BOOL rc = TRUE; // return code TRACEAPI((__TEXT("EnumColorProfilesA\n"))); // // Validate parameters before we touch them // if (! pdwSize || IsBadWritePtr(pdwSize, sizeof(DWORD)) || (pBuffer && IsBadWritePtr(pBuffer, *pdwSize)) || ! pEnumRecord || IsBadReadPtr(pEnumRecord, sizeof(DWORD)*3)) // probe until ENUMTYPE.dwFields { ParameterError_EnumColorProfilesA: WARNING((__TEXT("Invalid parameter to EnumColorProfiles\n"))); SetLastError(ERROR_INVALID_PARAMETER); return FALSE; } // // Check structure size based on its version. // dwSizeOfStruct = pEnumRecord->dwSize; dwVersion = pEnumRecord->dwVersion; if (dwVersion >= ENUM_TYPE_VERSION) { if (dwSizeOfStruct < sizeof(ENUMTYPE)) goto ParameterError_EnumColorProfilesA; } else if (dwVersion == 0x0200) { if (dwSizeOfStruct < sizeof(ENUMTYPE)-sizeof(DWORD)) goto ParameterError_EnumColorProfilesA; // // Version 2 should not have ET_DEVICECLASS bit // if (pEnumRecord->dwFields & ET_DEVICECLASS) goto ParameterError_EnumColorProfilesA; WARNING((__TEXT("Old version ENUMTYPE to EnumColorProfiles\n"))); } else { goto ParameterError_EnumColorProfilesA; } if (IsBadReadPtr(pEnumRecord, dwSizeOfStruct)) { goto ParameterError_EnumColorProfilesA; } // // Convert machine name to Unicode // if (pMachineName) { rc = ConvertToUnicode(pMachineName, &pwszMachineName, TRUE); } else pwszMachineName = NULL; // // If device name is specified, convert it to Unicode // if (pEnumRecord->dwFields & ET_DEVICENAME) { if (! pEnumRecord->pDeviceName) { WARNING((__TEXT("Invalid parameter to EnumColorProfiles\n"))); SetLastError(ERROR_INVALID_PARAMETER); rc = FALSE; goto EndEnumColorProfilesA; } // // Convert device name to Unicode // pAnsiDeviceName = (PSTR)pEnumRecord->pDeviceName; rc = rc && ConvertToUnicode(pAnsiDeviceName, &pwszDeviceName, TRUE); pEnumRecord->pDeviceName = (PSTR) pwszDeviceName; } dwSize = *pdwSize * sizeof(WCHAR); // // Allocate buffer of suitable size // if (pBuffer && dwSize) { pwBuffer = MemAlloc(dwSize); if (! pwBuffer) { WARNING((__TEXT("Error allocating memory for Unicode buffer\n"))); SetLastError(ERROR_NOT_ENOUGH_MEMORY); rc = FALSE; goto EndEnumColorProfilesA; } } // // Call the internal Unicode function // rc = rc && InternalEnumColorProfiles(pwszMachineName, (PENUMTYPEW)pEnumRecord, (PBYTE)pwBuffer, &dwSize, pnProfiles); if (pwBuffer && rc) { pwTempBuffer = pwBuffer; while (*pwTempBuffer) { rc = rc && ConvertToAnsi(pwTempBuffer, (PSTR *)&pBuffer, FALSE); if (!rc) { pBuffer = NULL; break; } pwTempBuffer += lstrlenW(pwTempBuffer) + 1; pBuffer += (lstrlenA((PSTR)pBuffer) + 1) * sizeof(char); } if (pBuffer) { *((PSTR)pBuffer) = '\0'; } } *pdwSize = dwSize / sizeof(WCHAR); EndEnumColorProfilesA: if (pwszMachineName) { MemFree(pwszMachineName); } if (pAnsiDeviceName) { ASSERT(pEnumRecord->pDeviceName != NULL); MemFree((PBYTE)pEnumRecord->pDeviceName); pEnumRecord->pDeviceName = (PCSTR)pAnsiDeviceName; } if (pwBuffer) { MemFree(pwBuffer); } return rc; } BOOL WINAPI EnumColorProfilesW( PCWSTR pMachineName, PENUMTYPEW pEnumRecord, PBYTE pBuffer, PDWORD pdwSize, PDWORD pnProfiles ) { TRACEAPI((__TEXT("EnumColorProfilesW\n"))); // // Internal function is Unicode in Windows NT, call it directly. // return InternalEnumColorProfiles(pMachineName, pEnumRecord, pBuffer, pdwSize, pnProfiles); } #else // Windows 95 versions BOOL WINAPI EnumColorProfilesA( PCSTR pMachineName, PENUMTYPEA pEnumRecord, PBYTE pBuffer, PDWORD pdwSize, PDWORD pnProfiles ) { TRACEAPI((__TEXT("EnumColorProfilesA\n"))); // // Internal function is ANSI in Windows 95, call it directly. // return InternalEnumColorProfiles(pMachineName, pEnumRecord, pBuffer, pdwSize, pnProfiles); } BOOL WINAPI EnumColorProfilesW( PCWSTR pMachineName, PENUMTYPEW pEnumRecord, PBYTE pBuffer, PDWORD pdwSize, PDWORD pnProfiles ) { PSTR pszMachineName = NULL; // Ansi machine name PSTR pszDeviceName = NULL; // Ansi device name PWSTR pUnicodeDeviceName = NULL;// incoming Unicode device name PSTR pszBuffer = NULL; // buffer to receive data PSTR pszTempBuffer = NULL; // temporary pointer to buffer DWORD dwSize; // size of buffer DWORD dwSizeOfStruct; // size of ENUMTYPE structure DWORD dwVersion; // ENUMTYPE structure version BOOL rc = TRUE; // return code TRACEAPI((__TEXT("EnumColorProfilesW\n"))); // // Validate parameters before we touch them // if (! pdwSize || IsBadWritePtr(pdwSize, sizeof(DWORD)) || (pBuffer && IsBadWritePtr(pBuffer, *pdwSize)) || ! pEnumRecord || IsBadReadPtr(pEnumRecord, sizeof(DWORD)*3)) // probe until ENUMTYPE.dwFields { ParameterError_EnumColorProfilesW: WARNING((__TEXT("Invalid parameter to EnumColorProfiles\n"))); SetLastError(ERROR_INVALID_PARAMETER); return FALSE; } // // Check structure size based on its version. // dwSizeOfStruct = pEnumRecord->dwSize; dwVersion = pEnumRecord->dwVersion; if (dwVersion >= ENUM_TYPE_VERSION) { if (dwSizeOfStruct < sizeof(ENUMTYPE)) goto ParameterError_EnumColorProfilesW; } else if (dwVersion == 0x0200) { if (dwSizeOfStruct < sizeof(ENUMTYPE)-sizeof(DWORD)) goto ParameterError_EnumColorProfilesW; // // Version 2 should not have ET_DEVICECLASS bit // if (pEnumRecord->dwFields & ET_DEVICECLASS) goto ParameterError_EnumColorProfilesW; WARNING((__TEXT("Old version ENUMTYPE to EnumColorProfiles\n"))); } else { goto ParameterError_EnumColorProfilesW; } if (IsBadReadPtr(pEnumRecord, dwSizeOfStruct)) { goto ParameterError_EnumColorProfilesW; } // // Convert machine name to Ansi // if (pMachineName) { rc = ConvertToAnsi(pMachineName, &pszMachineName, TRUE); } // // If device name is specified, convert it to Unicode // if (pEnumRecord->dwFields & ET_DEVICENAME) { if (! pEnumRecord->pDeviceName) { WARNING((__TEXT("Invalid parameter to EnumColorProfiles\n"))); SetLastError(ERROR_INVALID_PARAMETER); goto EndEnumColorProfilesW; } // // Convert device name to Ansi // pUnicodeDeviceName = (PWSTR)pEnumRecord->pDeviceName; rc = rc && ConvertToAnsi(pUnicodeDeviceName, &pszDeviceName, TRUE); pEnumRecord->pDeviceName = (PCWSTR) pszDeviceName; } dwSize = *pdwSize / sizeof(WCHAR); // // Allocate buffer of suitable size // if (pBuffer && dwSize) { pszBuffer = MemAlloc(dwSize); if (! pszBuffer) { WARNING((__TEXT("Error allocating memory for Ansi buffer\n"))); SetLastError(ERROR_NOT_ENOUGH_MEMORY); rc = FALSE; goto EndEnumColorProfilesW; } } // // Call the internal Ansi function // rc = rc && InternalEnumColorProfiles(pszMachineName, (PENUMTYPEA)pEnumRecord, (PBYTE)pszBuffer, &dwSize, pnProfiles); if (pszBuffer && rc) { pszTempBuffer = pszBuffer; while (*pszTempBuffer) { rc = rc && ConvertToUnicode(pszTempBuffer, (PWSTR *)&pBuffer, FALSE); pszTempBuffer += lstrlenA(pszTempBuffer) + 1; pBuffer += (lstrlenW((PWSTR)pBuffer) + 1) * sizeof(WCHAR); } *((PWSTR)pBuffer) = '\0'; } *pdwSize = dwSize * sizeof(WCHAR); EndEnumColorProfilesW: if (pszMachineName) { MemFree(pszMachineName); } if (pUnicodeDeviceName) { ASSERT(pEnumRecord->pDeviceName != NULL); MemFree((PSTR)pEnumRecord->pDeviceName); pEnumRecord->pDeviceName = (PCWSTR)pUnicodeDeviceName; } if (pszBuffer) { MemFree(pszBuffer); } return rc; } #endif // ! UNICODE /****************************************************************************** * * SetStandardColorSpaceProfile * * Function: * These are the ANSI & Unicode wrappers for InternalSetSCSProfile. * Please see InternalSetSCSProfile for more details on this * function. * * Arguments: * pMachineName - name identifying machine on which the standard color * space profile should be registered * dwSCS - ID for the standard color space * pProfileName - pointer to profile filename * * Returns: * TRUE if successful, NULL otherwise * ******************************************************************************/ #ifdef UNICODE // Windows NT versions BOOL WINAPI SetStandardColorSpaceProfileA( PCSTR pMachineName, DWORD dwSCS, PCSTR pProfileName ) { PWSTR pwszMachineName = NULL; // Unicode machine name PWSTR pwszProfileName = NULL; // Unicode profile name BOOL rc = TRUE; // return code TRACEAPI((__TEXT("SetStandardColorSpaceProfileA\n"))); // // Validate parameters before we touch them // if (! pProfileName) { WARNING((__TEXT("Invalid parameter to SetStandardColorSpaceProfile\n"))); SetLastError(ERROR_INVALID_PARAMETER); return FALSE; } // // Convert machine name to Unicode // if (pMachineName) { rc = ConvertToUnicode(pMachineName, &pwszMachineName, TRUE); } else pwszMachineName = NULL; // // Convert profile name to Unicode // rc = rc && ConvertToUnicode(pProfileName, &pwszProfileName, TRUE); // // Call the internal Unicode function // rc = rc && InternalSetSCSProfile(pwszMachineName, dwSCS, pwszProfileName); // // Free memory before leaving // if (pwszProfileName) { MemFree(pwszProfileName); } if (pwszMachineName) { MemFree(pwszMachineName); } return rc; } BOOL WINAPI SetStandardColorSpaceProfileW( PCWSTR pMachineName, DWORD dwSCS, PCWSTR pProfileName ) { TRACEAPI((__TEXT("SetStandardColorSpaceProfileW\n"))); // // Internal function is Unicode in Windows NT, call it directly. // return InternalSetSCSProfile(pMachineName, dwSCS, pProfileName); } #else // Windows 95 versions BOOL WINAPI SetStandardColorSpaceProfileA( PCSTR pMachineName, DWORD dwSCS, PCSTR pProfileName ) { TRACEAPI((__TEXT("SetStandardColorSpaceProfileA\n"))); // // Internal function is ANSI in Windows 95, call it directly. // return InternalSetSCSProfile(pMachineName, dwSCS, pProfileName); } BOOL WINAPI SetStandardColorSpaceProfileW( PCWSTR pMachineName, DWORD dwSCS, PCWSTR pProfileName ) { PSTR pszMachineName = NULL; // Ansi machine name PSTR pszProfileName = NULL; // Ansi profile name BOOL rc = TRUE; // return code TRACEAPI((__TEXT("SetStandardColorSpaceProfileW\n"))); // // Validate parameters before we touch them // if (! pProfileName) { WARNING((__TEXT("Invalid parameter to SetStandardColorSpaceProfile\n"))); SetLastError(ERROR_INVALID_PARAMETER); return FALSE; } // // Convert machine name to Ansi // if (pMachineName) { rc = ConvertToAnsi(pMachineName, &pszMachineName, TRUE); } else pszMachineName = NULL; // // Convert profile name to Ansi // rc = rc && ConvertToAnsi(pProfileName, &pszProfileName, TRUE); // // Call the internal Ansi function // rc = rc && InternalSetSCSProfile(pszMachineName, dwSCS, pszProfileName); // // Free memory before leaving // if (pszProfileName) { MemFree(pszProfileName); } if (pszMachineName) { MemFree(pszMachineName); } return rc; } #endif // ! UNICODE /****************************************************************************** * * GetStandardColorSpaceProfile * * Function: * These are the ANSI & Unicode wrappers for InternalGetSCSProfile. * Please see InternalGetSCSProfile for more details on this * function. * * Arguments: * pMachineName - name identifying machine on which the standard color * space profile should be queried * dwSCS - ID for the standard color space * pBuffer - pointer to buffer to receive profile filename * pdwSize - pointer to DWORD specifying size of buffer. On return * it has size needed/used * * Returns: * TRUE if successful, NULL otherwise * ******************************************************************************/ #ifdef UNICODE // Windows NT versions BOOL WINAPI GetStandardColorSpaceProfileA( PCSTR pMachineName, DWORD dwSCS, PSTR pBuffer, PDWORD pdwSize ) { PWSTR pwszMachineName = NULL; // Unicode machine name PWSTR pwBuffer = NULL; // Unicode color directory path DWORD dwSize; // size of Unicode buffer BOOL rc = TRUE; // return code TRACEAPI((__TEXT("GetStandardColorSpaceProfileA\n"))); // // Validate parameters before we touch them // if (! pdwSize || IsBadWritePtr(pdwSize, sizeof(DWORD)) || (pBuffer && IsBadWritePtr(pBuffer, *pdwSize))) { WARNING((__TEXT("Invalid parameter to GetStandardColorSpaceProfile\n"))); SetLastError(ERROR_INVALID_PARAMETER); return FALSE; } // // Convert machine name to Unicode // if (pMachineName) { rc = ConvertToUnicode(pMachineName, &pwszMachineName, TRUE); } else pwszMachineName = NULL; dwSize = *pdwSize * sizeof(WCHAR); // // Create a buffer to get Unicode filename from system // if (pBuffer && dwSize) { pwBuffer = (PWSTR)MemAlloc(dwSize); if (! pwBuffer) { WARNING((__TEXT("Error allocating memory for Unicode string\n"))); SetLastError(ERROR_NOT_ENOUGH_MEMORY); rc = FALSE; goto EndGetSCSProfileA; } } rc = rc && InternalGetSCSProfile(pwszMachineName, dwSCS, pwBuffer, &dwSize); *pdwSize = dwSize / sizeof(WCHAR); // // Convert Unicode path to Ansi // if (pwBuffer) { rc = rc && ConvertToAnsi(pwBuffer, &pBuffer, FALSE); } EndGetSCSProfileA: if (pwszMachineName) { MemFree(pwszMachineName); } if (pwBuffer) { MemFree(pwBuffer); } return rc; } BOOL WINAPI GetStandardColorSpaceProfileW( PCWSTR pMachineName, DWORD dwSCS, PWSTR pBuffer, PDWORD pdwSize ) { TRACEAPI((__TEXT("GetStandardColorSpaceProfileW\n"))); // // Internal function is Unicode in Windows NT, call it directly. // return InternalGetSCSProfile(pMachineName, dwSCS, pBuffer, pdwSize); } #else // Windows 95 versions BOOL WINAPI GetStandardColorSpaceProfileA( PCSTR pMachineName, DWORD dwSCS, PSTR pBuffer, PDWORD pdwSize ) { TRACEAPI((__TEXT("GetStandardColorSpaceProfileA\n"))); // // Internal function is ANSI in Windows 95, call it directly. // return InternalGetSCSProfile(pMachineName, dwSCS, pBuffer, pdwSize); } BOOL WINAPI GetStandardColorSpaceProfileW( PCWSTR pMachineName, DWORD dwSCS, PWSTR pBuffer, PDWORD pdwSize ) { PSTR pszMachineName = NULL; // Ansi machine name PSTR pszBuffer = NULL; // Ansi color directory path DWORD dwSize; // size of Ansi buffer BOOL rc = TRUE; // return code TRACEAPI((__TEXT("GetStandardColorSpaceProfileW\n"))); // // Validate parameters before we touch them // if (! pdwSize || IsBadWritePtr(pdwSize, sizeof(DWORD)) || (pBuffer && IsBadWritePtr(pBuffer, *pdwSize))) { WARNING((__TEXT("Invalid parameter to GetStandardColorSpaceProfile\n"))); SetLastError(ERROR_INVALID_PARAMETER); return FALSE; } // // Convert machine name to Ansi // if (pMachineName) { rc = ConvertToAnsi(pMachineName, &pszMachineName, TRUE); } else pszMachineName = NULL; dwSize = *pdwSize / sizeof(WCHAR); // // Create a buffer to get Ansi profilename from system // if (pBuffer && dwSize) { pszBuffer = (PSTR)MemAlloc(dwSize); if (! pBuffer) { WARNING((__TEXT("Error allocating memory for Ansi string\n"))); SetLastError(ERROR_NOT_ENOUGH_MEMORY); rc = FALSE; goto EndGetSCSProfileW; } } rc = rc && InternalGetSCSProfile(pszMachineName, dwSCS, pszBuffer, &dwSize); *pdwSize = dwSize * sizeof(WCHAR); // // Convert Ansi path to Unicode // if (pszBuffer) { rc = rc && ConvertToUnicode(pszBuffer, &pBuffer, FALSE); } EndGetSCSProfileW: if (pszMachineName) { MemFree(pszMachineName); } if (pszBuffer) { MemFree(pszBuffer); } return rc; } #endif // ! UNICODE /****************************************************************************** * * GenerateCopyFilePaths * * Function: * This function is called by the Windows NT spooler to find the * directories from which color profiles should be picked up and copied * to. This is useful if the locations are version or processor * architecture dependent. As color profiles depend on neither, we don't * have to do anything, but have to export this function. * * Arguments: * don't care * * Returns: * ERROR_SUCCESS if successful, error code otherwise * ******************************************************************************/ DWORD WINAPI GenerateCopyFilePaths( LPCWSTR pszPrinterName, LPCWSTR pszDirectory, LPBYTE pSplClientInfo, DWORD dwLevel, LPWSTR pszSourceDir, LPDWORD pcchSourceDirSize, LPWSTR pszTargetDir, LPDWORD pcchTargetDirSize, DWORD dwFlags ) { TRACEAPI((__TEXT("GenerateCopyFilePaths\n"))); return ERROR_SUCCESS; } /****************************************************************************** * * SpoolerCopyFileEvent * * Function: * This function is called by the Windows NT spooler when one of the * following events happens: * 1. When someone does a SetPrinterDataEx of the CopyFiles section * 2. When a printer connection is made * 3. When files for a printer connection get updated * 4. When a printer is deleted * * Arguments: * pszPrinterName - friendly name of printer * pszKey - "CopyFiles\ICM" for us * dwCopyFileEvent - reason for calling * * Returns: * TRUE if successful, NULL otherwise * ******************************************************************************/ BOOL WINAPI SpoolerCopyFileEvent( LPWSTR pszPrinterName, LPWSTR pszKey, DWORD dwCopyFileEvent ) { PTSTR pProfileList, pTemp, pBuffer; DWORD dwSize; BOOL bRc = FALSE; TCHAR szPath[MAX_PATH]; TRACEAPI((__TEXT("SpoolerCopyFileEvent\n"))); switch (dwCopyFileEvent) { case COPYFILE_EVENT_SET_PRINTER_DATAEX: // // When associating profiles with printer connections, we copy // the files to the remote machine, and then do a SePrinterDataEx. // This causes this event to be generated on the remote machine. We // use this to install the profile. This is not needed after we make // our APIs remotable // // Fall thru' // TERSE((__TEXT("SetPrinterDataEx event\n"))); case COPYFILE_EVENT_ADD_PRINTER_CONNECTION: case COPYFILE_EVENT_FILES_CHANGED: // // This event is generated when a printer connection is added or // associated profiles have changed. Install all the profiles in // the client machine now. // #if DBG if (dwCopyFileEvent == COPYFILE_EVENT_ADD_PRINTER_CONNECTION) { WARNING((__TEXT("AddPrinterConnection Event\n"))); } else if (dwCopyFileEvent == COPYFILE_EVENT_FILES_CHANGED) { WARNING((__TEXT("FilesChanged Event\n"))); } #endif dwSize = 0; if (GetDeviceData((PTSTR)pszPrinterName, CLASS_PRINTER, DEVICE_PROFILE_DATA, (PVOID *)&pProfileList, &dwSize, TRUE)) { dwSize = sizeof(szPath); if (InternalGetColorDirectory(NULL, szPath, &dwSize)) { lstrcat(szPath, gszBackslash); pBuffer = szPath + lstrlen(szPath); pTemp = pProfileList; while (*pTemp) { lstrcpy(pBuffer, pTemp); InstallColorProfile(NULL, szPath); pTemp += lstrlen(pTemp) + 1; } } MemFree(pProfileList); } break; case COPYFILE_EVENT_DELETE_PRINTER: // // This event is generated when a printer is about to be deleted. // Get all profiles associated with the printer and disassociate // them now. // TERSE((__TEXT("DeletePrinterDataEx Event\n"))); dwSize = 0; if (GetDeviceData((PTSTR)pszPrinterName, CLASS_PRINTER, DEVICE_PROFILE_DATA, (PVOID *)&pProfileList, &dwSize, TRUE)) { pTemp = pProfileList; while (*pTemp) { DisassociateColorProfileFromDevice(NULL, pTemp, (PTSTR)pszPrinterName); pTemp += lstrlen(pTemp) + 1; } MemFree(pProfileList); } break; } bRc = TRUE; return bRc; } /*****************************************************************************/ /***************************** Internal Functions ****************************/ /*****************************************************************************/ /****************************************************************************** * * InternalGetColorDirectory * * Function: * This function returns the path to the color directory on the machine * specified. * associations should be removed before calling this function. It also * optionally deletes the file if the profile was successfully * uninstalled. * * Arguments: * pMachineName - name identifying machine on which the path * to the color directory is requested * pBuffer - pointer to buffer to receive pathname * pdwSize - pointer to size of buffer. On return it has size of * buffer needed if failure, and used on success * * Returns: * TRUE if successful, FALSE otherwise * ******************************************************************************/ BOOL InternalGetColorDirectory( LPCTSTR pMachineName, PTSTR pBuffer, DWORD *pdwSize ) { DWORD dwBufLen = *pdwSize; // size supplied BOOL rc = FALSE; // return value // // Get the printer driver directory // #if !defined(_WIN95_) DWORD dwNeeded; // size needed BOOL bSuccess; DWORD dwTempSize; bSuccess = FALSE; if (!pBuffer && pdwSize && !IsBadWritePtr(pdwSize, sizeof(DWORD))) { *pdwSize = MAX_PATH; // // Doing the same thing as GetPrinterDriverDirectory does. // When the buffer is NULL, return FALSE and set last error. // SetLastError(ERROR_INSUFFICIENT_BUFFER); return FALSE; } dwTempSize = *pdwSize; bSuccess = GetPrinterDriverDirectory( (PTSTR)pMachineName, NULL, 1, (PBYTE)pBuffer, *pdwSize, pdwSize ); if( (!bSuccess) && (GetLastError() == ERROR_INVALID_ENVIRONMENT) ) { // // We failed with invalid environment, try this again with a // guaranteed valid environment... // Could be IA64 -> win2K and win2K with no SP1 will fail as // it didn't know about "Windows IA64" // *pdwSize = dwTempSize; bSuccess = GetPrinterDriverDirectory( (PTSTR)pMachineName, __TEXT("Windows NT x86"), 1, (PBYTE)pBuffer, *pdwSize, pdwSize ); } if (bSuccess) { // // This API returns the print$ path appended with the environment // directory. e.g. c:\winnt\system32\spool\drivers\w32x86. So we need // to go back one step and then append the color directory. // PWSTR pDriverDir; if(pDriverDir = GetFilenameFromPath(pBuffer)) { ASSERT (pDriverDir != NULL); *pdwSize -= lstrlen(pDriverDir) * sizeof(WCHAR); *pDriverDir = '\0'; // // Calculate size of buffer needed to append color directory // dwNeeded = *pdwSize + lstrlen(gszColorDir) * sizeof(WCHAR); if (pBuffer[lstrlen(pBuffer) - 1] != '\\') { dwNeeded += sizeof(WCHAR); } // // Update size needed // *pdwSize = dwNeeded; // // If supplied buffer is big enough, append our stuff // if (dwNeeded <= dwBufLen) { if (pBuffer[lstrlen(pBuffer) - 1] != '\\') { lstrcat(pBuffer, gszBackslash); } lstrcat(pBuffer, gszColorDir); rc = TRUE; } else { WARNING((__TEXT("Input buffer to GetColorDirectory not big enough\n"))); SetLastError(ERROR_INSUFFICIENT_BUFFER); } } } else if (GetLastError() == ERROR_INVALID_USER_BUFFER) { // // Spooler sets this error if buffer is NULL. Map it to our error // SetLastError(ERROR_INSUFFICIENT_BUFFER); } else if (GetLastError() == RPC_S_SERVER_UNAVAILABLE) { TCHAR achTempPath[MAX_PATH * 2]; // Make sure enough path space. // // Spooler service is not running. Use hardcoded path // if (GetSystemDirectory(achTempPath,MAX_PATH) != 0) { _tcscat(achTempPath,TEXT("\\spool\\drivers\\color")); *pdwSize = wcslen(achTempPath) + 1; if (pBuffer && (*pdwSize <= dwBufLen)) { _tcscpy(pBuffer,achTempPath); rc = TRUE; } else { WARNING((__TEXT("Input buffer to GetColorDirectory not big enough\n"))); SetLastError(ERROR_INSUFFICIENT_BUFFER); } } } #else HKEY hkSetup; // registry key DWORD dwErr; // error code // // Only local color directory query is allowed in Memphis // if (pMachineName) { WARNING((__TEXT("Remote color directory query, failing...\n"))); SetLastError(ERROR_INVALID_PARAMETER); return FALSE; } // // On Memphis, get this information from the setup section in the registry. // The reason we don't call GetPrinterDriverDirectory is that when we call // this function from GDI 16, it tries to go back into 16-bit mode and // deadlocks on the Win16 lock. // if ((dwErr = RegOpenKey(HKEY_LOCAL_MACHINE, gszSetupPath, &hkSetup)) == ERROR_SUCCESS) { if ((dwErr = RegQueryValueEx(hkSetup, gszICMDir, 0, NULL, (PBYTE)pBuffer, pdwSize)) == ERROR_SUCCESS) { rc = TRUE; } RegCloseKey(hkSetup); } if (!rc) { // // Make error codes consistent // if (dwErr == ERROR_MORE_DATA) { dwErr = ERROR_INSUFFICIENT_BUFFER; } WARNING((__TEXT("Error getting color directory: %d\n"), dwErr)); SetLastError(dwErr); } // // RegQueryValueEx returns TRUE even if the calling buffer is NULL. Our API // is supposed to return FALSE. Check for this case. // if (pBuffer == NULL && rc) { SetLastError(ERROR_INSUFFICIENT_BUFFER); rc = FALSE; } #endif // !defined(_WIN95_) return rc; } /****************************************************************************** * * InternalInstallColorProfile * * Function: * This function installs a given color profile on a a given machine. * * Arguments: * pMachineName - name identifying machine on which the profile * should be uninstalled. NULL implies local * pProfileName - Fully qualified pathname of profile to uninstall * bDelete - TRUE if profile should be deleted in disk * * Returns: * TRUE if successful, NULL otherwise * * Warning: * Currently only local install is supported, so pMachineName should * be NULL. * ******************************************************************************/ BOOL InternalInstallColorProfile( LPCTSTR pMachineName, LPCTSTR pProfileName ) { PROFILEHEADER header; // profile header REGDATA regData; // for storing registry data about profile HKEY hkICM = NULL; // key to ICM branch in registry HKEY hkDevice = NULL; // key to ICM device branch in registry DWORD dwSize; // size of registry data for profile DWORD dwErr; // error code BOOL rc = FALSE; // return code PTSTR pFilename; // profile name without path TCHAR szDest[MAX_PATH]; // destination path for profile TCHAR szClass[5]; // profile class BOOL FileExist; // profile already in directory? BOOL RegExist; // profile in registry? // // Validate parameters // if (!pProfileName) { WARNING((__TEXT("Invalid parameter to InstallColorProfile\n"))); SetLastError(ERROR_INVALID_PARAMETER); return FALSE; } // // Only local installs are allowed now // if (pMachineName) { WARNING((__TEXT("Remote install attempted, failing...\n"))); SetLastError(ERROR_INVALID_PARAMETER); return FALSE; } // // Get rid of the directory path and get a pointer to the filename // pFilename = GetFilenameFromPath((PTSTR)pProfileName); if (! pFilename) { WARNING((__TEXT("Could not parse file name from profile path %s\n"), pProfileName)); SetLastError(ERROR_INVALID_PARAMETER); goto EndInstallColorProfile; } // // Get the profile class in the form of a string // if (! GetProfileClassString(pProfileName, szClass, &header)) { WARNING((__TEXT("Installing invalid profile %s\n"), pProfileName)); SetLastError(ERROR_INVALID_PROFILE); goto EndInstallColorProfile; } // // Open the registry path where profiles are kept // if (((dwErr = RegCreateKey(HKEY_LOCAL_MACHINE, gszICMRegPath, &hkICM)) != ERROR_SUCCESS) || ((dwErr = RegCreateKey(hkICM, szClass, &hkDevice)) != ERROR_SUCCESS)) { WARNING((__TEXT("Cannot open ICM\\device branch of registry: %d\n"), dwErr)); SetLastError(dwErr); goto EndInstallColorProfile; } // // If registry data exists && the profile is in the directory, then the profile is already installed, // in which case, return success. Otherwise, copy profile to color // directory (if it's not already there) and add it to the registry (if it's not already there). // dwSize = sizeof(szDest); // // Copy the file to the color directory // if (! InternalGetColorDirectory(NULL, szDest, &dwSize)) { WARNING((__TEXT("Could not get color directory\n"))); goto EndInstallColorProfile; } // // This creates the directory if it doesn't exist, doesn't do anything // if it already exists // CreateDirectory(szDest, NULL); if (szDest[lstrlen(szDest) - 1] != '\\') { lstrcat(szDest, gszBackslash); } lstrcat(szDest, pFilename); // // If the profile is already in the color directory, do not attempt // to copy it again; it will fail. // dwSize = sizeof(REGDATA); FileExist = GetFileAttributes(szDest) != (DWORD)-1; RegExist = RegQueryValueEx(hkDevice, pFilename, 0, NULL, (PBYTE)®Data, &dwSize) == ERROR_SUCCESS; // // If the file does exist, short circuit the CopyFile // and go on to add it into the registry. // if (!FileExist && !CopyFile(pProfileName, szDest, FALSE)) { WARNING((__TEXT("Could not copy profile %s to color directory\n"), pProfileName)); goto EndInstallColorProfile; } // // Add profile to the registry // if(!RegExist) { regData.dwRefCount = 0; regData.dwManuID = FIX_ENDIAN(header.phManufacturer); regData.dwModelID = FIX_ENDIAN(header.phModel); if ((dwErr = RegSetValueEx(hkDevice, pFilename, 0, REG_BINARY, (PBYTE)®Data, sizeof(REGDATA))) != ERROR_SUCCESS) { WARNING((__TEXT("Could not set registry data to install profile %s: %d\n"), pFilename, dwErr)); SetLastError(dwErr); goto EndInstallColorProfile; } } rc = TRUE; // Everything went well! EndInstallColorProfile: if (hkICM) { RegCloseKey(hkICM); } if (hkDevice) { RegCloseKey(hkDevice); } return rc; } /****************************************************************************** * * InternalUninstallColorProfile * * Function: * This function uninstalls a given color profile on a a given machine. * It fails if the color profile is associated with any device, so all * associations should be removed before calling this function. It also * optionally deletes the file if the profile was successfully * uninstalled. * * Arguments: * pMachineName - name identifying machine on which the profile * should be uninstalled. NULL implies local * pProfileName - pointer to profile to uninstall * bDelete - TRUE if profile should be deleted in disk * * Returns: * TRUE if successful, NULL otherwise * * Warning: * Currently only local uninstall is supported, so pMachineName should * be NULL. * ******************************************************************************/ BOOL InternalUninstallColorProfile( LPCTSTR pMachineName, LPCTSTR pProfileName, BOOL bDelete ) { REGDATA regData; // for storing registry data about profile HKEY hkICM = NULL; // key to ICM branch in registry HKEY hkDevice = NULL; // key to ICM device branch in registry DWORD dwSize; // size of registry data for profile DWORD dwErr; // error code BOOL rc = FALSE; // return code PTSTR pFilename; // profile name without path TCHAR szColorPath[MAX_PATH]; // full path name of profile TCHAR szClass[5]; // profile class // // Validate parameters // if (!pProfileName) { WARNING((__TEXT("Invalid parameter to UninstallColorProfile\n"))); SetLastError(ERROR_INVALID_PARAMETER); return FALSE; } // // Only local installs are allowed now // if (pMachineName != NULL) { WARNING((__TEXT("Remote uninstall attempted, failing...\n"))); SetLastError(ERROR_NOT_SUPPORTED); return FALSE; } // // Get rid of the directory path and get a pointer to the filename // pFilename = GetFilenameFromPath((PTSTR)pProfileName); if (! pFilename) { WARNING((__TEXT("Could not parse file name from profile path\n"), pProfileName)); SetLastError(ERROR_INVALID_PARAMETER); goto EndUninstallColorProfile; } // // Create a fully qualified path name // dwSize = sizeof(szColorPath); if (! InternalGetColorDirectory(NULL, szColorPath, &dwSize)) { WARNING((__TEXT("Could not get color directory\n"))); goto EndUninstallColorProfile; } if (szColorPath[lstrlen(szColorPath) - 1] != '\\') { lstrcat(szColorPath, gszBackslash); } lstrcat(szColorPath, pFilename); // // Get the profile class in the form of a string // if (! GetProfileClassString(szColorPath, szClass, NULL)) { WARNING((__TEXT("Installing invalid profile\n"))); SetLastError(ERROR_INVALID_PROFILE); goto EndUninstallColorProfile; } // // Open the registry path where profiles are kept // if (((dwErr = RegOpenKey(HKEY_LOCAL_MACHINE, gszICMRegPath, &hkICM)) != ERROR_SUCCESS) || ((dwErr = RegOpenKey(hkICM, szClass, &hkDevice)) != ERROR_SUCCESS)) { WARNING((__TEXT("Cannot open ICM\\device branch of registry: %d\n"), dwErr)); SetLastError(dwErr); goto EndUninstallColorProfile; } // // Check if reference count is zero and remove value from registry // dwSize = sizeof(REGDATA); if ((dwErr = RegQueryValueEx(hkDevice, pFilename, 0, NULL, (PBYTE)®Data, &dwSize)) != ERROR_SUCCESS) { WARNING((__TEXT("Trying to uninstall a profile that is not installed %s: %d\n"), pFilename, dwErr)); SetLastError(dwErr); goto EndUninstallColorProfile; } if (regData.dwRefCount != 0) { WARNING((__TEXT("Trying to uninstall profile %s whose refcount is %d\n"), pFilename, regData.dwRefCount)); goto EndUninstallColorProfile; } if ((dwErr = RegDeleteValue(hkDevice, pFilename)) != ERROR_SUCCESS) { WARNING((__TEXT("Error deleting profile %s from registry: %d\n"), pFilename, dwErr)); SetLastError(dwErr); goto EndUninstallColorProfile; } // // Remove profile from the registry // if (bDelete) { // // Delete profile from the color directory // if (! DeleteFile(szColorPath)) { WARNING((__TEXT("Error deleting profile %s: %d\n"), szColorPath, GetLastError())); goto EndUninstallColorProfile; } } rc = TRUE; // Everything went well! EndUninstallColorProfile: if (hkICM) { RegCloseKey(hkICM); } if (hkDevice) { RegCloseKey(hkDevice); } return rc; } /****************************************************************************** * * InternalAssociateColorProfileWithDevice * * Function: * This function associates a color profile on a a given machine with a * particular device. It fails if the color profile is not installed on * the machine. It increases the usage reference count of the profile. * * Arguments: * pMachineName - name identifying machine. NULL implies local * pProfileName - pointer to profile to associate * pDeviceName - pointer to device name * * Returns: * TRUE if successful, NULL otherwise * * Warning: * Currently only local association is supported, so pMachineName should * be NULL. * ******************************************************************************/ BOOL InternalAssociateColorProfileWithDevice( LPCTSTR pMachineName, LPCTSTR pProfileName, LPCTSTR pDeviceName ) { PROFILEHEADER header; // profile header REGDATA regData; // for storing registry data about profile HKEY hkICM = NULL; // key to ICM branch in registry HKEY hkDevice = NULL; // key to ICM device branch in registry DWORD dwSize; // size of registry data DWORD dwNewSize; // new size of device registry data DWORD dwErr; // error code BOOL rc = FALSE; // return code PTSTR pFilename; // profile name without path PTSTR pProfileList = NULL; // list of associated profiles TCHAR szColorPath[MAX_PATH]; // full path name of profile TCHAR szClass[5]; // profile class BOOL bFirstProfile = FALSE; // First profile to be associated for device DWORD dwDeviceClass; // device class // // Validate parameters // if (! pProfileName || ! pDeviceName) { WARNING((__TEXT("Invalid parameter to AssociateColorProfileWithDevice\n"))); SetLastError(ERROR_INVALID_PARAMETER); return FALSE; } // // Only local associations are allowed now // if (pMachineName != NULL) { WARNING((__TEXT("Remote profile association attempted, failing...\n"))); SetLastError(ERROR_NOT_SUPPORTED); return FALSE; } // // Get rid of the directory path and get a pointer to the filename // pFilename = GetFilenameFromPath((PTSTR)pProfileName); if (! pFilename) { WARNING((__TEXT("Could not parse file name from profile path %s\n"), pProfileName)); SetLastError(ERROR_INVALID_PARAMETER); goto EndAssociateProfileWithDevice; } // // Create a fully qualified path name // dwSize = sizeof(szColorPath); if (! InternalGetColorDirectory(NULL, szColorPath, &dwSize)) { WARNING((__TEXT("Could not get color directory\n"))); goto EndAssociateProfileWithDevice; } if (szColorPath[lstrlen(szColorPath) - 1] != '\\') { lstrcat(szColorPath, gszBackslash); } lstrcat(szColorPath, pFilename); // // Get the profile class in the form of a string // if (! GetProfileClassString(szColorPath, szClass, &header)) { WARNING((__TEXT("Installing invalid profile %s\n"), szColorPath)); SetLastError(ERROR_INVALID_PROFILE); goto EndAssociateProfileWithDevice; } // // Open the registry path where profiles are kept // if (((dwErr = RegOpenKey(HKEY_LOCAL_MACHINE, gszICMRegPath, &hkICM)) != ERROR_SUCCESS) || ((dwErr = RegOpenKey(hkICM, szClass, &hkDevice)) != ERROR_SUCCESS)) { WARNING((__TEXT("Cannot open ICM\\device branch of registry: %d\n"), dwErr)); SetLastError(dwErr); goto EndAssociateProfileWithDevice; } // // Check if profile is installed // dwSize = sizeof(REGDATA); if ((dwErr = RegQueryValueEx(hkDevice, pFilename, 0, NULL, (PBYTE)®Data, &dwSize)) != ERROR_SUCCESS) { WARNING((__TEXT("Trying to associate a profile that is not installed %s: %d\n"), pFilename, dwErr)); SetLastError(dwErr); goto EndAssociateProfileWithDevice; } // // Treat CLASS_MONITOR as CLASS_COLORSPACE. // if ((dwDeviceClass = header.phClass) == CLASS_MONITOR) { // // since CLASS_MONTOR profile can be associated any device class. // dwDeviceClass = CLASS_COLORSPACE; } // // Read in the list of profiles associated with the device // dwSize = 0; if (! GetDeviceData(pDeviceName, dwDeviceClass, DEVICE_PROFILE_DATA, (PVOID *)&pProfileList, &dwSize, TRUE)) { pProfileList = NULL; // no data found } // // If the profile is already associated with the device, return success. // Do not check if we didn't get a profile list // if (pProfileList && IsStringInMultiSz(pProfileList, pFilename) == TRUE) { rc = TRUE; goto EndAssociateProfileWithDevice; } if (dwSize <= sizeof(TCHAR)) { bFirstProfile = TRUE; } // // Add new profile to the list of profiles, and double NULL // terminate the MULTI_SZ string. // if (dwSize > 0) { // // Use a temporary pointer, so that if MemReAlloc fails, we do // not have a memory leak - the original pointer needs to be freed // PTSTR pTemp; dwNewSize = dwSize + (lstrlen(pFilename) + 1) * sizeof(TCHAR); pTemp = MemReAlloc(pProfileList, dwNewSize); if (! pTemp) { WARNING((__TEXT("Error reallocating pProfileList\n"))); SetLastError(ERROR_NOT_ENOUGH_MEMORY); goto EndAssociateProfileWithDevice; } else pProfileList = pTemp; } else { // // Allocate extra character for double NULL termination. Setting // dwSize to 1 accomplishes this and lets the lstrcpy below // to work correctly. // dwSize = sizeof(TCHAR); // extra char for double NULL termination dwNewSize = dwSize + (lstrlen(pFilename) + 1) * sizeof(TCHAR); pProfileList = MemAlloc(dwNewSize); if (! pProfileList) { WARNING((__TEXT("Error allocating pProfileList\n"))); SetLastError(ERROR_NOT_ENOUGH_MEMORY); goto EndAssociateProfileWithDevice; } } { PTSTR pPtr; // temporary pointer pPtr = (PTSTR)((PBYTE)pProfileList + dwSize - sizeof(TCHAR)); lstrcpy(pPtr, pFilename); pPtr = (PTSTR)((PBYTE)pProfileList + dwNewSize - sizeof(TCHAR)); *pPtr = '\0'; // double NULL terminate } // // Set the device data // if (! SetDeviceData(pDeviceName, dwDeviceClass, DEVICE_PROFILE_DATA, pProfileList, dwNewSize)) { WARNING((__TEXT("Error setting device profile data for %s\n"), pDeviceName)); goto EndAssociateProfileWithDevice; } // // Increment usage count and set it // regData.dwRefCount++; if ((dwErr = RegSetValueEx(hkDevice, pFilename, 0, REG_BINARY, (PBYTE)®Data, sizeof(REGDATA))) != ERROR_SUCCESS) { ERR((__TEXT("Could not set registry data for profile %s: %d\n"), pFilename, dwErr)); SetLastError(dwErr); goto EndAssociateProfileWithDevice; } #if !defined(_WIN95_) if (bFirstProfile) { ChangeICMSetting(pMachineName, pDeviceName, ICM_ON); } #endif rc = TRUE; // Everything went well! EndAssociateProfileWithDevice: if (hkICM) { RegCloseKey(hkICM); } if (hkDevice) { RegCloseKey(hkDevice); } if (pProfileList) { MemFree(pProfileList); } return rc; } /****************************************************************************** * * InternalDisassociateColorProfileFromDevice * * Function: * This function disassociates a color profile on a a given machine from * a particular device. It fails if the color profile is not installed * on the machine and associated with the device. It decreases the usage * reference count of the profile. * * Arguments: * pMachineName - name identifying machine. NULL implies local * pProfileName - pointer to profile to disassociate * pDeviceName - pointer to device name * * Returns: * TRUE if successful, NULL otherwise * * Warning: * Currently only local disassociation is supported, so pMachineName * should be NULL. * ******************************************************************************/ BOOL InternalDisassociateColorProfileFromDevice( LPCTSTR pMachineName, LPCTSTR pProfileName, LPCTSTR pDeviceName ) { PROFILEHEADER header; // profile header REGDATA regData; // for storing registry data about profile HKEY hkICM = NULL; // key to ICM branch in registry HKEY hkDevice = NULL; // key to ICM device branch in registry DWORD dwSize; // size of registry data DWORD dwNewSize; // new size of device registry data DWORD dwErr; // error code BOOL rc = FALSE; // return code PTSTR pFilename; // profile name without path PTSTR pProfileList = NULL; // list of associated profiles TCHAR szColorPath[MAX_PATH]; // full path name of profile TCHAR szClass[5]; // profile class BOOL bLastProfile = FALSE; // whether last profile is being removed DWORD dwDeviceClass; // device class // // Validate parameters // if (! pProfileName || ! pDeviceName) { WARNING((__TEXT("Invalid parameter to DisassociateColorProfileFromDevice\n"))); SetLastError(ERROR_INVALID_PARAMETER); return FALSE; } // // Only local associations are allowed now // if (pMachineName != NULL) { WARNING((__TEXT("Remote profile disassociation attempted, failing...\n"))); SetLastError(ERROR_NOT_SUPPORTED); return FALSE; } // // Get rid of the directory path and get a pointer to the filename // pFilename = GetFilenameFromPath((PTSTR)pProfileName); if (! pFilename) { WARNING((__TEXT("Could not parse file name from profile path %s\n"), pProfileName)); SetLastError(ERROR_INVALID_PARAMETER); goto EndDisassociateProfileWithDevice; } // // Create a fully qualified path name // dwSize = sizeof(szColorPath); if (! InternalGetColorDirectory(NULL, szColorPath, &dwSize)) { WARNING((__TEXT("Could not get color directory\n"))); goto EndDisassociateProfileWithDevice; } if (szColorPath[lstrlen(szColorPath) - 1] != '\\') { lstrcat(szColorPath, gszBackslash); } lstrcat(szColorPath, pFilename); // // Get the profile class in the form of a string // if (! GetProfileClassString(szColorPath, szClass, &header)) { WARNING((__TEXT("Installing invalid profile %s\n"), szColorPath)); SetLastError(ERROR_INVALID_PROFILE); goto EndDisassociateProfileWithDevice; } // // Open the registry path where profiles are kept // if (((dwErr = RegOpenKey(HKEY_LOCAL_MACHINE, gszICMRegPath, &hkICM)) != ERROR_SUCCESS) || ((dwErr = RegOpenKey(hkICM, szClass, &hkDevice)) != ERROR_SUCCESS)) { WARNING((__TEXT("Cannot open ICM\\device branch of registry: %d\n"), dwErr)); SetLastError(dwErr); goto EndDisassociateProfileWithDevice; } // // Check if profile is installed // dwSize = sizeof(REGDATA); if ((dwErr = RegQueryValueEx(hkDevice, pFilename, 0, NULL, (PBYTE)®Data, &dwSize)) != ERROR_SUCCESS) { WARNING((__TEXT("Trying to disassociate a profile that is not installed %s: %d\n"), pFilename, dwErr)); SetLastError(dwErr); goto EndDisassociateProfileWithDevice; } // // Treat CLASS_MONITOR as CLASS_COLORSPACE. // if ((dwDeviceClass = header.phClass) == CLASS_MONITOR) { // // since CLASS_MONTOR profile can be associated any device class. // dwDeviceClass = CLASS_COLORSPACE; } // // Read in the list of profiles associated with the device // dwSize = 0; if (! GetDeviceData(pDeviceName, dwDeviceClass, DEVICE_PROFILE_DATA, (PVOID *)&pProfileList, &dwSize, TRUE)) { pProfileList = NULL; // no data found } // // If the profile is not associated with the device, return failure // if (! pProfileList || ! IsStringInMultiSz(pProfileList, pFilename)) { WARNING((__TEXT("Trying to disassociate a profile that is not associated %s\n"), pFilename)); SetLastError(ERROR_PROFILE_NOT_ASSOCIATED_WITH_DEVICE); goto EndDisassociateProfileWithDevice; } // // Remove profile from the list of profiles, and double NULL // terminate the MULTI_SZ string. // dwNewSize = RemoveStringFromMultiSz(pProfileList, pFilename, dwSize); // // Set the device data // if (! SetDeviceData(pDeviceName, dwDeviceClass, DEVICE_PROFILE_DATA, pProfileList, dwNewSize)) { WARNING((__TEXT("Error setting device profile data for %s\n"), pDeviceName)); goto EndDisassociateProfileWithDevice; } if (dwNewSize <= sizeof(TCHAR)) { bLastProfile = TRUE; } // // Decrement usage count and set it // regData.dwRefCount--; if ((dwErr = RegSetValueEx(hkDevice, pFilename, 0, REG_BINARY, (PBYTE)®Data, sizeof(REGDATA))) != ERROR_SUCCESS) { ERR((__TEXT("Could not set registry data for profile %s: %d\n"), pFilename, dwErr)); SetLastError(dwErr); goto EndDisassociateProfileWithDevice; } #if !defined(_WIN95_) if (bLastProfile) { ChangeICMSetting(pMachineName, pDeviceName, ICM_OFF); } #endif rc = TRUE; // Everything went well! EndDisassociateProfileWithDevice: if (hkICM) { RegCloseKey(hkICM); } if (hkDevice) { RegCloseKey(hkDevice); } if (pProfileList) { MemFree(pProfileList); } return rc; } /****************************************************************************** * * InternalEnumColorProfiles * * Function: * These functions enumerates color profiles satisfying the given * enumeration criteria. It searches among all installed profiles, and * on return fills out a buffer with a series of NULL terminated profile * filenames double NULL terminated at the end. * * Arguments: * pMachineName - name identifying machine on which the enumeration * needs to be done * pEnumRecord - pointer to enumeration criteria * pBuffer - pointer to buffer to receive result, can be NULL * pdwSize - pointer to buffer size. On return it is actual number * of bytes copied/needed. * pnProfiles - pointer to DWORD. On return, it is number of profiles * copied to pBuffer. * * Returns: * TRUE if successful, NULL otherwise * * Warning: * Currently only local enumeration is supported, so pMachineName should * be NULL. * ******************************************************************************/ BOOL InternalEnumColorProfiles( LPCTSTR pMachineName, PENUMTYPE pEnumRecord, PBYTE pBuffer, PDWORD pdwSize, PDWORD pnProfiles ) { REGDATA regData; // for storing registry data about profile HKEY hkICM = NULL; // key to ICM branch in registry HKEY hkDevice = NULL; // key to ICM device branch in registry PTSTR pProfileList = NULL; // list of associated profiles PTSTR pTempProfileList; // temporary copy of profile list DWORD dwSize; // size of profile value DWORD dwDataSize; // size of profile data DWORD dwInputSize; // incoming size of buffer DWORD i, j; // counter variables DWORD dwErr; // error code BOOL rc = FALSE; // return code TCHAR szFullPath[MAX_PATH]; // full path of profile to open PTSTR pProfile; // pointer to profile name in full path DWORD dwLen; // length of color directory string DWORD bSkipMatch; // true for skipping exact profile matching MATCHTYPE match; // Type of profile match PBYTE pBufferStart; // Start of user given buffer DWORD dwSizeOfStruct; // size of ENUMTYPE structure DWORD dwVersion; // ENUMTYPE structure version // // Validate parameters // if (! pdwSize || IsBadWritePtr(pdwSize, sizeof(DWORD)) || (pBuffer && IsBadWritePtr(pBuffer, *pdwSize)) || (pnProfiles && IsBadWritePtr(pnProfiles, sizeof(DWORD))) || ! pEnumRecord || IsBadReadPtr(pEnumRecord, sizeof(DWORD)*3)) // probe until ENUMTYPE.dwFields { ParameterError_InternalEnumColorProfiles: WARNING((__TEXT("Invalid parameter to EnumColorProfiles\n"))); SetLastError(ERROR_INVALID_PARAMETER); return FALSE; } // // Check structure size based on its version. // dwSizeOfStruct = pEnumRecord->dwSize; dwVersion = pEnumRecord->dwVersion; if (dwVersion >= ENUM_TYPE_VERSION) { if (dwSizeOfStruct < sizeof(ENUMTYPE)) goto ParameterError_InternalEnumColorProfiles; } else if (dwVersion == 0x0200) { if (dwSizeOfStruct < sizeof(ENUMTYPE)-sizeof(DWORD)) goto ParameterError_InternalEnumColorProfiles; // // Version 2 should not have ET_DEVICECLASS bit // if (pEnumRecord->dwFields & ET_DEVICECLASS) goto ParameterError_InternalEnumColorProfiles; WARNING((__TEXT("Old version ENUMTYPE to InternalEnumColorProfiles\n"))); } else { goto ParameterError_InternalEnumColorProfiles; } if (IsBadReadPtr(pEnumRecord, dwSizeOfStruct)) { goto ParameterError_InternalEnumColorProfiles; } // // Only local enumerations are allowed now // if (pMachineName != NULL) { WARNING((__TEXT("Remote profile enumeration attempted, failing...\n"))); SetLastError(ERROR_NOT_SUPPORTED); return FALSE; } dwInputSize = *pdwSize; // // Get color directory // dwLen = sizeof(szFullPath); if (! InternalGetColorDirectory(NULL, szFullPath, &dwLen)) { WARNING((__TEXT("Error getting color directory\n"))); return FALSE; } if (szFullPath[lstrlen(szFullPath) - 1] != '\\') { lstrcat(szFullPath, gszBackslash); } pProfile = &szFullPath[lstrlen(szFullPath)]; dwLen = lstrlen(szFullPath) * sizeof(TCHAR); // // Initialize return parameters // *pdwSize = 0; if (pnProfiles) *pnProfiles = 0; if (pBuffer && dwInputSize >= sizeof(TCHAR)) { *((PTSTR)pBuffer) = '\0'; } // // Check if we are looking for the profiles of a particular device or // not because we enumerate them from different places. // if (pEnumRecord->dwFields & ET_DEVICENAME) { DWORD *pbSkipMatch = &bSkipMatch; DWORD dwDeviceClass; if (! pEnumRecord->pDeviceName) { WARNING((__TEXT("Invalid parameter to EnumColorProfiles\n"))); SetLastError(ERROR_INVALID_PARAMETER); goto EndEnumerateColorProfiles; } // // Get list of profiles associated with the device. If we don't // know what device it is, specify ColorSpace, which tries all three // if (pEnumRecord->dwFields & ET_DEVICECLASS) { dwDeviceClass = pEnumRecord->dwDeviceClass; } else { dwDeviceClass = CLASS_COLORSPACE; } // // Get the device configuration whether we do exact matching or not. // dwSize = sizeof(DWORD); if (! GetDeviceData(pEnumRecord->pDeviceName, dwDeviceClass, DEVICE_PROFILE_ENUMMODE, (PVOID *)&pbSkipMatch, &dwSize, FALSE)) { bSkipMatch = FALSE; } // // Get the profile data. // dwSize = 0; if (! GetDeviceData(pEnumRecord->pDeviceName, dwDeviceClass, DEVICE_PROFILE_DATA, (PVOID *)&pProfileList, &dwSize, TRUE)) { pProfileList = NULL; // no data found } if(! pProfileList) { // // No profiles associated with this device // rc = TRUE; if (pBuffer && dwInputSize >= sizeof(TCHAR)*2) { *((PTSTR)pBuffer + 1) = '\0'; } goto EndEnumerateColorProfiles; } // // Run through the list of profiles and check each one to see if it // matches the enumeration criteria. If it does, and the buffer is // large enough, copy it to the buffer, and increment the byte count // and number of profiles enumerated. // pBufferStart = pBuffer; pTempProfileList = pProfileList; while (*pTempProfileList) { lstrcpy(pProfile, pTempProfileList); if (bSkipMatch) { match = EXACT_MATCH; } else { match = DoesProfileMatchEnumRecord(szFullPath, pEnumRecord); } if (match != NOMATCH) { *pdwSize += (lstrlen(pTempProfileList) + 1) * sizeof(TCHAR); // // Check strictly less than because you need one more for // the final NULL termination // if (pBuffer && (*pdwSize < dwInputSize)) { if (match == MATCH) { lstrcpy((PTSTR)pBuffer, pTempProfileList); } else { // // Exact match, add to beginning of buffer // InsertInBuffer(pBufferStart, pBuffer, pTempProfileList); } pBuffer += (lstrlen(pTempProfileList) + 1) * sizeof(TCHAR); } if (pnProfiles) (*pnProfiles)++; } pTempProfileList += lstrlen(pTempProfileList) + 1; } } else { DWORD dwNumClasses; PTSTR *ppszEnumClasses; PTSTR pszEnumClassArray[2]; // // We are not looking at a particular device, so enumerate // profiles from the registry // if (pEnumRecord->dwFields & ET_DEVICECLASS) { // // If device class is specified, enumrate the specified device class and color // space class which can be associated to any device. // pszEnumClassArray[0] = ConvertClassIdToClassString(pEnumRecord->dwDeviceClass); pszEnumClassArray[1] = ConvertClassIdToClassString(CLASS_COLORSPACE); if (!pszEnumClassArray[0] || !pszEnumClassArray[1]) { WARNING((__TEXT("Invalid DeviceClass to EnumColorProfiles\n"))); SetLastError(ERROR_INVALID_PARAMETER); goto EndEnumerateColorProfiles; } ppszEnumClasses = pszEnumClassArray; dwNumClasses = 2; } else { ppszEnumClasses = gpszClasses; dwNumClasses = sizeof(gpszClasses)/sizeof(PTSTR); } // // Open the registry path where profiles are kept (and create it if not exist) // if ((dwErr = RegCreateKey(HKEY_LOCAL_MACHINE, gszICMRegPath, &hkICM)) != ERROR_SUCCESS) { WARNING((__TEXT("Cannot open ICM branch of registry: %d\n"), dwErr)); SetLastError(dwErr); goto EndEnumerateColorProfiles; } pBufferStart = pBuffer; for (i=0; iphClass, pClass); rc= TRUE; EndGetProfileClassString: if (hProfile) { CloseColorProfile(hProfile); } return rc; } /****************************************************************************** * * GetFilenameFromPath * * Function: * This function takes a fully qualified pathname and returns a pointer * to the filename part alone * * Arguments: * pPathName - pointer to pathname * * Returns: * Pointer to filename on success, NULL otherwise * ******************************************************************************/ PTSTR GetFilenameFromPath( PTSTR pPathName ) { DWORD dwLen; // length of pathname PTSTR pPathNameStart = pPathName; dwLen = lstrlen(pPathName); if (dwLen == 0) { return NULL; } // // Go to the end of the pathname, and start going backwards till // you reach the beginning or a backslash // pPathName += dwLen; // // Currently 'pPathName' points null-terminate character, so move // the pointer to last character. // do { pPathName = CharPrev(pPathNameStart,pPathName); if (*pPathName == TEXT('\\')) { pPathName = CharNext(pPathName); break; } // // Loop until fist // } while (pPathNameStart < pPathName); // // if *pPathName is zero, then we had a string that ends in a backslash // return *pPathName ? pPathName : NULL; } /****************************************************************************** * * GetDeviceData * * Function: * This function is a wrapper for IGetDeviceData. For devices like monitor, * printer & scanner it calls the internal function. If we are asked * to get the device data for a "colorspace device", we try monitor, printer * and scanner till one succeeds or they all fail. This is done so that we * we can associate sRGB like profiles with any device. * * Arguments: * pDeviceName - pointer to name of the device * dwClass - device type like monitor, printer etc. * ppDeviceData - pointer to pointer to buffer to receive data * pdwSize - pointer to size of buffer. On return it is size of * data returned/size needed. * bAllocate - If TRUE, allocate memory for data * * Returns: * TRUE if successful, FALSE otherwise * ******************************************************************************/ BOOL GetDeviceData( LPCTSTR pDeviceName, DWORD dwClass, DWORD dwDataType, PVOID *ppDeviceData, PDWORD pdwSize, BOOL bAllocate ) { BOOL rc = FALSE; if (dwClass == CLASS_MONITOR || dwClass == CLASS_PRINTER || dwClass == CLASS_SCANNER) { rc = IGetDeviceData(pDeviceName, dwClass, dwDataType, ppDeviceData, pdwSize, bAllocate); } else if (dwClass == CLASS_COLORSPACE) { rc = IGetDeviceData(pDeviceName, CLASS_MONITOR, dwDataType, ppDeviceData, pdwSize, bAllocate) || IGetDeviceData(pDeviceName, CLASS_PRINTER, dwDataType, ppDeviceData, pdwSize, bAllocate) || IGetDeviceData(pDeviceName, CLASS_SCANNER, dwDataType, ppDeviceData, pdwSize, bAllocate); } return rc; } /****************************************************************************** * * IGetDeviceData * * Function: * This function retrieves ICM data stored with the different devices. * * Arguments: * pDeviceName - pointer to name of the device * dwClass - device type like monitor, printer etc. * ppDeviceData - pointer to pointer to buffer to receive data * pdwSize - pointer to size of buffer. On return it is size of * data returned/size needed. * bAllocate - If TRUE, allocate memory for data * * Returns: * TRUE if successful, FALSE otherwise * ******************************************************************************/ BOOL IGetDeviceData( LPCTSTR pDeviceName, DWORD dwClass, DWORD dwDataType, PVOID *ppDeviceData, PDWORD pdwSize, BOOL bAllocate ) { PFNOPENDEVICE fnOpenDevice; PFNCLOSEDEVICE fnCloseDevice; PFNGETDEVICEDATA fnGetData; HANDLE hDevice; DWORD dwSize; LPTSTR pDataKey; LPTSTR pDataValue; BOOL rc = FALSE; // // Set up function pointers so we can write common code // switch (dwClass) { case CLASS_PRINTER: fnOpenDevice = (PFNOPENDEVICE)OpenPrtr; fnCloseDevice = (PFNCLOSEDEVICE)ClosePrtr; fnGetData = (PFNGETDEVICEDATA)GetPrtrData; break; case CLASS_MONITOR: fnOpenDevice = (PFNOPENDEVICE)OpenMonitor; fnCloseDevice = (PFNCLOSEDEVICE)CloseMonitor; fnGetData = (PFNGETDEVICEDATA)GetMonitorData; break; case CLASS_SCANNER: fnOpenDevice = (PFNOPENDEVICE)OpenScanner; fnCloseDevice = (PFNCLOSEDEVICE)CloseScanner; fnGetData = (PFNGETDEVICEDATA)GetScannerData; break; default: return FALSE; } // // Set up registry keywords. // switch (dwDataType) { case DEVICE_PROFILE_DATA: pDataKey = gszICMProfileListKey; // // The way to store printer profile is different than others... trim it. // if (dwClass == CLASS_PRINTER) { pDataValue = gszFiles; } else { pDataValue = gszICMProfileListValue; } break; case DEVICE_PROFILE_ENUMMODE: pDataKey = gszICMDeviceDataKey; pDataValue = gszICMProfileEnumMode; break; default: return FALSE; } // // Open the device and get a handle to it // if (! (*fnOpenDevice)((PTSTR)pDeviceName, &hDevice, NULL)) { return FALSE; } if (bAllocate || (ppDeviceData == NULL)) { DWORD retcode; // // We need to allocate memory. Find out how much we need, and // allocate it. // dwSize = 0; retcode = (*fnGetData)(hDevice, pDataKey, pDataValue, NULL, NULL, 0, &dwSize); if ((retcode != ERROR_SUCCESS) && // Win 95 returns this (retcode != ERROR_MORE_DATA)) // NT returns this { VERBOSE((__TEXT("GetDeviceData failed for %s\n"), pDeviceName)); goto EndGetDeviceData; } *pdwSize = dwSize; if (ppDeviceData == NULL) { // // Caller wants to know the data size. // rc = TRUE; goto EndGetDeviceData; } else { // // Allocate buffer. // *ppDeviceData = MemAlloc(dwSize); if (! *ppDeviceData) { WARNING((__TEXT("Error allocating memory\n"))); SetLastError(ERROR_NOT_ENOUGH_MEMORY); goto EndGetDeviceData; } } } // // Get the data // if ((*fnGetData)(hDevice, pDataKey, pDataValue, NULL, (PBYTE)*ppDeviceData, *pdwSize, pdwSize) == ERROR_SUCCESS) { rc = TRUE; } EndGetDeviceData: (*fnCloseDevice)(hDevice); return rc; } /****************************************************************************** * * SetDeviceData * * Function: * This function is a wrapper for ISetDeviceData. For devices like monitor, * printer & scanner it calls the internal function. If we are asked * to set the device data for a "colorspace device", we try monitor, printer * and scanner till one succeeds or they all fail. This is done so that we * we can associate sRGB like profiles with any device. * * Arguments: * pDeviceName - pointer to name of the device * dwClass - device type like monitor, printer etc. * pDeviceData - pointer buffer containing data * dwSize - size of data * * Returns: * TRUE if successful, FALSE otherwise * ******************************************************************************/ BOOL SetDeviceData( LPCTSTR pDeviceName, DWORD dwClass, DWORD dwDataType, PVOID pDeviceData, DWORD dwSize ) { BOOL rc = FALSE; if (dwClass == CLASS_MONITOR || dwClass == CLASS_PRINTER || dwClass == CLASS_SCANNER) { rc = ISetDeviceData(pDeviceName, dwClass, dwDataType, pDeviceData, dwSize); } else if (dwClass == CLASS_COLORSPACE) { rc = ISetDeviceData(pDeviceName, CLASS_MONITOR, dwDataType, pDeviceData, dwSize) || ISetDeviceData(pDeviceName, CLASS_PRINTER, dwDataType, pDeviceData, dwSize) || ISetDeviceData(pDeviceName, CLASS_SCANNER, dwDataType, pDeviceData, dwSize); } return rc; } /****************************************************************************** * * ISetDeviceData * * Function: * This function sets ICM data stored with the different devices. * * Arguments: * pDeviceName - pointer to name of the device * dwClass - device type like monitor, printer etc. * pDeviceData - pointer buffer containing data * dwSize - size of data * * Returns: * TRUE if successful, FALSE otherwise * ******************************************************************************/ BOOL ISetDeviceData( LPCTSTR pDeviceName, DWORD dwClass, DWORD dwDataType, PVOID pDeviceData, DWORD dwSize ) { PRINTER_DEFAULTS pd; PFNOPENDEVICE fnOpenDevice; PFNCLOSEDEVICE fnCloseDevice; PFNSETDEVICEDATA fnSetData; HANDLE hDevice; LPTSTR pDataKey; LPTSTR pDataValue; DWORD dwRegType = REG_BINARY; BOOL rc = FALSE; // // Set up function pointers so we can write common code // switch (dwClass) { case CLASS_PRINTER: fnOpenDevice = (PFNOPENDEVICE)OpenPrtr; fnCloseDevice = (PFNCLOSEDEVICE)ClosePrtr; fnSetData = (PFNSETDEVICEDATA)SetPrtrData; pd.pDatatype = __TEXT("RAW"); pd.pDevMode = NULL; pd.DesiredAccess = PRINTER_ACCESS_ADMINISTER; break; case CLASS_MONITOR: fnOpenDevice = (PFNOPENDEVICE)OpenMonitor; fnCloseDevice = (PFNCLOSEDEVICE)CloseMonitor; fnSetData = (PFNSETDEVICEDATA)SetMonitorData; break; case CLASS_SCANNER: fnOpenDevice = (PFNOPENDEVICE)OpenScanner; fnCloseDevice = (PFNCLOSEDEVICE)CloseScanner; fnSetData = (PFNSETDEVICEDATA)SetScannerData; break; default: return FALSE; } // // Set up registry keywords. // switch (dwDataType) { case DEVICE_PROFILE_DATA: pDataKey = gszICMProfileListKey; // // The way to store printer profile is different than others... trim it. // if (dwClass == CLASS_PRINTER) { pDataValue = gszFiles; dwRegType = REG_MULTI_SZ; } else { pDataValue = gszICMProfileListValue; } break; case DEVICE_PROFILE_ENUMMODE: pDataKey = gszICMDeviceDataKey; pDataValue = gszICMProfileEnumMode; break; default: return FALSE; } // // Open the device and get a handle to it // if (! (*fnOpenDevice)((PTSTR)pDeviceName, &hDevice, (PTSTR)&pd)) { WARNING((__TEXT("Error opening device %s\n"), pDeviceName)); return FALSE; } // // Set the data // if ((*fnSetData)(hDevice, pDataKey, pDataValue, dwRegType, (PBYTE)pDeviceData, dwSize) == ERROR_SUCCESS) { rc = TRUE; } #if !defined(_WIN95_) // // If this is printer class, need some more data for profile list. // if ((rc == TRUE) && (dwClass == CLASS_PRINTER) && (dwDataType == DEVICE_PROFILE_DATA)) { if (((*fnSetData)(hDevice, pDataKey, gszDirectory, REG_SZ, (PBYTE)gszColorDir, (lstrlen(gszColorDir) + 1)*sizeof(TCHAR)) != ERROR_SUCCESS) || ((*fnSetData)(hDevice, pDataKey, gszModule, REG_SZ, (PBYTE)gszMSCMS, (lstrlen(gszMSCMS) + 1)*sizeof(TCHAR)) != ERROR_SUCCESS)) { rc = FALSE; } } #endif (*fnCloseDevice)(hDevice); return rc; } /****************************************************************************** * * IsStringInMultiSz * * Function: * This functions checks if a given multi-sz string has the given string * as one of the strings, and returns TRUE if it does. * * Arguments: * pMultiSzString - multi sz string to look in * pString - string to find * * Returns: * TRUE * ******************************************************************************/ BOOL IsStringInMultiSz( PTSTR pMultiSzString, PTSTR pString ) { BOOL rc = FALSE; // return code while (*pMultiSzString) { if (! lstrcmpi(pMultiSzString, pString)) { rc = TRUE; break; } pMultiSzString += lstrlen(pMultiSzString) + 1; } return rc; } /****************************************************************************** * * RemoveStringFromMultiSz * * Function: * This functions removes a given string from a multi-sz string. * * Arguments: * pMultiSzString - multi sz string to look in * pString - string to remove * dwSize - size in bytes of multi-sz string * * Returns: * TRUE * ******************************************************************************/ DWORD RemoveStringFromMultiSz( PTSTR pMultiSzString, PTSTR pString, DWORD dwSize ) { DWORD dwCount = dwSize; // count of bytes remaining while (*pMultiSzString) { dwCount -= (lstrlen(pMultiSzString) + 1) * sizeof(TCHAR); if (! lstrcmpi(pMultiSzString, pString)) { break; } pMultiSzString += lstrlen(pMultiSzString) + 1; } MyCopyMemory((PBYTE)pMultiSzString, (PBYTE)(pMultiSzString + lstrlen(pString) + 1), dwCount); return dwSize - sizeof(TCHAR) * (lstrlen(pString) + 1); } /****************************************************************************** * * DoesProfileMatchEnumRecord * * Function: * This functions checks if a profile matches the criteria given in * the enumeration record. Note that it does not check if the profile * belongs to the device specified by pDeviceName. So that check must * have happened before itself. * * Arguments: * pProfileName - profile to look at * pEnumRecord - pointer to criteria to check against * * Returns: * MATCH or EXACT_MATCH if the profile matches the criteria, NOMATCH otherwise * ******************************************************************************/ #define SET(pEnumRecord, bit) ((pEnumRecord)->dwFields & (bit)) MATCHTYPE DoesProfileMatchEnumRecord( PTSTR pProfileName, PENUMTYPE pEnumRecord ) { PROFILEHEADER header; // color profile header PROFILE prof; // profile object for opening profile HPROFILE hProfile = NULL; // handle to opened profile MATCHTYPE rc = NOMATCH; // return code // // Open a handle to the profile // prof.dwType = PROFILE_FILENAME; prof.pProfileData = (PVOID)pProfileName; prof.cbDataSize = (lstrlen(pProfileName) + 1) * sizeof(TCHAR); hProfile = OpenColorProfile(&prof, PROFILE_READ, FILE_SHARE_READ, OPEN_EXISTING); if (! hProfile) { WARNING((__TEXT("Error opening profile %s\n"), pProfileName)); goto EndDoesProfileMatchEnumRecord; } // // Get the profile header // if (! GetColorProfileHeader(hProfile, &header)) { ERR((__TEXT("Error getting color profile header for %s\n"), pProfileName)); goto EndDoesProfileMatchEnumRecord; } if ((!SET(pEnumRecord, ET_CMMTYPE) || (pEnumRecord->dwCMMType == header.phCMMType)) && (!SET(pEnumRecord, ET_CLASS) || (pEnumRecord->dwClass == header.phClass)) && (!SET(pEnumRecord, ET_DATACOLORSPACE) || (pEnumRecord->dwDataColorSpace == header.phDataColorSpace)) && (!SET(pEnumRecord, ET_CONNECTIONSPACE) || (pEnumRecord->dwConnectionSpace == header.phConnectionSpace)) && (!SET(pEnumRecord, ET_SIGNATURE) || (pEnumRecord->dwSignature == header.phSignature)) && (!SET(pEnumRecord, ET_PLATFORM) || (pEnumRecord->dwPlatform == header.phPlatform)) && (!SET(pEnumRecord, ET_PROFILEFLAGS) || (pEnumRecord->dwProfileFlags == header.phProfileFlags)) && (!SET(pEnumRecord, ET_MANUFACTURER) || (pEnumRecord->dwManufacturer == header.phManufacturer)) && (!SET(pEnumRecord, ET_MODEL) || (pEnumRecord->dwModel == header.phModel)) && (!SET(pEnumRecord, ET_ATTRIBUTES) || (pEnumRecord->dwAttributes[0] == header.phAttributes[0] && pEnumRecord->dwAttributes[1] == header.phAttributes[1])) && (!SET(pEnumRecord, ET_RENDERINGINTENT) || (pEnumRecord->dwRenderingIntent == header.phRenderingIntent)) && (!SET(pEnumRecord, ET_CREATOR) || (pEnumRecord->dwCreator == header.phCreator))) { rc = EXACT_MATCH; } // // Check for resolution, media type and halftoning match // if (rc != NOMATCH && SET(pEnumRecord, ET_RESOLUTION|ET_MEDIATYPE|ET_DITHERMODE)) { rc = CheckResMedHftnMatch(hProfile, pEnumRecord); } EndDoesProfileMatchEnumRecord: if (hProfile) { CloseColorProfile(hProfile); } return rc; } /****************************************************************************** * * CheckResMedHftnMatch * * Function: * This functions checks if a profile matches the resolution, * media type and halftoning criteria specified by the enumeration record. * It allows an exact match, as well as an ambiguous match. If the * profile doesn't specify the criteria, it is considered to ambiguously * match the specification. * is desired. * * Arguments: * hProfile - handle identifying profile * pEnumRecord - pointer to criteria to check against * * Returns: * MATCH or EXACT_MATCH if the profile matches the criteria, NOMATCH otherwise * ******************************************************************************/ MATCHTYPE CheckResMedHftnMatch( HPROFILE hProfile, PENUMTYPE pEnumRecord ) { PDEVICESETTINGS pDevSettings = NULL; PPLATFORMENTRY pPlatform; PSETTINGCOMBOS pCombo; PSETTINGS pSetting; DWORD dwMSData[4]; DWORD dwSize, i, iMax, j, jMax; MATCHTYPE rc = MATCH; // Assume ambiguous match BOOL bReference; // // Check if the profile has the new device settings tag // dwSize = 0; GetColorProfileElement(hProfile, TAG_DEVICESETTINGS, 0, &dwSize, NULL, &bReference); if (dwSize > 0) { if (!(pDevSettings = (PDEVICESETTINGS)GlobalAllocPtr(GHND, dwSize))) { WARNING((__TEXT("Error allocating memory\n"))); return NOMATCH; } if (GetColorProfileElement(hProfile, TAG_DEVICESETTINGS, 0, &dwSize, (PBYTE)pDevSettings, &bReference)) { pPlatform = &pDevSettings->PlatformEntry[0]; // // Navigate to the place where Microsoft specific settings are kept // i = 0; iMax = FIX_ENDIAN(pDevSettings->nPlatforms); while ((i < iMax) && (pPlatform->PlatformID != ID_MSFT_REVERSED)) { i++; pPlatform = (PPLATFORMENTRY)((PBYTE)pPlatform + FIX_ENDIAN(pPlatform->dwSize)); } if (i >= iMax) { // // There are no MS specific settings, assume this profile is valid // for all settings (ambigous match) // goto EndCheckResMedHftnMatch; } // // Found MS specific data. Now go through each combination of settings // pCombo = &pPlatform->SettingCombos[0]; iMax = FIX_ENDIAN(pPlatform->nSettingCombos); for (i=0; iSettings[0]; jMax = FIX_ENDIAN(pCombo->nSettings); for (j=0; jdwSettingType == ID_MEDIATYPE_REVERSED) { if (SET(pEnumRecord, ET_MEDIATYPE) && !DwordMatches(pSetting, pEnumRecord->dwMediaType)) { goto NextCombo; } } else if (pSetting->dwSettingType == ID_DITHER_REVERSED) { if (SET(pEnumRecord, ET_DITHERMODE) && !DwordMatches(pSetting, pEnumRecord->dwDitheringMode)) { goto NextCombo; } } else if (pSetting->dwSettingType == ID_RESLN_REVERSED) { if (SET(pEnumRecord, ET_RESOLUTION) && !QwordMatches(pSetting, &pEnumRecord->dwResolution[0])) { goto NextCombo; } } pSetting = (PSETTINGS)((PBYTE)pSetting + sizeof(SETTINGS) - sizeof(DWORD) + FIX_ENDIAN(pSetting->dwSizePerValue) * FIX_ENDIAN(pSetting->nValues)); } // // This combination worked! // rc = EXACT_MATCH; goto EndCheckResMedHftnMatch; NextCombo: pCombo = (PSETTINGCOMBOS)((PBYTE)pCombo + FIX_ENDIAN(pCombo->dwSize)); } rc = NOMATCH; goto EndCheckResMedHftnMatch; } else { rc = NOMATCH; goto EndCheckResMedHftnMatch; } } else { // // Check if the old MSxx tags are present // dwSize = sizeof(dwMSData); if (SET(pEnumRecord, ET_MEDIATYPE)) { if (GetColorProfileElement(hProfile, TAG_MS01, 0, &dwSize, dwMSData, &bReference)) { rc = EXACT_MATCH; // Assume exact match if (pEnumRecord->dwMediaType != FIX_ENDIAN(dwMSData[2])) { return NOMATCH; } } } dwSize = sizeof(dwMSData); if (SET(pEnumRecord, ET_DITHERMODE)) { if (GetColorProfileElement(hProfile, TAG_MS02, 0, &dwSize, dwMSData, &bReference)) { rc = EXACT_MATCH; // Assume exact match if (pEnumRecord->dwDitheringMode != FIX_ENDIAN(dwMSData[2])) { return NOMATCH; } } } dwSize = sizeof(dwMSData); if (SET(pEnumRecord, ET_RESOLUTION)) { if (GetColorProfileElement(hProfile, TAG_MS03, 0, &dwSize, dwMSData, &bReference)) { rc = EXACT_MATCH; // Assume exact match if (pEnumRecord->dwResolution[0] != FIX_ENDIAN(dwMSData[2]) || pEnumRecord->dwResolution[1] != FIX_ENDIAN(dwMSData[3])) { return NOMATCH; } } } } EndCheckResMedHftnMatch: if (pDevSettings) { GlobalFreePtr(pDevSettings); } return rc; } BOOL DwordMatches( PSETTINGS pSetting, DWORD dwValue ) { DWORD i, iMax; PDWORD pValue; dwValue = FIX_ENDIAN(dwValue); // so we don't have to do this in the loop // // Go through all the values. If any of them match, return TRUE. // pValue = &pSetting->Value[0]; iMax = FIX_ENDIAN(pSetting->nValues); for (i=0; iValue[0]; iMax = FIX_ENDIAN(pSetting->nValues); for (i=0; i= *pdwNeeded) && pData) { *((PTSTR)pData + lstrlen((PTSTR)pData) + 1) = '\0'; // // Set the profile name in new format // RegSetValueEx((HKEY)hDevice, pName, 0, REG_BINARY, pData, (lstrlen((PTSTR)pData)+2)*sizeof(TCHAR)); } } else if (*pdwNeeded == 1) { // // If we have picked up the data and it is a 1 byte non-zero // value, it is an 1 based index in a list of // predefined profiles. Deal with this case. // // If pData is NULL, then we don't know if it is non-zero or // not, so we assume it is and ask for a large enough buffer. // if (!pData || *pData != 0) { // // Old style 1-based index value // if ((dwSize >= MAX_PATH) && pData) { HKEY hkICM = NULL; HKEY hkDevice = NULL; REGDATA regData; // // Make sure buggy inf doesn't crash us // if (pData[0] > sizeof(gszDispProfiles)/sizeof(gszDispProfiles[0])) { WARNING((__TEXT("Predefined profile index too large: %d\n"), pData[0])); goto EndCompatMode; } lstrcpy((PTSTR)pData, gszDispProfiles[pData[0] - 1]); *((PTSTR)pData + lstrlen((PTSTR)pData) + 1) = '\0'; // // We need to update reference count as it wasn't set up // using the new API // // Open the registry path where profiles are kept // if ((RegCreateKey(HKEY_LOCAL_MACHINE, gszICMRegPath, &hkICM) != ERROR_SUCCESS) || (RegCreateKey(hkICM, __TEXT("mntr"), &hkDevice) != ERROR_SUCCESS)) { WARNING((__TEXT("Cannot open ICM\\device branch of registry\n"))); goto EndCompatMode; } // // If registry data exists, then the profile is already installed, // in which case, increment use count, otherwise add entry // dwTemp = sizeof(REGDATA); if (RegQueryValueEx(hkDevice, (PTSTR)pData, 0, NULL, (PBYTE)®Data, &dwTemp) == ERROR_SUCCESS) { regData.dwRefCount++; } else { regData.dwRefCount = 1; regData.dwManuID = 'enon'; // it is our profile regData.dwModelID = 'enon'; } if (RegSetValueEx(hkDevice, (PTSTR)pData, 0, REG_BINARY, (PBYTE)®Data, sizeof(REGDATA)) != ERROR_SUCCESS) { WARNING((__TEXT("Error setting registry value\n"))); goto EndCompatMode; } // // Set the profile name in new format // RegSetValueEx((HKEY)hDevice, pName, 0, REG_BINARY, pData, (lstrlen((PTSTR)pData) + 2)*sizeof(TCHAR)); EndCompatMode: if (hkICM) { RegCloseKey(hkICM); } if (hkDevice) { RegCloseKey(hkDevice); } } *pdwNeeded = MAX_PATH; } } } if ((rc == ERROR_SUCCESS) && (*pdwNeeded > dwSize)) { rc = ERROR_MORE_DATA; } return rc; } /****************************************************************************** * * SetMonitorData * * Function: * This functions stores ICM data with the monitor instance * * Arguments: * hDevice - open monitor handle * pKey - registry key for compatibility with SetPrinterDataEx * pName - name of registry value * dwType - type of value * pData - pointer to data buffer * dwSize - size of buffer * * Returns: * ERROR_SUCCESS if successful, error code otherwise * ******************************************************************************/ DWORD WINAPI SetMonitorData( HANDLE hDevice, PTSTR pKey, PTSTR pName, DWORD dwType, PBYTE pData, DWORD dwSize ) { return RegSetValueEx((HKEY)hDevice, pName, 0, dwType, pData, dwSize); } /****************************************************************************** * * OpenScanner * * Function: * This function returns a handle to the scanner * * Arguments: * pDeviceName - pointer to name of the device * phDevice - pointer that receives the handle. * pDummy - dummy parameter * * Returns: * TRUE * ******************************************************************************/ BOOL WINAPI OpenScanner( PTSTR pDeviceName, LPHANDLE phDevice, PTSTR pDummy ) { PFNSTICREATEINSTANCE pStiCreateInstance; PSCANNERDATA psd = NULL; HRESULT hres; BOOL bRc = FALSE; if (!(psd = (PSCANNERDATA)MemAlloc(sizeof(SCANNERDATA)))) { WARNING((__TEXT("Error allocating memory for scanner data\n"))); return FALSE; } if (!(psd->pDeviceName = MemAlloc((lstrlen(pDeviceName) + 1) * sizeof(WCHAR)))) { WARNING((__TEXT("Error allocating memory for scanner name\n"))); goto EndOpenScanner; } #ifdef UNICODE lstrcpy(psd->pDeviceName, pDeviceName); #else if (! ConvertToUnicode(pDeviceName, &psd->pDeviceName, FALSE)) { WARNING((__TEXT("Error converting scanner name to Unicode\n"))); goto EndOpenScanner; } #endif if (!(psd->hModule = LoadLibrary(gszStiDll))) { WARNING((__TEXT("Error loading sti.dll: %d\n"), GetLastError())); goto EndOpenScanner; } if (!(pStiCreateInstance = (PFNSTICREATEINSTANCE)GetProcAddress(psd->hModule, gszStiCreateInstance))) { WARNING((__TEXT("Error getting proc StiCreateInstance\n"))); goto EndOpenScanner; } hres = (*pStiCreateInstance)(GetModuleHandle(NULL), STI_VERSION, &psd->pSti, NULL); if (FAILED(hres)) { WARNING((__TEXT("Error creating sti instance: %d\n"), hres)); goto EndOpenScanner; } *phDevice = (HANDLE)psd; bRc = TRUE; EndOpenScanner: if (!bRc && psd) { CloseScanner((HANDLE)psd); } return bRc; } /****************************************************************************** * * CloseScanner * * Function: * This function closes the monitor handle opened by OpenMonitor * * Arguments: * hDevice - handle of device * * Returns: * TRUE * ******************************************************************************/ BOOL WINAPI CloseScanner( HANDLE hDevice ) { PSCANNERDATA psd = (PSCANNERDATA)hDevice; if (psd) { if (psd->pSti) { psd->pSti->lpVtbl->Release(psd->pSti); } if (psd->pDeviceName) { MemFree(psd->pDeviceName); } if (psd->hModule) { FreeLibrary(psd->hModule); } MemFree(psd); } return TRUE; } /****************************************************************************** * * GetScannerData * * Function: * This functions returns ICM data stored with the scannerr instance * * Arguments: * hDevice - open scanner handle * pKey - registry key for compatibility with GetPrinterDataEx * pName - name of registry value * pdwType - pointer to dword that receives type of value * pData - pointer to buffer to receive data * dwSize - size of buffer * pdwNeeded - on return, this has size of buffer filled/needed * * Returns: * ERROR_SUCCESS if successful, error code otherwise * ******************************************************************************/ DWORD WINAPI GetScannerData( HANDLE hDevice, PTSTR pKey, PTSTR pName, PDWORD pdwType, PBYTE pData, DWORD dwSize, PDWORD pdwNeeded ) { PSCANNERDATA psd = (PSCANNERDATA)hDevice; HRESULT hres; #ifndef UNICODE PWSTR pwszName; // // STI interface "ALWAYS" expects Unicode. // hres = ConvertToUnicode(pName, &pwszName, TRUE); if (!hres) { return (ERROR_INVALID_PARAMETER); } pName = (PSTR)pwszName; #endif *pdwNeeded = dwSize; hres = psd->pSti->lpVtbl->GetDeviceValue(psd->pSti, psd->pDeviceName, (PWSTR)pName, pdwType, pData, pdwNeeded); #ifndef UNICODE MemFree(pwszName); #endif return hres; } /****************************************************************************** * * SetScannerData * * Function: * This functions stores ICM data with the scanner instance * * Arguments: * hDevice - open scanner handle * pKey - registry key for compatibility with SetPrinterDataEx * pName - name of registry value * dwType - type of value * pData - pointer to data buffer * dwSize - size of buffer * * Returns: * ERROR_SUCCESS if successful, error code otherwise * ******************************************************************************/ DWORD WINAPI SetScannerData( HANDLE hDevice, PTSTR pKey, PTSTR pName, DWORD dwType, PBYTE pData, DWORD dwSize ) { PSCANNERDATA psd = (PSCANNERDATA)hDevice; HRESULT hres; #ifndef UNICODE PWSTR pwszName; // // STI interface "ALWAYS" expects Unicode. // hres = ConvertToUnicode(pName, &pwszName, TRUE); if (!hres) { return (ERROR_INVALID_PARAMETER); } pName = (PSTR)pwszName; #endif hres = psd->pSti->lpVtbl->SetDeviceValue(psd->pSti, psd->pDeviceName, (PWSTR)pName, dwType, pData, dwSize); #ifndef UNICODE MemFree(pwszName); #endif return hres; } // // Internal functions // BOOL WINAPI InternalGetDeviceConfig( LPCTSTR pDeviceName, DWORD dwDeviceClass, DWORD dwConfigType, PVOID pConfigData, PDWORD pdwSize ) { DWORD dwDataType; DWORD dwSizeRequired = 0; BOOL rc = FALSE; switch (dwConfigType) { case MSCMS_PROFILE_ENUM_MODE: dwDataType = DEVICE_PROFILE_ENUMMODE; break; default: WARNING((__TEXT("Invalid parameter to InternalGetDeviceConfig\n"))); SetLastError(ERROR_INVALID_PARAMETER); return FALSE; } // // Query the size of the data. // if (GetDeviceData(pDeviceName,dwDeviceClass,dwDataType,NULL,&dwSizeRequired,FALSE)) { if ((dwSizeRequired <= *pdwSize) && (pConfigData != NULL)) { // // If buffer is enough, get the data. // if (GetDeviceData(pDeviceName,dwDeviceClass,dwDataType, (PVOID *)&pConfigData,pdwSize,FALSE)) { rc = TRUE; } else { WARNING((__TEXT("Failed on GetDeviceData to query data\n"))); SetLastError(ERROR_INVALID_PARAMETER); } } else { // // Return nessesary buffer size to caller. // *pdwSize = dwSizeRequired; SetLastError(ERROR_INSUFFICIENT_BUFFER); } } else { WARNING((__TEXT("Failed on GetDeviceData to query data size\n"))); SetLastError(ERROR_INVALID_PARAMETER); } return rc; } BOOL WINAPI InternalSetDeviceConfig( LPCTSTR pDeviceName, DWORD dwDeviceClass, DWORD dwConfigType, PVOID pConfigData, DWORD dwSize ) { DWORD dwDataType; switch (dwConfigType) { case MSCMS_PROFILE_ENUM_MODE: dwDataType = DEVICE_PROFILE_ENUMMODE; break; default: WARNING((__TEXT("Invalid parameter to InternalGetDeviceConfig\n"))); SetLastError(ERROR_INVALID_PARAMETER); return FALSE; } // // Save the data. // return (SetDeviceData(pDeviceName,dwDeviceClass,dwDataType,pConfigData,dwSize)); } #ifdef _WIN95_ // // Win9x specific functions are here. // BOOL LoadSetupAPIDll( VOID ) { EnterCriticalSection(&critsec); if (ghModSetupAPIDll == NULL) { ghModSetupAPIDll = LoadLibrary(TEXT("setupapi.dll")); if (ghModSetupAPIDll) { fpSetupDiOpenDevRegKey = (FP_SetupDiOpenDevRegKey) GetProcAddress(ghModSetupAPIDll,"SetupDiOpenDevRegKey"); fpSetupDiDestroyDeviceInfoList = (FP_SetupDiDestroyDeviceInfoList) GetProcAddress(ghModSetupAPIDll,"SetupDiDestroyDeviceInfoList"); fpSetupDiEnumDeviceInfo = (FP_SetupDiEnumDeviceInfo) GetProcAddress(ghModSetupAPIDll,"SetupDiEnumDeviceInfo"); fpSetupDiGetDeviceInstanceId = (FP_SetupDiGetDeviceInstanceId) GetProcAddress(ghModSetupAPIDll,"SetupDiGetDeviceInstanceIdA"); fpSetupDiGetClassDevs = (FP_SetupDiGetClassDevs) GetProcAddress(ghModSetupAPIDll,"SetupDiGetClassDevsA"); if ((fpSetupDiOpenDevRegKey == NULL) || (fpSetupDiDestroyDeviceInfoList == NULL) || (fpSetupDiEnumDeviceInfo == NULL) || (fpSetupDiGetDeviceInstanceId == NULL) || (fpSetupDiGetClassDevs == NULL)) { WARNING((__TEXT("Could not find Export function in setupapi.dll\n"))); FreeLibrary(ghModSetupAPIDll); ghModSetupAPIDll = NULL; } } } LeaveCriticalSection(&critsec); return (!!ghModSetupAPIDll); } #else // // Win NT specific functions are here. // VOID ChangeICMSetting( LPCTSTR pMachineName, LPCTSTR pDeviceName, DWORD dwICMMode ) { PRINTER_INFO_8 *ppi8; PRINTER_INFO_9 *ppi9; PRINTER_DEFAULTS pd; HANDLE hPrinter; DWORD dwSize; BYTE temp[2*1024]; // sufficient for devmode pd.pDatatype = NULL; pd.pDevMode = NULL; pd.DesiredAccess = PRINTER_ALL_ACCESS; if (!OpenPrinter((PTSTR)pDeviceName, &hPrinter, &pd)) return; // // Get and update system devmode // ppi8 = (PRINTER_INFO_8 *)&temp; if (GetPrinter(hPrinter, 8, (PBYTE)ppi8, sizeof(temp), &dwSize) && ppi8->pDevMode) { switch (dwICMMode) { case ICM_ON: case ICM_OFF: ppi8->pDevMode->dmFields |= DM_ICMMETHOD; if (dwICMMode == ICM_ON) ppi8->pDevMode->dmICMMethod = DMICMMETHOD_SYSTEM; else ppi8->pDevMode->dmICMMethod = DMICMMETHOD_NONE; SetPrinter(hPrinter, 8, (PBYTE)ppi8, 0); break; } } // // If the user has a per-user devmode, update this as well // ppi9 = (PRINTER_INFO_9 *)&temp; if (GetPrinter(hPrinter, 9, (PBYTE)ppi9, sizeof(temp), &dwSize) && ppi9->pDevMode) { switch (dwICMMode) { case ICM_ON: case ICM_OFF: ppi9->pDevMode->dmFields |= DM_ICMMETHOD; if (dwICMMode == ICM_ON) ppi9->pDevMode->dmICMMethod = DMICMMETHOD_SYSTEM; else ppi9->pDevMode->dmICMMethod = DMICMMETHOD_NONE; SetPrinter(hPrinter, 9, (PBYTE)ppi9, 0); break; } } ClosePrinter(hPrinter); return; } #endif // _WIN95_