![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to spy.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 spy.c CVS log | Up to [OS/2 SDKs] / os232sdk / toolkt20 / c / samples / spy |
1.1 ! root 1: /****************************** Module Header ******************************\ ! 2: * Module Name: spy.c - Spy application ! 3: * ! 4: * Created: Microsoft, IBM Corporation 1990 ! 5: * ! 6: * DISCLAIMER OF WARRANTIES. The following [enclosed] code is ! 7: * sample code created by Microsoft Corporation and/or IBM ! 8: * Corporation. This sample code is not part of any standard ! 9: * Microsoft or IBM product and is provided to you solely for ! 10: * the purpose of assisting you in the development of your ! 11: * applications. The code is provided "AS IS", without ! 12: * warranty of any kind. Neither Microsoft nor IBM shall be ! 13: * liable for any damages arising out of your use of the sample ! 14: * code, even if they have been advised of the possibility of ! 15: * such damages. ! 16: * ! 17: \***************************************************************************/ ! 18: ! 19: #define INCL_WIN ! 20: #define INCL_WINSYS ! 21: #define INCL_DOSPROCESS ! 22: #define INCL_DOSSEMAPHORES ! 23: #define INCL_DOSMODULEMGR ! 24: #define INCL_DOSRESOURCES ! 25: #define INCL_HELP ! 26: #include <os2.h> ! 27: #include <stdio.h> ! 28: #include <string.h> ! 29: #include "spy.h" ! 30: #include "spyhk32.h" ! 31: #include "help.h" ! 32: #include <time.h> ! 33: #include <stdlib.h> ! 34: ! 35: ! 36: /************* GLOBAL VARIABLES */ ! 37: ! 38: /************************** IN SPY.H *********************************** */ ! 39: HAB hab; ! 40: HMQ hmqSpy; ! 41: HWND hwndSpy; ! 42: HWND hwndSpyFrame; ! 43: HWND hwndSpyList = NULL; ! 44: HWND hwndWindowLB; ! 45: HWND hwndMessageLB; ! 46: HWND hwndHelpInstance = NULL; ! 47: HHEAP hHeap; ! 48: SHORT cxBorder; ! 49: SHORT cyBorder; ! 50: ULONG uVersion; ! 51: BOOL fV11 = TRUE; // Are we version 1.1? ! 52: ! 53: HPOINTER hptrArrow; ! 54: HPOINTER hptrSelWin; ! 55: HPOINTER hptrIcon11 = NULL; /* 1.1 Spy Icon */ ! 56: ! 57: BOOL fDebug = FALSE; ! 58: USHORT iCurItemFocus; /* Index to item that has the focus */ ! 59: BOOL fSpyActive = MIA_CHECKED; /* Any non-zero is true */ ! 60: BOOL fTrackingListBox = FALSE; /* Tracking windows active ? */ ! 61: BOOL fAllFrames = 0; /* Are we processing all frames ? */ ! 62: BOOL fAllWindows = 0; /* Are we processing all windows ? */ ! 63: ! 64: ! 65: HWND hwndWinDlgDisp = NULL; /* hwnds info in Window Dialog */ ! 66: ! 67: SHORT wDumpCount = 0; /* Count of which window is being dumped */ ! 68: SPWD *pspwd = NULL; ! 69: /*********************************************************************** */ ! 70: ! 71: /* Define memory semaphore to have second thread sleep on */ ! 72: HEV hevThread; /* Event semaphore to wait on */ ! 73: UCHAR rgMsgData[MAXMSGBYTES]; /* Max bytes to extract per message */ ! 74: ! 75: ! 76: char szSpyClass[] = "Spy"; ! 77: char szTitle[] = "32-bit spy sample"; ! 78: ! 79: /************* PROCEDURE DECLARATIONS */ ! 80: ! 81: ! 82: ! 83: void ProcHookThread(void); /* will process the hook messages */ ! 84: ! 85: void ProcessQueueMsg(QMSGSPY *); ! 86: void UpdateMsgBoxCurMsgText(HWND); ! 87: void InitializeOptions(int, char **); /* initialize Spy initial state */ ! 88: void InitializeMenus(void); ! 89: void InitializeHelp(void); ! 90: void DebugBreak(void); ! 91: ! 92: PSZ DumpParam(PSZ prgData, SHORT cb, BOOL fValidData, ! 93: UCHAR bMPType); ! 94: ! 95: /* Define some variables needed for help processing */ ! 96: ! 97: ! 98: /**************************** Public Function ******************************\ ! 99: * int cdecl main (argc, argv) ! 100: * ! 101: * Effects: Spy Main function ! 102: * ! 103: * Return value: ! 104: \***************************************************************************/ ! 105: int main(argc, argv) ! 106: int argc; ! 107: char **argv; ! 108: { ! 109: ULONG flCreateFlags; ! 110: QMSG qmsg; ! 111: RECTL rcl; ! 112: TID tid; ! 113: ! 114: ! 115: // Make sure the Spy Hook DLL is initialized ! 116: SpyInitializeHook(); ! 117: ! 118: hab = WinInitialize(0); ! 119: uVersion = WinQueryVersion(hab); ! 120: if ((LOBYTE(LOUSHORT(uVersion)) > 10) || ! 121: (HIBYTE(LOUSHORT(uVersion)) > 10)) ! 122: fV11 = FALSE; ! 123: ! 124: hmqSpy = WinCreateMsgQueue(hab, 0); ! 125: ! 126: if (!WinRegisterClass((HAB)NULL, szSpyClass, (PFNWP)SpyWndProc, ! 127: CS_SYNCPAINT, 0)) { ! 128: WinAlarm(HWND_DESKTOP, WA_ERROR); ! 129: return(0); ! 130: } ! 131: ! 132: /* ! 133: * We need to process the options, before we create a heap, or we ! 134: * will blow away our options ! 135: */ ! 136: InitializeOptions(argc, argv); /* initialize Spy initial state */ ! 137: ! 138: /* ! 139: * Create a heap for the program ! 140: */ ! 141: hHeap = WinCreateHeap(0, 0, 0, 0, 0, 0); ! 142: ! 143: hptrArrow = WinQuerySysPointer(HWND_DESKTOP, SPTR_ARROW, TRUE); ! 144: cxBorder = (SHORT)WinQuerySysValue(HWND_DESKTOP, SV_CXBORDER); ! 145: cyBorder = (SHORT)WinQuerySysValue(HWND_DESKTOP, SV_CYBORDER); ! 146: ! 147: hptrSelWin = WinQuerySysPointer(HWND_DESKTOP, SPTR_MOVE, TRUE); ! 148: ! 149: SpyInstallHook(hab, hmqSpy, spyopt.bHooks); ! 150: SpySetAllWindowOpt (fAllWindows); ! 151: SpySetAllFrameOpt (fAllFrames); ! 152: ! 153: flCreateFlags = FCF_TITLEBAR | FCF_SYSMENU | FCF_SIZEBORDER ! 154: | FCF_MINMAX | FCF_SHELLPOSITION | FCF_TASKLIST | FCF_MENU ! 155: | FCF_ACCELTABLE | FCF_ICON; ! 156: ! 157: // See if we get here ! 158: hwndSpyFrame = WinCreateStdWindow(HWND_DESKTOP, ! 159: WS_VISIBLE, ! 160: (PULONG)&flCreateFlags, ! 161: (PSZ)szSpyClass, (PSZ)szTitle, ! 162: WS_VISIBLE, ! 163: (HMODULE)NULL, IDR_SPY, ! 164: (PHWND)&hwndSpy); ! 165: ! 166: WinQueryWindowRect(hwndSpy, &rcl); ! 167: hwndSpyList = WinCreateWindow (hwndSpy, WC_LISTBOX, "", ! 168: fV11 ? (WS_VISIBLE | LS_NOADJUSTPOS) : ! 169: (WS_VISIBLE | LS_NOADJUSTPOS | LS_HORZSCROLL), ! 170: -cxBorder, -cyBorder, ! 171: (SHORT)(rcl.xRight - rcl.xLeft) + 2 * cxBorder, ! 172: (SHORT)(rcl.yTop - rcl.yBottom) + 2 * cyBorder, ! 173: hwndSpy, HWND_TOP, DID_SPYLIST, NULL, NULL); ! 174: ! 175: /* ! 176: * Read the os2.ini information if it exists, and set the menu items ! 177: * to correspond to the initial state read from OS2.ini ! 178: */ ! 179: InitializeMenus(); ! 180: InitializeHelp(); ! 181: ! 182: /* ! 183: * Set the focus to the list box. Note: Only call WinSetFocus if ! 184: * our frame is the active window. As we may have been started in ! 185: * the background. If this is the case, we want to set the frames ! 186: * focus save to the listbox, such that it will be the active window ! 187: * when our frame is activated ! 188: */ ! 189: if (WinQueryWindow(HWND_DESKTOP, QW_TOP, FALSE) == hwndSpyFrame) ! 190: WinSetFocus(HWND_DESKTOP, hwndSpyList); ! 191: else ! 192: WinSetWindowULong(hwndSpyFrame, QWL_HWNDFOCUSSAVE, ! 193: (ULONG)hwndSpyList); ! 194: ! 195: ! 196: ! 197: /* Start the thread that will process the messages from the hook */ ! 198: DosCreateEventSem(NULL, &hevThread, 0L, FALSE); ! 199: DosCreateThread((PTID)&tid, ProcHookThread, 0L, 0L, 4096L); ! 200: ! 201: UpdateHooksMsgTable(); /* Set Spys Msg table */ ! 202: SpyHookOnOrOff (TRUE); /* Turn the hook on */ ! 203: ! 204: ! 205: /* ! 206: * Now process all of the messages ! 207: */ ! 208: while (WinGetMsg(NULL, (PQMSG)&qmsg, NULL, 0, 0)) { ! 209: WinDispatchMsg(NULL, (PQMSG)&qmsg); ! 210: } ! 211: ! 212: SpyReleaseHook (TRUE); /* Release input hook */ ! 213: ! 214: WinDestroyWindow(hwndSpyFrame); ! 215: SpyTerminateHook (); ! 216: ! 217: WinDestroyPointer(hptrArrow); ! 218: WinDestroyPointer(hptrSelWin); ! 219: if (hptrIcon11 != NULL) ! 220: WinDestroyPointer (hptrIcon11); ! 221: ! 222: if (hwndHelpInstance != NULL) ! 223: WinDestroyHelpInstance(hwndHelpInstance); ! 224: ! 225: ! 226: WinDestroyMsgQueue(hmqSpy); ! 227: WinTerminate(hab); ! 228: ! 229: /* If the spy output file is open, close it now */ ! 230: if (spyopt.hfileSpy != NULL) ! 231: DosClose(spyopt.hfileSpy); ! 232: ! 233: ! 234: DosExit(EXIT_PROCESS, 0); ! 235: } ! 236: ! 237: ! 238: ! 239: ! 240: /**************************** Public Function ******************************\ ! 241: * InitializeOptions(argc, argv) ! 242: * ! 243: * Effects: Initialize spy, first from the default options, second from ! 244: * OS2.INI file, and override from command switches. ! 245: * ! 246: * Return value: ! 247: \***************************************************************************/ ! 248: VOID InitializeOptions(argc, argv) ! 249: int argc; ! 250: char **argv; ! 251: { ! 252: ULONG cch; ! 253: ! 254: ! 255: /* ! 256: * If the OS2.INI information exists, initialize our options to ! 257: * the stored values ! 258: */ ! 259: if (PrfQueryProfileSize (HINI_USER, "Spy", "Options", &cch) == 0) { ! 260: cch = sizeof(SPYOPT); ! 261: ! 262: PrfQueryProfileData(HINI_USER, "Spy", "Options", (PSZ)&spyopt, ! 263: &cch); ! 264: PrfQueryProfileString(HINI_USER, "Spy", "FileName", "spy.out", ! 265: (PSZ)spystr.szFileName, sizeof(spystr.szFileName)); ! 266: PrfQueryProfileString(HINI_USER, "Spy", "SaveFileName", "spy.lis", ! 267: (PSZ)spystr.szSaveFileName, sizeof(spystr.szSaveFileName)); ! 268: } ! 269: ! 270: /* ! 271: * Then check for command line overrides ! 272: */ ! 273: while (argc > 1) { ! 274: argv++; /* get beyond the program name */ ! 275: ! 276: /* Test for debug flag */ ! 277: if (!strcmpi(*argv, "/d") ) { ! 278: fDebug = TRUE; ! 279: DebugBreak(); ! 280: } ! 281: ! 282: /* Test for send message hook flag */ ! 283: if (!strcmpi(*argv, "+s")) ! 284: spyopt.bHooks |= SPYH_SENDMSG; ! 285: if (!strcmpi(*argv, "-s")) ! 286: spyopt.bHooks &= ~SPYH_SENDMSG; ! 287: ! 288: /* Test for input hook flag */ ! 289: if (!strcmpi(*argv, "+i")) ! 290: spyopt.bHooks |= SPYH_INPUT; ! 291: if (!strcmpi(*argv, "-i")) ! 292: spyopt.bHooks &= ~SPYH_INPUT; ! 293: ! 294: argc--; ! 295: } ! 296: } ! 297: ! 298: ! 299: ! 300: /**************************** Public Function ******************************\ ! 301: * InitializeMenus() ! 302: * ! 303: * Effects: Initialize the menus from the initialized defaults. ! 304: * ! 305: * Return value: ! 306: \***************************************************************************/ ! 307: VOID InitializeMenus() ! 308: { ! 309: HWND hwndMenu; ! 310: USHORT wAction; ! 311: ! 312: /* ! 313: * Now we need to update the menu items to the final ! 314: * state ! 315: */ ! 316: hwndMenu = WinWindowFromID(hwndSpyFrame, FID_MENU); ! 317: ! 318: WinSendMsg(hwndMenu, MM_SETITEMATTR, MPFROM2SHORT(CMD_INPUTHOOK, TRUE), ! 319: MPFROM2SHORT(MIA_CHECKED, ! 320: (spyopt.bHooks & SPYH_INPUT) ? MIA_CHECKED : 0)); ! 321: WinSendMsg(hwndMenu, MM_SETITEMATTR, MPFROM2SHORT(CMD_SENDMSGHOOK, TRUE), ! 322: MPFROM2SHORT(MIA_CHECKED, ! 323: (spyopt.bHooks & SPYH_SENDMSG) ? MIA_CHECKED : 0)); ! 324: ! 325: WinSendMsg(hwndMenu, MM_SETITEMATTR, MPFROM2SHORT(CMD_SENDEXTEND, TRUE), ! 326: MPFROM2SHORT(MIA_CHECKED, ! 327: spyopt.fSendExtend ? MIA_CHECKED : 0)); ! 328: ! 329: WinSendMsg(hwndMenu, MM_SETITEMATTR, MPFROM2SHORT(CMD_OUTSCREEN, TRUE), ! 330: MPFROM2SHORT(MIA_CHECKED, spyopt.fWindow ? MIA_CHECKED : 0)); ! 331: ! 332: WinSendMsg(hwndMenu, MM_SETITEMATTR, MPFROM2SHORT(CMD_OUTTERM, TRUE), ! 333: MPFROM2SHORT(MIA_CHECKED, spyopt.fDebugOutput ? MIA_CHECKED : 0)); ! 334: ! 335: WinSendMsg(hwndMenu, MM_SETITEMATTR, MPFROM2SHORT(CMD_OUTFILE, TRUE), ! 336: MPFROM2SHORT(MIA_CHECKED, spyopt.fFile ? MIA_CHECKED : 0)); ! 337: ! 338: WinSendMsg(hwndMenu, MM_SETITEMATTR, MPFROM2SHORT(CMD_ALPHASORT, TRUE), ! 339: MPFROM2SHORT(MIA_CHECKED, ! 340: spyopt.fAlphaSortMsgList ? MIA_CHECKED : 0)); ! 341: ! 342: /* ! 343: * If the options specify output to file, open the file now ! 344: */ ! 345: if (spyopt.fFile) { ! 346: if (DosOpen((PSZ)spystr.szFileName, &spyopt.hfileSpy, ! 347: (ULONG *)&wAction, 0L, 0, ! 348: 0x0012, 0x00C1, 0L) != 0) ! 349: spyopt.hfileSpy = NULL; /* Failed on open */ ! 350: } ! 351: } ! 352: ! 353: ! 354: ! 355: /**************************** Public Function ******************************\ ! 356: * InitializeHelp ! 357: * ! 358: * Effects: Initialize the help subsubsystem. ! 359: * ! 360: * ! 361: * Return value: ! 362: \***************************************************************************/ ! 363: VOID InitializeHelp() ! 364: { ! 365: ! 366: /* ! 367: * Now initialize Help - First we need to verify that the the help ! 368: * DLL is avaialable, if not, we will not do help processing. ! 369: */ ! 370: HELPINIT hi; ! 371: char szTitle[256]; /* Assume the title is not more than 256 chars */ ! 372: HWND hwndMenu; ! 373: SHORT sMenuIndex; ! 374: ! 375: /* Now try to create the help instance */ ! 376: hi.hmodHelpTableModule = ! 377: hi.hmodAccelActionBarModule = (HMODULE)NULL; ! 378: hi.pszTutorialName = (PSZ)NULL; ! 379: hi.pszHelpLibraryName = "spy32.hlp"; ! 380: hi.idAccelTable = ! 381: hi.idActionBar = 0; ! 382: hi.cb = sizeof(HELPINIT); ! 383: hi.usShowPanelId = CMIC_HIDE_PANEL_ID; ! 384: hi.phtHelpTable = (PHELPTABLE)MAKEULONG(IDR_SPY, 0xffff); ! 385: ! 386: WinQueryWindowText(hwndSpyFrame, sizeof(szTitle), szTitle); ! 387: hi.pszHelpWindowTitle = szTitle; ! 388: ! 389: hwndHelpInstance = WinCreateHelpInstance(hab, &hi); ! 390: if (hwndHelpInstance != NULL) { ! 391: if(!WinAssociateHelpInstance(hwndHelpInstance, hwndSpyFrame) ) { ! 392: WinDestroyHelpInstance(hwndHelpInstance); ! 393: hwndHelpInstance = (HWND)NULL; ! 394: } ! 395: } ! 396: ! 397: if (hwndHelpInstance == NULL) { ! 398: /* Help was not initialized, so gray out help items */ ! 399: hwndMenu = WinWindowFromID(hwndSpyFrame, FID_MENU); ! 400: for (sMenuIndex = CMD_HOWHELP; sMenuIndex <= CMD_HELPINDEX; ! 401: sMenuIndex++) { ! 402: WinSendMsg(hwndMenu, MM_SETITEMATTR, ! 403: MPFROM2SHORT(sMenuIndex, TRUE), ! 404: MPFROM2SHORT(MIA_DISABLED, MIA_DISABLED)); ! 405: } ! 406: } ! 407: } ! 408: ! 409: ! 410: ! 411: /**************************** Public Function ******************************\ ! 412: * MRESULT EXPENTRY SpyWndProc(hwnd, msg, mp1, mp2) ! 413: * ! 414: * Effects: Spy Client window procedure ! 415: * ! 416: * ! 417: * Return value: ! 418: \***************************************************************************/ ! 419: MRESULT EXPENTRY SpyWndProc(hwnd, msg, mp1, mp2) ! 420: HWND hwnd; ! 421: USHORT msg; ! 422: MPARAM mp1; ! 423: MPARAM mp2; ! 424: { ! 425: QMSGSPY qmsgspy; ! 426: VOID SpyPaint(); ! 427: SHORT cBytes; ! 428: ULONG ulAction; ! 429: ! 430: switch (msg) { ! 431: case WM_CREATE: ! 432: /* Set up this global first thing in case we need it elsewhere */ ! 433: hwndSpy = hwnd; ! 434: break; ! 435: ! 436: case WM_SEM2: ! 437: /* ! 438: * Other thread told use there are some messages out there. Loop ! 439: * through and process all of the pending messages, and output ! 440: * the listbox position at the end. Also make sure to flush ! 441: * the file buffer before we go back to sleep. ! 442: */ ! 443: while (SpyGetNextMessage(&qmsgspy, rgMsgData, sizeof(rgMsgData), 0L)) { ! 444: ProcessQueueMsg(&qmsgspy); ! 445: } ! 446: ! 447: if (spyopt.fFile) ! 448: DosBufReset(spyopt.hfileSpy); ! 449: ! 450: DosPostEventSem(hevThread); ! 451: ! 452: break; ! 453: ! 454: case WM_COMMAND: ! 455: switch (SHORT1FROMMP(mp1)) { ! 456: case CMD_ACTIVE: ! 457: ! 458: /* ! 459: * THe active menu item was selected, we will toggle the ! 460: * the selection by setting active to 0 or MIA_CHECKED. ! 461: * Call the hook, and then update the checkmark on the menu ! 462: */ ! 463: fSpyActive ^= MIA_CHECKED; /* Toggle on or off */ ! 464: SpyHookOnOrOff (fSpyActive); ! 465: WinSendMsg(WinWindowFromID(hwndSpyFrame, FID_MENU), ! 466: MM_SETITEMATTR, MPFROM2SHORT(CMD_ACTIVE, TRUE), ! 467: MPFROM2SHORT(MIA_CHECKED, fSpyActive)); ! 468: ! 469: break; ! 470: case CMD_ABOUT: ! 471: WinDlgBox(HWND_DESKTOP, hwnd, (PFNWP)AboutWndProc, NULL, ! 472: IDD_About1Dlg, (PCH)NULL); ! 473: break; ! 474: ! 475: case CMD_EXIT: ! 476: WinPostMsg(NULL, WM_QUIT, 0L, 0L); ! 477: break; ! 478: ! 479: case CMD_CLRWIN: ! 480: /* ! 481: * Delete all items in the list. Simply do this ! 482: * By deleting the first item, until the count goes to ! 483: * zero ! 484: */ ! 485: WinSendMsg(hwndSpyList, LM_DELETEALL, 0L, 0L); ! 486: break; ! 487: ! 488: case CMD_SAVEWIN: ! 489: SpyHookOnOrOff (FALSE); ! 490: WinDlgBox(HWND_DESKTOP, hwndSpyFrame, ! 491: (PFNWP)SpySaveListDlgProc, (HMODULE)NULL, ! 492: IDD_SaveListDlg, (PCH)NULL); ! 493: SpyHookOnOrOff (fSpyActive); ! 494: break; ! 495: ! 496: /* ! 497: * This command saves out the current options to OS2.ini ! 498: */ ! 499: case CMD_SAVEOPT: ! 500: PrfWriteProfileData(HINI_USER, "Spy", "Options", (PSZ)&spyopt, ! 501: sizeof(SPYOPT)); ! 502: PrfWriteProfileString(HINI_USER, "Spy", "FileName", ! 503: (PSZ)spystr.szFileName); ! 504: PrfWriteProfileString(HINI_USER, "Spy", "SaveFileName", ! 505: (PSZ)spystr.szSaveFileName); ! 506: ! 507: break; ! 508: ! 509: case CMD_WINDOWS: ! 510: SpyHookOnOrOff (FALSE); ! 511: hwndWindowLB = NULL; ! 512: iCurItemFocus = (USHORT)-1; ! 513: WinDlgBox(HWND_DESKTOP, hwndSpyFrame, ! 514: (PFNWP)SpyWindowsDlgProc, (HMODULE)NULL, ! 515: IDD_WindowsDlg, (PCH)NULL); ! 516: ! 517: SpyHookOnOrOff (fSpyActive); ! 518: break; ! 519: ! 520: case CMD_QUEUES: ! 521: SpyHookOnOrOff (FALSE); ! 522: hwndWindowLB = NULL; ! 523: iCurItemFocus = (USHORT)-1; ! 524: WinDlgBox(HWND_DESKTOP, hwndSpyFrame, ! 525: (PFNWP)SpyQueuesDlgProc, (HMODULE)NULL, ! 526: IDD_MsgQueueDlg, (PCH)NULL); ! 527: ! 528: SpyHookOnOrOff (fSpyActive); ! 529: break; ! 530: ! 531: case CMD_WNMSSEL: ! 532: case CMD_WNMSDSL: ! 533: SpyHookOnOrOff (FALSE); ! 534: SelOrDeselWithMouse(SHORT1FROMMP(mp1) == CMD_WNMSSEL); ! 535: SpyHookOnOrOff (fSpyActive); ! 536: break; ! 537: ! 538: case CMD_ALLWNDWS: ! 539: ! 540: /* ! 541: * The user selected the ALLFRAMES, toggle the state, and ! 542: * update the menu and the hook state. ! 543: */ ! 544: fAllWindows ^= MIA_CHECKED; /* Toggle on or off */ ! 545: SpySetAllWindowOpt (fAllWindows); ! 546: WinSendMsg(WinWindowFromID(hwndSpyFrame, FID_MENU), ! 547: MM_SETITEMATTR, MPFROM2SHORT(CMD_ALLWNDWS, TRUE), ! 548: MPFROM2SHORT(MIA_CHECKED, fAllWindows)); ! 549: break; ! 550: ! 551: case CMD_ALLFRAMES: ! 552: ! 553: /* ! 554: * The user selected the ALLFRAMES, toggle the state, and ! 555: * update the menu and the hook state. ! 556: */ ! 557: fAllFrames ^= MIA_CHECKED; /* Toggle on or off */ ! 558: SpySetAllFrameOpt (fAllFrames); ! 559: WinSendMsg(WinWindowFromID(hwndSpyFrame, FID_MENU), ! 560: MM_SETITEMATTR, MPFROM2SHORT(CMD_ALLFRAMES, TRUE), ! 561: MPFROM2SHORT(MIA_CHECKED, fAllFrames)); ! 562: break; ! 563: ! 564: case CMD_WNDPWIN: ! 565: wDumpCount = 0; ! 566: DumpOneWindowInfo(); ! 567: break; ! 568: case CMD_WNDPALL: ! 569: wDumpCount = 0; ! 570: pspwd = (SPWD *)WinAllocMem(hHeap, sizeof(SPWD)* MAXSPYDUMP); ! 571: cBytes = DumpAllWindowsInfo(HWND_DESKTOP, 0); ! 572: cBytes += DumpAllWindowsInfo(HWND_OBJECT, -10); ! 573: DumpWindowIndex(cBytes); ! 574: WinFreeMem(hHeap, (char *)pspwd, sizeof(SPWD)* MAXSPYDUMP); ! 575: break; ! 576: case CMD_DACCEL: ! 577: DumpFrameAcclTable(); ! 578: break; ! 579: ! 580: case CMD_MESSAGES: ! 581: SpyHookOnOrOff (FALSE); ! 582: WinDlgBox(HWND_DESKTOP, hwndSpyFrame, ! 583: (PFNWP)SpyMsgDlgProc, (HMODULE)NULL, ! 584: IDD_MessagesDlg, (PCH)NULL); ! 585: SpyHookOnOrOff (fSpyActive); ! 586: break; ! 587: ! 588: case CMD_ALPHASORT: ! 589: spyopt.fAlphaSortMsgList ^= TRUE; ! 590: ! 591: WinSendMsg(WinWindowFromID(hwndSpyFrame, FID_MENU), ! 592: MM_SETITEMATTR, MPFROM2SHORT(CMD_ALPHASORT, TRUE), ! 593: MPFROM2SHORT(MIA_CHECKED, ! 594: spyopt.fAlphaSortMsgList ? MIA_CHECKED : 0)); ! 595: break; ! 596: ! 597: case CMD_SENDMSG: ! 598: WinSendMsg(WinWindowFromID(hwndSpyFrame, FID_MENU), ! 599: MM_SETITEMATTR, MPFROM2SHORT(CMD_SENDMSG, TRUE), ! 600: MPFROM2SHORT(MIA_DISABLED, MIA_DISABLED)); ! 601: WinLoadDlg(HWND_DESKTOP, hwndSpyFrame, ! 602: (PFNWP)SendMsgDlgProc, (HMODULE)NULL, ! 603: IDD_SendMsgDlg, (PCH)NULL); ! 604: break; ! 605: ! 606: /* ! 607: * The command in this section are defined in the Hooks Menu. ! 608: * All of these items toggle selections on or off. The first two ! 609: * Items must be registered with the input hook. The last two simply ! 610: * retrict how much information is displayed for send messages ! 611: */ ! 612: ! 613: case CMD_INPUTHOOK: ! 614: spyopt.bHooks ^= SPYH_INPUT; ! 615: WinSendMsg(WinWindowFromID(hwndSpyFrame, FID_MENU), ! 616: MM_SETITEMATTR, MPFROM2SHORT(CMD_INPUTHOOK, TRUE), ! 617: MPFROM2SHORT(MIA_CHECKED, ! 618: (spyopt.bHooks & SPYH_INPUT) ? MIA_CHECKED : 0)); ! 619: SpyReleaseHook (FALSE); /* Dont clear queue */ ! 620: SpyInstallHook(hab, hmqSpy, spyopt.bHooks); ! 621: break; ! 622: ! 623: case CMD_SENDMSGHOOK: ! 624: spyopt.bHooks ^= SPYH_SENDMSG; ! 625: WinSendMsg(WinWindowFromID(hwndSpyFrame, FID_MENU), ! 626: MM_SETITEMATTR, MPFROM2SHORT(CMD_SENDMSGHOOK, TRUE), ! 627: MPFROM2SHORT(MIA_CHECKED, ! 628: (spyopt.bHooks & SPYH_SENDMSG) ? MIA_CHECKED : 0)); ! 629: SpyReleaseHook (FALSE); /* Dont clear queue */ ! 630: SpyInstallHook(hab, hmqSpy, spyopt.bHooks); ! 631: break; ! 632: ! 633: case CMD_SENDEXTEND: ! 634: spyopt.fSendExtend ^= 1; /* Toggle on or off */ ! 635: WinSendMsg(WinWindowFromID(hwndSpyFrame, FID_MENU), ! 636: MM_SETITEMATTR, MPFROM2SHORT(CMD_SENDEXTEND, TRUE), ! 637: MPFROM2SHORT(MIA_CHECKED, ! 638: spyopt.fSendExtend ? MIA_CHECKED : 0)); ! 639: break; ! 640: ! 641: /* ! 642: * The commands in this section are defined in the Outputs Menu. ! 643: * The first 3 items simply toggle outputs on or off, where the ! 644: * last item allows the user to change all of the output options. ! 645: */ ! 646: case CMD_OUTSCREEN: ! 647: spyopt.fWindow ^= 1; /* Toggle on or off */ ! 648: WinSendMsg(WinWindowFromID(hwndSpyFrame, FID_MENU), ! 649: MM_SETITEMATTR, MPFROM2SHORT(CMD_OUTSCREEN, TRUE), ! 650: MPFROM2SHORT(MIA_CHECKED, spyopt.fWindow ? MIA_CHECKED : 0)); ! 651: break; ! 652: ! 653: case CMD_OUTTERM: ! 654: spyopt.fDebugOutput ^= 1; /* Toggle on or off */ ! 655: WinSendMsg(WinWindowFromID(hwndSpyFrame, FID_MENU), ! 656: MM_SETITEMATTR, MPFROM2SHORT(CMD_OUTTERM, TRUE), ! 657: MPFROM2SHORT(MIA_CHECKED, spyopt.fDebugOutput ? MIA_CHECKED : 0)); ! 658: break; ! 659: ! 660: case CMD_OUTFILE: ! 661: spyopt.fFile ^= 1; /* Toggle on or off */ ! 662: WinSendMsg(WinWindowFromID(hwndSpyFrame, FID_MENU), ! 663: MM_SETITEMATTR, MPFROM2SHORT(CMD_OUTFILE, TRUE), ! 664: MPFROM2SHORT(MIA_CHECKED, spyopt.fFile ? MIA_CHECKED : 0)); ! 665: /* ! 666: * Open or close the output file ! 667: */ ! 668: if (spyopt.fFile) { ! 669: if (spyopt.hfileSpy == NULL) ! 670: if (DosOpen((PSZ)spystr.szFileName, &spyopt.hfileSpy, ! 671: &ulAction, 0L, 0, ! 672: 0x0012, 0x00C1, 0L) != 0) ! 673: spyopt.hfileSpy = NULL; /* Failed on open */ ! 674: } else { ! 675: if (spyopt.hfileSpy != NULL) { ! 676: /* file open, not outputing, close it now */ ! 677: DosClose (spyopt.hfileSpy); ! 678: spyopt.hfileSpy = NULL; ! 679: } ! 680: } ! 681: break; ! 682: ! 683: case CMD_OUTPUTS: ! 684: SpyHookOnOrOff (FALSE); ! 685: WinDlgBox(HWND_DESKTOP, hwndSpyFrame, ! 686: (PFNWP)SpyOutputsDlgProc, (HMODULE)NULL, ! 687: IDD_OutputsDlg, (PCH)NULL); ! 688: SpyHookOnOrOff (fSpyActive); ! 689: break; ! 690: ! 691: case CMD_MGDABLE: ! 692: case CMD_MGEABLE: ! 693: EnableOrDisableMsg(SHORT1FROMMP(mp1) == CMD_MGEABLE); ! 694: break; ! 695: /* ! 696: * Help Menu items, send message to help manager ! 697: */ ! 698: case CMD_HOWHELP: ! 699: if (hwndHelpInstance != NULL) ! 700: WinSendMsg(hwndHelpInstance, HM_DISPLAY_HELP, ! 701: (MPARAM)NULL, (MPARAM)NULL); ! 702: break; ! 703: ! 704: /* Extended help option was chosen from pull-down */ ! 705: case CMD_HELPEXTENDED: ! 706: if (hwndHelpInstance != NULL) ! 707: WinSendMsg(hwndHelpInstance, HM_EXT_HELP, ! 708: (MPARAM) 0, (MPARAM) 0 ); ! 709: break; ! 710: ! 711: /* Keys help option was chosen from pull-down */ ! 712: ! 713: case CMD_HELPKEYS: ! 714: if (hwndHelpInstance != NULL) ! 715: WinSendMsg(hwndHelpInstance, HM_KEYS_HELP, ! 716: (MPARAM) 0, (MPARAM) 0 ); ! 717: break; ! 718: ! 719: /* Index option was chosen from pull-down */ ! 720: ! 721: case CMD_HELPINDEX: ! 722: if (hwndHelpInstance != NULL) ! 723: WinSendMsg(hwndHelpInstance, HM_HELP_INDEX, ! 724: (MPARAM) 0, (MPARAM) 0 ); ! 725: break; ! 726: } ! 727: ! 728: break; ! 729: case HM_HELPSUBITEM_NOT_FOUND: ! 730: if (hwndHelpInstance != NULL) ! 731: (void)WinSendMsg(hwndHelpInstance, HM_EXT_HELP, ! 732: (MPARAM)NULL, (MPARAM)NULL); ! 733: break; ! 734: case HM_QUERY_KEYS_HELP: ! 735: return (MRESULT)HLP_KEYS; ! 736: ! 737: case WM_SIZE: ! 738: /* We need to resize the listbox, if it exists */ ! 739: if (hwndSpyList != NULL) { ! 740: WinSetWindowPos(hwndSpyList, HWND_TOP, -cxBorder, -cyBorder, ! 741: SHORT1FROMMP(mp2) + 2 * cxBorder, ! 742: SHORT2FROMMP(mp2) + 2 * cyBorder, SWP_MOVE | SWP_SIZE); ! 743: } ! 744: ! 745: /* Now fall through to process the message */ ! 746: default: ! 747: return(WinDefWindowProc(hwnd, msg, mp1, mp2)); ! 748: break; ! 749: } ! 750: return(0L); ! 751: } ! 752: ! 753: ! 754: ! 755: ! 756: /***************************** Private Function ****************************\ ! 757: * USHORT UConvertStringToNum(psz) ! 758: * ! 759: * Effects: ! 760: * Converts the passed string to a number 0xffff if not number ! 761: * ! 762: * History: ! 763: * 27-September-1988 KurtE ! 764: \***************************************************************************/ ! 765: USHORT UConvertStringToNum(psz) ! 766: register char *psz; ! 767: { ! 768: register USHORT uNum; ! 769: /* ! 770: * This aint to fancy yet, but if the first few chars are ! 771: * 0x, we assume the user typed in a HEX number, else if 0-9, ! 772: * we assume decimal, else we use the string, also for windows if the ! 773: * user left the 0000:0000 we ignore the high end and assume it is ! 774: * hex. ! 775: */ ! 776: ! 777: /* First see if digit in first position */ ! 778: if ((*psz >= '0') && (*psz <= '9')) { ! 779: /* Assume numbers now */ ! 780: if ((*psz == '0') && (*(psz+1) == 'x')) { ! 781: ! 782: /* We are in hex mode */ ! 783: psz += 2; ! 784: uNum = 0; ! 785: for (;;) { ! 786: if ((*psz >= '0') && (*psz <= '9')) ! 787: uNum = uNum * 16 + (USHORT)(*psz - '0'); ! 788: else if ((*psz >= 'a') && (*psz <= 'f')) ! 789: uNum = uNum * 16 + (USHORT)(*psz - 'a'); ! 790: else if ((*psz >= 'F') && (*psz <= 'F')) ! 791: uNum = uNum * 16 + (USHORT)(*psz - 'A'); ! 792: else ! 793: break; ! 794: psz++; ! 795: } ! 796: ! 797: } else { ! 798: /* Decimal mode */ ! 799: uNum = (USHORT)(*psz++ - '0'); ! 800: while ((*psz >= '0') && (*psz <= '9')) { ! 801: uNum = uNum * 10 + (USHORT)(*psz++ - '0'); ! 802: } ! 803: } ! 804: ! 805: return (uNum); ! 806: ! 807: } else if (psz=strchr(psz,':')) { ! 808: // boy this is sh.t, it should be combined above!!! ! 809: /* We are in hex mode */ ! 810: psz++; ! 811: uNum = 0; ! 812: for (;;) { ! 813: if ((*psz >= '0') && (*psz <= '9')) ! 814: uNum = uNum * 16 + (USHORT)(*psz - '0'); ! 815: else if ((*psz >= 'a') && (*psz <= 'f')) ! 816: uNum = uNum * 16 + (USHORT)(*psz - 'a'); ! 817: else if ((*psz >= 'F') && (*psz <= 'F')) ! 818: uNum = uNum * 16 + (USHORT)(*psz - 'A'); ! 819: else ! 820: break; ! 821: psz++; ! 822: } ! 823: ! 824: } else ! 825: /* Not num, return 0xffff */ ! 826: return (0xffff); ! 827: } ! 828: ! 829: ! 830: ! 831: ! 832: ! 833: /**************************** Public Function ******************************\ ! 834: * void ProcHookThread() ! 835: * ! 836: * Effects: This function will wait for the hook to have messages, when it ! 837: * does, it will Set a memory semaphore, Post a WM_SEM1 message to the other ! 838: * thread, and wait for the other thread has processed all of the messages. ! 839: * ! 840: * Return value: none ! 841: \***************************************************************************/ ! 842: ! 843: void ProcHookThread() ! 844: { ! 845: ULONG ulPostCt; ! 846: /* We'll look for a variation to run while the thread is active. */ ! 847: if (fDebug) ! 848: DebugBreak(); ! 849: ! 850: while (TRUE) { ! 851: /* ! 852: * Wait for a message to become available. ! 853: */ ! 854: if (!SpyGetNextMessage(NULL, NULL, 0, -1L)) ! 855: break; ! 856: ! 857: /* ! 858: * Now we have a message, set our semaphore, Post a WM_SEM2 ! 859: * message to the Client window, and wait for the client to ! 860: * clear the semaphore. ! 861: */ ! 862: DosResetEventSem(hevThread, &ulPostCt); ! 863: WinPostMsg(hwndSpy, WM_SEM2, (MPARAM)1, (MPARAM)1); ! 864: DosWaitEventSem(hevThread, -1L); ! 865: } ! 866: ! 867: DosExit(EXIT_THREAD, 0); ! 868: } ! 869: ! 870: ! 871: ! 872: ! 873: /**************************** Public Function ******************************\ ! 874: * void ProcessQueueMsg(pqmsg) ! 875: * ! 876: * Effects: This function will process the hook, by calling the hooks ! 877: * get message. We will than post the message to the current output ! 878: * destinations. ! 879: * ! 880: * Return value: none ! 881: \***************************************************************************/ ! 882: ! 883: void ProcessQueueMsg(pqmsgspy) ! 884: QMSGSPY *pqmsgspy; ! 885: { ! 886: MSGI *pmsgi; ! 887: CHAR cSource; ! 888: CHAR cThread; ! 889: char szNextMessage[100]; ! 890: char szTime[12]; ! 891: SHORT cch; ! 892: CHAR bAscii; ! 893: PSZ prgData; ! 894: ! 895: ! 896: ! 897: /* ! 898: * Now lets Build the message to output ! 899: */ ! 900: if (WinIsWindow(hab, pqmsgspy->qmsg.hwnd)) { ! 901: if (WinIsChild(pqmsgspy->qmsg.hwnd, hwndSpy)) ! 902: return; /* dont want endless loops */ ! 903: } ! 904: ! 905: cThread = ':'; ! 906: if (pqmsgspy->qmsg.time == (ULONG)-1) { ! 907: /* Sent message */ ! 908: szTime[0] = '\0'; ! 909: cSource = 'S'; ! 910: if (pqmsgspy->fs) ! 911: cThread = '*'; ! 912: } else { ! 913: cSource = 'I'; ! 914: if (pqmsgspy->fs != PM_REMOVE) ! 915: cThread = '-'; /* Show different for non-remove */ ! 916: ! 917: sprintf (szTime, "%-08lx", pqmsgspy->qmsg.time); ! 918: } ! 919: ! 920: if ((pmsgi = PmsgiFromMsg(pqmsgspy->qmsg.msg)) == NULL) { ! 921: /* ! 922: * Message not in list, use default ! 923: */ ! 924: cch = sprintf(szNextMessage, ! 925: "%c%cMSG:0x%04x H:%p 1:%08lx 2:%08lx T:%s", ! 926: cSource, cThread, (SHORT)pqmsgspy->qmsg.msg, pqmsgspy->qmsg.hwnd, ! 927: pqmsgspy->qmsg.mp1, pqmsgspy->qmsg.mp2, szTime); ! 928: } else if (pmsgi->wOptions & MSGI_MOUSE) { ! 929: /* ! 930: * Mouse message, decode to mouse types ! 931: */ ! 932: cch = sprintf(szNextMessage, ! 933: "%c%c%-20s H:%p X:%-4d Y:%-4d HT:%04x T:%s", ! 934: cSource, cThread, pmsgi->szMsg, pqmsgspy->qmsg.hwnd, ! 935: SHORT1FROMMP(pqmsgspy->qmsg.mp1), SHORT2FROMMP(pqmsgspy->qmsg.mp1), ! 936: SHORT1FROMMP(pqmsgspy->qmsg.mp2), szTime); ! 937: } else if (pmsgi->wOptions & MSGI_KEY) { ! 938: /* ! 939: * Key messages, output special ! 940: */ ! 941: bAscii = (CHAR)SHORT1FROMMP(pqmsgspy->qmsg.mp2); ! 942: if ((bAscii < ' ') || (bAscii > '~')) ! 943: bAscii = ' '; ! 944: ! 945: cch = sprintf(szNextMessage, ! 946: "%c%c%-20s H:%p F:%04x R:%d S:%2x C:%04x(%c) V:%02x T:%s", ! 947: cSource, cThread, pmsgi->szMsg, pqmsgspy->qmsg.hwnd, ! 948: SHORT1FROMMP(pqmsgspy->qmsg.mp1), ! 949: CHAR3FROMMP(pqmsgspy->qmsg.mp1), CHAR4FROMMP(pqmsgspy->qmsg.mp1), ! 950: SHORT1FROMMP(pqmsgspy->qmsg.mp2), bAscii, ! 951: SHORT2FROMMP(pqmsgspy->qmsg.mp2), szTime); ! 952: } else { ! 953: /* No special format */ ! 954: cch = sprintf(szNextMessage, ! 955: "%c%c%-20s H:%p 1:%08lx 2:%08lx T:%s", ! 956: cSource, cThread, pmsgi->szMsg, pqmsgspy->qmsg.hwnd, ! 957: pqmsgspy->qmsg.mp1, pqmsgspy->qmsg.mp2, szTime); ! 958: } ! 959: ! 960: OutputString(szNextMessage, cch); ! 961: ! 962: /* ! 963: * Now dump out any additional information associated with the ! 964: * message. The processing depends of the type of message on ! 965: * how we are going to process the data. ! 966: */ ! 967: if (spyopt.fSendExtend) { ! 968: prgData = DumpParam((PSZ)rgMsgData, pqmsgspy->cbDataMP1, ! 969: pqmsgspy->fMP1Valid, pqmsgspy->bMPType); ! 970: ! 971: DumpParam(prgData, pqmsgspy->cbDataMP2, pqmsgspy->fMP1Valid, ! 972: (UCHAR)((pqmsgspy->bMPType) >> 3)); ! 973: } ! 974: ! 975: } ! 976: ! 977: ! 978: ! 979: ! 980: /**************************** Public Function ******************************\ ! 981: * PSZ DumpParam(PSZ prgData, MPARAM mp, SHORT cb, BOOL fValid, UCHAR bMPType) ! 982: * ! 983: * Dump the additional information that was captured for the message. ! 984: * using the currently defined types. ! 985: * ! 986: * Return value: PSZ - Pointer to next available byte after process DATA ! 987: \***************************************************************************/ ! 988: PSZ DumpParam(prgData, cb, fValidData, bMPType) ! 989: PSZ prgData; ! 990: SHORT cb; ! 991: BOOL fValidData; ! 992: UCHAR bMPType; ! 993: { ! 994: char szNextMessage[100]; ! 995: SHORT cch; ! 996: ! 997: ! 998: if (fValidData) { ! 999: /* Process by type */ ! 1000: switch (bMPType & 0x07) { ! 1001: case MPT_SWP: ! 1002: cch = sprintf(szNextMessage, ! 1003: " SWP: fs:%p cx:%d cy:%d y:%d x:%d HB:%p H:%p", ! 1004: ((PSWP)prgData)->fl, ((PSWP)prgData)->cy, ((PSWP)prgData)->cx, ! 1005: ((PSWP)prgData)->y, ((PSWP)prgData)->x, ! 1006: ((PSWP)prgData)->hwndInsertBehind, ! 1007: ((PSWP)prgData)->hwnd); ! 1008: ! 1009: break; ! 1010: ! 1011: case MPT_RECTL: ! 1012: cch = sprintf(szNextMessage, ! 1013: " RECTL: xLeft:%d yBottom:%d xRight:%d yTop:%d", ! 1014: ((PRECTL)prgData)->xLeft, ((PRECTL)prgData)->yBottom, ! 1015: ((PRECTL)prgData)->xRight, ((PRECTL)prgData)->yTop); ! 1016: break; ! 1017: ! 1018: case MPT_QMSG: ! 1019: cch = sprintf(szNextMessage, ! 1020: " QMSG: H:%p M:%04x M1:%08lx M2:%08lx T:%08lx (%d, %d)", ! 1021: ((PQMSG)prgData)->hwnd, ((PQMSG)prgData)->msg, ! 1022: ((PQMSG)prgData)->mp1,((PQMSG)prgData)->mp2, ! 1023: ((PQMSG)prgData)->time, ! 1024: ((PQMSG)prgData)->ptl.x, ((PQMSG)prgData)->ptl.y); ! 1025: break; ! 1026: ! 1027: default: ! 1028: goto NoData; ! 1029: } ! 1030: ! 1031: OutputString(szNextMessage, cch); ! 1032: } ! 1033: NoData: ! 1034: return (prgData + cb); ! 1035: } ! 1036: ! 1037: ! 1038: ! 1039: ! 1040: /**************************** Public Function ******************************\ ! 1041: * void OutputString(char szOut, SHORT cch); ! 1042: * ! 1043: * Effects: This function will output the specified string to the ! 1044: * destinations. ! 1045: * ! 1046: * Return value: none ! 1047: \***************************************************************************/ ! 1048: ! 1049: void OutputString(szOut, cch) ! 1050: char szOut[]; ! 1051: SHORT cch; ! 1052: { ! 1053: SHORT item; ! 1054: char *psz; ! 1055: ULONG cchWritten; ! 1056: ! 1057: /* This is a private entry point in the PMWIN dll that places */ ! 1058: /* strings into the window. */ ! 1059: SHORT _far16 _pascal _loadds DebugOutput( char _far16 * ); ! 1060: ! 1061: /* Now display the new Line on the screen */ ! 1062: if (spyopt.fWindow) { ! 1063: item = (SHORT)WinSendMsg(hwndSpyList, LM_INSERTITEM, ! 1064: (MPARAM)LIT_END, (MPARAM)(PSZ)szOut); ! 1065: ! 1066: WinSendMsg(hwndSpyList, LM_SETTOPINDEX, (MPARAM)item, 0L); ! 1067: ! 1068: /* See if we have to many lines now */ ! 1069: while (item >= spyopt.cWindowLines) ! 1070: item = (SHORT)WinSendMsg(hwndSpyList, LM_DELETEITEM, ! 1071: (MPARAM)0, 0L); ! 1072: } ! 1073: ! 1074: /* now for file or debug terminal need cr/lf */ ! 1075: psz = szOut + cch; /* point to trailing null */ ! 1076: *psz++ = '\r'; ! 1077: *psz++ = '\n'; ! 1078: *psz = '\0'; ! 1079: ! 1080: if (spyopt.fDebugOutput) ! 1081: DebugOutput((char _far16*)szOut); ! 1082: ! 1083: if (spyopt.fFile) ! 1084: DosWrite(spyopt.hfileSpy, (PSZ)szOut, cch+2, ! 1085: &cchWritten); ! 1086: ! 1087: } ! 1088: ! 1089: ! 1090: /**************************** Public Function ******************************\ ! 1091: * MSGI * PmsgiFromMsg(USHORT msg) ! 1092: * ! 1093: * Effects: Locate the msg in the array of message items ! 1094: * ! 1095: * Return value: pointer to item that has the specified msg, or NULL ! 1096: \***************************************************************************/ ! 1097: MSGI *PmsgiFromMsg(msg) ! 1098: USHORT msg; ! 1099: { ! 1100: register MSGI *pmsgi = rgmsgi; /* Start at beginning */ ! 1101: register USHORT i; ! 1102: ! 1103: /* ! 1104: * Currently is a simple linear search, should be made faster ! 1105: * Probabably a binary search. ! 1106: */ ! 1107: for (i=0; i< cmsgi; i++) { ! 1108: if (pmsgi->msg == msg) ! 1109: return (pmsgi); ! 1110: if (pmsgi->msg > msg) ! 1111: return (NULL); ! 1112: pmsgi++; ! 1113: }; ! 1114: ! 1115: return (NULL); ! 1116: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.