![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to window.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [OS/2 SDKs] / os232sdk / toolkt20 / c / samples / spy|
Return to window.c CVS log | Up to [OS/2 SDKs] / os232sdk / toolkt20 / c / samples / spy |
1.1 root 1: /****************************** Module Header ******************************\
2: * Module Name: window.c - Spy Window dialog functions.
3: *
4: * Created: Microsoft, IBM Corporation 1990
5: *
6: \***************************************************************************/
7:
8: #define INCL_WIN
9: #define INCL_WINSYS
10: #define INCL_DOSPROCESS
11: #include <os2.h>
12: #include <stdio.h>
13: #include <string.h>
14: #include "spy.h"
15: #include "spyhk32.h"
16: #include <time.h>
17: #include <stdlib.h>
18:
19:
20: /************* GLOBAL VARIABLES */
21:
22:
23:
24:
25: /************* PROCEDURE DECLARATIONS */
26:
27: void InitWindowList(HWND, HWND, int);
28: void BuildWindowWatchList(void);
29: void DisplayWindowInfo(HWND, HWND);
30:
31:
32: void SelectWindowFromText(HWND);
33: SHORT DumpWindowInfo(HWND, SHORT);
34: int _cdecl CompareHwnds(const void *, const void *);
35:
36:
37:
38:
39: /**************************** Public Function ******************************\
40: * MRESULT EXPENTRY SpyWindowsDlgProc(hwnd, msg, mp1, mp2)
41: *
42: * Effects: The Spy Windows Dialog procedure
43: *
44: * Return value: none
45: \***************************************************************************/
46: MRESULT EXPENTRY SpyWindowsDlgProc(hwnd, msg, mp1, mp2)
47: HWND hwnd;
48: USHORT msg;
49: MPARAM mp1;
50: MPARAM mp2;
51: {
52: BOOL fSelect = TRUE;
53: SHORT cWindows;
54: HWND hwndPoint;
55: HWND hwndItem; /* from handle of list item */
56: USHORT iItemFocus; /* Index to item that has the focus */
57:
58: switch (msg) {
59:
60: case WM_INITDLG:
61: /* Initialize the dialog items */
62: hwndWindowLB = WinWindowFromID(hwnd, DID_WINDOWLIST);
63: InitWindowList(hwnd, HWND_DESKTOP, 0);
64: InitWindowList(hwnd, HWND_OBJECT, -10);
65: hwndWinDlgDisp = NULL;
66: fTrackingListBox = TRUE;
67: break;
68:
69: case WM_CHAR:
70: /*
71: * Handle VK_ENTER and VK_NEWLINE if our Edit control has
72: * the focus and it is a keydown
73: */
74: if (!(SHORT1FROMMP(mp1) & KC_KEYUP) &&
75: (SHORT1FROMMP(mp1) & KC_VIRTUALKEY) &&
76: ( (SHORT2FROMMP(mp2) == VK_ENTER) ||
77: (SHORT2FROMMP(mp2) == VK_NEWLINE) )) {
78:
79:
80: if (WinQueryFocus(HWND_DESKTOP, FALSE) ==
81: WinWindowFromID(hwnd, DID_WHANDLE)) {
82: SelectWindowFromText(hwnd);
83: break;
84: }
85: }
86:
87: /* Normaly pass to dialog procedure to handle message */
88: return(WinDefDlgProc(hwnd, msg, mp1, mp2));
89: break;
90:
91: case WM_COMMAND:
92: switch (SHORT1FROMMP(mp1)) {
93: case DID_OK:
94: BuildWindowWatchList();
95: case DID_CANCEL:
96: /* Now dismiss the dialog */
97: WinDismissDlg(hwnd, SHORT1FROMMP(mp1));
98: break;
99: case DID_WUNSELALL:
100: fSelect = FALSE;
101: case DID_WSELALL:
102: cWindows = (SHORT) WinSendMsg(hwndWindowLB, LM_QUERYITEMCOUNT,
103: 0L, 0L);
104:
105: fTrackingListBox = FALSE;
106: while (cWindows) {
107: /* Loop through all windows, selecting or unselcting all */
108: WinSendMsg(hwndWindowLB, LM_SELECTITEM, (MPARAM)--cWindows,
109: (MPARAM)fSelect);
110: }
111: fTrackingListBox = TRUE;
112: break;
113:
114: case DID_WSELMOUSE:
115: /* Call function to track mouse, returns window handle */
116: hwndPoint = HwndSelWinWithMouse(hwnd, DisplayWindowInfo, FALSE);
117: if (hwndPoint == NULL)
118: break; /* No window to process */
119:
120: /*
121: * Now find the window in the list, Make the item visible
122: * and set the item as selected.
123: */
124: cWindows = (SHORT) WinSendMsg(hwndWindowLB, LM_QUERYITEMCOUNT,
125: 0L, 0L);
126:
127: while (cWindows) {
128: /*
129: * Loop through all windows until we wind the right
130: * one with the correct window handle
131: */
132: hwndItem = (HWND)WinSendMsg(hwndWindowLB, LM_QUERYITEMHANDLE,
133: (MPARAM)--cWindows, 0L);
134:
135: if (hwndItem == hwndPoint) {
136: /* found the right item, move it to top */
137: WinSendMsg(hwndWindowLB, LM_SETTOPINDEX, (MPARAM)cWindows, 0L);
138: WinSendMsg(hwndWindowLB, LM_SELECTITEM, (MPARAM)cWindows,
139: (MPARAM)TRUE);
140: break;
141: }
142: }
143: break;
144:
145: }
146: break;
147:
148:
149: default:
150: /*
151: * Default is to see if the listbox has changed its focus
152: * item number. If it has, then we want to display the information
153: * about the window that the listbox cursor is over. There is no
154: * legal way to do this, One approach appears to temporary set the
155: * listbox to be a single selection listbox, then query its selection
156: * and set it back into multiple selection mode.
157: */
158: if (fTrackingListBox && hwndWindowLB != NULL) {
159:
160: WinSetWindowBits(hwndWindowLB, QWL_STYLE, 0L, LS_MULTIPLESEL);
161: iItemFocus = (USHORT)WinSendMsg(hwndWindowLB, LM_QUERYSELECTION,
162: (MPARAM)LIT_FIRST, 0L);
163: WinSetWindowBits(hwndWindowLB, QWL_STYLE, LS_MULTIPLESEL,
164: LS_MULTIPLESEL);
165:
166: if (iItemFocus != iCurItemFocus) {
167: iCurItemFocus = iItemFocus;
168: if (iItemFocus != (USHORT)-1) {
169:
170: hwndItem = (HWND)WinSendMsg(hwndWindowLB, LM_QUERYITEMHANDLE,
171: (MPARAM)iItemFocus, 0L);
172: DisplayWindowInfo(hwnd, hwndItem);
173: }
174: }
175: }
176: return(WinDefDlgProc(hwnd, msg, mp1, mp2));
177: }
178: return 0L;
179: }
180:
181:
182:
183:
184: /***************************** Private Function ****************************\
185: * void SelectWindowFromText(hwndDlg)
186: *
187: * Effects:
188: * Updates the text that is displayed in the message text line
189: *
190: * History:
191: * 27-September-1988 KurtE
192: \***************************************************************************/
193: void SelectWindowFromText(hwndDlg)
194: HWND hwndDlg;
195: {
196: char szTemp[80];
197: HWND hwndSelect;
198: SHORT cItems;
199: SHORT i;
200:
201:
202: /* First get the edit text from the string */
203: WinQueryDlgItemText(hwndDlg, DID_WHANDLE, sizeof(szTemp),
204: (PSZ)szTemp);
205:
206: hwndSelect = (HWND)UConvertStringToNum(szTemp);
207:
208: cItems = (SHORT)WinSendMsg(hwndWindowLB, LM_QUERYITEMCOUNT,
209: 0L, 0L);
210:
211: for (i=0; i < cItems; i++) {
212: if ((HWND)WinSendMsg(hwndWindowLB, LM_QUERYITEMHANDLE,
213: (MPARAM)i, 0L) == hwndSelect)
214: break; /* found it */
215: }
216:
217: if (i < cItems) {
218: /*
219: * found the hwnd, bring to top, and select it
220: */
221: WinSendMsg(hwndWindowLB, LM_SETTOPINDEX,
222: MPFROMSHORT(i), (MPARAM)0L);
223:
224: /* Always set it on */
225: WinSendMsg(hwndWindowLB, LM_SELECTITEM,
226: MPFROMSHORT(i), MPFROMSHORT(TRUE));
227:
228: } else {
229: WinAlarm(HWND_DESKTOP, WA_WARNING);
230: WinSetDlgItemText(hwndDlg, DID_WHANDLE, (PSZ)"");
231: }
232:
233: }
234:
235:
236: /**************************** Private Function ******************************\
237: * InitWindowList (hwndDialog, hwnd, level)
238: *
239: * Effects: Builds the list of windows displayed in the windows dialog
240: *
241: *
242: * Return value:
243: \***************************************************************************/
244: void InitWindowList(hwndDialog, hwnd, level)
245: HWND hwndDialog;
246: HWND hwnd;
247: int level;
248: {
249: char szTemp[30];
250: char szId[20];
251: HWND hwndT;
252: USHORT item;
253: USHORT id;
254: int i;
255:
256: /*
257: * We will first add this item to our list of
258: * items in the listbox, If the item is in our list of hwnds,
259: * set the item selected. To keep from getting into endless loops
260: * will not add spywindow client, and descendants.
261: */
262: if (hwnd != hwndSpy) {
263: id = (USHORT)WinQueryWindowUShort(hwnd, QWS_ID);
264: sprintf(szId, "ID: %x", id);
265:
266: for (i = 0; i < cToName; i++) {
267: if (id == rgidtoname[i].id) {
268: strcpy (szId, rgidtoname[i].szIdName);
269: break;
270: }
271: }
272:
273: sprintf(szTemp, "%04x(%d) - %s", (USHORT)hwnd, level, szId);
274: item = (USHORT)WinSendMsg(hwndWindowLB, LM_INSERTITEM,
275: (MPARAM)LIT_END, (MPARAM)(PSZ)szTemp);
276:
277: /* Set the item handle to the handle of the window */
278: WinSendMsg(hwndWindowLB, LM_SETITEMHANDLE, (MPARAM)item,
279: (MPARAM)hwnd);
280:
281: if (SpyFWindowInList(hwnd, TRUE))
282: WinSendMsg(hwndWindowLB, LM_SELECTITEM, (MPARAM)item,
283: (MPARAM)TRUE);
284:
285: /*
286: * Then we recurse with all of our children
287: */
288: if ((hwndT = WinQueryWindow(hwnd, QW_TOP, FALSE)) != NULL)
289: InitWindowList(hwndDialog, hwndT, level+1);
290: }
291:
292: /*
293: * Then go to our next sibling
294: */
295: if ((hwndT = WinQueryWindow(hwnd, QW_NEXT, FALSE)) != NULL)
296: InitWindowList(hwndDialog, hwndT, level);
297: }
298:
299:
300:
301: /**************************** Private Function *****************************\
302: * BuildWindowWatchList()
303: *
304: * Effects: Updates the list of windows to be watched from the listbox
305: *
306: *
307: * Return value:
308: \***************************************************************************/
309: void BuildWindowWatchList()
310: {
311:
312: USHORT itemPrevious;
313: USHORT item;
314: HWND hwnd;
315:
316: SHORT chwnd;
317: HWND rghwnd[MAXHWNDS];
318:
319: /*
320: * Simply loop through asking for the next selected item in the
321: * list. Make sure not to overrun our list.
322: */
323: itemPrevious = (USHORT)LIT_FIRST;
324: chwnd = 0;
325:
326: while ((item = (USHORT)WinSendMsg(hwndWindowLB, LM_QUERYSELECTION,
327: (MPARAM)itemPrevious, 0L)) != (USHORT)LIT_NONE) {
328: /*
329: * Get the items handle, which has the value of the window handle
330: */
331: hwnd = (HWND)WinSendMsg(hwndWindowLB, LM_QUERYITEMHANDLE,
332: (MPARAM)item, 0L);
333:
334: /* Make sure it still is a valid window */
335: if (WinIsWindow(hab, hwnd)) {
336: rghwnd[chwnd++] = hwnd;
337: if (chwnd >= MAXHWNDS)
338: break; /* Dont overflow array */
339: }
340:
341: itemPrevious = item; /* Where to cointinue the search */
342: }
343:
344: SpySetWindowList (chwnd, rghwnd);
345: }
346:
347:
348: /**************************** Public Function ******************************\
349: * HWND HwndSelWinWithMouse(HWND hwnd, void (*pfnDisplayInfo)(HWND, HWND),
350: * BOOL fFrameOnly)
351: *
352: * Effects: This function is used to allow the user to select a window with
353: * the mouse. If fDisplayInfo is TRUE, it will update the
354: * information in the dialog box, about the window that the
355: * mouse is currently over.
356: *
357: * Return value: none
358: \***************************************************************************/
359: HWND HwndSelWinWithMouse(hwnd, pfnDisplayInfo, fFrameOnly)
360: HWND hwnd;
361: void (*pfnDisplayInfo)(HWND, HWND);
362: BOOL fFrameOnly;
363: {
364:
365: QMSG qmsg;
366: HWND hwndPoint;
367: char szClassName[50]; /* Class name of window */
368: CLASSINFO classinfo; /* Information about class */
369:
370:
371: /*
372: * First set the capture to the specified window
373: */
374: WinSetCapture(HWND_DESKTOP, hwnd);
375: WinSetPointer (HWND_DESKTOP, hptrSelWin);
376:
377: /*
378: * Now loop through all of the messages that are sent, until
379: * we get our mouse 1 down message. We will also filter out
380: * the WM_MOVE message, else we will dispatch the messages.
381: */
382: while (WinGetMsg(hab, &qmsg, NULL, 0, 0)) {
383: if (qmsg.msg == WM_MOUSEMOVE) {
384: if (pfnDisplayInfo != NULL) {
385: hwndPoint = WinWindowFromPoint(HWND_DESKTOP,
386: &qmsg.ptl, TRUE, FALSE);
387: (*pfnDisplayInfo)(hwnd, hwndPoint);
388: }
389: }
390: else if (qmsg.msg == WM_BUTTON1DOWN)
391: break;
392: else
393: WinDispatchMsg(hab, &qmsg);
394: }
395:
396: WinSetPointer (HWND_DESKTOP, hptrArrow);
397: WinSetCapture(HWND_DESKTOP, NULL);
398:
399:
400: /*
401: * Map the point to the window, If the CTRL-Key is down,
402: * we will go up through the parent chain until we get to
403: * a frame window or desktop. Dont let hwndSpy through!!!
404: */
405: hwndPoint = WinWindowFromPoint(HWND_DESKTOP,
406: &qmsg.ptl, TRUE, FALSE);
407: if (fFrameOnly || WinGetKeyState(HWND_DESKTOP, VK_CTRL) & 0x8000) {
408: /* Asked for frame window */
409: for (;;) {
410: if (hwndPoint == NULL)
411: return (NULL); /* No frames available */
412: /* See if frame class */
413: WinQueryClassName(hwndPoint, sizeof(szClassName),
414: (PSZ)szClassName);
415: if (WinQueryClassInfo(hab, (PSZ)szClassName, &classinfo) &&
416: (classinfo.flClassStyle & CS_FRAME))
417: break; /* We have our frame */
418:
419: /* Not frame, go back to parent */
420: hwndPoint = WinQueryWindow(hwndPoint, QW_PARENT, FALSE);
421: }
422: }
423:
424: if (pfnDisplayInfo != NULL)
425: (*pfnDisplayInfo)(hwnd, hwndPoint);
426:
427: if (WinIsChild(hwndPoint, hwndSpy))
428: return (NULL); /* Dont want to get in endless loops */
429:
430: return (hwndPoint);
431: }
432:
433:
434:
435: /**************************** Private Function *****************************\
436: * DisplayWindowInfo(HWND hwndDialog, HWND hwnd)
437: *
438: * Effects: Displays the information about the selected window in the dialog
439: *
440: *
441: * Return value:
442: \***************************************************************************/
443: void DisplayWindowInfo(hwndDlg, hwnd)
444: HWND hwndDlg;
445: HWND hwnd;
446: {
447: HWND hwndT;
448: HWND hwndParent;
449: char szTemp[50];
450: char szTemp2[10];
451: CLASSINFO classinfo;
452: RECTL rcl;
453: USHORT id;
454: ULONG ul;
455: USHORT us1;
456: USHORT us2;
457: USHORT us3;
458: USHORT us4;
459: PID pidWindow;
460: TID tidWindow;
461:
462:
463: if (hwnd != hwndWinDlgDisp)
464: {
465: hwndWinDlgDisp = hwnd;
466:
467: /* This could be table driven */
468: sprintf(szTemp, "%p", hwnd);
469: WinSetDlgItemText(hwndDlg, DID_WHANDLE, (PSZ)szTemp);
470:
471: /*
472: * Make sure the window has not been deleted
473: */
474: if (WinIsWindow(hab, hwnd)) {
475: WinQueryClassName(hwnd, sizeof(szTemp), (PSZ)szTemp);
476: if (!WinQueryClassInfo(hab, (PSZ)szTemp, &classinfo)) {
477: classinfo.flClassStyle = -1; /* Let know error conditon */
478: classinfo.cbWindowData = 0; /* Make sure we dont dump */
479: }
480:
481: WinSetDlgItemText(hwndDlg, DID_WCLASS, (PSZ)szTemp);
482:
483:
484: /*
485: * Warning, we only query the text if the window is not an object
486: * window. If it is an object window, the message queue may not
487: * be processing messages, which could hang us
488: */
489: if (WinIsChild(hwnd, HWND_OBJECT))
490: szTemp[0] = '\0'; /* No text available */
491: else
492: WinQueryWindowText(hwnd, sizeof(szTemp), (PSZ)szTemp);
493: WinSetDlgItemText(hwndDlg, DID_WTEXT, (PSZ)szTemp);
494:
495: hwndParent = WinQueryWindow(hwnd, QW_PARENT, FALSE);
496: sprintf(szTemp, "%p", hwndParent);
497: WinSetDlgItemText(hwndDlg, DID_WPARENT, (PSZ)szTemp);
498:
499: hwndT = WinQueryWindow(hwnd, QW_TOP, FALSE);
500: sprintf(szTemp, "%p", hwndT);
501: WinSetDlgItemText(hwndDlg, DID_WCHILD, (PSZ)szTemp);
502:
503: hwndT = WinQueryWindow(hwnd, QW_OWNER, FALSE);
504: sprintf(szTemp, "%p", hwndT);
505: WinSetDlgItemText(hwndDlg, DID_WOWNER, (PSZ)szTemp);
506:
507: WinQueryWindowRect(hwnd, &rcl);
508: WinMapWindowPoints(hwnd, hwndParent, (PPOINTL)&rcl, 2);
509: sprintf(szTemp, "(%d, %d), (%d, %d)", (SHORT)rcl.xLeft,
510: (SHORT)rcl.yBottom, (SHORT)rcl.xRight, (SHORT)rcl.yTop);
511: WinSetDlgItemText(hwndDlg, DID_WRECT, (PSZ)szTemp);
512:
513: id = (USHORT)WinQueryWindowUShort(hwnd, QWS_ID);
514: sprintf(szTemp, "0x%04x", id);
515: WinSetDlgItemText(hwndDlg, DID_WID, (PSZ)szTemp);
516:
517: ul = (ULONG)WinQueryWindowULong(hwnd, QWL_STYLE);
518: sprintf(szTemp, "0x%08lx", ul);
519: WinSetDlgItemText(hwndDlg, DID_WSTYLE, (PSZ)szTemp);
520:
521: sprintf(szTemp, "0x%08lx", classinfo.flClassStyle);
522: WinSetDlgItemText(hwndDlg, DID_WCSTYLE, (PSZ)szTemp);
523:
524: ul = (ULONG)WinQueryWindowULong(hwnd, QWP_PFNWP);
525: sprintf(szTemp, "%p", ul);
526: WinSetDlgItemText(hwndDlg, DID_WPFNWP, (PSZ)szTemp);
527:
528: ul = (ULONG)WinQueryWindowULong(hwnd, QWL_HMQ);
529: sprintf(szTemp, "0x%04x", (SHORT)ul);
530: WinSetDlgItemText(hwndDlg, DID_WHMQ, (PSZ)szTemp);
531:
532: WinQueryWindowProcess(hwnd, &pidWindow, &tidWindow);
533: sprintf(szTemp, "%d", pidWindow);
534: WinSetDlgItemText(hwndDlg, DID_WPID, (PSZ)szTemp);
535: sprintf(szTemp, "%d", tidWindow);
536: WinSetDlgItemText(hwndDlg, DID_WTID, (PSZ)szTemp);
537:
538: /*
539: * We have four General purpose lines left, used only for
540: * frames now
541: */
542: if ((classinfo.flClassStyle & CS_FRAME) &&
543: (classinfo.cbWindowData > QWL_HWNDFOCUSSAVE)) {
544: ul = (ULONG)WinQueryWindowULong(hwnd, QWL_HWNDFOCUSSAVE);
545: sprintf(szTemp, "Frame Focus: %p",ul);
546: WinSetDlgItemText(hwndDlg, DID_WOLINE1, (PSZ)szTemp);
547:
548: us1 = (USHORT)WinQueryWindowUShort(hwnd, QWS_FLAGS);
549: us2 = (USHORT)WinQueryWindowUShort(hwnd, QWS_RESULT);
550: sprintf(szTemp, "Flags: 0x%04x Rslt: 0x%04x", us1, us2);
551: WinSetDlgItemText(hwndDlg, DID_WOLINE2, (PSZ)szTemp);
552:
553: us1 = (USHORT)WinQueryWindowUShort(hwnd, QWS_XRESTORE);
554: us2 = (USHORT)WinQueryWindowUShort(hwnd, QWS_YRESTORE);
555: us3 = (USHORT)WinQueryWindowUShort(hwnd, QWS_CXRESTORE);
556: us4 = (USHORT)WinQueryWindowUShort(hwnd, QWS_CYRESTORE);
557: sprintf(szTemp, "Restore: (%d, %d, %d, %d)",us1, us2, us3, us4);
558: WinSetDlgItemText(hwndDlg, DID_WOLINE3, (PSZ)szTemp);
559:
560: us1 = (USHORT)WinQueryWindowUShort(hwnd, QWS_XMINIMIZE);
561: us2 = (USHORT)WinQueryWindowUShort(hwnd, QWS_YMINIMIZE);
562: sprintf(szTemp, "Minimize: (%d, %d)",us1, us2);
563: WinSetDlgItemText(hwndDlg, DID_WOLINE4, (PSZ)szTemp);
564: } else {
565: /*
566: * Nothing special to output for this window type, so lets
567: * dump the window extra words.
568: * Note: This code is sh.ty
569: */
570: us1 = 0; /* Word offset */
571: for (id=DID_WOLINE1; id <= DID_WOLINE4; id++) {
572: szTemp[0] = '\0';
573: for (us2 = 0; us2 < 4; us2++) {
574: if (us1 >= classinfo.cbWindowData)
575: break;
576: us3 = (USHORT)WinQueryWindowUShort(hwnd, us1);
577: sprintf(szTemp2, "%04x ", us3);
578: strcat(szTemp, szTemp2);
579: us1 += 2; /* Setup for next word */
580: }
581:
582: /* output this line */
583: WinSetDlgItemText(hwndDlg, id, (PSZ)szTemp);
584: }
585: }
586: } else {
587: /*
588: * Window was deleted, Show the window text as deleted, and
589: * clear out the remaining fields.
590: */
591: WinSetDlgItemText(hwndDlg, DID_WTEXT, (PSZ)"*** Deleted ***");
592: szTemp[0] = '\0';
593: for (id=DID_WCLASS; id <= DID_WOLINE4; id++) {
594: WinSetDlgItemText(hwndDlg, id, (PSZ)szTemp);
595: }
596: }
597: }
598: }
599:
600:
601:
602:
603: /**************************** Public Function ******************************\
604: * DumpOneWindowInfo()
605: *
606: * Effects: Dump the information about one window to the current outputs
607: *
608: * Return value: none
609: \***************************************************************************/
610: void DumpOneWindowInfo()
611: {
612: HWND hwndPoint;
613: HWND hwndT;
614: SHORT wLevel;
615:
616: hwndPoint = HwndSelWinWithMouse(hwndSpy, NULL, FALSE);
617: if (hwndPoint == NULL)
618: return; /* No window selected */
619:
620: /* Now see what level the window is at */
621: wLevel = 0;
622: hwndT = hwndPoint;
623: while (hwndT != NULL) {
624: wLevel++;
625: hwndT = WinQueryWindow(hwndT, QW_PARENT, FALSE);
626: };
627:
628:
629: DumpWindowInfo(hwndPoint, wLevel);
630: }
631:
632:
633: /**************************** Private Function ******************************\
634: * DumpAllWIndowsInfo (HWND hwnd, WORD wLevel)
635: *
636: * Effects: Dumps the complet window list out to the current output units.
637: *
638: *
639: * Return value:
640: \***************************************************************************/
641: SHORT DumpAllWindowsInfo(hwnd, wLevel)
642: HWND hwnd;
643: SHORT wLevel;
644: {
645: HWND hwndT;
646: SPWD *pspwdT;
647: SHORT cWindowBytes;
648:
649: pspwdT = pspwd + wDumpCount;
650:
651: cWindowBytes = DumpWindowInfo(hwnd, wLevel);
652:
653: pspwdT->hwnd = hwnd;
654: pspwdT->index = wDumpCount;
655:
656:
657: /*
658: * Then we recurse with all of our children
659: */
660: if ((hwndT = WinQueryWindow(hwnd, QW_TOP, FALSE)) != NULL)
661: cWindowBytes += DumpAllWindowsInfo(hwndT, wLevel+1);
662:
663: /*
664: * Then go to our next sibling
665: */
666: if ((hwndT = WinQueryWindow(hwnd, QW_NEXT, FALSE)) != NULL)
667: cWindowBytes += DumpAllWindowsInfo(hwndT, wLevel);
668:
669: return (cWindowBytes);
670: }
671:
672:
673:
674: /**************************** Private Function ******************************\
675: * DumpWindowIndex (void)
676: *
677: * Effects: Dump a sorted list of Hwnds and index into other list
678: * This function works like sh.t
679: *
680: *
681: * Return value:
682: \***************************************************************************/
683: void DumpWindowIndex(cBytes)
684: SHORT cBytes;
685: {
686: SHORT cch;
687: char szTemp[20];
688: char szOutput[100];
689: SPWD *pspwdT;
690: SHORT i;
691:
692: /* Sort the hwnds first */
693: qsort((void *)pspwd, wDumpCount, sizeof(SPWD), CompareHwnds);
694: pspwdT = pspwd;
695:
696: strcpy (szOutput, "Index of Window Handles");
697: cch = strlen(szOutput);
698: for (i=0; i< wDumpCount; i++) {
699: if ((i & 3) == 0) {
700: /* 4 per row */
701: OutputString(szOutput, cch);
702: szOutput[0] = '\0';
703: cch = 0;
704: }
705:
706: cch += sprintf(szTemp, "%3d-%04x ",
707: pspwdT->index, (USHORT)pspwdT->hwnd);
708: strcat (szOutput, szTemp);
709: pspwdT++;
710: }
711:
712: OutputString(szOutput, cch);
713:
714: cch = sprintf(szOutput, "Number of Windows: %d, Approx heap size: %d",
715: wDumpCount, cBytes);
716: OutputString(szOutput, cch);
717:
718:
719: }
720:
721:
722: /**************************** Private Function ******************************\
723: * int CompareHwnds(SPWD *pspwd1, SPWD *pspwd2)
724: *
725: * Effects: Compares two window handles.
726: *
727: *
728: * Return value:
729: \***************************************************************************/
730: int _cdecl CompareHwnds(pspwd1, pspwd2)
731: const void *pspwd1;
732: const void *pspwd2;
733: {
734: return (((SPWD *)pspwd1)->hwnd < ((SPWD *)pspwd2)->hwnd)? -1 : 1;
735: }
736:
737:
738:
739:
740: /**************************** Private Function *****************************\
741: * DumpWindowInfo(HWND hwnd, SHORT wLevel)
742: *
743: * Effects: Displays the information about the selected window in the dialog
744: *
745: *
746: * Return value:
747: \***************************************************************************/
748: SHORT DumpWindowInfo(hwnd, wLevel)
749: HWND hwnd;
750: SHORT wLevel;
751: {
752: HWND hwndParent;
753: HWND hwndChild;
754: HWND hwndOwner;
755:
756: char szTemp[128];
757: char szTemp2[20];
758: SHORT cch;
759: char szClass[30];
760: RECTL rcl;
761: USHORT id;
762: ULONG ulStyle;
763: ULONG ulPFNWP;
764: ULONG ulHMQ;
765: SHORT wOffsetClassData;
766: SHORT wWindowWord;
767: PID pidWindow;
768: TID tidWindow;
769:
770: CLASSINFO classinfo;
771:
772: hwndParent = WinQueryWindow(hwnd, QW_PARENT, FALSE);
773: hwndChild = WinQueryWindow(hwnd, QW_TOP, FALSE);
774: hwndOwner = WinQueryWindow(hwnd, QW_OWNER, FALSE);
775: id = (USHORT)WinQueryWindowUShort(hwnd, QWS_ID);
776:
777: cch = sprintf(szTemp,
778: "%d-H:%p(%d) P:%p C:%p O:%p ID:%04x",
779: ++wDumpCount, hwnd, wLevel, hwndParent,
780: hwndChild, hwndOwner, id);
781:
782: OutputString(szTemp, cch);
783:
784: ulHMQ = (ULONG)WinQueryWindowULong(hwnd, QWL_HMQ);
785: WinQueryWindowRect(hwnd, &rcl);
786: WinMapWindowPoints(hwnd, hwndParent, (PPOINTL)&rcl, 2);
787: ulStyle = (ULONG)WinQueryWindowULong(hwnd, QWL_STYLE);
788:
789: cch = sprintf(szTemp,
790: " MQ:%p St:%08lx Rect: (%d, %d) (%d, %d)",
791: ulHMQ, ulStyle,
792: (SHORT)rcl.xLeft, (SHORT)rcl.yBottom,
793: (SHORT)rcl.xRight, (SHORT)rcl.yTop);
794: OutputString(szTemp, cch);
795:
796: ulPFNWP = (ULONG)WinQueryWindowULong(hwnd, QWP_PFNWP);
797: WinQueryClassName(hwnd, sizeof(szClass), (PSZ)szClass);
798: if (!WinQueryClassInfo(hab, (PSZ)szClass, &classinfo)) {
799: classinfo.flClassStyle = -1; /* Let know error conditon */
800: classinfo.cbWindowData = 0; /* Make sure we dont dump */
801: }
802:
803: WinQueryWindowProcess(hwnd, &pidWindow, &tidWindow);
804:
805: cch = sprintf(szTemp,
806: " PID:%d TID:%d Pfn:%p Cl:%s",
807: ulStyle, pidWindow, tidWindow, ulPFNWP, szClass);
808: OutputString(szTemp, cch);
809:
810: /*
811: * Dump the window extra words out also.
812: */
813: strcpy (szTemp, " ");
814: id = 8;
815: for (wOffsetClassData = 0; wOffsetClassData < classinfo.cbWindowData;
816: wOffsetClassData += 2) {
817:
818: wWindowWord = (USHORT)WinQueryWindowUShort(hwnd, wOffsetClassData);
819: sprintf(szTemp2, "%04x ", wWindowWord);
820: strcat(szTemp, szTemp2);
821: if (--id == 0) {
822: /* line full is full */
823: OutputString(szTemp, strlen(szTemp));
824: szTemp[10] = '\0';
825: id = 8;
826: }
827: }
828:
829: if (id != 8)
830: OutputString(szTemp, strlen(szTemp));
831:
832: /* Return the number of bytes associated with the window */
833: return ((SIZEOFWND + classinfo.cbWindowData + 3) & 0xfffc);
834: }
835:
836:
837: /**************************** Public Function ******************************\
838: * DumpFrameAcclTable()
839: *
840: * Effects: Dump the information about one window to the current outputs
841: *
842: * Return value: none
843: \***************************************************************************/
844: void DumpFrameAcclTable()
845: {
846: HWND hwndPoint;
847: HACCEL haccel;
848: ACCELTABLE *npAcclTbl;
849: SHORT cbAccel;
850: char szTemp[100];
851: char szFS[100];
852: SHORT cch;
853: ACCEL *npAccel;
854: PID pidHwnd;
855: TID tidHwnd;
856: PPIB ppib;
857: PTIB ptib;
858: SHORT i;
859: SHORT j;
860: char szChar[2];
861: char *pszChar;
862:
863: hwndPoint = HwndSelWinWithMouse(hwndSpy, NULL, TRUE);
864: if (hwndPoint == NULL)
865: return;
866:
867: // Now lets get the accel table for the frame window
868: haccel = WinQueryAccelTable(hab, hwndPoint);
869: if (haccel == NULL)
870: return;
871:
872: WinQueryWindowProcess(hwndPoint, &pidHwnd, &tidHwnd);
873: DosGetThreadInfo(&ptib, &ppib);
874: if (ppib->pib_ulpid == pidHwnd) {
875: // It is in our own process, so do it local
876: // Allocate memory for the Accel table. If over 4K to much anyway!
877: cbAccel = WinCopyAccelTable(haccel, (PACCELTABLE)NULL, 0);
878: npAcclTbl = (ACCELTABLE *)WinAllocMem(hHeap, cbAccel);
879: if (npAcclTbl == NULL)
880: return;
881: WinCopyAccelTable(haccel, npAcclTbl, cbAccel);
882: } else {
883: // Let the hook do it for us
884: /* Lets use the hook */
885: SpySetPIDIntercept(pidHwnd, PIT_ACCEL, (ULONG)haccel);
886:
887: /* HACK: Send message to frame known to send another message */
888: WinSendMsg(hwndPoint, WM_QUERYTASKFOCUS, 0L, 0L);
889:
890: // Ask for size
891: cbAccel = SpyGetPIDInterceptData(NULL, 0, NULL);
892: npAcclTbl = (ACCELTABLE *)WinAllocMem(hHeap, cbAccel);
893: if (npAcclTbl == NULL)
894: return;
895: SpyGetPIDInterceptData((char *)npAcclTbl, cbAccel, NULL);
896: }
897:
898: // Now Dump the Accel table header
899: cch = sprintf(szTemp,"HACCEL:%p for HWND:%p CP:%d CNT:%d",
900: haccel, hwndPoint, npAcclTbl->codepage, npAcclTbl->cAccel);
901: OutputString(szTemp, cch);
902:
903: // Now dump each of the items
904: npAccel = npAcclTbl->aaccel;
905: szChar[1] = '\0'; // Make it NULL TERMINATED
906: for (i=npAcclTbl->cAccel; i > 0; i--) {
907: pszChar = szChar;
908: if (npAccel->fs & AF_CHAR) {
909: if ((npAccel->key >= ' ') && (npAccel->key <= '~'))
910: szChar[0] = (char)npAccel->key;
911: else
912: szChar[0] = ' ';
913: } else if (npAccel->fs & AF_VIRTUALKEY) {
914: if ((npAccel->key >= ivktosMin) && (npAccel->key < cvktos))
915: pszChar = avktos[npAccel->key].szVkey;
916: else
917: szChar[0] = ' ';
918: }
919: szFS[0] = '\0';
920: for (j=0; j < caftos; j++) {
921: if (npAccel->fs & aaftos[j].usBit)
922: strcat(szFS, aaftos[j].szBit);
923: }
924:
925: cch=sprintf(szTemp, " fs:%x key:%x(%s) cmd:%x - %s",
926: npAccel->fs, npAccel->key, pszChar, npAccel->cmd, szFS);
927: OutputString(szTemp, cch);
928: npAccel++;
929: }
930:
931: // And free the memory we allocated
932: WinFreeMem(hHeap, (NPBYTE)npAcclTbl, cbAccel);
933: }
934:
935:
936: /**************************** Public Function ******************************\
937: * SelOrDeselWithMouse(BOOL fSelect)
938: *
939: * Effects: Fastway to add/or remove window from watch list
940: *
941: * Return value: none
942: \***************************************************************************/
943:
944: void SelOrDeselWithMouse(fSelect)
945: BOOL fSelect;
946: {
947: HWND rghwnd[MAXHWNDS];
948: HWND hwndPoint;
949: SHORT chwnd;
950: BOOL fWinCurInList;
951: SHORT i;
952:
953: /* First get the window of interest */
954: hwndPoint = HwndSelWinWithMouse(hwndSpy, NULL, FALSE);
955: if (hwndPoint == NULL)
956: return; /* No window selected */
957: fWinCurInList = SpyFWindowInList(hwndPoint, TRUE);
958:
959: if ((fWinCurInList && fSelect)
960: || (!fWinCurInList && !fSelect))
961: return; /* Alredy right state */
962:
963: chwnd = SpyGetWindowList(MAXHWNDS, (HWND FAR *)rghwnd);
964:
965: if (fSelect) {
966: /* Add window to end of list */
967: rghwnd[chwnd++] = hwndPoint;
968: } else {
969: /* find it in the list, and delete it out */
970: for (i=0; rghwnd[i] != hwndPoint; i++)
971: ;
972:
973: /* Now copy rest of them down */
974: chwnd--; /* One less item */
975: for (;i < chwnd; i++ ) {
976: rghwnd[i] = rghwnd[i+1];
977: }
978: }
979:
980: /* Now call to update the list */
981: SpySetWindowList(chwnd, (HWND FAR *)rghwnd);
982: }
983:
984:
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.