home *** CD-ROM | disk | FTP | other *** search
/ Tricks of the Windows Gam…ming Gurus (2nd Edition) / Disc2.iso / msdn_vcb / samples / vc98 / sdk / graphics / icm20 / icmview / debug.c < prev    next >
C/C++ Source or Header  |  1997-09-07  |  26KB  |  760 lines
  1. //THIS CODE AND INFORMATION IS PROVIDED "AS IS" WITHOUT WARRANTY OF
  2. //ANY KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING BUT NOT LIMITED TO
  3. //THE IMPLIED WARRANTIES OF MERCHANTABILITY AND/OR FITNESS FOR A
  4. // PARTICULAR PURPOSE.
  5. //
  6. // Copyright  1994-1997  Microsoft Corporation.  All Rights Reserved.
  7. //
  8. //  FILE:
  9. //    DEBUG.C
  10. //
  11. //  PURPOSE:
  12. //    Debugging routines.
  13. //
  14. //  PLATFORMS:
  15. //    Windows 95, Windows NT
  16. //
  17. //  SPECIAL INSTRUCTIONS: N/A
  18. //
  19.  
  20. // Windows Header Files:
  21. #pragma warning(disable:4001)   // Single-line comment warnings
  22. #pragma warning(disable:4115)   // Named type definition in parentheses
  23. #pragma warning(disable:4201)   // Nameless struct/union warning
  24. #pragma warning(disable:4214)   // Bit field types other than int warnings
  25. #pragma warning(disable:4514)   // Unreferenced inline function has been removed
  26.  
  27. // Windows Header Files:
  28. #include <Windows.h>
  29. #include <WindowsX.h>
  30. #include <icm.h>
  31.  
  32.  
  33. // Restore the warnings--leave the single-line comment warning OFF
  34. #pragma warning(default:4115)   // Named type definition in parentheses
  35. #pragma warning(default:4201)   // Nameless struct/union warning
  36. #pragma warning(default:4214)   // Bit field types other than int warnings
  37. #pragma warning(default:4514)   // Unreferenced inline function has been removed
  38.  
  39. // C RunTime Header Files
  40. #include <stdio.h>
  41. #include <TCHAR.H>
  42. #include <stdlib.h>
  43.  
  44. // Local Header Files
  45. #include "icmview.h"
  46. #include "dibinfo.h"
  47. #define I_AM_DEBUG
  48. #include "Debug.h"
  49. #undef I_AM_DEBUG
  50.  
  51. // local definitions
  52.  
  53. // default settings
  54.  
  55. // external functions
  56.  
  57. // external data
  58.  
  59. // public data
  60.  
  61. // private data
  62.  
  63. // public functions
  64.  
  65. // private functions
  66.  
  67.  
  68.  
  69.  
  70. //////////////////////////////////////////////////////////////////////////
  71. //  Function:  _Assert
  72. //
  73. //  Description:
  74. //    Replacement assertion function
  75. //
  76. //  Parameters:
  77. //    LPSTR    Name of file
  78. //    UINT      Line number@@@
  79. //
  80. //  Returns:
  81. //    void
  82. //
  83. //  Comments:
  84. //
  85. //
  86. //////////////////////////////////////////////////////////////////////////
  87. void _Assert(LPSTR strFile, UINT uiLine)
  88. {
  89.     // Local variables
  90.     char  stAssert[255];
  91.  
  92.     //  Initialize variables
  93.     wsprintfA(stAssert, "Assertion failed %s, line %u\r\n", strFile, uiLine);
  94.     OutputDebugStringA(stAssert);
  95. } // End of function _Assert
  96.  
  97. ///////////////////////////////////////////////////////////////////////////
  98. //
  99. //  FUNCTION: DebugMsg
  100. //
  101. //  PURPOSE:
  102. //    To provide a printf type DebugMsg function.
  103. //
  104. //  PARAMETERS:
  105. //    LPTSTR  Format string
  106. //    <variable arguments>  printf-style arguments
  107. //
  108. //  RETURN VALUE:
  109. //    void
  110. //
  111. //  COMMENTS:
  112. //
  113. ///////////////////////////////////////////////////////////////////////////
  114.  
  115. void DebugMsg (LPTSTR lpszMessage,...)
  116. {
  117. #ifdef _DEBUG
  118.     va_list VAList;
  119.     TCHAR   szMsgBuf[256];
  120.  
  121.     // Pass the variable parameters to wvsprintf to be formated.
  122.     va_start(VAList, lpszMessage);
  123.     wvsprintf(szMsgBuf, lpszMessage, VAList);
  124.     va_end(VAList);
  125.  
  126.     ASSERT(lstrlen((LPTSTR)szMsgBuf) < MAX_DEBUG_STRING);
  127.     OutputDebugString(szMsgBuf);
  128. #endif
  129.     lpszMessage = lpszMessage;  // Eliminates 'unused formal parameter' warning
  130. }
  131.  
  132. void DebugMsgA (LPSTR lpszMessage,...)
  133. {
  134. #ifdef _DEBUG
  135.     va_list VAList;
  136.     char    szMsgBuf[256];
  137.  
  138.     // Pass the variable parameters to wvsprintf to be formated.
  139.     va_start(VAList, lpszMessage);
  140.     wvsprintfA(szMsgBuf, lpszMessage, VAList);
  141.     va_end(VAList);
  142.  
  143.     ASSERT(strlen((LPSTR)szMsgBuf) < MAX_DEBUG_STRING);
  144.     OutputDebugStringA(szMsgBuf);
  145. #endif
  146.     lpszMessage = lpszMessage;  // Eliminates 'unused formal parameter' warning
  147. }
  148.  
  149.  
  150. ///////////////////////////////////////////////////////////////////////////
  151. //
  152. //  FUNCTION: ErrMsg
  153. //
  154. //  PURPOSE:
  155. //    To provide a printf type error message box.
  156. //
  157. //  PARAMETERS:
  158. //    LPTSTR  wsprintf-style format string
  159. //    ...     formatting information
  160. //
  161. //  RETURN VALUE:
  162. //    Value from MessageBox function; 0 if failure, non-zero
  163. //    otherwise.  For specific values, see MessageBox.
  164. //
  165. //  COMMENTS:
  166. //
  167. ///////////////////////////////////////////////////////////////////////////
  168. int ErrMsg (HWND hwndOwner, LPTSTR lpszMessage,...)
  169. {
  170.     va_list VAList;
  171.     TCHAR   szMsgBuf[256];
  172.  
  173.     // Pass the variable parameters to wvsprintf to be formated.
  174.     va_start(VAList, lpszMessage);
  175.     wvsprintf(szMsgBuf, lpszMessage, VAList);
  176.     va_end(VAList);
  177.  
  178.     ASSERT(lstrlen((LPTSTR)szMsgBuf) < MAX_DEBUG_STRING);
  179.     return(MessageBox(hwndOwner, (LPCTSTR)szMsgBuf, (LPCTSTR)__TEXT("Error"), MB_ICONSTOP|MB_APPLMODAL));
  180. }
  181.  
  182. //////////////////////////////////////////////////////////////////////////
  183. //  Function:  DumpMemory
  184. //
  185. //  Description:
  186. //    Dumps values at specified memory.
  187. //
  188. //  Parameters:
  189. //    LPVOID    Pointer to memory
  190. //    UINT      Size of each element, i.e. 8 or 16
  191. //    UINT      Number of elements to dump.
  192. //
  193. //  Returns:
  194. //    void
  195. //
  196. //  Comments:
  197. //    -Need to add validation of uiElementSize.
  198. //    -uiElementSize * uiNumElements should not exceed the size
  199. //     of the buffer; otherwise, wacky and wonderful events will
  200. //     take place.
  201. //
  202. //////////////////////////////////////////////////////////////////////////
  203. void DumpMemory(LPBYTE lpbMem, UINT uiElementSize, UINT uiNumElements)
  204. {
  205.     // Local variables
  206.     UINT  uiIdx;
  207.  
  208.     uiElementSize = uiElementSize; // Eliminates 'unused formal parameters'
  209.  
  210.     // Initialize variables
  211.     for (uiIdx = 0; uiIdx < uiNumElements; uiIdx++)
  212.     {
  213.         if (uiIdx == 0 || ((uiIdx % 16) == 0))
  214.         {
  215.             DebugMsg(__TEXT("\r\n0x%08X\t"), (DWORD)(lpbMem + (uiIdx)));
  216.         }
  217.         DebugMsg(__TEXT("%02x "), (WORD)*(lpbMem + uiIdx));
  218.     }
  219. } // End of function DumpMemory
  220.  
  221. //////////////////////////////////////////////////////////////////////////
  222. //  Function:  DumpProfile
  223. //
  224. //  Description:
  225. //    Dumps the PROFILE structure provided.
  226. //
  227. //  Parameters:
  228. //    PPROFILE  Pointer to the profile.
  229. //
  230. //  Returns:
  231. //    void
  232. //
  233. //  Comments:
  234. //////////////////////////////////////////////////////////////////////////
  235. void DumpProfile(PPROFILE pProfile)
  236. {
  237.     // Local variables
  238.     TCHAR   stProfileType[MAX_PATH];
  239.  
  240.     // Initialize variables
  241.     if (pProfile == NULL)
  242.     {
  243.         DebugMsg(__TEXT("DEBUG.C : DumpProfile : NULL pProfile\r\n"));
  244.         return;
  245.     }
  246.  
  247.     // Set type string
  248.     _tcscpy(stProfileType, __TEXT("UNKNOWN"));
  249.     if (PROFILE_FILENAME == pProfile->dwType)
  250.     {
  251.         _tcscpy(stProfileType, __TEXT("FILE"));
  252.     }
  253.     if (PROFILE_MEMBUFFER == pProfile->dwType)
  254.     {
  255.         _tcscpy(stProfileType, __TEXT("MEMBUFFER"));
  256.     }
  257.  
  258.     DebugMsg(__TEXT("***** PROFILE *****\r\n"));
  259.     DebugMsg(__TEXT("pProfile        0x%08lX\r\n"), pProfile);
  260.     DebugMsg(__TEXT("dwType          %s\r\n"), stProfileType);
  261.     DebugMsg(__TEXT("pProfileData    0x%08lX\r\n"), pProfile->pProfileData);
  262.     if (PROFILE_FILENAME == pProfile->dwType)
  263.     {
  264.         DebugMsg(__TEXT("Filename        %s\r\n"), pProfile->pProfileData);
  265.     }
  266.     DebugMsg(__TEXT("cbDataSize      %ld\r\n\r\n"), pProfile->cbDataSize);
  267. } // End of function DumpMemory
  268.  
  269.  
  270. //////////////////////////////////////////////////////////////////////////
  271. //  Function:  DumpRectangle
  272. //
  273. //  Description:
  274. //    Dumps the coordinates of a rectangle structure
  275. //
  276. //  Parameters:
  277. //    LPTSTR    Comment
  278. //    LPRECT    Rectangle to dump
  279. //
  280. //  Returns:
  281. //    void
  282. //
  283. //  Comments:
  284. //
  285. //
  286. //////////////////////////////////////////////////////////////////////////
  287. void DumpRectangle(LPTSTR lpszDesc, LPRECT lpRect)
  288. {
  289.     DebugMsg(__TEXT("%s:  %ld, %ld, %ld, %ld\r\n"), lpszDesc, lpRect->left, lpRect->top, lpRect->right,
  290.              lpRect->bottom);
  291. }   // End of function DumpRectangle
  292.  
  293.  
  294. //////////////////////////////////////////////////////////////////////////
  295. //  Function:  SafeFree
  296. //
  297. //  Description:
  298. //    Debug Free routine which checks lock counts and return codes.
  299. //
  300. //  Parameters:
  301. //    @@@
  302. //
  303. //  Returns:
  304. //    HGLOBAL
  305. //
  306. //  Comments:
  307. //    This function assumes that the HGLOBAL object has been unlocked;
  308. //    if not, the item will still be freed, but a warning message will
  309. //    be displayed.  This is useful for tracking down items which have
  310. //    been locked without being unlocked.
  311. //
  312. //    The last error value will be preserved if no error occurs in this
  313. //    function.  If an error does occur, it will be passed to the calling
  314. //    function.
  315. //
  316. //////////////////////////////////////////////////////////////////////////
  317. HGLOBAL SafeFree(LPTSTR lpszFile, UINT uiLine, HGLOBAL hMemory)
  318. {
  319.     // Local variables
  320.     UINT      uiLockCount, uiFlags;
  321.     DWORD     dwLastError;
  322.     HGLOBAL   hFreed;                         // Return from GlobalFree
  323.     TCHAR   szName[MAX_PATH], szExt[MAX_PATH];
  324.  
  325.     //  Initialize variables
  326.     _tsplitpath(lpszFile, NULL, NULL, szName, szExt);
  327.     wsprintf(lpszFile,__TEXT("%s%s"), szName, szExt);
  328.     if (NULL == hMemory)
  329.     {
  330.         DebugMsg(__TEXT("%s(%lu) : SafeFree:  NULL hMem!!!  This will cause an exception!!!!   Fix it!!!\r\n"), lpszFile, uiLine);
  331.         DebugBreak();
  332.         return(NULL);
  333.     }
  334.     SetLastError(0);
  335.  
  336.     hFreed = GlobalFree(hMemory);
  337.     if (NULL != hFreed) // unsuccessful free
  338.     {
  339.         dwLastError = GetLastError();
  340.         uiFlags = GlobalFlags(hMemory);
  341.         uiLockCount = uiFlags & GMEM_LOCKCOUNT;
  342.         uiFlags = HIBYTE(LOWORD(uiFlags));
  343.         DebugMsg(__TEXT("SafeFree : <%s(%lu)> failed\tLastError = %ld, Flags = %lu, Lock Count = %lu\r\n"),
  344.                  lpszFile, uiLine, dwLastError, uiFlags, uiLockCount);
  345.     }
  346.     return(hFreed);
  347. }   // End of function SafeFree
  348.  
  349. //////////////////////////////////////////////////////////////////////////
  350. //  Function:  SafeUnlock
  351. //
  352. //  Description:
  353. //    Unlocks handle and displays the lock count and flags information.
  354. //
  355. //  Parameters:
  356. //    @@@
  357. //
  358. //  Returns:
  359. //    BOOL
  360. //
  361. //  Comments:
  362. //
  363. //
  364. //////////////////////////////////////////////////////////////////////////
  365. BOOL SafeUnlock(LPTSTR lpszFile, UINT uiLine, HGLOBAL hMemory)
  366. {
  367.     // Local variables
  368.     BOOL    bUnlocked;
  369.     UINT    uiLockCount,   uiFlags;
  370.     DWORD   dwLastError;
  371.     TCHAR   szName[MAX_PATH], szExt[MAX_PATH];
  372.  
  373.     //  Initialize variables
  374.     _tsplitpath(lpszFile, NULL, NULL, szName, szExt);
  375.     wsprintf(lpszFile, __TEXT("%s%s"), szName, szExt);
  376.  
  377.     if (NULL == hMemory)
  378.     {
  379.         DebugMsg(__TEXT("%s(%lu) : SafeUnlock:  NULL hMem\r\n"), lpszFile, uiLine);
  380.         return(0);
  381.     }
  382.     SetLastError(0);
  383.  
  384.     bUnlocked = GlobalUnlock(hMemory);
  385.     dwLastError = GetLastError();
  386.     uiFlags = GlobalFlags(hMemory);
  387.     uiLockCount = uiFlags & GMEM_LOCKCOUNT;
  388.     if (0 != dwLastError)
  389.     {
  390.         uiFlags = HIBYTE(LOWORD(uiFlags));
  391.     }
  392.     DebugMsg(__TEXT("SafeUnlock : <%s(%lu)>\tGlobalUnlock(0x%08lX) returned %4d w/LastError = %4ld, Lock Count = %4lu, Flags = %4lu\r\n"),
  393.              lpszFile, uiLine, hMemory, bUnlocked, dwLastError, uiLockCount, uiFlags);
  394.     return(bUnlocked);
  395. }   // End of function SafeUnlock
  396.  
  397.  
  398.  
  399. //////////////////////////////////////////////////////////////////////////
  400. //  Function:  SafeLock
  401. //
  402. //  Description:
  403. //    Locks memory and reports lock count.
  404. //
  405. //  Parameters:
  406. //    @@@
  407. //
  408. //  Returns:
  409. //    LPVOID
  410. //
  411. //  Comments:
  412. //
  413. //
  414. //////////////////////////////////////////////////////////////////////////
  415. LPVOID SafeLock(LPTSTR lpszFile, UINT uiLine, HGLOBAL hMemory)
  416. {
  417.     // Local variables
  418.     LPVOID  lpMem;
  419.     UINT    uiLockCount, uiFlags;
  420.     DWORD   dwLastError;
  421.     TCHAR   szName[MAX_PATH], szExt[MAX_PATH];
  422.  
  423.     //  Initialize variables
  424.     _tsplitpath(lpszFile, NULL, NULL, szName, szExt);
  425.     wsprintf(lpszFile, __TEXT("%s%s"), szName, szExt);
  426.     if (NULL == hMemory)
  427.     {
  428.         DebugMsg(__TEXT("%s(%lu) : SafeLock:  NULL hMem\r\n"), lpszFile, uiLine);
  429.         return((LPVOID)NULL);
  430.     }
  431.     SetLastError(0);
  432.  
  433.     lpMem = GlobalLock(hMemory);
  434.     dwLastError = GetLastError();
  435.     uiFlags = GlobalFlags(hMemory);
  436.     uiLockCount = uiFlags & GMEM_LOCKCOUNT;
  437.     uiFlags = HIBYTE(LOWORD(uiFlags));
  438.  
  439.     DebugMsg(__TEXT("SafeLock : <%s(%lu)>\tGlobalLock(0x%08lX) returned 0x%08lX w/LastError = %ld, Lock Count = %lu, Flags = %lu\r\n"),
  440.              lpszFile, uiLine, hMemory, lpMem, dwLastError, uiLockCount, uiFlags);
  441.     return(lpMem);
  442. }   // End of function SafeLock
  443.  
  444. //////////////////////////////////////////////////////////////////////////
  445. //  Function:  FormatLastError
  446. //
  447. //  Description:
  448. //    Allocates and formats a string of LastError's text-equivalent message.
  449. //    If the caller requests, the message will be displayed and the memory
  450. //    will be deallocated.
  451. //
  452. //  Parameters:
  453. //    LPTSTR  Name of file where error occured
  454. //    UINT    Line of file at which point error occured
  455. //    DWORD Numeric value of LastError
  456. //    UINT  Display and free indicator
  457. //            LASTERROR_NOALLOC  Display via DebugMsg and deallocate
  458. //            LASTERROR_ALLOC    Return pointer to allocated string
  459. //
  460. //  Returns:
  461. //    BOOL
  462. //
  463. //  Comments:
  464. //    Caller must free memory returned by this function.
  465. //
  466. //////////////////////////////////////////////////////////////////////////
  467. LPTSTR FormatLastError(LPTSTR lpszFile, UINT uiLine, UINT uiOutput, DWORD dwLastError)
  468. {
  469.     // Local variables
  470.     LPTSTR  lpszLastErrorMsg;
  471.     LPTSTR  lpszDebugMsg;
  472.     DWORD   cbBytes;
  473.  
  474.     //  Initialize variables
  475.     lpszLastErrorMsg = NULL;
  476.     cbBytes = FormatMessage(FORMAT_MESSAGE_ALLOCATE_BUFFER
  477.                             | FORMAT_MESSAGE_FROM_SYSTEM,
  478.                             NULL,
  479.                             dwLastError,
  480.                             MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT), //The user default language
  481.                             (LPTSTR) &lpszLastErrorMsg,
  482.                             0,
  483.                             NULL );
  484.  
  485.     if (0 == cbBytes) // Error occured in FormatMessage
  486.     {
  487.         SetLastError(dwLastError); // restore the last error to time of call
  488.     }
  489.  
  490.     // Create the error message
  491.     lpszDebugMsg = GlobalAlloc(GPTR, ((cbBytes + 512) * sizeof(TCHAR)));
  492.     ASSERT(NULL != lpszDebugMsg);
  493.     wsprintf(lpszDebugMsg, __TEXT("<%s(%lu)>:\r\n\tLastError(ld, lu) = (%ld, %lu)\r\n\t\t%s\r\n"),
  494.              lpszFile,
  495.              uiLine,
  496.              dwLastError,
  497.              dwLastError,
  498.              NULL != lpszLastErrorMsg ? lpszLastErrorMsg : __TEXT("UNKNOWN LASTERROR"));
  499.  
  500.     // Free the buffer memory if requested
  501.     if (LASTERROR_NOALLOC == uiOutput)
  502.     {
  503.         DebugMsg(lpszDebugMsg);
  504.         GlobalFree(lpszDebugMsg);
  505.     }
  506.  
  507.     // Always free the string created by FormatMessage
  508.     if (NULL != lpszLastErrorMsg)
  509.     {
  510.         GlobalFree(lpszLastErrorMsg);
  511.     }
  512.     return(lpszDebugMsg);
  513. }   // End of function FormatLastError
  514.  
  515.  
  516. //////////////////////////////////////////////////////////////////////////
  517. //  Function:  DumpBITMAPFILEHEADER
  518. //
  519. //  Description:
  520. //    Dumps the contents of a BITMAPFILEHEADER.
  521. //
  522. //  Parameters:
  523. //    @@@
  524. //
  525. //  Returns:
  526. //    void
  527. //
  528. //  Comments:
  529. //
  530. //
  531. //////////////////////////////////////////////////////////////////////////
  532. void DumpBITMAPFILEHEADER(LPBITMAPFILEHEADER lpBmpFileHeader)
  533. {
  534.     // Local variables
  535.     DebugMsg(__TEXT("////////////////// BITMAPFILEHEADER ///////////////////\r\n"));
  536.     DebugMsg(__TEXT("sizeof(BITMAPFILEHEADER)    %ld\r\n"), sizeof(BITMAPFILEHEADER));
  537.     DebugMsg(__TEXT("bfType                      0x%04x\r\n"), lpBmpFileHeader->bfType);
  538.     DebugMsg(__TEXT("bfSize                      %ld\r\n"), lpBmpFileHeader->bfSize);
  539.     DebugMsg(__TEXT("bfReserved1                 %d\r\n"), lpBmpFileHeader->bfReserved1);
  540.     DebugMsg(__TEXT("bfReserved2                 %d\r\n"), lpBmpFileHeader->bfReserved1);
  541.     DebugMsg(__TEXT("bfOffBits                   %ld\r\n"), lpBmpFileHeader->bfOffBits);
  542.     DebugMsg(__TEXT("///////////////////////////////////////////////////////\r\n"));
  543.  
  544.     //  Initialize variables
  545.  
  546. }   // End of function DumpBITMAPFILEHEADER
  547.  
  548.  
  549. //////////////////////////////////////////////////////////////////////////
  550. //  Function:  DumpBITMAPINFOHEADER
  551. //
  552. //  Description:
  553. //    Dumps a BITMAPINFO header structure.
  554. //
  555. //  Parameters:
  556. //    @@@
  557. //
  558. //  Returns:
  559. //    void
  560. //
  561. //  Comments:
  562. //
  563. //
  564. //////////////////////////////////////////////////////////////////////////
  565. void DumpBmpHeader(LPVOID lpvBmpHeader)
  566. {
  567.     // Local variables
  568.     LPBITMAPV5HEADER  lpBmpV5Header;
  569.     TCHAR             stNumText[MAX_PATH];
  570.  
  571.     //  Initialize variables
  572.     lpBmpV5Header = (LPBITMAPV5HEADER)lpvBmpHeader;
  573.  
  574.     switch (lpBmpV5Header->bV5Size)
  575.     {
  576.         case sizeof(BITMAPCOREHEADER):
  577.             _tcscpy(stNumText,__TEXT("BITMAPCOREHEADER"));
  578.             break;
  579.  
  580.         case sizeof(BITMAPINFOHEADER):
  581.             _tcscpy(stNumText, __TEXT("BITMAPINFOHEADER"));
  582.             break;
  583.  
  584.         case sizeof(BITMAPV4HEADER):
  585.             _tcscpy(stNumText, __TEXT("BITMAPV4HEADER"));
  586.             break;
  587.  
  588.         case sizeof(BITMAPV5HEADER):
  589.             _tcscpy(stNumText,__TEXT("BITMAPV5HEADER"));
  590.             break;
  591.  
  592.         default:
  593.             _tcscpy(stNumText, __TEXT("UNKNOWN HEADER SIZE"));
  594.             break;
  595.     }
  596.     DebugMsg(__TEXT("/////////////////// %s /////////////////////\r\n"), stNumText);
  597.     DebugMsg(__TEXT("HeaderSize        %ld\r\n"), lpBmpV5Header->bV5Size);
  598.     DebugMsg(__TEXT("Width             %lu\r\n"), lpBmpV5Header->bV5Width);
  599.     DebugMsg(__TEXT("Height            %lu\r\n"), lpBmpV5Header->bV5Height);
  600.     DebugMsg(__TEXT("Planes            %d\r\n"), lpBmpV5Header->bV5Planes);
  601.     DebugMsg(__TEXT("BitCount          %d\r\n"), lpBmpV5Header->bV5BitCount);
  602.     if ( sizeof(BITMAPCOREHEADER)== lpBmpV5Header->bV5Size) goto End;
  603.  
  604.     switch (lpBmpV5Header->bV5Compression)
  605.     {
  606.         case BI_RGB:
  607.             _tcscpy(stNumText, __TEXT("BI_RGB"));
  608.             break;
  609.  
  610.         case BI_RLE8:
  611.             _tcscpy(stNumText, __TEXT("BI_RLE8"));
  612.             break;
  613.  
  614.         case BI_RLE4:
  615.             _tcscpy(stNumText,__TEXT("BI_RLE4"));
  616.             break;
  617.  
  618.         case BI_BITFIELDS:
  619.             _tcscpy(stNumText, __TEXT("BI_BITFIELDS"));
  620.             break;
  621.  
  622.         default:
  623.             _tcscpy(stNumText,__TEXT("Unknown Compression"));
  624.             break;
  625.     }
  626.     DebugMsg(__TEXT("Compression       %s\r\n"), stNumText);
  627.     DebugMsg(__TEXT("SizeImage         %ld\r\n"), lpBmpV5Header->bV5SizeImage);
  628.     DebugMsg(__TEXT("XPelsPerMeter     %ld\r\n"), lpBmpV5Header->bV5XPelsPerMeter);
  629.     DebugMsg(__TEXT("YPelsPerMeter     %ld\r\n"), lpBmpV5Header->bV5YPelsPerMeter);
  630.     DebugMsg(__TEXT("ClrUsed           %ld\r\n"), lpBmpV5Header->bV5ClrUsed);
  631.     DebugMsg(__TEXT("ClrImportant      %ld\r\n"), lpBmpV5Header->bV5ClrImportant);
  632.     if (sizeof(BITMAPINFOHEADER) == lpBmpV5Header->bV5Size) goto End;
  633.  
  634.     DebugMsg(__TEXT("Red Mask          0x%08lx\r\n"), lpBmpV5Header->bV5RedMask);
  635.     DebugMsg(__TEXT("Green Mask        0x%08lx\r\n"), lpBmpV5Header->bV5GreenMask);
  636.     DebugMsg(__TEXT("Blue Mask         0x%08lx\r\n"), lpBmpV5Header->bV5BlueMask);
  637.     DebugMsg(__TEXT("Alpha Mask        0x%08lx\r\n"), lpBmpV5Header->bV5AlphaMask);
  638.  
  639.     DebugMsg(__TEXT("CS Type           "));
  640.     switch (lpBmpV5Header->bV5CSType)
  641.     {
  642.         case PROFILE_LINKED:
  643.             DebugMsg(__TEXT("LINKED\r\n"));
  644.             break;
  645.  
  646.         case PROFILE_EMBEDDED:
  647.             DebugMsg(__TEXT("EMBEDDED\r\n"));
  648.             break;
  649.  
  650.         default:
  651.             DebugMsg(__TEXT("0x%08lx\r\n"), lpBmpV5Header->bV5CSType);
  652.             break;
  653.     }
  654.  
  655.  
  656.     DebugMsg(__TEXT("Gamma Red         %ld\r\n"), lpBmpV5Header->bV5GammaRed);
  657.     DebugMsg(__TEXT("Gamma Green       %ld\r\n"), lpBmpV5Header->bV5GammaGreen);
  658.     DebugMsg(__TEXT("Gamma Blue        %ld\r\n"), lpBmpV5Header->bV5GammaBlue);
  659.     if (sizeof(BITMAPV4HEADER) == lpBmpV5Header->bV5Size) goto End;
  660.  
  661.     DebugMsg(__TEXT("Intent            %ld\r\n"), lpBmpV5Header->bV5Intent);
  662.     DebugMsg(__TEXT("ProfileData       %ld\r\n"), lpBmpV5Header->bV5ProfileData);
  663.     DebugMsg(__TEXT("ProfileSize       %ld\r\n"), lpBmpV5Header->bV5ProfileSize);
  664.     DebugMsg(__TEXT("Reserved          %ld\r\n"), lpBmpV5Header->bV5Reserved);
  665.  
  666.     End:
  667.     DebugMsg(__TEXT("///////////////////////////////////////////////////////\r\n"));
  668. }   // End of function DumpBITMAPINFOHEADER
  669.  
  670.  
  671. //////////////////////////////////////////////////////////////////////////
  672. //  Function:  DumpLogColorSpace
  673. //
  674. //  Description:
  675. //    Dumps a LOGCOLORSPACE structure.
  676. //
  677. //  Parameters:
  678. //    @@@
  679. //
  680. //  Returns:
  681. //    void
  682. //
  683. //  Comments:
  684. //
  685. //
  686. //////////////////////////////////////////////////////////////////////////
  687.  
  688. void DumpLogColorSpace(LPLOGCOLORSPACE pColorSpace)
  689. {
  690.     DebugMsg(__TEXT("/////////////////// LOGCOLORSPACE /////////////////////\r\n"));
  691.     DebugMsg(__TEXT("lcsSignature                       %#lx\r\n"), pColorSpace->lcsSignature);
  692.     DebugMsg(__TEXT("lcsVersion                         %#lx\r\n"), pColorSpace->lcsVersion);
  693.     DebugMsg(__TEXT("lcsSize                            %#lx\r\n"), pColorSpace->lcsSize);
  694.     DebugMsg(__TEXT("lcsCSType                          %#lx\r\n"), pColorSpace->lcsCSType);
  695.     DebugMsg(__TEXT("lcsIntent                          %#lx\r\n"), pColorSpace->lcsIntent);
  696.     DebugMsg(__TEXT("lcsEndpoints.ciexyzRed.ciexyzX      %#lx\r\n"), pColorSpace->lcsEndpoints.ciexyzRed.ciexyzX);
  697.     DebugMsg(__TEXT("lcsEndpoints.ciexyzRed.ciexyzY      %#lx\r\n"), pColorSpace->lcsEndpoints.ciexyzRed.ciexyzY);
  698.     DebugMsg(__TEXT("lcsEndpoints.ciexyzRed.ciexyzZ      %#lx\r\n"), pColorSpace->lcsEndpoints.ciexyzRed.ciexyzZ);
  699.     DebugMsg(__TEXT("lcsEndpoints.ciexyzGreen.ciexyzX    %#lx\r\n"), pColorSpace->lcsEndpoints.ciexyzGreen.ciexyzX);
  700.     DebugMsg(__TEXT("lcsEndpoints.ciexyzGreen.ciexyzY    %#lx\r\n"), pColorSpace->lcsEndpoints.ciexyzGreen.ciexyzY);
  701.     DebugMsg(__TEXT("lcsEndpoints.ciexyzGreen.ciexyzZ    %#lx\r\n"), pColorSpace->lcsEndpoints.ciexyzGreen.ciexyzZ);
  702.     DebugMsg(__TEXT("lcsEndpoints.ciexyzBlue.ciexyzX     %#lx\r\n"), pColorSpace->lcsEndpoints.ciexyzBlue.ciexyzX);
  703.     DebugMsg(__TEXT("lcsEndpoints.ciexyzBlue.ciexyzY     %#lx\r\n"), pColorSpace->lcsEndpoints.ciexyzBlue.ciexyzY);
  704.     DebugMsg(__TEXT("lcsEndpoints.ciexyzBlue.ciexyzZ     %#lx\r\n"), pColorSpace->lcsEndpoints.ciexyzBlue.ciexyzZ);
  705.     DebugMsg(__TEXT("lcsGammaRed                        %#lx\r\n"), pColorSpace->lcsGammaRed);
  706.     DebugMsg(__TEXT("lcsGammaGreen                      %#lx\r\n"), pColorSpace->lcsGammaGreen);
  707.     DebugMsg(__TEXT("lcsGammaBlue                       %#lx\r\n"), pColorSpace->lcsGammaBlue);
  708.     DebugMsg(__TEXT("lcsFilename                        %s\r\n"), pColorSpace->lcsFilename);
  709.     DebugMsg(__TEXT("///////////////////////////////////////////////////////\r\n"));
  710. }
  711.  
  712. //////////////////////////////////////////////////////////////////////////
  713. //  Function:  DumpCOLORMATCHSETUP
  714. //
  715. //  Description:
  716. //    Dumps COLORMATCHSETUP structure
  717. //
  718. //  Parameters:
  719. //    @@@
  720. //
  721. //  Returns:
  722. //    void
  723. //
  724. //  Comments:
  725. //
  726. //
  727. //////////////////////////////////////////////////////////////////////////
  728. void DumpCOLORMATCHSETUP(LPCOLORMATCHSETUP lpCM)
  729. {
  730.     // Local variables
  731.  
  732.     //  ASSERTs and parameter validations
  733.     DebugMsg(__TEXT("***** COLORMATCHSETUP 0x%08lx\r\n"), lpCM);
  734.     DebugMsg(__TEXT("dwSize                        %ld\r\n"),     lpCM->dwSize);
  735.     DebugMsg(__TEXT("dwVersion                     0x%08lx\r\n"), lpCM->dwVersion);
  736.     DebugMsg(__TEXT("dwFlags                       0x%08lx\r\n"), lpCM->dwFlags);
  737.     DebugMsg(__TEXT("hwndOwner                     0x%08lx\r\n"), lpCM->hwndOwner);
  738.  
  739.     DebugMsg(__TEXT("pSourceName                   0x%08lX <%s>\r\n"), lpCM->pSourceName   , lpCM->pSourceName    ? lpCM->pSourceName    : __TEXT("NULL PTR"));
  740.     DebugMsg(__TEXT("pDisplayName                  0x%08lX <%s>\r\n"), lpCM->pDisplayName   , lpCM->pDisplayName    ? lpCM->pDisplayName    : __TEXT("NULL PTR"));
  741.     DebugMsg(__TEXT("pPrinterName                  0x%08lX <%s>\r\n"), lpCM->pPrinterName   , lpCM->pPrinterName    ? lpCM->pPrinterName    : __TEXT("NULL PTR"));
  742.  
  743.     DebugMsg(__TEXT("dwRenderIntent                %ld\r\n"),     lpCM->dwRenderIntent);
  744.     DebugMsg(__TEXT("dwProofingIntent              %ld\r\n"),     lpCM->dwProofingIntent);
  745.  
  746.     DebugMsg(__TEXT("pMonitorProfile               0x%08lX <%s>\r\n"), lpCM->pMonitorProfile   , lpCM->pMonitorProfile    ? lpCM->pMonitorProfile    : __TEXT("NULL PTR"));
  747.     DebugMsg(__TEXT("ccMonitorProfile              %ld\r\n"),     lpCM->ccMonitorProfile);
  748.  
  749.     DebugMsg(__TEXT("pPrinterProfile               0x%08lX <%s>\r\n"), lpCM->pPrinterProfile   , lpCM->pPrinterProfile    ? lpCM->pPrinterProfile    : __TEXT("NULL PTR"));
  750.     DebugMsg(__TEXT("ccPrinterProfile              %ld\r\n"),     lpCM->ccPrinterProfile);
  751.  
  752.     DebugMsg(__TEXT("pTargetProfile                0x%08lX <%s>\r\n"), lpCM->pTargetProfile   , lpCM->pTargetProfile    ? lpCM->pTargetProfile    : __TEXT("NULL PTR"));
  753.     DebugMsg(__TEXT("ccTargetProfile               %ld\r\n"),     lpCM->ccTargetProfile);
  754.  
  755.     DebugMsg(__TEXT("lpfnHook                      0x%08lx\r\n"), lpCM->lpfnHook);
  756.     DebugMsg(__TEXT("lParam                        0x%08lx\r\n"), lpCM->lParam);
  757.     DebugMsg(__TEXT("***** COLORMATCHSETUP 0x%08lx\r\n"), lpCM);
  758. } // End of function DumpCOLORMATCHSETUP
  759.  
  760.