DEBUG.C
//THIS CODE AND INFORMATION IS PROVIDED "AS IS" WITHOUT WARRANTY OF
//ANY KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING BUT NOT LIMITED TO
//THE IMPLIED WARRANTIES OF MERCHANTABILITY AND/OR FITNESS FOR A
// PARTICULAR PURPOSE.
//
// Copyright 1994-1997 Microsoft Corporation. All Rights Reserved.
//
// FILE:
// DEBUG.C
//
// PURPOSE:
// Debugging routines.
//
// PLATFORMS:
// Windows 95, Windows NT
//
// SPECIAL INSTRUCTIONS: N/A
//
// Windows Header Files:
#pragma warning(disable:4001) // Single-line comment warnings
#pragma warning(disable:4115) // Named type definition in parentheses
#pragma warning(disable:4201) // Nameless struct/union warning
#pragma warning(disable:4214) // Bit field types other than int warnings
#pragma warning(disable:4514) // Unreferenced inline function has been removed
// Windows Header Files:
#include <Windows.h>
#include <WindowsX.h>
#include <icm.h>
// Restore the warnings--leave the single-line comment warning OFF
#pragma warning(default:4115) // Named type definition in parentheses
#pragma warning(default:4201) // Nameless struct/union warning
#pragma warning(default:4214) // Bit field types other than int warnings
#pragma warning(default:4514) // Unreferenced inline function has been removed
// C RunTime Header Files
#include <stdio.h>
#include <TCHAR.H>
#include <stdlib.h>
// Local Header Files
#include "icmview.h"
#include "dibinfo.h"
#define I_AM_DEBUG
#include "Debug.h"
#undef I_AM_DEBUG
// local definitions
// default settings
// external functions
// external data
// public data
// private data
// public functions
// private functions
//////////////////////////////////////////////////////////////////////////
// Function: _Assert
//
// Description:
// Replacement assertion function
//
// Parameters:
// LPSTR Name of file
// UINT Line number@@@
//
// Returns:
// void
//
// Comments:
//
//
//////////////////////////////////////////////////////////////////////////
void _Assert(LPSTR strFile, UINT uiLine)
{
// Local variables
char stAssert[255];
// Initialize variables
wsprintfA(stAssert, "Assertion failed %s, line %u\r\n", strFile, uiLine);
OutputDebugStringA(stAssert);
} // End of function _Assert
///////////////////////////////////////////////////////////////////////////
//
// FUNCTION: DebugMsg
//
// PURPOSE:
// To provide a printf type DebugMsg function.
//
// PARAMETERS:
// LPTSTR Format string
// <variable arguments> printf-style arguments
//
// RETURN VALUE:
// void
//
// COMMENTS:
//
///////////////////////////////////////////////////////////////////////////
void DebugMsg (LPTSTR lpszMessage,...)
{
#ifdef _DEBUG
va_list VAList;
TCHAR szMsgBuf[256];
// Pass the variable parameters to wvsprintf to be formated.
va_start(VAList, lpszMessage);
wvsprintf(szMsgBuf, lpszMessage, VAList);
va_end(VAList);
ASSERT(lstrlen((LPTSTR)szMsgBuf) < MAX_DEBUG_STRING);
OutputDebugString(szMsgBuf);
#endif
lpszMessage = lpszMessage; // Eliminates 'unused formal parameter' warning
}
void DebugMsgA (LPSTR lpszMessage,...)
{
#ifdef _DEBUG
va_list VAList;
char szMsgBuf[256];
// Pass the variable parameters to wvsprintf to be formated.
va_start(VAList, lpszMessage);
wvsprintfA(szMsgBuf, lpszMessage, VAList);
va_end(VAList);
ASSERT(strlen((LPSTR)szMsgBuf) < MAX_DEBUG_STRING);
OutputDebugStringA(szMsgBuf);
#endif
lpszMessage = lpszMessage; // Eliminates 'unused formal parameter' warning
}
///////////////////////////////////////////////////////////////////////////
//
// FUNCTION: ErrMsg
//
// PURPOSE:
// To provide a printf type error message box.
//
// PARAMETERS:
// LPTSTR wsprintf-style format string
// ... formatting information
//
// RETURN VALUE:
// Value from MessageBox function; 0 if failure, non-zero
// otherwise. For specific values, see MessageBox.
//
// COMMENTS:
//
///////////////////////////////////////////////////////////////////////////
int ErrMsg (HWND hwndOwner, LPTSTR lpszMessage,...)
{
va_list VAList;
TCHAR szMsgBuf[256];
// Pass the variable parameters to wvsprintf to be formated.
va_start(VAList, lpszMessage);
wvsprintf(szMsgBuf, lpszMessage, VAList);
va_end(VAList);
ASSERT(lstrlen((LPTSTR)szMsgBuf) < MAX_DEBUG_STRING);
return(MessageBox(hwndOwner, (LPCTSTR)szMsgBuf, (LPCTSTR)__TEXT("Error"), MB_ICONSTOP|MB_APPLMODAL));
}
//////////////////////////////////////////////////////////////////////////
// Function: DumpMemory
//
// Description:
// Dumps values at specified memory.
//
// Parameters:
// LPVOID Pointer to memory
// UINT Size of each element, i.e. 8 or 16
// UINT Number of elements to dump.
//
// Returns:
// void
//
// Comments:
// -Need to add validation of uiElementSize.
// -uiElementSize * uiNumElements should not exceed the size
// of the buffer; otherwise, wacky and wonderful events will
// take place.
//
//////////////////////////////////////////////////////////////////////////
void DumpMemory(LPBYTE lpbMem, UINT uiElementSize, UINT uiNumElements)
{
// Local variables
UINT uiIdx;
uiElementSize = uiElementSize; // Eliminates 'unused formal parameters'
// Initialize variables
for (uiIdx = 0; uiIdx < uiNumElements; uiIdx++)
{
if (uiIdx == 0 || ((uiIdx % 16) == 0))
{
DebugMsg(__TEXT("\r\n0x%08X\t"), (DWORD)(lpbMem + (uiIdx)));
}
DebugMsg(__TEXT("%02x "), (WORD)*(lpbMem + uiIdx));
}
} // End of function DumpMemory
//////////////////////////////////////////////////////////////////////////
// Function: DumpProfile
//
// Description:
// Dumps the PROFILE structure provided.
//
// Parameters:
// PPROFILE Pointer to the profile.
//
// Returns:
// void
//
// Comments:
//////////////////////////////////////////////////////////////////////////
void DumpProfile(PPROFILE pProfile)
{
// Local variables
TCHAR stProfileType[MAX_PATH];
// Initialize variables
if (pProfile == NULL)
{
DebugMsg(__TEXT("DEBUG.C : DumpProfile : NULL pProfile\r\n"));
return;
}
// Set type string
_tcscpy(stProfileType, __TEXT("UNKNOWN"));
if (PROFILE_FILENAME == pProfile->dwType)
{
_tcscpy(stProfileType, __TEXT("FILE"));
}
if (PROFILE_MEMBUFFER == pProfile->dwType)
{
_tcscpy(stProfileType, __TEXT("MEMBUFFER"));
}
DebugMsg(__TEXT("***** PROFILE *****\r\n"));
DebugMsg(__TEXT("pProfile 0x%08lX\r\n"), pProfile);
DebugMsg(__TEXT("dwType %s\r\n"), stProfileType);
DebugMsg(__TEXT("pProfileData 0x%08lX\r\n"), pProfile->pProfileData);
if (PROFILE_FILENAME == pProfile->dwType)
{
DebugMsg(__TEXT("Filename %s\r\n"), pProfile->pProfileData);
}
DebugMsg(__TEXT("cbDataSize %ld\r\n\r\n"), pProfile->cbDataSize);
} // End of function DumpMemory
//////////////////////////////////////////////////////////////////////////
// Function: DumpRectangle
//
// Description:
// Dumps the coordinates of a rectangle structure
//
// Parameters:
// LPTSTR Comment
// LPRECT Rectangle to dump
//
// Returns:
// void
//
// Comments:
//
//
//////////////////////////////////////////////////////////////////////////
void DumpRectangle(LPTSTR lpszDesc, LPRECT lpRect)
{
DebugMsg(__TEXT("%s: %ld, %ld, %ld, %ld\r\n"), lpszDesc, lpRect->left, lpRect->top, lpRect->right,
lpRect->bottom);
} // End of function DumpRectangle
//////////////////////////////////////////////////////////////////////////
// Function: SafeFree
//
// Description:
// Debug Free routine which checks lock counts and return codes.
//
// Parameters:
// @@@
//
// Returns:
// HGLOBAL
//
// Comments:
// This function assumes that the HGLOBAL object has been unlocked;
// if not, the item will still be freed, but a warning message will
// be displayed. This is useful for tracking down items which have
// been locked without being unlocked.
//
// The last error value will be preserved if no error occurs in this
// function. If an error does occur, it will be passed to the calling
// function.
//
//////////////////////////////////////////////////////////////////////////
HGLOBAL SafeFree(LPTSTR lpszFile, UINT uiLine, HGLOBAL hMemory)
{
// Local variables
UINT uiLockCount, uiFlags;
DWORD dwLastError;
HGLOBAL hFreed; // Return from GlobalFree
TCHAR szName[MAX_PATH], szExt[MAX_PATH];
// Initialize variables
_tsplitpath(lpszFile, NULL, NULL, szName, szExt);
wsprintf(lpszFile,__TEXT("%s%s"), szName, szExt);
if (NULL == hMemory)
{
DebugMsg(__TEXT("%s(%lu) : SafeFree: NULL hMem!!! This will cause an exception!!!! Fix it!!!\r\n"), lpszFile, uiLine);
DebugBreak();
return(NULL);
}
SetLastError(0);
hFreed = GlobalFree(hMemory);
if (NULL != hFreed) // unsuccessful free
{
dwLastError = GetLastError();
uiFlags = GlobalFlags(hMemory);
uiLockCount = uiFlags & GMEM_LOCKCOUNT;
uiFlags = HIBYTE(LOWORD(uiFlags));
DebugMsg(__TEXT("SafeFree : <%s(%lu)> failed\tLastError = %ld, Flags = %lu, Lock Count = %lu\r\n"),
lpszFile, uiLine, dwLastError, uiFlags, uiLockCount);
}
return(hFreed);
} // End of function SafeFree
//////////////////////////////////////////////////////////////////////////
// Function: SafeUnlock
//
// Description:
// Unlocks handle and displays the lock count and flags information.
//
// Parameters:
// @@@
//
// Returns:
// BOOL
//
// Comments:
//
//
//////////////////////////////////////////////////////////////////////////
BOOL SafeUnlock(LPTSTR lpszFile, UINT uiLine, HGLOBAL hMemory)
{
// Local variables
BOOL bUnlocked;
UINT uiLockCount, uiFlags;
DWORD dwLastError;
TCHAR szName[MAX_PATH], szExt[MAX_PATH];
// Initialize variables
_tsplitpath(lpszFile, NULL, NULL, szName, szExt);
wsprintf(lpszFile, __TEXT("%s%s"), szName, szExt);
if (NULL == hMemory)
{
DebugMsg(__TEXT("%s(%lu) : SafeUnlock: NULL hMem\r\n"), lpszFile, uiLine);
return(0);
}
SetLastError(0);
bUnlocked = GlobalUnlock(hMemory);
dwLastError = GetLastError();
uiFlags = GlobalFlags(hMemory);
uiLockCount = uiFlags & GMEM_LOCKCOUNT;
if (0 != dwLastError)
{
uiFlags = HIBYTE(LOWORD(uiFlags));
}
DebugMsg(__TEXT("SafeUnlock : <%s(%lu)>\tGlobalUnlock(0x%08lX) returned %4d w/LastError = %4ld, Lock Count = %4lu, Flags = %4lu\r\n"),
lpszFile, uiLine, hMemory, bUnlocked, dwLastError, uiLockCount, uiFlags);
return(bUnlocked);
} // End of function SafeUnlock
//////////////////////////////////////////////////////////////////////////
// Function: SafeLock
//
// Description:
// Locks memory and reports lock count.
//
// Parameters:
// @@@
//
// Returns:
// LPVOID
//
// Comments:
//
//
//////////////////////////////////////////////////////////////////////////
LPVOID SafeLock(LPTSTR lpszFile, UINT uiLine, HGLOBAL hMemory)
{
// Local variables
LPVOID lpMem;
UINT uiLockCount, uiFlags;
DWORD dwLastError;
TCHAR szName[MAX_PATH], szExt[MAX_PATH];
// Initialize variables
_tsplitpath(lpszFile, NULL, NULL, szName, szExt);
wsprintf(lpszFile, __TEXT("%s%s"), szName, szExt);
if (NULL == hMemory)
{
DebugMsg(__TEXT("%s(%lu) : SafeLock: NULL hMem\r\n"), lpszFile, uiLine);
return((LPVOID)NULL);
}
SetLastError(0);
lpMem = GlobalLock(hMemory);
dwLastError = GetLastError();
uiFlags = GlobalFlags(hMemory);
uiLockCount = uiFlags & GMEM_LOCKCOUNT;
uiFlags = HIBYTE(LOWORD(uiFlags));
DebugMsg(__TEXT("SafeLock : <%s(%lu)>\tGlobalLock(0x%08lX) returned 0x%08lX w/LastError = %ld, Lock Count = %lu, Flags = %lu\r\n"),
lpszFile, uiLine, hMemory, lpMem, dwLastError, uiLockCount, uiFlags);
return(lpMem);
} // End of function SafeLock
//////////////////////////////////////////////////////////////////////////
// Function: FormatLastError
//
// Description:
// Allocates and formats a string of LastError's text-equivalent message.
// If the caller requests, the message will be displayed and the memory
// will be deallocated.
//
// Parameters:
// LPTSTR Name of file where error occured
// UINT Line of file at which point error occured
// DWORD Numeric value of LastError
// UINT Display and free indicator
// LASTERROR_NOALLOC Display via DebugMsg and deallocate
// LASTERROR_ALLOC Return pointer to allocated string
//
// Returns:
// BOOL
//
// Comments:
// Caller must free memory returned by this function.
//
//////////////////////////////////////////////////////////////////////////
LPTSTR FormatLastError(LPTSTR lpszFile, UINT uiLine, UINT uiOutput, DWORD dwLastError)
{
// Local variables
LPTSTR lpszLastErrorMsg;
LPTSTR lpszDebugMsg;
DWORD cbBytes;
// Initialize variables
lpszLastErrorMsg = NULL;
cbBytes = FormatMessage(FORMAT_MESSAGE_ALLOCATE_BUFFER
| FORMAT_MESSAGE_FROM_SYSTEM,
NULL,
dwLastError,
MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT), //The user default language
(LPTSTR) &lpszLastErrorMsg,
0,
NULL );
if (0 == cbBytes) // Error occured in FormatMessage
{
SetLastError(dwLastError); // restore the last error to time of call
}
// Create the error message
lpszDebugMsg = GlobalAlloc(GPTR, ((cbBytes + 512) * sizeof(TCHAR)));
ASSERT(NULL != lpszDebugMsg);
wsprintf(lpszDebugMsg, __TEXT("<%s(%lu)>:\r\n\tLastError(ld, lu) = (%ld, %lu)\r\n\t\t%s\r\n"),
lpszFile,
uiLine,
dwLastError,
dwLastError,
NULL != lpszLastErrorMsg ? lpszLastErrorMsg : __TEXT("UNKNOWN LASTERROR"));
// Free the buffer memory if requested
if (LASTERROR_NOALLOC == uiOutput)
{
DebugMsg(lpszDebugMsg);
GlobalFree(lpszDebugMsg);
}
// Always free the string created by FormatMessage
if (NULL != lpszLastErrorMsg)
{
GlobalFree(lpszLastErrorMsg);
}
return(lpszDebugMsg);
} // End of function FormatLastError
//////////////////////////////////////////////////////////////////////////
// Function: DumpBITMAPFILEHEADER
//
// Description:
// Dumps the contents of a BITMAPFILEHEADER.
//
// Parameters:
// @@@
//
// Returns:
// void
//
// Comments:
//
//
//////////////////////////////////////////////////////////////////////////
void DumpBITMAPFILEHEADER(LPBITMAPFILEHEADER lpBmpFileHeader)
{
// Local variables
DebugMsg(__TEXT("////////////////// BITMAPFILEHEADER ///////////////////\r\n"));
DebugMsg(__TEXT("sizeof(BITMAPFILEHEADER) %ld\r\n"), sizeof(BITMAPFILEHEADER));
DebugMsg(__TEXT("bfType 0x%04x\r\n"), lpBmpFileHeader->bfType);
DebugMsg(__TEXT("bfSize %ld\r\n"), lpBmpFileHeader->bfSize);
DebugMsg(__TEXT("bfReserved1 %d\r\n"), lpBmpFileHeader->bfReserved1);
DebugMsg(__TEXT("bfReserved2 %d\r\n"), lpBmpFileHeader->bfReserved1);
DebugMsg(__TEXT("bfOffBits %ld\r\n"), lpBmpFileHeader->bfOffBits);
DebugMsg(__TEXT("///////////////////////////////////////////////////////\r\n"));
// Initialize variables
} // End of function DumpBITMAPFILEHEADER
//////////////////////////////////////////////////////////////////////////
// Function: DumpBITMAPINFOHEADER
//
// Description:
// Dumps a BITMAPINFO header structure.
//
// Parameters:
// @@@
//
// Returns:
// void
//
// Comments:
//
//
//////////////////////////////////////////////////////////////////////////
void DumpBmpHeader(LPVOID lpvBmpHeader)
{
// Local variables
LPBITMAPV5HEADER lpBmpV5Header;
TCHAR stNumText[MAX_PATH];
// Initialize variables
lpBmpV5Header = (LPBITMAPV5HEADER)lpvBmpHeader;
switch (lpBmpV5Header->bV5Size)
{
case sizeof(BITMAPCOREHEADER):
_tcscpy(stNumText,__TEXT("BITMAPCOREHEADER"));
break;
case sizeof(BITMAPINFOHEADER):
_tcscpy(stNumText, __TEXT("BITMAPINFOHEADER"));
break;
case sizeof(BITMAPV4HEADER):
_tcscpy(stNumText, __TEXT("BITMAPV4HEADER"));
break;
case sizeof(BITMAPV5HEADER):
_tcscpy(stNumText,__TEXT("BITMAPV5HEADER"));
break;
default:
_tcscpy(stNumText, __TEXT("UNKNOWN HEADER SIZE"));
break;
}
DebugMsg(__TEXT("/////////////////// %s /////////////////////\r\n"), stNumText);
DebugMsg(__TEXT("HeaderSize %ld\r\n"), lpBmpV5Header->bV5Size);
DebugMsg(__TEXT("Width %lu\r\n"), lpBmpV5Header->bV5Width);
DebugMsg(__TEXT("Height %lu\r\n"), lpBmpV5Header->bV5Height);
DebugMsg(__TEXT("Planes %d\r\n"), lpBmpV5Header->bV5Planes);
DebugMsg(__TEXT("BitCount %d\r\n"), lpBmpV5Header->bV5BitCount);
if ( sizeof(BITMAPCOREHEADER)== lpBmpV5Header->bV5Size) goto End;
switch (lpBmpV5Header->bV5Compression)
{
case BI_RGB:
_tcscpy(stNumText, __TEXT("BI_RGB"));
break;
case BI_RLE8:
_tcscpy(stNumText, __TEXT("BI_RLE8"));
break;
case BI_RLE4:
_tcscpy(stNumText,__TEXT("BI_RLE4"));
break;
case BI_BITFIELDS:
_tcscpy(stNumText, __TEXT("BI_BITFIELDS"));
break;
default:
_tcscpy(stNumText,__TEXT("Unknown Compression"));
break;
}
DebugMsg(__TEXT("Compression %s\r\n"), stNumText);
DebugMsg(__TEXT("SizeImage %ld\r\n"), lpBmpV5Header->bV5SizeImage);
DebugMsg(__TEXT("XPelsPerMeter %ld\r\n"), lpBmpV5Header->bV5XPelsPerMeter);
DebugMsg(__TEXT("YPelsPerMeter %ld\r\n"), lpBmpV5Header->bV5YPelsPerMeter);
DebugMsg(__TEXT("ClrUsed %ld\r\n"), lpBmpV5Header->bV5ClrUsed);
DebugMsg(__TEXT("ClrImportant %ld\r\n"), lpBmpV5Header->bV5ClrImportant);
if (sizeof(BITMAPINFOHEADER) == lpBmpV5Header->bV5Size) goto End;
DebugMsg(__TEXT("Red Mask 0x%08lx\r\n"), lpBmpV5Header->bV5RedMask);
DebugMsg(__TEXT("Green Mask 0x%08lx\r\n"), lpBmpV5Header->bV5GreenMask);
DebugMsg(__TEXT("Blue Mask 0x%08lx\r\n"), lpBmpV5Header->bV5BlueMask);
DebugMsg(__TEXT("Alpha Mask 0x%08lx\r\n"), lpBmpV5Header->bV5AlphaMask);
DebugMsg(__TEXT("CS Type "));
switch (lpBmpV5Header->bV5CSType)
{
case PROFILE_LINKED:
DebugMsg(__TEXT("LINKED\r\n"));
break;
case PROFILE_EMBEDDED:
DebugMsg(__TEXT("EMBEDDED\r\n"));
break;
default:
DebugMsg(__TEXT("0x%08lx\r\n"), lpBmpV5Header->bV5CSType);
break;
}
DebugMsg(__TEXT("Gamma Red %ld\r\n"), lpBmpV5Header->bV5GammaRed);
DebugMsg(__TEXT("Gamma Green %ld\r\n"), lpBmpV5Header->bV5GammaGreen);
DebugMsg(__TEXT("Gamma Blue %ld\r\n"), lpBmpV5Header->bV5GammaBlue);
if (sizeof(BITMAPV4HEADER) == lpBmpV5Header->bV5Size) goto End;
DebugMsg(__TEXT("Intent %ld\r\n"), lpBmpV5Header->bV5Intent);
DebugMsg(__TEXT("ProfileData %ld\r\n"), lpBmpV5Header->bV5ProfileData);
DebugMsg(__TEXT("ProfileSize %ld\r\n"), lpBmpV5Header->bV5ProfileSize);
DebugMsg(__TEXT("Reserved %ld\r\n"), lpBmpV5Header->bV5Reserved);
End:
DebugMsg(__TEXT("///////////////////////////////////////////////////////\r\n"));
} // End of function DumpBITMAPINFOHEADER
//////////////////////////////////////////////////////////////////////////
// Function: DumpLogColorSpace
//
// Description:
// Dumps a LOGCOLORSPACE structure.
//
// Parameters:
// @@@
//
// Returns:
// void
//
// Comments:
//
//
//////////////////////////////////////////////////////////////////////////
void DumpLogColorSpace(LPLOGCOLORSPACE pColorSpace)
{
DebugMsg(__TEXT("/////////////////// LOGCOLORSPACE /////////////////////\r\n"));
DebugMsg(__TEXT("lcsSignature %#lx\r\n"), pColorSpace->lcsSignature);
DebugMsg(__TEXT("lcsVersion %#lx\r\n"), pColorSpace->lcsVersion);
DebugMsg(__TEXT("lcsSize %#lx\r\n"), pColorSpace->lcsSize);
DebugMsg(__TEXT("lcsCSType %#lx\r\n"), pColorSpace->lcsCSType);
DebugMsg(__TEXT("lcsIntent %#lx\r\n"), pColorSpace->lcsIntent);
DebugMsg(__TEXT("lcsEndpoints.ciexyzRed.ciexyzX %#lx\r\n"), pColorSpace->lcsEndpoints.ciexyzRed.ciexyzX);
DebugMsg(__TEXT("lcsEndpoints.ciexyzRed.ciexyzY %#lx\r\n"), pColorSpace->lcsEndpoints.ciexyzRed.ciexyzY);
DebugMsg(__TEXT("lcsEndpoints.ciexyzRed.ciexyzZ %#lx\r\n"), pColorSpace->lcsEndpoints.ciexyzRed.ciexyzZ);
DebugMsg(__TEXT("lcsEndpoints.ciexyzGreen.ciexyzX %#lx\r\n"), pColorSpace->lcsEndpoints.ciexyzGreen.ciexyzX);
DebugMsg(__TEXT("lcsEndpoints.ciexyzGreen.ciexyzY %#lx\r\n"), pColorSpace->lcsEndpoints.ciexyzGreen.ciexyzY);
DebugMsg(__TEXT("lcsEndpoints.ciexyzGreen.ciexyzZ %#lx\r\n"), pColorSpace->lcsEndpoints.ciexyzGreen.ciexyzZ);
DebugMsg(__TEXT("lcsEndpoints.ciexyzBlue.ciexyzX %#lx\r\n"), pColorSpace->lcsEndpoints.ciexyzBlue.ciexyzX);
DebugMsg(__TEXT("lcsEndpoints.ciexyzBlue.ciexyzY %#lx\r\n"), pColorSpace->lcsEndpoints.ciexyzBlue.ciexyzY);
DebugMsg(__TEXT("lcsEndpoints.ciexyzBlue.ciexyzZ %#lx\r\n"), pColorSpace->lcsEndpoints.ciexyzBlue.ciexyzZ);
DebugMsg(__TEXT("lcsGammaRed %#lx\r\n"), pColorSpace->lcsGammaRed);
DebugMsg(__TEXT("lcsGammaGreen %#lx\r\n"), pColorSpace->lcsGammaGreen);
DebugMsg(__TEXT("lcsGammaBlue %#lx\r\n"), pColorSpace->lcsGammaBlue);
DebugMsg(__TEXT("lcsFilename %s\r\n"), pColorSpace->lcsFilename);
DebugMsg(__TEXT("///////////////////////////////////////////////////////\r\n"));
}
//////////////////////////////////////////////////////////////////////////
// Function: DumpCOLORMATCHSETUP
//
// Description:
// Dumps COLORMATCHSETUP structure
//
// Parameters:
// @@@
//
// Returns:
// void
//
// Comments:
//
//
//////////////////////////////////////////////////////////////////////////
void DumpCOLORMATCHSETUP(LPCOLORMATCHSETUP lpCM)
{
// Local variables
// ASSERTs and parameter validations
DebugMsg(__TEXT("***** COLORMATCHSETUP 0x%08lx\r\n"), lpCM);
DebugMsg(__TEXT("dwSize %ld\r\n"), lpCM->dwSize);
DebugMsg(__TEXT("dwVersion 0x%08lx\r\n"), lpCM->dwVersion);
DebugMsg(__TEXT("dwFlags 0x%08lx\r\n"), lpCM->dwFlags);
DebugMsg(__TEXT("hwndOwner 0x%08lx\r\n"), lpCM->hwndOwner);
DebugMsg(__TEXT("pSourceName 0x%08lX <%s>\r\n"), lpCM->pSourceName , lpCM->pSourceName ? lpCM->pSourceName : __TEXT("NULL PTR"));
DebugMsg(__TEXT("pDisplayName 0x%08lX <%s>\r\n"), lpCM->pDisplayName , lpCM->pDisplayName ? lpCM->pDisplayName : __TEXT("NULL PTR"));
DebugMsg(__TEXT("pPrinterName 0x%08lX <%s>\r\n"), lpCM->pPrinterName , lpCM->pPrinterName ? lpCM->pPrinterName : __TEXT("NULL PTR"));
DebugMsg(__TEXT("dwRenderIntent %ld\r\n"), lpCM->dwRenderIntent);
DebugMsg(__TEXT("dwProofingIntent %ld\r\n"), lpCM->dwProofingIntent);
DebugMsg(__TEXT("pMonitorProfile 0x%08lX <%s>\r\n"), lpCM->pMonitorProfile , lpCM->pMonitorProfile ? lpCM->pMonitorProfile : __TEXT("NULL PTR"));
DebugMsg(__TEXT("ccMonitorProfile %ld\r\n"), lpCM->ccMonitorProfile);
DebugMsg(__TEXT("pPrinterProfile 0x%08lX <%s>\r\n"), lpCM->pPrinterProfile , lpCM->pPrinterProfile ? lpCM->pPrinterProfile : __TEXT("NULL PTR"));
DebugMsg(__TEXT("ccPrinterProfile %ld\r\n"), lpCM->ccPrinterProfile);
DebugMsg(__TEXT("pTargetProfile 0x%08lX <%s>\r\n"), lpCM->pTargetProfile , lpCM->pTargetProfile ? lpCM->pTargetProfile : __TEXT("NULL PTR"));
DebugMsg(__TEXT("ccTargetProfile %ld\r\n"), lpCM->ccTargetProfile);
DebugMsg(__TEXT("lpfnHook 0x%08lx\r\n"), lpCM->lpfnHook);
DebugMsg(__TEXT("lParam 0x%08lx\r\n"), lpCM->lParam);
DebugMsg(__TEXT("***** COLORMATCHSETUP 0x%08lx\r\n"), lpCM);
} // End of function DumpCOLORMATCHSETUP