![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to pview.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [WindowsNT SDKs] / mstools / samples / sdktools / walker|
Return to pview.c CVS log | Up to [WindowsNT SDKs] / mstools / samples / sdktools / walker |
1.1 root 1: #include "pwalk.h"
2:
3: #define BYTE_WIN_WIDTH 77
4: #define CLINESSHOW 8
5: #define ABS(x) ((x) < 0? -(x) : (x))
6:
7: /* externally defined system constants */
8: extern int xChar,
9: yChar,
10: xScreen,
11: yScreen,
12: yFrame,
13: xFrame,
14: yCaption,
15: xVScrollBar;
16: extern HFONT hFont;
17: extern HWND hMemWnd;
18:
19: void WINAPI VScrollBytes (HWND, int, int, LPMEMVIEW);
20: void WINAPI KeyToScrollMsg (HWND, WPARAM);
21: void WINAPI DisplayBytes (HDC, LPRECT, LPMEMVIEW, LPMEMVIEW);
22: void WINAPI GetBytesLine (LPBYTE, UINT, DWORD, int, char *);
23: BOOL WINAPI parcmp (LPBYTE, LPBYTE, int, LPBYTE);
24:
25:
26:
27:
28: HWND WINAPI EnumViewWindows (
29: HWND hWndParent,
30: HWND hWndLast)
31: {
32:
33: HMENU hMenu = GetMenu (hWndParent);
34: HMENU hViewMenu = GetSubMenu (hMenu, 2);
35: char szClass[MAX_PATH];
36: char szCaption[MAX_PATH];
37: HWND hWnd;
38: int i;
39:
40: static int nWindows;
41: static ATOM *aMenuItems = NULL;
42: static int iWnd;
43:
44: /* load window class name */
45: LoadString (GetModuleHandle (NULL), IDS_MEMVIEWCLASS, szClass, MAX_PATH);
46:
47: if (hWndLast == NULL)
48: {
49: /* start with first window in menu list */
50: iWnd = 0;
51:
52: /* determine number of windows */
53: nWindows = GetMenuItemCount (hViewMenu) - 5;
54:
55: /* if no popup windows, just return */
56: if (nWindows <= 0)
57: return NULL;
58:
59: /* free memory from last time, if any */
60: if (aMenuItems != NULL)
61: LocalFree ((HANDLE)aMenuItems);
62:
63: /* get menuitem IDs */
64: aMenuItems = (ATOM *)LocalAlloc (LPTR, nWindows*sizeof (ATOM));
65: for (i=5; i-5<nWindows; i++)
66: aMenuItems[i-5] = (ATOM)GetMenuItemID (hViewMenu, i);
67: }
68:
69: else
70: if (iWnd >= nWindows)
71: return (NULL);
72:
73: GetAtomName (aMenuItems[iWnd], szCaption, MAX_PATH);
74: hWnd = FindWindow (szClass, szCaption);
75: iWnd++;
76:
77: return (hWnd);
78: }
79:
80:
81:
82: /* activate view window identified by atom */
83: void WINAPI ActivateViewWindow (
84: ATOM aCaption)
85: {
86: char szClass[MAX_PATH];
87: char szCaption[MAX_PATH];
88: HWND hWnd;
89:
90: GetAtomName (aCaption, szCaption, MAX_PATH);
91: LoadString (GetModuleHandle (NULL), IDS_MEMVIEWCLASS, szClass, MAX_PATH);
92: hWnd = FindWindow (szClass, szCaption);
93: BringWindowToTop (hWnd);
94: }
95:
96:
97:
98: /* function creates a window for viewing memory */
99: HWND WINAPI ViewMemory (
100: HWND hWndParent,
101: char *lpszObject,
102: LPVOID lpMem,
103: int nSize,
104: int nBase)
105: {
106: char szClass[MAX_PATH];
107:
108: /* load resource strings for class and window title */
109: LoadString (GetModuleHandle (NULL), IDS_MEMVIEWCLASS, szClass, MAX_PATH);
110:
111: /* create memory view window */
112: return (CreateWindow (szClass,
113: lpszObject,
114: WS_POPUPWINDOW | WS_VISIBLE | WS_CAPTION |
115: WS_VSCROLL | WS_THICKFRAME | WS_MAXIMIZEBOX,
116: nSize, /* use xposition to pass memory size to window */
117: nBase, /* use yposition to pass base memory location */
118: BYTE_WIN_WIDTH * xChar + xVScrollBar + 2*xFrame,
119: yScreen/2,
120: hWndParent,
121: NULL,
122: GetModuleHandle (NULL),
123: lpMem));
124: }
125:
126:
127:
128: LONG WINAPI MemWndProc (
129: HWND hWnd,
130: UINT uMsg,
131: WPARAM wParam,
132: LPARAM lParam)
133: {
134: LONG lRet = 1;
135: MEMVIEW *pmv = (LPMEMVIEW)GetWindowLong (hWnd, WXB_LPMEMVIEW);
136:
137:
138: switch (uMsg)
139: {
140: case WM_CREATE:
141: pmv = (LPMEMVIEW)LocalAlloc (LPTR, sizeof (MEMVIEW));
142: SetWindowLong (hWnd, WXB_LPMEMVIEW, (LONG)pmv);
143: SetWindowLong (hWnd, WXB_LPOLDMEMVIEW, 0);
144:
145: pmv->lpMem = ((LPCREATESTRUCT)lParam)->lpCreateParams;
146: pmv->nSize = ((LPCREATESTRUCT)lParam)->x;
147: pmv->nBase = ((LPCREATESTRUCT)lParam)->y;
148: pmv->nLines = (pmv->nSize+15)/16;
149: pmv->nExtraBytes = (pmv->nSize & 0x0000000F);
150: pmv->PosV = 0;
151:
152: /* reposition window with proper x,y positions */
153: MoveWindow (hWnd,
154: 15,
155: 15,
156: ((LPCREATESTRUCT)lParam)->cx,
157: ((LPCREATESTRUCT)lParam)->cy,
158: TRUE);
159: break;
160:
161: case WM_SIZE:
162: pmv->xWin = LOWORD (lParam);
163: pmv->yWin = HIWORD (lParam);
164:
165: pmv->RangeV = pmv->nLines-pmv->yWin/yChar;
166:
167: if (pmv->RangeV < 0)
168: pmv->RangeV = 0;
169:
170: if (pmv->PosV > pmv->RangeV)
171: pmv->PosV = pmv->RangeV;
172:
173: SetScrollRange (hWnd, SB_VERT, 0, pmv->RangeV, FALSE);
174: SetScrollPos (hWnd, SB_VERT, pmv->PosV, TRUE);
175: break;
176:
177: case WM_PAINT:
178: {
179: PAINTSTRUCT ps;
180:
181: BeginPaint (hWnd, &ps);
182: DisplayBytes (ps.hdc,
183: &(ps.rcPaint),
184: pmv,
185: (LPMEMVIEW)GetWindowLong (hWnd, WXB_LPOLDMEMVIEW));
186: EndPaint (hWnd, &ps);
187: }
188: break;
189:
190: case UM_UPDATE:
191: InvalidateRect (hWnd, NULL, TRUE);
192: UpdateWindow (hWnd);
193: break;
194:
195: case WM_KEYDOWN:
196: KeyToScrollMsg (hWnd, wParam);
197: break;
198:
199: case WM_VSCROLL:
200: VScrollBytes (hWnd, LOWORD (wParam), GetScrollPos (hWnd, SB_VERT), pmv);
201: break;
202:
203: case WM_DESTROY:
204: {
205: char szCaption[MAX_PATH];
206: LPMEMVIEW lpmv;
207:
208: /* free virtual memory block and local memory buffer */
209: VirtualFree (pmv->lpMem, 0, MEM_RELEASE);
210: LocalFree ((HANDLE)pmv);
211:
212: /* remove any old view memory */
213: if ((lpmv = (LPMEMVIEW)GetWindowLong (hWnd, WXB_LPOLDMEMVIEW)) != NULL)
214: {
215: VirtualFree (lpmv->lpMem, 0, MEM_RELEASE);
216: LocalFree ((HANDLE)lpmv);
217: }
218:
219: /* send message to parent to remove menuitem */
220: GetWindowText (hWnd, szCaption, MAX_PATH);
221: SendMessage (GetParent (hWnd), WM_COMMAND, IDM_REMOVEVIEWWND, (LONG)szCaption);
222: }
223: break;
224:
225: default:
226: return (DefWindowProc(hWnd, uMsg, wParam, lParam));
227: break;
228: }
229: return 0L;
230: }
231:
232:
233:
234:
235: void WINAPI VScrollBytes (
236: HWND hWnd,
237: int cmd,
238: int pos,
239: LPMEMVIEW lpmv)
240: {
241: int nScrollInc;
242:
243: switch (cmd)
244: {
245: case SB_TOP:
246: nScrollInc = -lpmv->PosV;
247: break ;
248:
249: case SB_BOTTOM:
250: nScrollInc = lpmv->RangeV - lpmv->PosV;
251: break ;
252:
253: case SB_LINEUP:
254: nScrollInc = -1;
255: break;
256:
257: case SB_LINEDOWN:
258: nScrollInc = 1;
259: break;
260:
261: case SB_PAGEDOWN:
262: nScrollInc = max (1, lpmv->yWin/yChar);
263: break;
264:
265: case SB_PAGEUP:
266: nScrollInc = min (-1, -(lpmv->yWin/yChar));
267: break;
268:
269: case SB_THUMBPOSITION:
270: nScrollInc = pos - lpmv->PosV;
271: break;
272:
273: case SB_THUMBTRACK:
274: nScrollInc = pos - lpmv->PosV;
275: break;
276:
277: default:
278: nScrollInc = 0;
279: }
280:
281: if (nScrollInc > lpmv->RangeV-lpmv->PosV)
282: nScrollInc = lpmv->RangeV-lpmv->PosV;
283:
284: if (nScrollInc < -lpmv->PosV)
285: nScrollInc = -lpmv->PosV;
286:
287: if (nScrollInc)
288: {
289: lpmv->PosV += nScrollInc;
290:
291: if (ABS (nScrollInc) < lpmv->yWin/yChar)
292: ScrollWindow (hWnd, 0, -(yChar*nScrollInc), NULL, NULL);
293: else
294: InvalidateRect (hWnd, NULL, TRUE);
295:
296: SetScrollPos (hWnd, SB_VERT, lpmv->PosV, TRUE);
297: UpdateWindow(hWnd);
298: }
299: }
300:
301:
302:
303: void WINAPI KeyToScrollMsg (
304: HWND hWnd,
305: WPARAM wParam)
306: {
307: int i, nKeys;
308: static struct
309: {
310: WORD wVirtKey;
311: int iMessage;
312: WORD wRequest;
313: }key2scroll [] = {
314: VK_HOME, WM_VSCROLL, SB_TOP, VK_END, WM_VSCROLL,
315: SB_BOTTOM, VK_PRIOR, WM_VSCROLL, SB_PAGEUP, VK_NEXT,
316: WM_VSCROLL, SB_PAGEDOWN, VK_UP, WM_VSCROLL, SB_LINEUP,
317: VK_DOWN, WM_VSCROLL, SB_LINEDOWN, VK_LEFT, WM_HSCROLL,
318: SB_LINEUP, VK_RIGHT, WM_HSCROLL, SB_LINEDOWN,
319: };
320:
321: nKeys = sizeof key2scroll / sizeof key2scroll[0];
322:
323: for (i=0; i<nKeys; i++)
324: {
325: if (wParam == key2scroll[i].wVirtKey)
326: {
327: SendMessage (hWnd, key2scroll[i].iMessage, key2scroll[i].wRequest, 0L);
328: return;
329: }
330: }
331: }
332:
333:
334:
335: void WINAPI DisplayBytes (
336: HDC hDC,
337: RECT *pRect,
338: LPMEMVIEW lpmv,
339: LPMEMVIEW lpmvOld)
340: {
341: UINT i, r, iFirst, iLast, y;
342: char szBuf[MAX_PATH], szText[MAX_PATH];
343: LPBYTE pMem = (LPBYTE)lpmv->lpMem;
344: LPBYTE pOldMem;
345: BYTE bRes[16];
346: COLORREF crOldColor = 0;
347: SIZE sz;
348: int cx;
349:
350: if (lpmvOld != NULL)
351: {
352: pOldMem = (LPBYTE)lpmvOld->lpMem;
353:
354: /* normalize to beginning of section relative to current memory */
355: (int)pOldMem += lpmvOld->nBase - lpmv->nBase;
356: }
357:
358: SelectObject (hDC, hFont);
359: SetTextColor (hDC, GetSysColor (COLOR_WINDOWTEXT));
360: SetBkColor (hDC, GetSysColor (COLOR_WINDOW));
361:
362: y = lpmv->PosV;
363:
364: iFirst = y + pRect->top/yChar-1;
365:
366: if (iFirst == 0xFFFFFFFFL)
367: iFirst = 0;
368:
369: iLast = min (y + pRect->bottom/yChar+1, (UINT)lpmv->nLines-1);
370: pMem += iFirst << 4;
371: pOldMem += iFirst << 4;
372:
373: if (lpmv->nExtraBytes)
374: iLast--;
375:
376: /* paint complete lines (lines with 16 bytes) */
377: y = (iFirst - y) * yChar;
378: for (i = iFirst; i<iLast; i++)
379: {
380: GetBytesLine (pMem, i, lpmv->nBase, 16, szBuf);
381:
382: if (lpmvOld != NULL &&
383: ((int)pMem-(int)lpmv->lpMem + lpmv->nBase) >= lpmvOld->nBase &&
384: ((int)pMem-(int)lpmv->lpMem + lpmv->nBase) < (lpmvOld->nBase + lpmvOld->nSize) &&
385: !parcmp (pMem, pOldMem, 16, bRes))
386: {
387: /* write line number and leading space */
388: strncpy (szText, szBuf, 12);
389: szText[12] = 0;
390: GetTextExtentPoint (hDC, szText, 12, &sz);
391: cx = xChar;
392: SetTextColor (hDC, GetSysColor (COLOR_HIGHLIGHTTEXT));
393: TextOut (hDC, cx, LOWORD (y), szText, 12);
394:
395: /* check each hex byte for change */
396: for (r=0; r<16; r++)
397: {
398: if (bRes[r])
399: SetTextColor (hDC, RGB (191, 0, 0));
400: else
401: SetTextColor (hDC, GetSysColor(COLOR_WINDOWTEXT));
402:
403: /* draw next byte */
404: szText[0] = szBuf[3*r+12];
405: szText[1] = szBuf[3*r+1+12];
406: szText[2] = szBuf[3*r+2+12];
407: szText[3] = 0;
408: cx += sz.cx;
409: GetTextExtentPoint (hDC, szText, 3, &sz);
410: TextOut (hDC, cx, LOWORD (y), szText, 3);
411: }
412:
413: /* check each ascii byte */
414: for (r=0; r<16; r++)
415: {
416: if (bRes[r])
417: SetTextColor (hDC, RGB (191, 0, 0));
418: else
419: SetTextColor (hDC, GetSysColor(COLOR_WINDOWTEXT));
420:
421: /* draw next byte */
422: szText[0] = szBuf[r+60];
423: szText[1] = 0;
424: cx += sz.cx;
425: GetTextExtentPoint (hDC, szText, 1, &sz);
426: TextOut (hDC, cx, LOWORD (y), szText, 3);
427: }
428: }
429:
430: else
431: {
432: SetTextColor (hDC, GetSysColor(COLOR_WINDOWTEXT));
433: TextOut (hDC, xChar, LOWORD (y), szBuf, lstrlen (szBuf));
434: }
435:
436: pMem += 16;
437: pOldMem += 16;
438: y += yChar;
439: }
440:
441: /* paint last partial line if any (line with less than 16 bytes) */
442: if (lpmv->nExtraBytes)
443: {
444: GetBytesLine (pMem, i, lpmv->nBase, lpmv->nExtraBytes, szBuf);
445:
446: if (lpmvOld != NULL &&
447: ((int)pMem-(int)lpmv->lpMem + lpmv->nBase) >= lpmvOld->nBase &&
448: ((int)pMem-(int)lpmv->lpMem + lpmv->nBase) < (lpmvOld->nBase + lpmvOld->nSize) &&
449: !parcmp (pMem, pOldMem, lpmv->nExtraBytes, bRes))
450: {
451: /* write line number and leading space */
452: strncpy (szText, szBuf, 12);
453: szText[12] = 0;
454: GetTextExtentPoint (hDC, szText, 12, &sz);
455: cx = xChar;
456: SetTextColor (hDC, RGB (191, 0, 0));
457: TextOut (hDC, cx, LOWORD (y), szText, 12);
458:
459: /* check each hex byte for change */
460: for (r=0; r<(UINT)lpmv->nExtraBytes; r++)
461: {
462: if (bRes[r])
463: SetTextColor (hDC, RGB (191, 0, 0));
464: else
465: SetTextColor (hDC, GetSysColor(COLOR_WINDOWTEXT));
466:
467: /* draw next byte */
468: szText[0] = szBuf[3*r+12];
469: szText[1] = szBuf[3*r+1+12];
470: szText[2] = szBuf[3*r+2+12];
471: szText[3] = 0;
472: cx += sz.cx;
473: GetTextExtentPoint (hDC, szText, 3, &sz);
474: TextOut (hDC, cx, LOWORD (y), szText, 3);
475: }
476:
477: /* check each ascii byte */
478: for (r=0; r<(UINT)lpmv->nExtraBytes; r++)
479: {
480: if (bRes[r])
481: SetTextColor (hDC, RGB (191, 0, 0));
482: else
483: SetTextColor (hDC, GetSysColor(COLOR_WINDOWTEXT));
484:
485: /* draw next byte */
486: szText[0] = szBuf[r+60];
487: szText[1] = 0;
488: cx += sz.cx;
489: GetTextExtentPoint (hDC, szText, 1, &sz);
490: TextOut (hDC, cx, LOWORD (y), szText, 1);
491: }
492: }
493:
494: else
495: {
496: SetTextColor (hDC, GetSysColor(COLOR_WINDOWTEXT));
497: TextOut(hDC, xChar, y, szBuf, lstrlen (szBuf));
498: }
499: }
500:
501: SelectObject(hDC, GetStockObject(SYSTEM_FONT));
502: }
503:
504:
505:
506:
507:
508: void WINAPI GetBytesLine (
509: LPBYTE pBytes,
510: UINT LineNum,
511: DWORD dwBase,
512: int nBytes,
513: char *szLine)
514: {
515: int j;
516: unsigned char ch;
517: char szAscii[17];
518:
519: wsprintf (szLine, "%#08lx ", dwBase + (LineNum*16));
520:
521: for (j = 0; j < nBytes; j++)
522: {
523: ch = *pBytes++;
524: wsprintf (szLine, "%s%02X ", (LPSTR)szLine, (WORD)ch);
525: szAscii[j] = ((ch & 0x7F) >= ' ') ? ch : '.';
526: }
527:
528: szAscii[nBytes] = 0;
529: wsprintf(szLine, "%-59s%s", (LPSTR)szLine, (LPSTR)szAscii);
530: }
531:
532:
533:
534:
535: BOOL WINAPI parcmp (
536: LPBYTE pMem,
537: LPBYTE pOldMem,
538: int nWidth,
539: LPBYTE pRes)
540: {
541: BOOL bResult = TRUE;
542: int i;
543:
544: /* clear result array */
545: for (i=0; i<16; i++)
546: pRes[i] = 0;
547:
548: for (i=0; i<nWidth; i++)
549: {
550: if (pMem[i] ^ pOldMem[i])
551: {
552: pRes[i] = 1;
553: bResult = FALSE;
554: }
555: }
556:
557: return bResult;
558: }
559:
560:
561:
562:
563: BOOL WINAPI AddrDlgProc (
564: HWND hDlg,
565: UINT uMsg,
566: WPARAM wParam,
567: LPARAM lParam)
568: {
569: BOOL bRet = TRUE;
570: char szAddr[MAX_PATH];
571: int nAddr;
572: HWND hAddr = GetDlgItem (hDlg, IDC_ADDR);
573:
574: switch (uMsg)
575: {
576: case WM_INITDIALOG:
577: SetFocus (hAddr);
578: bRet = FALSE;
579: break;
580:
581: case WM_COMMAND:
582: switch (LOWORD (wParam))
583: {
584: case IDC_HEX:
585: if (HIWORD (wParam) == BN_CLICKED)
586: {
587: GetWindowText (hAddr, szAddr, MAX_PATH);
588:
589: if (SendMessage (GetDlgItem (hDlg, IDC_HEX), BM_GETCHECK, 0, 0))
590: {
591: /* convert to hex and return to control */
592: nAddr = atoi (szAddr);
593: wsprintf (szAddr, "%16x", nAddr);
594: SetWindowText (hAddr, szAddr);
595: }
596: else
597: {
598: /* convert to decimal and return to control */
599: sscanf (szAddr, "%16x", &nAddr);
600: SetWindowText (hAddr, itoa (nAddr, szAddr, 10));
601: }
602:
603: /* select entire string for easy change */
604: SendMessage (hAddr, EM_SETSEL, 0, (LONG)-1);
605: SetFocus (hAddr);
606: }
607: break;
608:
609: case IDOK:
610: GetWindowText (hAddr, szAddr, MAX_PATH);
611:
612: /* if hex, convert to decimal integer */
613: if (SendMessage (GetDlgItem (hDlg, IDC_HEX), BM_GETCHECK, 0, 0))
614: sscanf (szAddr, "%16x", &nAddr);
615: else
616: nAddr = atoi (szAddr);
617:
618: EndDialog (hDlg, nAddr);
619: break;
620:
621: case IDCANCEL:
622: EndDialog (hDlg, 0);
623: break;
624: }
625: break;
626:
627: default:
628: bRet = FALSE;
629: }
630:
631: return (bRet);
632: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.