开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > Windows编程 > 查看源码
PVIEW.C
资源名称：MSDN_VC98.zip　[点击查看]
上传用户：bangxh
上传日期：2007-01-31
资源大小：42235k
文件大小：15k
源码类别：

Windows编程

开发平台：

Visual C++

PVIEW.C：源码内容
  2. /******************************************************************************
  3. *       This is a part of the Microsoft Source Code Samples. 
  4. *       Copyright (C) 1993-1997 Microsoft Corporation.
  5. *       All rights reserved. 
  6. *       This source code is only intended as a supplement to 
  7. *       Microsoft Development Tools and/or WinHelp documentation.
  8. *       See these sources for detailed information regarding the 
  9. *       Microsoft samples programs.
  10. ******************************************************************************/
  12. #include "pwalk.h"
  14. #define BYTE_WIN_WIDTH     77
  15. #define CLINESSHOW   8
  16. #define ABS(x) ((x) < 0? -(x) : (x))
  18. /* externally defined system constants */
  19. extern int     xChar,
  20.     yChar,
  21.     xScreen,
  22.     yScreen,
  23.     yFrame,
  24.     xFrame,
  25.     yCaption,
  26.     xVScrollBar;
  27. extern HFONT hFont;
  28. extern HWND  hMemWnd;
  30. void WINAPI VScrollBytes (HWND, int, int, LPMEMVIEW);
  31. void WINAPI KeyToScrollMsg (HWND, WPARAM);
  32. void WINAPI DisplayBytes (HDC, LPRECT, LPMEMVIEW, LPMEMVIEW);
  33. void WINAPI GetBytesLine (LPBYTE, UINT, DWORD, int, char *);
  34. BOOL WINAPI parcmp (LPBYTE, LPBYTE, int, LPBYTE);
  39. HWND   WINAPI EnumViewWindows (
  40.     HWND    hWndParent,
  41.     HWND    hWndLast)
  42. {
  44.     HMENU   hMenu = GetMenu (hWndParent);
  45.     HMENU   hViewMenu = GetSubMenu (hMenu, 2);
  46.     char    szClass[MAX_PATH];
  47.     char    szCaption[MAX_PATH];
  48.     HWND    hWnd;
  49.     int     i;
  51. static   int   nWindows;
  52. static   ATOM   *aMenuItems = NULL;
  53. static   int   iWnd;
  55.     /* load window class name */
  56.     LoadString (GetModuleHandle (NULL), IDS_MEMVIEWCLASS, szClass, MAX_PATH);
  58.     if (hWndLast == NULL)
  59. {
  60. /* start with first window in menu list */
  61. iWnd = 0;
  63. /* determine number of windows */
  64. nWindows = GetMenuItemCount (hViewMenu) - 5;
  66. /* if no popup windows, just return */
  67. if (nWindows <= 0)
  68.     return NULL;
  70. /* free memory from last time, if any */
  71. if (aMenuItems != NULL)
  72.     LocalFree ((HANDLE)aMenuItems);
  74. /* get menuitem IDs */
  75. aMenuItems = (ATOM *)LocalAlloc (LPTR, nWindows*sizeof (ATOM));
  76. for (i=5; i-5<nWindows; i++)
  77.     aMenuItems[i-5] = (ATOM)GetMenuItemID (hViewMenu, i);
  78. }
  80.     else
  81. if (iWnd >= nWindows)
  82.     return (NULL);
  84.     GetAtomName (aMenuItems[iWnd], szCaption, MAX_PATH);
  85.     hWnd = FindWindow (szClass, szCaption);
  86.     iWnd++;
  88.     return (hWnd);
  89. }
  93. /* activate view window identified by atom */
  94. void   WINAPI ActivateViewWindow (
  95.     ATOM    aCaption)
  96. {
  97.     char    szClass[MAX_PATH];
  98.     char    szCaption[MAX_PATH];
  99.     HWND    hWnd;
  101.     GetAtomName (aCaption, szCaption, MAX_PATH);
  102.     LoadString (GetModuleHandle (NULL), IDS_MEMVIEWCLASS, szClass, MAX_PATH);
  103.     hWnd = FindWindow (szClass, szCaption);
  104.     BringWindowToTop (hWnd);
  105. }
  109. /* function creates a window for viewing memory */
  110. HWND  WINAPI ViewMemory (
  111.     HWND      hWndParent,
  112.     char      *lpszObject,
  113.     LPVOID    lpMem,
  114.     int       nSize,
  115.     int       nBase)
  116. {
  117.     char      szClass[MAX_PATH];
  119.     /* load resource strings for class and window title */
  120.     LoadString (GetModuleHandle (NULL), IDS_MEMVIEWCLASS, szClass, MAX_PATH);
  122.     /* create memory view window */
  123.     return (CreateWindow (szClass,
  124.   lpszObject,
  125.   WS_POPUPWINDOW | WS_VISIBLE | WS_CAPTION |
  126.   WS_VSCROLL | WS_THICKFRAME | WS_MAXIMIZEBOX,
  127.   nSize,   /* use xposition to pass memory size to window */
  128.   nBase,   /* use yposition to pass base memory location  */
  129.   BYTE_WIN_WIDTH * xChar + xVScrollBar + 2*xFrame + xChar,
  130.   yScreen/2,
  131.   hWndParent,
  132.   NULL,
  133.   GetModuleHandle (NULL),
  134.   lpMem));
  135. }
  139. LONG WINAPI MemWndProc (
  140.     HWND      hWnd,
  141.     UINT      uMsg,
  142.     WPARAM    wParam,
  143.     LPARAM    lParam)
  144. {
  145.     LONG       lRet = 1;
  146.     MEMVIEW    *pmv = (LPMEMVIEW)GetWindowLong (hWnd, WXB_LPMEMVIEW);
  148.     
  149.     switch (uMsg)
  150. {
  151. case WM_CREATE:
  152.     pmv = (LPMEMVIEW)LocalAlloc (LPTR, sizeof (MEMVIEW));
  153.     SetWindowLong (hWnd, WXB_LPMEMVIEW, (LONG)pmv);
  154.     SetWindowLong (hWnd, WXB_LPOLDMEMVIEW, 0);
  156.     pmv->lpMem = ((LPCREATESTRUCT)lParam)->lpCreateParams;
  157.     pmv->nSize = ((LPCREATESTRUCT)lParam)->x;
  158.     pmv->nBase = ((LPCREATESTRUCT)lParam)->y;
  159.     pmv->nLines = (pmv->nSize+15)/16;
  160.     pmv->nExtraBytes = (pmv->nSize & 0x0000000F);
  161.     pmv->PosV = 0;
  163.     /* reposition window with proper x,y positions */
  164.     MoveWindow (hWnd,
  165. 15,
  166. 15,
  167. ((LPCREATESTRUCT)lParam)->cx,
  168. ((LPCREATESTRUCT)lParam)->cy,
  169. TRUE);
  170.             break;
  172. case WM_SIZE:
  173.     pmv->xWin = LOWORD (lParam);
  174.     pmv->yWin = HIWORD (lParam);
  176.     pmv->RangeV = pmv->nLines-pmv->yWin/yChar;
  178.     if (pmv->RangeV < 0)
  179. pmv->RangeV = 0;
  181.     if (pmv->PosV > pmv->RangeV)
  182. pmv->PosV = pmv->RangeV;
  184.     SetScrollRange (hWnd, SB_VERT, 0, pmv->RangeV, FALSE);
  185.     SetScrollPos (hWnd, SB_VERT, pmv->PosV, TRUE);
  186.             break;
  188. case WM_PAINT:
  189.     {
  190.     PAINTSTRUCT    ps;
  192.     BeginPaint (hWnd, &ps);
  193.     DisplayBytes (ps.hdc,
  194.   &(ps.rcPaint),
  195.   pmv,
  196.   (LPMEMVIEW)GetWindowLong (hWnd, WXB_LPOLDMEMVIEW));
  197.     EndPaint (hWnd, &ps);
  198.     }
  199.             break;
  201. case UM_UPDATE:
  202.     InvalidateRect (hWnd, NULL, TRUE);
  203.     UpdateWindow (hWnd);
  204.     break;
  206.         case WM_KEYDOWN:
  207.     KeyToScrollMsg (hWnd, wParam);
  208.             break;
  210.         case WM_VSCROLL:
  211.     VScrollBytes (hWnd, LOWORD (wParam), GetScrollPos (hWnd, SB_VERT), pmv);
  212.             break;
  214. case WM_DESTROY:
  215.     {
  216.     char  szCaption[MAX_PATH];
  217.     LPMEMVIEW  lpmv;
  219.     /* free virtual memory block  and local memory buffer */
  220.     VirtualFree (pmv->lpMem, 0, MEM_RELEASE);
  221.     LocalFree ((HANDLE)pmv);
  223.     /* remove any old view memory */
  224.     if ((lpmv = (LPMEMVIEW)GetWindowLong (hWnd, WXB_LPOLDMEMVIEW)) != NULL)
  225. {
  226. VirtualFree (lpmv->lpMem, 0, MEM_RELEASE);
  227. LocalFree ((HANDLE)lpmv);
  228. }
  230.     /* send message to parent to remove menuitem */
  231.     GetWindowText (hWnd, szCaption, MAX_PATH);
  232.     SendMessage (GetParent (hWnd), WM_COMMAND, IDM_REMOVEVIEWWND, (LONG)szCaption);
  233.     }
  234.             break;
  236.         default:
  237.     return (DefWindowProc(hWnd, uMsg, wParam, lParam));
  238.             break;
  239. }
  240.     return 0L;
  241. }
  246. void  WINAPI VScrollBytes (
  247.     HWND  hWnd,
  248.     int   cmd,
  249.     int   pos,
  250.     LPMEMVIEW  lpmv)
  251. {
  252.     int    nScrollInc;
  254.     switch (cmd)
  255. {
  256.         case SB_TOP:
  257.     nScrollInc = -lpmv->PosV;
  258.             break ;
  260.         case SB_BOTTOM:
  261.     nScrollInc = lpmv->RangeV - lpmv->PosV;
  262.             break ;
  264.         case SB_LINEUP:
  265.             nScrollInc = -1;
  266.             break;
  268.         case SB_LINEDOWN:
  269.             nScrollInc = 1;
  270.             break;
  272.         case SB_PAGEDOWN:
  273.     nScrollInc = max (1, lpmv->yWin/yChar);
  274.             break;
  276.         case SB_PAGEUP:
  277.     nScrollInc = min (-1, -(lpmv->yWin/yChar));
  278.             break;
  279.     
  280.         case SB_THUMBPOSITION:
  281.     nScrollInc = pos - lpmv->PosV;
  282.             break;
  284. case SB_THUMBTRACK:
  285.     nScrollInc = pos - lpmv->PosV;
  286.             break;
  288.         default:
  289.             nScrollInc = 0;
  290. }
  292.     if (nScrollInc > lpmv->RangeV-lpmv->PosV)
  293. nScrollInc = lpmv->RangeV-lpmv->PosV;
  295.     if (nScrollInc < -lpmv->PosV)
  296. nScrollInc = -lpmv->PosV;
  298.     if (nScrollInc)
  299. {
  300. lpmv->PosV += nScrollInc;
  302. if (ABS (nScrollInc) < lpmv->yWin/yChar)
  303.     ScrollWindow (hWnd, 0, -(yChar*nScrollInc), NULL, NULL);
  304. else
  305.     InvalidateRect (hWnd, NULL, TRUE);
  307. SetScrollPos (hWnd, SB_VERT, lpmv->PosV, TRUE);
  308. UpdateWindow(hWnd);
  309. }
  310. }
  314. void  WINAPI KeyToScrollMsg (
  315.     HWND      hWnd,
  316.     WPARAM    wParam)
  317. {
  318.     int       i, nKeys;
  319.     static    struct
  320. {
  321.         WORD wVirtKey;
  322.         int  iMessage;
  323.         WORD wRequest;
  324. }key2scroll [] = {
  325.  VK_HOME,  WM_VSCROLL, SB_TOP,   VK_END,   WM_VSCROLL,
  326.  SB_BOTTOM, VK_PRIOR, WM_VSCROLL, SB_PAGEUP, VK_NEXT,
  327.  WM_VSCROLL, SB_PAGEDOWN, VK_UP,    WM_VSCROLL, SB_LINEUP,
  328.  VK_DOWN,  WM_VSCROLL, SB_LINEDOWN, VK_LEFT,  WM_HSCROLL,
  329.  SB_LINEUP, VK_RIGHT, WM_HSCROLL, SB_LINEDOWN,
  330.  };
  332.     nKeys = sizeof key2scroll / sizeof key2scroll[0];
  334.     for (i=0; i<nKeys; i++)
  335. {
  336.         if (wParam == key2scroll[i].wVirtKey)   
  337.     {
  338.             SendMessage (hWnd, key2scroll[i].iMessage, key2scroll[i].wRequest, 0L);
  339.             return;
  340.     }
  341. }
  342. }
  346. void  WINAPI DisplayBytes (
  347.     HDC   hDC,
  348.     RECT  *pRect,
  349.     LPMEMVIEW  lpmv,
  350.     LPMEMVIEW  lpmvOld)
  351. {
  352.     UINT      i, r, iFirst, iLast, y;
  353.     char      szBuf[MAX_PATH], szText[MAX_PATH];
  354.     LPBYTE    pMem = (LPBYTE)lpmv->lpMem;
  355.     LPBYTE    pOldMem;
  356.     BYTE      bRes[16];
  357.     COLORREF  crOldColor = 0;
  358.     SIZE      sz;
  359.     int       cx;
  361.     if (lpmvOld != NULL)
  362. {
  363. pOldMem = (LPBYTE)lpmvOld->lpMem;
  365. /* normalize to beginning of section relative to current memory */
  366. (int)pOldMem += lpmvOld->nBase - lpmv->nBase;
  367. }
  369.     SelectObject (hDC, hFont);
  370.     SetTextColor (hDC, GetSysColor (COLOR_WINDOWTEXT));
  371.     SetBkColor (hDC, GetSysColor (COLOR_WINDOW));
  373.     y = lpmv->PosV;
  375.     iFirst = y + pRect->top/yChar-1;
  377.     if (iFirst == 0xFFFFFFFFL)
  378. iFirst = 0;
  380.     iLast = min (y + pRect->bottom/yChar+1, (UINT)lpmv->nLines-1);
  381.     pMem += iFirst << 4;
  382.     pOldMem += iFirst << 4;
  384.     if (lpmv->nExtraBytes)
  385.         iLast--;
  387.     /* paint complete lines (lines with 16 bytes) */
  388.     GetBytesLine (NULL, 0, 0, 0, NULL);
  390.     y = (iFirst - y) * yChar;
  391.     for (i = iFirst; i<iLast; i++)
  392. {
  393. GetBytesLine (pMem, i, lpmv->nBase, 16, szBuf);
  395. if (lpmvOld != NULL &&
  396.     ((int)pMem-(int)lpmv->lpMem + lpmv->nBase) >= lpmvOld->nBase &&
  397.     ((int)pMem-(int)lpmv->lpMem + lpmv->nBase) < (lpmvOld->nBase + lpmvOld->nSize) &&
  398.     !parcmp (pMem, pOldMem, 16, bRes))
  399.     {
  400.     /* write line number and leading space */
  401.     strncpy (szText, szBuf, 12);
  402.     szText[12] = 0;
  403.     GetTextExtentPoint (hDC, szText, 12, &sz);
  404.     cx = xChar;
  405.     SetTextColor (hDC, GetSysColor (COLOR_HIGHLIGHTTEXT));
  406.     TextOut (hDC, cx, LOWORD (y), szText, 12);
  408.     /* check each hex byte for change */
  409.     for (r=0; r<16; r++)
  410. {
  411. if (bRes[r])
  412.     SetTextColor (hDC, RGB (191, 0, 0));
  413. else
  414.     SetTextColor (hDC, GetSysColor(COLOR_WINDOWTEXT));
  416. /* draw next byte */
  417. szText[0] = szBuf[3*r+12];
  418. szText[1] = szBuf[3*r+1+12];
  419. szText[2] = szBuf[3*r+2+12];
  420. szText[3] = 0;
  421. cx += sz.cx;
  422. GetTextExtentPoint (hDC, szText, 3, &sz);
  423. TextOut (hDC, cx, LOWORD (y), szText, 3);
  424. }
  426.     /* check each ascii byte */
  427.     for (r=0; r<16; r++)
  428. {
  429. if (bRes[r])
  430.     SetTextColor (hDC, RGB (191, 0, 0));
  431. else
  432.     SetTextColor (hDC, GetSysColor(COLOR_WINDOWTEXT));
  434. /* draw next byte */
  435. szText[0] = szBuf[r+60];
  436. szText[1] = 0;
  437. cx += sz.cx;
  438. GetTextExtentPoint (hDC, szText, 1, &sz);
  439. TextOut (hDC, cx, LOWORD (y), szText, 3);
  440. }
  441.     }
  443. else
  444.     {
  445.     SetTextColor (hDC, GetSysColor(COLOR_WINDOWTEXT));
  446.     TextOut (hDC, xChar, LOWORD (y), szBuf, lstrlen (szBuf));
  447.     }
  449. pMem += 16;
  450. pOldMem += 16;
  451. y += yChar;
  452. }
  454.     /* paint last partial line if any (line with less than 16 bytes) */
  455.     if (lpmv->nExtraBytes)
  456. {
  457. GetBytesLine (pMem, i, lpmv->nBase, lpmv->nExtraBytes, szBuf);
  459. if (lpmvOld != NULL &&
  460.     ((int)pMem-(int)lpmv->lpMem + lpmv->nBase) >= lpmvOld->nBase &&
  461.     ((int)pMem-(int)lpmv->lpMem + lpmv->nBase) < (lpmvOld->nBase + lpmvOld->nSize) &&
  462.     !parcmp (pMem, pOldMem, lpmv->nExtraBytes, bRes))
  463.     {
  464.     /* write line number and leading space */
  465.     strncpy (szText, szBuf, 12);
  466.     szText[12] = 0;
  467.     GetTextExtentPoint (hDC, szText, 12, &sz);
  468.     cx = xChar;
  469.     SetTextColor (hDC, RGB (191, 0, 0));
  470.     TextOut (hDC, cx, LOWORD (y), szText, 12);
  472.     /* check each hex byte for change */
  473.     for (r=0; r<(UINT)lpmv->nExtraBytes; r++)
  474. {
  475. if (bRes[r])
  476.     SetTextColor (hDC, RGB (191, 0, 0));
  477. else
  478.     SetTextColor (hDC, GetSysColor(COLOR_WINDOWTEXT));
  480. /* draw next byte */
  481. szText[0] = szBuf[3*r+12];
  482. szText[1] = szBuf[3*r+1+12];
  483. szText[2] = szBuf[3*r+2+12];
  484. szText[3] = 0;
  485. cx += sz.cx;
  486. GetTextExtentPoint (hDC, szText, 3, &sz);
  487. TextOut (hDC, cx, LOWORD (y), szText, 3);
  488. }
  490.     /* check each ascii byte */
  491.     for (r=0; r<(UINT)lpmv->nExtraBytes; r++)
  492. {
  493. if (bRes[r])
  494.     SetTextColor (hDC, RGB (191, 0, 0));
  495. else
  496.     SetTextColor (hDC, GetSysColor(COLOR_WINDOWTEXT));
  498. /* draw next byte */
  499. szText[0] = szBuf[r+60];
  500. szText[1] = 0;
  501. cx += sz.cx;
  502. GetTextExtentPoint (hDC, szText, 1, &sz);
  503. TextOut (hDC, cx, LOWORD (y), szText, 1);
  504. }
  505.     }
  507. else
  508.     {
  509.     SetTextColor (hDC, GetSysColor(COLOR_WINDOWTEXT));
  510.     TextOut(hDC, xChar, y, szBuf, lstrlen (szBuf));
  511.     }
  512. }
  514.     SelectObject(hDC, GetStockObject(SYSTEM_FONT));
  515. }
  521. void  WINAPI GetBytesLine (
  522.     LPBYTE   pBytes,
  523.     UINT     LineNum,
  524.     DWORD    dwBase,
  525.     int      nBytes,
  526.     char     *szLine)
  527. {
  528.     int       j;
  529.     unsigned char    ch;
  530.     char      szAscii[18];
  531.     static BOOL      bDBCS;
  533.     if (NULL == pBytes) {
  534. bDBCS = FALSE;
  535. return;
  536.     }
  538.     wsprintf (szLine, "%#08lx  ", dwBase + (LineNum*16));
  539.         
  540.     for (j = 0; j < nBytes; j++)
  541. {
  542. ch = *pBytes++;
  543. wsprintf (szLine, "%s%02X ", (LPSTR)szLine, (WORD)ch);
  545. if (bDBCS)
  546.     {
  547.     szAscii[j] = (0 == j) ? '.' : ch;
  548.     bDBCS = FALSE;
  549.     }
  550. else if (IsDBCSLeadByte(ch))
  551.     {
  552.     szAscii[j] = ch;
  553.     bDBCS = TRUE;
  554.     }
  555. else
  556.     {
  557.     szAscii[j] = ((ch & 0x7F) >= ' ') ? ch : '.';
  558.     }
  559. }
  561.     if (bDBCS && 16 == nBytes)
  562. szAscii[j++] = *pBytes;
  563.     szAscii[j] = 0;
  564.     wsprintf(szLine, "%-59s%s", (LPSTR)szLine, (LPSTR)szAscii);
  565. }
  570. BOOL WINAPI parcmp (
  571.     LPBYTE    pMem,
  572.     LPBYTE    pOldMem,
  573.     int       nWidth,
  574.     LPBYTE    pRes)
  575. {
  576.     BOOL    bResult = TRUE;
  577.     int     i;
  579.     /* clear result array */
  580.     for (i=0; i<16; i++)
  581. pRes[i] = 0;
  583.     for (i=0; i<nWidth; i++)
  584. {
  585. if (pMem[i] ^ pOldMem[i])
  586.     {
  587.     pRes[i] = 1;
  588.     bResult = FALSE;
  589.     }
  590. }
  592.     return bResult;
  593. }
  598. BOOL WINAPI AddrDlgProc (
  599.     HWND      hDlg,
  600.     UINT      uMsg,
  601.     WPARAM    wParam,
  602.     LPARAM    lParam)
  603. {
  604.     BOOL    bRet = TRUE;
  605.     char    szAddr[MAX_PATH];
  606.     int     nAddr;
  607.     HWND    hAddr = GetDlgItem (hDlg, IDC_ADDR);
  609.     switch (uMsg)
  610. {
  611. case WM_INITDIALOG:
  612.     SetFocus (hAddr);
  613.     bRet = FALSE;
  614.     break;
  616. case WM_COMMAND:
  617.     switch (LOWORD (wParam))
  618. {
  619. case IDC_HEX:
  620.     if (HIWORD (wParam) == BN_CLICKED)
  621. {
  622. GetWindowText (hAddr, szAddr, MAX_PATH);
  624. if (SendMessage (GetDlgItem (hDlg, IDC_HEX), BM_GETCHECK, 0, 0))
  625.     {
  626.     /* convert to hex and return to control */
  627.     nAddr = atoi (szAddr);
  628.     wsprintf (szAddr, "%16x", nAddr);
  629.     SetWindowText (hAddr, szAddr);
  630.     }
  631. else
  632.     {
  633.     /* convert to decimal and return to control */
  634.     sscanf (szAddr, "%16x", &nAddr);
  635.     SetWindowText (hAddr, itoa (nAddr, szAddr, 10));
  636.     }
  638. /* select entire string for easy change */
  639. SendMessage (hAddr, EM_SETSEL, 0, (LONG)-1);
  640. SetFocus (hAddr);
  641. }
  642.     break;
  644. case IDOK:
  645.     GetWindowText (hAddr, szAddr, MAX_PATH);
  647.     /* if hex, convert to decimal integer */
  648.     if (SendMessage (GetDlgItem (hDlg, IDC_HEX), BM_GETCHECK, 0, 0))
  649. sscanf (szAddr, "%16x", &nAddr);
  650.     else
  651. nAddr = atoi (szAddr);
  653.     EndDialog (hDlg, nAddr);
  654.     break;
  656. case IDCANCEL:
  657.     EndDialog (hDlg, 0);
  658.     break;
  659. }
  660.     break;
  662. default:
  663.     bRet = FALSE;
  664. }
  666.     return (bRet);
  667. }