![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to queues.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [OS/2 SDKs] / pmsdk / samples / spy|
Return to queues.c CVS log | Up to [OS/2 SDKs] / pmsdk / samples / spy |
1.1 root 1: /***************************************************************************\
2: * queues.c - Spy code to manager the queue list dialog
3: *
4: * Created by Microsoft Corporation, 1989
5: \***************************************************************************/
6:
7: #define INCL_WINDIALOGS
8: #define INCL_WINHEAP
9: #define INCL_WININPUT
10: #define INCL_WINLISTBOXES
11: #define INCL_WINMESSAGEMGR
12: #define INCL_WINPOINTERS /* needed for spy.h */
13: #define INCL_WINWINDOWMGR
14: #include <os2.h>
15: #include <spyhook.h>
16: #include <stdio.h>
17: #include <stdlib.h>
18: #include <string.h>
19: #include <time.h>
20: #include "spy.h"
21:
22: #define SIZEOFWND 34
23: #define MAXMSGBYTES 100
24:
25: /* File Global Variables */
26: HMQ hmqDlgDisp;
27: SHORT chmqWatched = 0;
28: SHORT chmqInList = 0;
29:
30:
31:
32: /* Function Prototypes */
33: MRESULT CALLBACK SpyQueuesDlgProc(HWND, USHORT, MPARAM, MPARAM);
34:
35: void InitQueueList(VOID);
36: void DisplayQueueInfoForWindow(HWND, HWND);
37: void DisplayQueueInfo(HWND, HMQ);
38: void SelectQueueFromText(HWND hwndDlg);
39: void BuildQueueWatchList(void);
40:
41:
42:
43: /***************************************************************************\
44: * MRESULT CALLBACK SpyQueuesDlgProc(hwnd, msg, mp1, mp2)
45: *
46: * The Spy Windows Dialog procedure
47: \***************************************************************************/
48: MRESULT CALLBACK SpyQueuesDlgProc(hwnd, msg, mp1, mp2)
49: HWND hwnd;
50: USHORT msg;
51: MPARAM mp1;
52: MPARAM mp2;
53: {
54: BOOL fSelect = TRUE;
55: SHORT cQueues;
56: HWND hwndPoint;
57: HMQ hmqDisp;
58: HMQ hmqItem; /* from handle of list item */
59: USHORT iItemFocus; /* Index to item that has the focus */
60:
61: switch (msg) {
62:
63: case WM_INITDLG:
64: /* Initialize the dialog items */
65: hwndWindowLB = WinWindowFromID(hwnd, DID_WINDOWLIST);
66: InitQueueList();
67: hmqDlgDisp = NULL;
68: fTrackingListBox = TRUE;
69: break;
70:
71: case WM_CHAR:
72: /*
73: * Handle VK_ENTER and VK_NEWLINE if our Edit control has
74: * the focus and it is a keydown
75: */
76: if (!(SHORT1FROMMP(mp1) & KC_KEYUP) &&
77: (SHORT1FROMMP(mp1) & KC_VIRTUALKEY) &&
78: ( (SHORT2FROMMP(mp2) == VK_ENTER) ||
79: (SHORT2FROMMP(mp2) == VK_NEWLINE) )) {
80:
81:
82: if (WinQueryFocus(HWND_DESKTOP, FALSE) ==
83: WinWindowFromID(hwnd, DID_WHANDLE)) {
84: SelectQueueFromText(hwnd);
85: break;
86: }
87: }
88:
89: /* Normaly pass to dialog procedure to handle message */
90: return(WinDefDlgProc(hwnd, msg, mp1, mp2));
91: break;
92:
93: case WM_COMMAND:
94: switch (SHORT1FROMMP(mp1)) {
95: case DID_OK:
96: BuildQueueWatchList();
97:
98: case DID_CANCEL:
99: /* Now dismiss the dialog */
100: WinDismissDlg(hwnd, SHORT1FROMMP(mp1));
101: break;
102: case DID_WUNSELALL:
103: fSelect = FALSE;
104: case DID_WSELALL:
105: cQueues = (SHORT) WinSendMsg(hwndWindowLB, LM_QUERYITEMCOUNT,
106: 0L, 0L);
107:
108: fTrackingListBox = FALSE;
109: while (cQueues) {
110: /* Loop through all windows, selecting or unselcting all */
111: WinSendMsg(hwndWindowLB, LM_SELECTITEM, (MPARAM)--cQueues,
112: (MPARAM)fSelect);
113: }
114: fTrackingListBox = TRUE;
115: break;
116:
117: case DID_WSELMOUSE:
118: /* Call function to track mouse, returns window handle */
119: hwndPoint = HwndSelWinWithMouse(hwnd, DisplayQueueInfoForWindow);
120: if (hwndPoint == NULL)
121: break; /* No window to process */
122:
123: /*
124: * Now find the window in the list, Make the item visible
125: * and set the item as selected.
126: */
127: hmqDisp = (HMQ)WinQueryWindowULong(hwndPoint, QWL_HMQ);
128: cQueues = (SHORT) WinSendMsg(hwndWindowLB, LM_QUERYITEMCOUNT,
129: 0L, 0L);
130:
131: while (cQueues) {
132: /*
133: * Loop through all windows until we wind the right
134: * one with the correct window handle
135: */
136: hmqItem = (HMQ)WinSendMsg(hwndWindowLB, LM_QUERYITEMHANDLE,
137: (MPARAM)--cQueues, 0L);
138:
139: if (hmqItem == hmqDisp) {
140: /* found the right item, move it to top */
141: WinSendMsg(hwndWindowLB, LM_SETTOPINDEX, (MPARAM)cQueues, 0L);
142: WinSendMsg(hwndWindowLB, LM_SELECTITEM, (MPARAM)cQueues,
143: (MPARAM)TRUE);
144: break;
145: }
146: }
147: break;
148: }
149: break;
150:
151:
152: default:
153: /*
154: * Default is to see if the listbox has changed its focus
155: * item number. If it has, then we want to display the information
156: * about the window that the listbox cursor is over. There is no
157: * legal way to do this, One approach appears to temporary set the
158: * listbox to be a single selection listbox, then query its selection
159: * and set it back into multiple selection mode.
160: */
161: if (fTrackingListBox && hwndWindowLB != NULL) {
162:
163: WinSetWindowBits(hwndWindowLB, QWL_STYLE, 0L, LS_MULTIPLESEL);
164: iItemFocus = (USHORT)WinSendMsg(hwndWindowLB, LM_QUERYSELECTION,
165: (MPARAM)LIT_FIRST, 0L);
166: WinSetWindowBits(hwndWindowLB, QWL_STYLE, LS_MULTIPLESEL,
167: LS_MULTIPLESEL);
168:
169: if (iItemFocus != iCurItemFocus) {
170: iCurItemFocus = iItemFocus;
171: if (iItemFocus != (USHORT)-1) {
172:
173: hmqDisp = (HMQ)WinSendMsg(hwndWindowLB, LM_QUERYITEMHANDLE,
174: (MPARAM)iItemFocus, 0L);
175: DisplayQueueInfo(hwnd, hmqDisp);
176: }
177: }
178: }
179: return(WinDefDlgProc(hwnd, msg, mp1, mp2));
180: }
181: return 0L;
182: }
183:
184:
185:
186:
187: /****************************************************************************\
188: * InitQueueList ()
189: *
190: * Builds the list of Queues displayed in the queues dialog
191: \***************************************************************************/
192: void InitQueueList()
193: {
194: HENUM henum;
195: char szClassName[50]; /* Class name of window */
196: HWND hwnd;
197: ULONG ulHMQ;
198: PID pidWindow;
199: TID tidWindow;
200: SHORT item;
201: HMQ *ahmqWatched;
202: HMQ *phmqT;
203: SHORT chmqAlloc;
204: SHORT i;
205:
206: /*
207: * We will enumerate through all of the OBJECT windows looking for
208: * windows that have the WC_QUEUE type.
209: */
210: if (chmqWatched > 0) {
211: ahmqWatched = (HMQ *)WinAllocMem(hHeap, sizeof(HMQ) * chmqWatched);
212: chmqAlloc = chmqWatched;
213: if (ahmqWatched != NULL)
214: chmqWatched = SpyGetQueueList(chmqWatched, ahmqWatched);
215: } else
216: ahmqWatched = NULL;
217:
218: henum = WinBeginEnumWindows(HWND_OBJECT);
219: if (henum == NULL)
220: return;
221:
222: chmqInList = 0;
223: while ((hwnd = WinGetNextWindow(henum)) != NULL) {
224: WinLockWindow(hwnd, FALSE);
225: WinQueryClassName(hwnd, sizeof(szClassName),
226: (PSZ)szClassName);
227:
228: if (strcmp(szClassName, "#32767") == 0) {
229: /*
230: * We found an HMQ, add it to our list, Do not add our own
231: * HMQ to the list!.
232: */
233: ulHMQ = (ULONG)WinQueryWindowULong(hwnd, QWL_HMQ);
234: if ((HMQ)ulHMQ != hmqSpy) {
235: WinQueryWindowProcess(hwnd, &pidWindow, &tidWindow);
236:
237: /* Reuse szClassName */
238: sprintf(szClassName, "0x%04x (PID:%d TID:%d)",
239: (USHORT)ulHMQ, (SHORT)pidWindow, (SHORT)tidWindow);
240:
241: item = (USHORT)WinSendMsg(hwndWindowLB, LM_INSERTITEM,
242: (MPARAM)LIT_END, (MPARAM)(PSZ)szClassName);
243:
244: /* Set the item handle to the handle of the window */
245: WinSendMsg(hwndWindowLB, LM_SETITEMHANDLE, (MPARAM)item,
246: (MPARAM)ulHMQ);
247: chmqInList++;
248:
249: /*
250: * Now see if we should select the item
251: */
252: if (phmqT = ahmqWatched) {
253: for (i = 0; i < chmqWatched; i++) {
254: if ((HMQ)ulHMQ == *phmqT++) {
255: WinSendMsg(hwndWindowLB, LM_SELECTITEM, (MPARAM)item,
256: (MPARAM)TRUE);
257: break;
258: }
259: }
260: }
261: }
262: }
263:
264: }
265:
266: WinEndEnumWindows(henum);
267:
268: if (ahmqWatched)
269: WinFreeMem(hHeap, (char *)ahmqWatched, chmqAlloc * sizeof(HMQ));
270: }
271:
272:
273:
274: /***************************************************************************\
275: * DisplayQueueInfoForWindow(HWND hwndDialog, HWND hwnd)
276: *
277: * Displays the information about the selected window in the dialog
278: \***************************************************************************/
279: void DisplayQueueInfoForWindow(hwndDlg, hwndDisp)
280: HWND hwndDlg;
281: HWND hwndDisp;
282: {
283: HMQ hmqDisp;
284:
285: /* simply get the HMQ for the window and call display function */
286: hmqDisp = (HMQ)WinQueryWindowULong(hwndDisp, QWL_HMQ);
287: DisplayQueueInfo(hwndDlg, hmqDisp);
288: }
289:
290:
291:
292:
293: /***************************************************************************\
294: * DisplayQueueInfo(HWND hwndDialog, HWND hwnd)
295: *
296: * Displays the information about the selected window in the dialog
297: \***************************************************************************/
298: void DisplayQueueInfo(hwndDlg, hmqDisp)
299: HWND hwndDlg;
300: HMQ hmqDisp;
301: {
302: HWND hwnd;
303: HMQ hmqWindow;
304: HENUM henum;
305: char szTemp[50];
306: PID pidWindow;
307: TID tidWindow;
308:
309:
310: if (hmqDisp != hmqDlgDisp)
311: {
312: hmqDlgDisp = hmqDisp;
313:
314: /*
315: * See if we can find a top level window for this HMQ
316: */
317: henum = WinBeginEnumWindows(HWND_DESKTOP);
318: if (henum == NULL)
319: return;
320:
321: while ((hwnd = WinGetNextWindow(henum)) != NULL) {
322: WinLockWindow(hwnd, FALSE);
323: hmqWindow = (HMQ)WinQueryWindowULong(hwnd, QWL_HMQ);
324:
325: if (hmqWindow == hmqDisp)
326: break;
327: }
328: WinEndEnumWindows(henum);
329:
330:
331: if (hwnd == NULL) {
332: /*
333: * No top level windows found look for object window.
334: */
335: henum = WinBeginEnumWindows(HWND_OBJECT);
336: if (henum == NULL)
337: return;
338:
339: while ((hwnd = WinGetNextWindow(henum)) != NULL) {
340: WinLockWindow(hwnd, FALSE);
341: hmqWindow = (HMQ)WinQueryWindowULong(hwnd, QWL_HMQ);
342:
343: if (hmqWindow == hmqDisp)
344: break;
345: }
346: WinEndEnumWindows(henum);
347: if (hwnd == NULL)
348: return;
349: }
350:
351: /* output information to window now */
352: sprintf(szTemp, "0x%04x", (SHORT)hmqDisp);
353: WinSetDlgItemText(hwndDlg, DID_WHMQ, (PSZ)szTemp);
354:
355: sprintf(szTemp, "0x%04x", (SHORT)hwnd);
356: WinSetDlgItemText(hwndDlg, DID_WHANDLE, (PSZ)szTemp);
357:
358: /*
359: * Warning, we only query the text if the window is not an object
360: * window. If it is an object window, the message queue may not
361: * be processing messages, which could hang us
362: */
363: if (WinIsChild(hwnd, HWND_OBJECT))
364: szTemp[0] = '\0'; /* No text available */
365: else
366: WinQueryWindowText(hwnd, sizeof(szTemp), (PSZ)szTemp);
367: WinSetDlgItemText(hwndDlg, DID_WTEXT, (PSZ)szTemp);
368:
369: WinQueryWindowProcess(hwnd, &pidWindow, &tidWindow);
370: sprintf(szTemp, "%d", (SHORT)pidWindow);
371: WinSetDlgItemText(hwndDlg, DID_WPID, (PSZ)szTemp);
372: sprintf(szTemp, "%d", (SHORT)tidWindow);
373: WinSetDlgItemText(hwndDlg, DID_WTID, (PSZ)szTemp);
374: }
375: }
376:
377:
378:
379: /***************************************************************************\
380: * void SelectQueueFromText(hwndDlg)
381: *
382: * Updates the text that is displayed in the message text line
383: \***************************************************************************/
384: void SelectQueueFromText(hwndDlg)
385: HWND hwndDlg;
386: {
387: char szTemp[80];
388: HMQ hmqSelect;
389: SHORT cItems;
390: SHORT i;
391:
392:
393: /* First get the edit text from the string */
394: WinQueryDlgItemText(hwndDlg, DID_WHANDLE, sizeof(szTemp),
395: (PSZ)szTemp);
396:
397: hmqSelect = (HMQ)UConvertStringToNum(szTemp);
398:
399: cItems = (SHORT)WinSendMsg(hwndWindowLB, LM_QUERYITEMCOUNT,
400: 0L, 0L);
401:
402: for (i=0; i < cItems; i++) {
403: if ((HMQ)WinSendMsg(hwndWindowLB, LM_QUERYITEMHANDLE,
404: (MPARAM)i, 0L) == hmqSelect)
405: break; /* found it */
406: }
407:
408: if (i < cItems) {
409: /*
410: * found the hmq, bring to top, and select it
411: */
412: WinSendMsg(hwndWindowLB, LM_SETTOPINDEX,
413: MPFROMSHORT(i), (MPARAM)0L);
414:
415: /* Always set it on */
416: WinSendMsg(hwndWindowLB, LM_SELECTITEM,
417: MPFROMSHORT(i), MPFROMSHORT(TRUE));
418:
419: } else {
420: WinAlarm(HWND_DESKTOP, WA_WARNING);
421: WinSetDlgItemText(hwndDlg, DID_WHANDLE, (PSZ)"");
422: }
423:
424: }
425:
426:
427:
428:
429: /***************************************************************************\
430: * BuildQueueWatchList()
431: *
432: * Updates the list of windows to be watched from the listbox
433: \***************************************************************************/
434: void BuildQueueWatchList(void)
435: {
436:
437: USHORT itemPrevious;
438: USHORT item;
439:
440: HMQ *ahmqList;
441: HMQ *phmqT;
442:
443:
444: ahmqList = (HMQ *)WinAllocMem(hHeap, sizeof(HMQ) * chmqInList);
445: if ((phmqT = ahmqList) == NULL)
446: return; /* Error */
447:
448:
449: /*
450: * Simply loop through asking for the next selected item in the
451: * list. Make sure not to overrun our list.
452: */
453: itemPrevious = (USHORT)LIT_FIRST;
454: chmqWatched = 0;
455:
456: while ((item = (USHORT)WinSendMsg(hwndWindowLB, LM_QUERYSELECTION,
457: (MPARAM)itemPrevious, 0L)) != (USHORT)LIT_NONE) {
458: /*
459: * Get the items handle, which has the value of the window handle
460: */
461: *phmqT++ = (HMQ)WinSendMsg(hwndWindowLB, LM_QUERYITEMHANDLE,
462: (MPARAM)item, 0L);
463: chmqWatched++;
464:
465: itemPrevious = item; /* Where to cointinue the search */
466: }
467:
468: SpySetQueueList (chmqWatched, ahmqList);
469:
470: WinFreeMem(hHeap, (char *)ahmqList, sizeof(HMQ) * chmqInList);
471: }
472:
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.