![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to wprintf.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [WindowsNT SDKs] / mstools / samples / sdktools / spy / app|
Return to wprintf.c CVS log | Up to [WindowsNT SDKs] / mstools / samples / sdktools / spy / app |
1.1 ! root 1: ! 2: /******************************************************************************\ ! 3: * This is a part of the Microsoft Source Code Samples. ! 4: * Copyright (C) 1993 Microsoft Corporation. ! 5: * All rights reserved. ! 6: * This source code is only intended as a supplement to ! 7: * Microsoft Development Tools and/or WinHelp documentation. ! 8: * See these sources for detailed information regarding the ! 9: * Microsoft samples programs. ! 10: \******************************************************************************/ ! 11: ! 12: /*****************************************************************************\ ! 13: * ! 14: * Module: wprintf.c ! 15: * ! 16: * Contains the routines for using printf windows ! 17: * ! 18: * Functions: ! 19: * ! 20: * MyCreatePrintfWin() ! 21: * SetPrintFont() ! 22: * SetPrintfTabs() ! 23: * ClearPrintfWindow() ! 24: * CopyToClipboard() ! 25: * IsPrintfEmpty() ! 26: * PrintfWndProc() ! 27: * DebugPaint() ! 28: * InsertString() ! 29: * DebugHScroll() ! 30: * DebugVScroll() ! 31: * SetWindowClass() ! 32: * LinesInDebugWindow() ! 33: * CharsInDebugWindow() ! 34: * wprintfSetScrollRange() ! 35: * NewLine() ! 36: * ! 37: * Comments: ! 38: * ! 39: \*****************************************************************************/ ! 40: ! 41: #include "spy.h" ! 42: ! 43: ! 44: ! 45: /*****************************************************************************\ ! 46: * ! 47: * g e n e r a l c o n s t a n t s ! 48: * ! 49: \*****************************************************************************/ ! 50: ! 51: #define MAXBUFLEN 200 /* Maximum string length for wprintf */ ! 52: ! 53: #define FIRST(pTxt) ((pTxt)->iFirst) ! 54: #define TOP(pTxt) (((pTxt)->iFirst + (pTxt)->iTop) % (pTxt)->iMaxLines) ! 55: #define LAST(pTxt) (((pTxt)->iFirst + (pTxt)->iCount-1) % (pTxt)->iMaxLines) ! 56: #define INC(pTxt,x) ((x) = ++(x) % (pTxt)->iMaxLines) ! 57: #define DEC(pTxt,x) ((x) = --(x) % (pTxt)->iMaxLines) ! 58: #define OFFSETX (pTxt->Tdx/2) ! 59: #define OFFSETY 1 ! 60: #define VARSIZE 1 ! 61: ! 62: #define BOUND(x,mn,mx) ((x) < (mn) ? (mn) : ((x) > (mx) ? (mx) : (x))) ! 63: ! 64: #define FTwixtI3(l,x,h) ((x)>=(l) && (x<=h)) ! 65: ! 66: #define EnterCrit(p) EnterCriticalSection(&p->csSync) ! 67: #define LeaveCrit(p) LeaveCriticalSection(&p->csSync) ! 68: ! 69: /*****************************************************************************\ ! 70: * ! 71: * g l o b a l v a r i a b l e s ! 72: * ! 73: \*****************************************************************************/ ! 74: ! 75: typedef struct { ! 76: INT iLen; ! 77: CHAR * *hText; ! 78: } LINE; ! 79: ! 80: struct TEXT_STRUCT { ! 81: CRITICAL_SECTION csSync; // CritSect to sync the threads ! 82: ! 83: INT iFirst; /* First line in queue */ ! 84: INT iCount; /* Number of lines in queue */ ! 85: INT iTop; /* Line at top of window */ ! 86: INT iLeft; /* X offset of the window */ ! 87: INT MaxLen; /* Max String Length */ ! 88: INT iMaxLines; /* max number of LINEs */ ! 89: HFONT hFont; /* Font to draw with */ ! 90: DWORD Tdx, Tdy; /* Font Size */ ! 91: LINE arLines[VARSIZE]; /* array of iMaxLines LINEs */ ! 92: }; ! 93: ! 94: typedef struct TEXT_STRUCT *PTXT; /* pointer to a text struct */ ! 95: typedef PTXT *HTXT; /* Handle to a text struct */ ! 96: ! 97: PRIVATE INT iSem = 0; ! 98: ! 99: INT tabs[20]; ! 100: INT nTabs = 0; ! 101: ! 102: /*****************************************************************************\ ! 103: * ! 104: * f u n c t i o n d e f i n i t i o n s ! 105: * ! 106: \*****************************************************************************/ ! 107: ! 108: LONG APIENTRY PrintfWndProc(HWND, UINT, WPARAM, LONG); ! 109: ! 110: PRIVATE VOID DebugPaint(HWND hwnd, LPPAINTSTRUCT pps); ! 111: PRIVATE INT InsertString (PTXT, CHAR *); ! 112: PRIVATE VOID DebugHScroll(HWND, PTXT, INT); ! 113: PRIVATE VOID DebugVScroll(HWND, PTXT, INT); ! 114: PRIVATE BOOL SetWindowClass (HANDLE, LPSTR); ! 115: PRIVATE INT LinesInDebugWindow (HWND); ! 116: PRIVATE INT CharsInDebugWindow (HWND); ! 117: PRIVATE VOID wprintfSetScrollRange (HWND, BOOL); ! 118: PRIVATE VOID NewLine (PTXT pTxt); ! 119: ! 120: ! 121: ! 122: /*****************************************************************************\ ! 123: * MyCreatePrintfWin ! 124: * ! 125: * Creates a window to printf to. ! 126: * ! 127: * Arguments: ! 128: * HWND hwnd - handle to the parent window ! 129: * ! 130: * Returns: ! 131: * VOID ! 132: \*****************************************************************************/ ! 133: ! 134: VOID ! 135: MyCreatePrintfWin( ! 136: HWND hwnd ! 137: ) ! 138: { ! 139: RECT rc; ! 140: ! 141: if (ghwndPrintf) ! 142: DestroyWindow(ghwndPrintf); ! 143: ! 144: GetClientRect(hwnd, &rc); ! 145: ! 146: ghwndPrintf = CreatePrintfWin(hwnd, ghInst, "", WS_CHILD | WS_VSCROLL | ! 147: WS_HSCROLL, -gcxBorder, -gcyBorder, rc.right + (2 *gcxBorder), ! 148: rc.bottom + (2 * gcyBorder), gnLines); ! 149: } ! 150: ! 151: ! 152: ! 153: /*****************************************************************************\ ! 154: * DebugPaint(hwnd, pps) ! 155: * ! 156: * The paint function. ! 157: * ! 158: * Arguments: ! 159: * HWND hwnd - Window to paint to. ! 160: * LPPAINTSTRUCT - pps ! 161: * ! 162: * Returns: ! 163: * nothing ! 164: * ! 165: \*****************************************************************************/ ! 166: ! 167: PRIVATE VOID ! 168: DebugPaint( ! 169: HWND hwnd, ! 170: LPPAINTSTRUCT pps ! 171: ) ! 172: { ! 173: PTXT pTxt; ! 174: HTXT hTxt; ! 175: INT iQueue; ! 176: INT xco; ! 177: INT yco; ! 178: INT iLast; ! 179: HBRUSH hb; ! 180: COLORREF c; ! 181: ! 182: hTxt = (HTXT)GetWindowLong(hwnd, 0); ! 183: pTxt = *hTxt; ! 184: ! 185: SetTextColor(pps->hdc, GetSysColor(COLOR_WINDOWTEXT)); ! 186: c = GetSysColor(COLOR_WINDOW); ! 187: SetBkColor(pps->hdc, c); ! 188: hb = CreateSolidBrush(c); ! 189: if (pTxt->hFont) ! 190: SelectObject(pps->hdc, pTxt->hFont); ! 191: ! 192: iLast = LAST(pTxt); ! 193: iQueue = TOP(pTxt); ! 194: ! 195: xco = OFFSETX - pTxt->iLeft * pTxt->Tdx; ! 196: yco = OFFSETY; ! 197: ! 198: for (;;) ! 199: { ! 200: if (FTwixtI3((INT)pps->rcPaint.top, yco,(INT)pps->rcPaint.bottom) ! 201: || FTwixtI3((INT)pps->rcPaint.top, yco + (INT)pTxt->Tdy, (INT)pps->rcPaint.bottom)) ! 202: { ! 203: if (pTxt->arLines[iQueue].hText == NULL ! 204: || (LPSTR)*(pTxt->arLines[iQueue].hText) == NULL) ! 205: { ! 206: RECT rcT; ! 207: ! 208: rcT.top = yco; ! 209: rcT.bottom = yco+pTxt->Tdy; ! 210: rcT.left = pps->rcPaint.left; ! 211: rcT.right = pps->rcPaint.right; ! 212: FillRect(pps->hdc, &rcT, hb); ! 213: } ! 214: else ! 215: { ! 216: TabbedTextOut(pps->hdc, xco, yco, ! 217: (LPSTR)*(pTxt->arLines[iQueue].hText), ! 218: pTxt->arLines[iQueue].iLen, nTabs, tabs, xco); ! 219: } ! 220: } ! 221: ! 222: if (iQueue == iLast) ! 223: break; ! 224: ! 225: yco += pTxt->Tdy; ! 226: INC(pTxt, iQueue); ! 227: } ! 228: ! 229: DeleteObject((HANDLE)hb); ! 230: } ! 231: ! 232: ! 233: ! 234: /*****************************************************************************\ ! 235: * SetWindowClass (hInstance) ! 236: * ! 237: * Registers the window class of the printf window ! 238: * ! 239: * Arguments: ! 240: * HANDLE hInstance - instance handle of current instance ! 241: * LPSTR lpch - pointer to class name ! 242: * ! 243: * Returns: ! 244: * TRUE if successful, FALSE if not ! 245: \*****************************************************************************/ ! 246: ! 247: PRIVATE BOOL ! 248: SetWindowClass( ! 249: HANDLE hInstance, ! 250: LPSTR lpch ! 251: ) ! 252: { ! 253: WNDCLASS wc; ! 254: ! 255: wc.style = CS_HREDRAW | CS_VREDRAW; ! 256: wc.lpfnWndProc = PrintfWndProc; ! 257: wc.cbClsExtra = 0; ! 258: wc.cbWndExtra = sizeof(HANDLE); ! 259: wc.hInstance = hInstance; ! 260: wc.hIcon = NULL; ! 261: wc.hCursor = LoadCursor(NULL, IDC_ARROW); ! 262: wc.hbrBackground = (HBRUSH)(COLOR_WINDOW + 1); ! 263: wc.lpszMenuName = NULL; ! 264: wc.lpszClassName = lpch; ! 265: ! 266: return RegisterClass(&wc); ! 267: } ! 268: ! 269: ! 270: /*****************************************************************************\ ! 271: * CreatePrintfWin (hParent, lpchName, dwStyle, x, y, dx, dy, iMaxLines) ! 272: * ! 273: * Creates a window for the depositing of debuging messages. ! 274: * ! 275: * Arguments: ! 276: * HWND hParent - Window handle of the parent window. ! 277: * HANDLE hInstance - Module instance handle. ! 278: * lPSTR lpchName - String to appear in the caption bar of the debuging window ! 279: * DWORD dwStyle - Window style ! 280: * INT x,y - Location of window ! 281: * INT dx,dy - Size of the window ! 282: * INT iMaxLines - The maximum number of text lines to display in the window ! 283: * ! 284: * Returns: ! 285: * A window handle of the debuging window, or NULL if a error occured. ! 286: \*****************************************************************************/ ! 287: ! 288: PUBLIC HWND APIENTRY ! 289: CreatePrintfWin ( ! 290: HWND hParent, ! 291: HANDLE hInstance, ! 292: LPSTR lpchName, ! 293: DWORD dwStyle, ! 294: INT x, ! 295: INT y, ! 296: INT dx, ! 297: INT dy, ! 298: INT iMaxLines ! 299: ) ! 300: { ! 301: static BOOL bClass = FALSE; /* Is the class registered */ ! 302: ! 303: HWND hwnd; ! 304: HTXT hTxt; /* handle to a debuging window struct */ ! 305: PTXT pTxt; ! 306: static CHAR achClass[40]; ! 307: ! 308: /* ! 309: * Make a Class name that is unique across instances ! 310: */ ! 311: if (!bClass++) { ! 312: wsprintf(achClass, "WPRINTF_%4.4X", hInstance); ! 313: SetWindowClass(hInstance, achClass); ! 314: } ! 315: ! 316: /* Allocate the window long before create the window, such that the ! 317: window proc can find the window long during the create. */ ! 318: ! 319: hTxt = (HTXT)LocalAlloc(LHND, sizeof(struct TEXT_STRUCT) + (iMaxLines ! 320: - VARSIZE) * sizeof(LINE)); ! 321: ! 322: if (!hTxt) { ! 323: return FALSE; ! 324: } ! 325: ! 326: pTxt = *hTxt; ! 327: ! 328: InitializeCriticalSection(&pTxt->csSync); ! 329: ! 330: pTxt->iFirst = 0; /* Set the queue up to have 1 NULL line */ ! 331: pTxt->iCount = 1; ! 332: pTxt->iTop = 0; ! 333: pTxt->iLeft = 0; ! 334: pTxt->MaxLen = 0; ! 335: pTxt->iMaxLines = iMaxLines; ! 336: pTxt->arLines[0].hText = NULL; ! 337: pTxt->arLines[0].iLen = 0; ! 338: ! 339: hwnd = CreateWindow((LPSTR)achClass, (LPSTR)lpchName, dwStyle, x, y, ! 340: dx, dy, (HWND)hParent, /* parent window */ ! 341: (HMENU)NULL, /* use class menu */ ! 342: (HANDLE)hInstance, /* handle to window instance */ ! 343: (LPSTR)hTxt /* used by WM_CREATE to set the window long */ ! 344: ); ! 345: ! 346: if (!hwnd) { ! 347: return FALSE; ! 348: } ! 349: ! 350: wprintfSetScrollRange(hwnd, FALSE); ! 351: ! 352: /* Make window visible */ ! 353: ShowWindow(hwnd, SHOW_OPENWINDOW); ! 354: return hwnd; ! 355: } ! 356: ! 357: ! 358: /*****************************************************************************\ ! 359: * SetPrintfFont (hwnd,hFont) ! 360: * ! 361: * Sets the font for the printf window. ! 362: * ! 363: * Arguments: ! 364: * HWND hwnd - Window handle of the printf window. ! 365: * HFONT hFont - Font handle ! 366: * ! 367: * Returns: ! 368: * ! 369: \*****************************************************************************/ ! 370: ! 371: VOID ! 372: SetPrintfFont( ! 373: HWND hwnd, ! 374: HFONT hfont ! 375: ) ! 376: { ! 377: PTXT pTxt; ! 378: HDC hDC; ! 379: TEXTMETRIC tm; ! 380: HFONT hfontOld; ! 381: ! 382: pTxt = *(HTXT)GetWindowLong(hwnd, 0); ! 383: pTxt->hFont = hfont; ! 384: ! 385: /* Find out the size of a Char in the font */ ! 386: hDC = GetDC(hwnd); ! 387: hfontOld = SelectObject(hDC, hfont); ! 388: DeleteObject(hfontOld); ! 389: GetTextMetrics(hDC, &tm); ! 390: pTxt->Tdy = tm.tmHeight; ! 391: pTxt->Tdx = tm.tmAveCharWidth; ! 392: ReleaseDC(hwnd, hDC); ! 393: ! 394: CalculatePrintfTabs(hfont); ! 395: ! 396: InvalidateRect(hwnd, NULL, TRUE); ! 397: UpdateWindow(hwnd); ! 398: } ! 399: ! 400: ! 401: ! 402: /*****************************************************************************\ ! 403: * SetPrintfTabs ! 404: * ! 405: * Sets the Tabstops in the printf window. ! 406: * ! 407: * Arguments: ! 408: * INT n - number of tabs to set. ! 409: * LPINT pTabs - arrays of tabstops ! 410: * ! 411: * Returns: ! 412: * VOID ! 413: \*****************************************************************************/ ! 414: ! 415: VOID ! 416: SetPrintfTabs( ! 417: INT n, ! 418: LPINT pTabs ! 419: ) ! 420: { ! 421: INT i; ! 422: ! 423: nTabs = n; ! 424: for (i = 0; i < nTabs; i++) ! 425: tabs[i] = *pTabs++; ! 426: } ! 427: ! 428: ! 429: ! 430: /*****************************************************************************\ ! 431: * ClearPrintfWindow ! 432: * ! 433: * Clears all text from the window ! 434: * ! 435: * Arguments: ! 436: * HWND hwnd - window handle for the Degubing window ! 437: * ! 438: * Returns: ! 439: * VOID ! 440: \*****************************************************************************/ ! 441: ! 442: VOID ! 443: ClearPrintfWindow( ! 444: HWND hwnd ! 445: ) ! 446: { ! 447: INT i, iQueue; ! 448: PTXT pTxt; ! 449: HTXT hTxt; ! 450: ! 451: if (hwnd != NULL && IsWindow(hwnd)) { ! 452: hTxt = (HTXT)GetWindowLong(hwnd, 0); ! 453: pTxt = *hTxt; ! 454: ! 455: EnterCrit(pTxt); ! 456: ! 457: iQueue = TOP(pTxt); ! 458: for (i = 0; i < (pTxt)->iCount; i++, INC(pTxt, iQueue)) ! 459: if ((pTxt)->arLines[iQueue].hText != NULL) { ! 460: LocalFree ((HANDLE)pTxt->arLines[iQueue].hText); ! 461: pTxt->arLines[iQueue].hText = NULL; ! 462: } ! 463: ! 464: pTxt->iFirst = 0; /* Set the queue up to have 1 NULL line */ ! 465: pTxt->iCount = 1; ! 466: pTxt->iTop = 0; ! 467: pTxt->iLeft = 0; ! 468: pTxt->MaxLen = 0; ! 469: pTxt->arLines[0].hText = NULL; ! 470: pTxt->arLines[0].iLen = 0; ! 471: ! 472: wprintfSetScrollRange(hwnd, FALSE); ! 473: InvalidateRect(hwnd, NULL, TRUE); ! 474: ! 475: LeaveCrit(pTxt); ! 476: } ! 477: } ! 478: ! 479: ! 480: /*****************************************************************************\ ! 481: * PrintfWndProc( hwnd, uiMessage, wParam, lParam ) ! 482: * ! 483: * The window proc for the debugging window. This processes all ! 484: * of the window's messages. ! 485: * ! 486: * Arguments: ! 487: * HWND hwnd - window handle for the parent window ! 488: * UINT uiMessage -message number ! 489: * WPARAM wParam - message-dependent ! 490: * LPARAM lParam - message-dependent ! 491: * ! 492: * Returns: ! 493: * 0 if processed, nonzero if ignored ! 494: \*****************************************************************************/ ! 495: ! 496: PUBLIC LONG APIENTRY ! 497: PrintfWndProc( ! 498: HWND hwnd, ! 499: UINT uiMessage, ! 500: WPARAM wParam, ! 501: LONG lParam ! 502: ) ! 503: { ! 504: PAINTSTRUCT rPS; ! 505: HTXT hTxt; ! 506: PTXT pTxt; ! 507: ! 508: hTxt = (HTXT)GetWindowLong(hwnd, 0); ! 509: ! 510: if ( hTxt ) { ! 511: pTxt = *hTxt; ! 512: } ! 513: ! 514: switch (uiMessage) { ! 515: case WM_CREATE: ! 516: { ! 517: /* set the WindowLong before any other message tries to ! 518: * reference it during the create of a window ! 519: */ ! 520: LPCREATESTRUCT csWindowLong = (LPCREATESTRUCT) lParam; ! 521: ! 522: hTxt = (HTXT)csWindowLong->lpCreateParams; ! 523: ! 524: SetWindowLong(hwnd, 0, (LONG)hTxt); ! 525: SetPrintfFont(hwnd, ghfontPrintf); ! 526: wprintfSetScrollRange(hwnd, FALSE); ! 527: } ! 528: break; ! 529: ! 530: case WM_DESTROY: ! 531: { ! 532: INT i, iQueue; ! 533: ! 534: EnterCrit(pTxt); ! 535: ! 536: iQueue = TOP(pTxt); ! 537: for (i = 0; i < (pTxt)->iCount; i++, INC(pTxt, iQueue)) ! 538: if ((pTxt)->arLines[iQueue].hText != NULL) { ! 539: LocalFree ((HANDLE)(pTxt)->arLines[iQueue].hText); ! 540: pTxt->arLines[iQueue].hText = NULL; ! 541: } ! 542: ! 543: LeaveCrit(pTxt); ! 544: DeleteCriticalSection(&pTxt->csSync); ! 545: ! 546: LocalFree((HANDLE)hTxt); ! 547: break; ! 548: } ! 549: ! 550: case WM_SIZE: ! 551: EnterCrit(pTxt); ! 552: if (!iSem) { ! 553: wprintfSetScrollRange(hwnd, TRUE); ! 554: } ! 555: DebugVScroll(hwnd, pTxt, 0); ! 556: LeaveCrit(pTxt); ! 557: break; ! 558: ! 559: case WM_VSCROLL: ! 560: EnterCrit(pTxt); ! 561: ! 562: switch (LOWORD(wParam)) { ! 563: case SB_LINEDOWN: ! 564: DebugVScroll(hwnd, pTxt, 1); ! 565: break; ! 566: case SB_LINEUP: ! 567: DebugVScroll(hwnd, pTxt, -1); ! 568: break; ! 569: case SB_PAGEUP: ! 570: DebugVScroll(hwnd, pTxt, -LinesInDebugWindow(hwnd)); ! 571: break; ! 572: case SB_PAGEDOWN: ! 573: DebugVScroll(hwnd, pTxt, LinesInDebugWindow(hwnd)); ! 574: break; ! 575: case SB_THUMBTRACK: ! 576: case SB_THUMBPOSITION: ! 577: DebugVScroll(hwnd, pTxt, HIWORD(wParam) - pTxt->iTop); ! 578: break; ! 579: case SB_ENDSCROLL: ! 580: break; ! 581: } ! 582: ! 583: LeaveCrit(pTxt); ! 584: break; ! 585: ! 586: case WM_HSCROLL: ! 587: EnterCrit(pTxt); ! 588: ! 589: switch (LOWORD(wParam)) { ! 590: case SB_LINEDOWN: ! 591: DebugHScroll (hwnd, pTxt, 1); ! 592: break; ! 593: case SB_LINEUP: ! 594: DebugHScroll (hwnd, pTxt, -1); ! 595: break; ! 596: case SB_PAGEUP: ! 597: DebugHScroll (hwnd, pTxt, -CharsInDebugWindow(hwnd)); ! 598: break; ! 599: case SB_PAGEDOWN: ! 600: DebugHScroll (hwnd, pTxt, CharsInDebugWindow(hwnd)); ! 601: break; ! 602: case SB_THUMBTRACK: ! 603: case SB_THUMBPOSITION: ! 604: DebugHScroll(hwnd, pTxt, HIWORD(wParam) - pTxt->iLeft); ! 605: break; ! 606: case SB_ENDSCROLL: ! 607: break; ! 608: } ! 609: ! 610: LeaveCrit(pTxt); ! 611: break; ! 612: ! 613: case WM_PAINT: ! 614: EnterCrit(pTxt); ! 615: ! 616: BeginPaint(hwnd, (LPPAINTSTRUCT) & rPS); ! 617: DebugPaint(hwnd, &rPS); ! 618: EndPaint(hwnd, (LPPAINTSTRUCT) & rPS); ! 619: ! 620: LeaveCrit(pTxt); ! 621: break; ! 622: ! 623: case WM_KEYDOWN: ! 624: EnterCrit(pTxt); ! 625: ! 626: switch (wParam) { ! 627: case VK_UP: ! 628: DebugVScroll(hwnd, pTxt, -1); ! 629: break; ! 630: case VK_DOWN: ! 631: DebugVScroll(hwnd, pTxt, 1); ! 632: break; ! 633: case VK_PRIOR: ! 634: DebugVScroll(hwnd, pTxt, -LinesInDebugWindow(hwnd)); ! 635: break; ! 636: case VK_NEXT: ! 637: DebugVScroll(hwnd, pTxt, LinesInDebugWindow(hwnd)); ! 638: break; ! 639: case VK_LEFT: ! 640: DebugHScroll(hwnd, pTxt, -1); ! 641: break; ! 642: case VK_RIGHT: ! 643: DebugHScroll(hwnd, pTxt, 1); ! 644: break; ! 645: } ! 646: ! 647: LeaveCrit(pTxt); ! 648: break; ! 649: ! 650: case WM_KEYUP: ! 651: break; ! 652: ! 653: default: ! 654: return DefWindowProc(hwnd, uiMessage, wParam, lParam); ! 655: } ! 656: return 0L; ! 657: } ! 658: ! 659: ! 660: /*****************************************************************************\ ! 661: * DebugScroll ! 662: * ! 663: * Scrolls the debug window vertically ! 664: * ! 665: * Arguments: ! 666: * HWND hwnd - handle to the debug window ! 667: * PTXT pTxt - pointer to the text to scroll ! 668: * INT n - number of lines to scroll ! 669: * ! 670: * Returns: ! 671: * VOID ! 672: \*****************************************************************************/ ! 673: ! 674: PRIVATE VOID ! 675: DebugVScroll( ! 676: HWND hwnd, ! 677: PTXT pTxt, ! 678: INT n ! 679: ) ! 680: { ! 681: RECT rect; ! 682: INT iMinPos, iMaxPos; ! 683: ! 684: GetScrollRange(hwnd, SB_VERT, (LPINT) &iMinPos, (LPINT) &iMaxPos); ! 685: GetClientRect(hwnd, (LPRECT) &rect); ! 686: rect.left += OFFSETX; ! 687: rect.top += OFFSETY; ! 688: ! 689: n = BOUND(pTxt->iTop + n, iMinPos, iMaxPos) - pTxt->iTop; ! 690: if (n == 0) ! 691: return; ! 692: ! 693: pTxt->iTop += n; ! 694: ScrollWindow(hwnd, 0, -n * pTxt->Tdy, (LPRECT) &rect, (LPRECT) &rect); ! 695: SetScrollPos(hwnd, SB_VERT, pTxt->iTop, TRUE); ! 696: } ! 697: ! 698: /*****************************************************************************\ ! 699: * DebugHScroll ! 700: * ! 701: * Performs the horizontal scroll calculations ! 702: * ! 703: * Arguments: ! 704: * HWND hwnd - handle to the debug window ! 705: * PTXT pTxt - pointer to the text to scroll ! 706: * INT n - number of characters to scroll ! 707: * ! 708: * Returns: ! 709: * VOID ! 710: \*****************************************************************************/ ! 711: ! 712: PRIVATE VOID ! 713: DebugHScroll( ! 714: HWND hwnd, ! 715: PTXT pTxt, ! 716: INT n ! 717: ) ! 718: { ! 719: RECT rect; ! 720: INT iMinPos, iMaxPos; ! 721: ! 722: GetScrollRange (hwnd, SB_HORZ, (LPINT) &iMinPos, (LPINT) &iMaxPos); ! 723: GetClientRect (hwnd, (LPRECT) & rect); ! 724: rect.left += OFFSETX; ! 725: rect.top += OFFSETY; ! 726: ! 727: n = BOUND(pTxt->iLeft + n, iMinPos, iMaxPos) - pTxt->iLeft; ! 728: if (n == 0) ! 729: return; ! 730: ! 731: pTxt->iLeft += n; ! 732: ScrollWindow(hwnd, -n * pTxt->Tdx, 0, (LPRECT) & rect, (LPRECT) & rect); ! 733: SetScrollPos(hwnd, SB_HORZ, pTxt->iLeft, TRUE); ! 734: } ! 735: ! 736: /*****************************************************************************\ ! 737: * LinesInDebugWindow ! 738: * ! 739: * Calculates the number of lines in the debug window ! 740: * ! 741: * Arguments: ! 742: * HWND hwnd - handle to the debug window ! 743: * ! 744: * Returns: ! 745: * INT - number of lines in the debug window ! 746: \*****************************************************************************/ ! 747: ! 748: PRIVATE INT ! 749: LinesInDebugWindow ( ! 750: HWND hwnd ! 751: ) ! 752: { ! 753: RECT CRect; ! 754: PTXT pTxt; ! 755: ! 756: pTxt = *(HTXT)GetWindowLong(hwnd, 0); ! 757: GetClientRect(hwnd, &CRect); ! 758: if ( pTxt->Tdy == 0 ) { ! 759: return 0; ! 760: } ! 761: return pTxt ? (CRect.bottom - CRect.top - OFFSETY) / pTxt->Tdy : 0; ! 762: } ! 763: ! 764: ! 765: /*****************************************************************************\ ! 766: * CharsInDebugWindow ! 767: * ! 768: * Calculates the number of characters horizontally in the debug window ! 769: * ! 770: * Arguments: ! 771: * HWND hwnd - handle to the debug window ! 772: * ! 773: * Returns: ! 774: * INT - number of horizontal characters in the debug window ! 775: \*****************************************************************************/ ! 776: ! 777: PRIVATE INT ! 778: CharsInDebugWindow ( ! 779: HWND hwnd ! 780: ) ! 781: { ! 782: RECT CRect; ! 783: PTXT pTxt; ! 784: ! 785: pTxt = *(HTXT)GetWindowLong (hwnd, 0); ! 786: GetClientRect(hwnd, (LPRECT) & CRect); ! 787: if ( pTxt->Tdx == 0 ) { ! 788: return 0; ! 789: } ! 790: return pTxt ? (CRect.right - CRect.left - OFFSETX) / pTxt->Tdx : 0; ! 791: } ! 792: ! 793: /*****************************************************************************\ ! 794: * vwprintf ! 795: * ! 796: * variable printf - works like the C runtime printf ! 797: * ! 798: * Arguments: ! 799: * HWND hwnd - handle to the debug window ! 800: * LPSTR format - pointer to the format string ! 801: * LPSTR marker - pointer to marker ! 802: * ! 803: * Returns: ! 804: * INT - number of arguments printed ! 805: \*****************************************************************************/ ! 806: ! 807: PUBLIC INT FAR cdecl ! 808: vwprintf( ! 809: HWND hwnd, ! 810: LPSTR format, ! 811: LPSTR marker ! 812: ) ! 813: { ! 814: static HWND hwndLast = NULL; ! 815: static CHAR pchBuf[MAXBUFLEN]; ! 816: RECT rect; ! 817: INT iRet; ! 818: INT iLine; // lines of output to show ! 819: INT cLine; // lines in the current window ! 820: INT cScroll; // how much left to scroll ! 821: PTXT pTxt; ! 822: HTXT hTxt; ! 823: ! 824: if (hwnd == NULL) ! 825: hwnd = hwndLast; ! 826: ! 827: if (hwnd == NULL || !IsWindow(hwnd)) ! 828: return 0; /* exit if bad window handle */ ! 829: ! 830: hwndLast = hwnd; ! 831: ! 832: // ! 833: // First format the line and wait until we can play with the Txt structure ! 834: // ! 835: iRet = wvsprintf((LPSTR)pchBuf, format, marker); ! 836: hTxt = (HTXT)GetWindowLong(hwnd, 0); ! 837: pTxt = (PTXT)LocalLock((HANDLE)hTxt); ! 838: ! 839: EnterCrit(pTxt); ! 840: ! 841: // ! 842: // Number of lines that we can display stuff in ! 843: // ! 844: cLine = LinesInDebugWindow(hwnd); ! 845: ! 846: // ! 847: // Number of lines actually displayed in the current window ! 848: // ! 849: iLine = pTxt->iCount - pTxt->iTop; ! 850: ! 851: // ! 852: // Return value is number of new lines to display ! 853: // ! 854: cScroll = InsertString(pTxt, pchBuf); ! 855: ! 856: // ! 857: // Now make sure the new text is painted only if visable ! 858: // ! 859: GetClientRect(hwnd, (LPRECT) & rect); ! 860: ! 861: // ! 862: // Calculate how much of the window to invalidate ! 863: // ! 864: rect.top += (iLine - 1) * pTxt->Tdy; ! 865: ! 866: InvalidateRect(hwnd, (LPRECT)&rect, TRUE); ! 867: ! 868: // ! 869: // If we have more lines than we can display, scroll the window ! 870: // such that the last line printed is now at the bottom ! 871: // ! 872: if (iLine + cScroll > cLine) { ! 873: cScroll = iLine + cScroll - cLine; ! 874: DebugVScroll(hwnd, pTxt, cScroll); ! 875: LeaveCrit(pTxt); ! 876: wprintfSetScrollRange(hwnd, FALSE); ! 877: } else { ! 878: LeaveCrit(pTxt); ! 879: } ! 880: ! 881: LocalUnlock((HANDLE)hTxt); ! 882: ! 883: return(iRet); /* return the count of arguments printed */ ! 884: } ! 885: ! 886: /*****************************************************************************\ ! 887: * wprintfSetScrollRange ! 888: * ! 889: * Sets the scroll range of the debug window ! 890: * ! 891: * Arguments: ! 892: * HWND hwnd - handle to the debug window ! 893: * BOOL fRedraw - whether or not to redraw the window ! 894: * ! 895: * Returns: ! 896: * VOID ! 897: \*****************************************************************************/ ! 898: ! 899: PRIVATE VOID ! 900: wprintfSetScrollRange ( ! 901: HWND hwnd, ! 902: BOOL bRedraw ! 903: ) ! 904: { ! 905: PTXT pTxt; ! 906: INT iRange; ! 907: INT iLeftCritSect = 0; ! 908: ! 909: iSem++; ! 910: pTxt = *(HTXT)GetWindowLong(hwnd, 0); ! 911: ! 912: /* Update the scroll bars */ ! 913: iRange = pTxt->iCount - 1 - LinesInDebugWindow(hwnd); ! 914: ! 915: if (iRange < 0) { ! 916: iRange = 0; ! 917: DebugVScroll(hwnd, pTxt, -pTxt->iTop); ! 918: } ! 919: ! 920: while (GetCurrentThreadId() == (DWORD)pTxt->csSync.OwningThread){ ! 921: LeaveCrit(pTxt); ! 922: iLeftCritSect++; ! 923: } ! 924: ! 925: SetScrollRange(hwnd, SB_VERT, 0, iRange, FALSE); ! 926: SetScrollPos(hwnd, SB_VERT, pTxt->iTop, bRedraw); ! 927: ! 928: if(iLeftCritSect) { ! 929: EnterCrit(pTxt); ! 930: } ! 931: ! 932: iRange = pTxt->MaxLen - CharsInDebugWindow(hwnd) + 1; ! 933: if (iRange < 0) { ! 934: iRange = 0; ! 935: DebugHScroll(hwnd, pTxt, -pTxt->iLeft); ! 936: } ! 937: ! 938: if(iLeftCritSect) ! 939: LeaveCrit(pTxt); ! 940: ! 941: SetScrollRange(hwnd, SB_HORZ, 0, iRange, FALSE); ! 942: SetScrollPos(hwnd, SB_HORZ, pTxt->iLeft, bRedraw); ! 943: ! 944: while (iLeftCritSect--) { ! 945: EnterCrit(pTxt); ! 946: } ! 947: ! 948: iSem--; ! 949: } ! 950: ! 951: /*****************************************************************************\ ! 952: * NewLine ! 953: * ! 954: * Calculates when a new line is needed in the debug window ! 955: * ! 956: * Arguments: ! 957: * PTXT pTxt - pointer to the text ! 958: * ! 959: * Returns: ! 960: * VOID ! 961: \*****************************************************************************/ ! 962: ! 963: PRIVATE VOID ! 964: NewLine ( ! 965: PTXT pTxt ! 966: ) ! 967: { ! 968: INT iLast = LAST(pTxt); ! 969: ! 970: if (pTxt->iCount == pTxt->iMaxLines) { ! 971: LocalFree ((HANDLE)pTxt->arLines[pTxt->iFirst].hText); ! 972: pTxt->arLines[pTxt->iFirst].hText = NULL; ! 973: INC (pTxt, pTxt->iFirst); ! 974: if (pTxt->iTop > 0) { ! 975: pTxt->iTop--; ! 976: } ! 977: } else { ! 978: pTxt->iCount++; ! 979: } ! 980: iLast = LAST(pTxt); ! 981: pTxt->arLines[iLast].hText = NULL; ! 982: pTxt->arLines[iLast].iLen = 0; ! 983: } ! 984: ! 985: /*****************************************************************************\ ! 986: * InsertString ! 987: * ! 988: * Inserts a string into the debug window ! 989: * ! 990: * Arguments: ! 991: * PTXT pTxt - pointer to the text ! 992: * CHAR *str - pointer to insertion string ! 993: * ! 994: * Returns: ! 995: * INT - Line number at which string was inserted ! 996: \*****************************************************************************/ ! 997: ! 998: PRIVATE INT ! 999: InsertString ( ! 1000: PTXT pTxt, ! 1001: CHAR *str ! 1002: ) ! 1003: { ! 1004: CHAR pchBuf[MAXBUFLEN]; /* intermediate buffer */ ! 1005: INT iBuf; ! 1006: INT iLast = LAST(pTxt); ! 1007: INT cLine = 0; ! 1008: ! 1009: for (iBuf = 0; iBuf < pTxt->arLines[iLast].iLen; iBuf++) ! 1010: pchBuf[iBuf] = (*pTxt->arLines[iLast].hText)[iBuf]; ! 1011: ! 1012: while (*str != '\0') { ! 1013: while ((*str != '\n') && (*str != '\0')) ! 1014: pchBuf[iBuf++] = *str++; ! 1015: ! 1016: if (pTxt->arLines[iLast].hText != NULL) ! 1017: LocalFree((HANDLE)pTxt->arLines[iLast].hText); ! 1018: ! 1019: /* Test for the case of a zero length line, Only brian would do this */ ! 1020: ! 1021: if (iBuf == 0) ! 1022: pTxt->arLines[iLast].hText == NULL; ! 1023: else { ! 1024: if ((pTxt->arLines[iLast].hText = (CHAR **)LocalAlloc(LHND, iBuf)) ! 1025: == NULL) { ! 1026: return 0; ! 1027: } ! 1028: } ! 1029: ! 1030: pTxt->arLines[iLast].iLen = iBuf; ! 1031: while (--iBuf >= 0 ) ! 1032: (*pTxt->arLines[iLast].hText)[iBuf] = pchBuf[iBuf]; ! 1033: ! 1034: if (*str == '\n') { /* Now do the next string after the \n */ ! 1035: str++; ! 1036: cLine++; ! 1037: iBuf = 0; ! 1038: NewLine(pTxt); ! 1039: INC(pTxt, iLast); ! 1040: } ! 1041: } ! 1042: ! 1043: return cLine; ! 1044: } ! 1045: ! 1046: /*****************************************************************************\ ! 1047: * CopyToClipboard ! 1048: * ! 1049: * Copies all lines to the clipboard in text format. ! 1050: * ! 1051: * Arguments: ! 1052: * none ! 1053: * ! 1054: * Returns: ! 1055: * TRUE if successful, FALSE if not. ! 1056: * ! 1057: \*****************************************************************************/ ! 1058: ! 1059: BOOL ! 1060: CopyToClipboard( ! 1061: VOID ! 1062: ) ! 1063: { ! 1064: PTXT pTxt; ! 1065: INT iQueue; ! 1066: INT cch; ! 1067: INT i; ! 1068: BOOL fSuccess = FALSE; ! 1069: LPSTR pBuf = NULL; ! 1070: LPSTR pb; ! 1071: ! 1072: pTxt = *(HTXT)GetWindowLong(ghwndPrintf, 0); ! 1073: ! 1074: EnterCrit(pTxt); ! 1075: ! 1076: iQueue = FIRST(pTxt); ! 1077: cch = 0; ! 1078: for (i = 0; i < pTxt->iCount; i++, INC(pTxt, iQueue)) ! 1079: { ! 1080: if (pTxt->arLines[iQueue].hText != NULL) ! 1081: { ! 1082: // ! 1083: // Count the characters in the line, plus room for the ! 1084: // carriage return and newline. ! 1085: // ! 1086: cch += pTxt->arLines[iQueue].iLen; ! 1087: cch += 2; ! 1088: } ! 1089: } ! 1090: ! 1091: // ! 1092: // Add one for the terminating null. ! 1093: // ! 1094: cch++; ! 1095: ! 1096: if (!(pBuf = (LPSTR)GlobalAlloc(GMEM_DDESHARE, cch * sizeof(TCHAR)))) ! 1097: { ! 1098: LeaveCrit(pTxt); ! 1099: return FALSE; ! 1100: } ! 1101: ! 1102: pb = pBuf; ! 1103: iQueue = FIRST(pTxt); ! 1104: for (i = 0; i < pTxt->iCount; i++, INC(pTxt, iQueue)) ! 1105: { ! 1106: if (pTxt->arLines[iQueue].hText != NULL) ! 1107: { ! 1108: lstrcpy(pb, *pTxt->arLines[iQueue].hText); ! 1109: pb += pTxt->arLines[iQueue].iLen; ! 1110: *pb++ = '\r'; ! 1111: *pb++ = '\n'; ! 1112: } ! 1113: } ! 1114: ! 1115: LeaveCrit(pTxt); ! 1116: ! 1117: if (OpenClipboard(ghwndSpyApp)) ! 1118: { ! 1119: EmptyClipboard(); ! 1120: fSuccess = SetClipboardData(CF_TEXT, pBuf) ? TRUE : FALSE; ! 1121: CloseClipboard(); ! 1122: } ! 1123: ! 1124: return fSuccess; ! 1125: } ! 1126: ! 1127: /*****************************************************************************\ ! 1128: * IsPrintfEmpty ! 1129: * ! 1130: * Used to determine if the printf window is empty or not. ! 1131: * ! 1132: * Arguments: ! 1133: * none ! 1134: * ! 1135: * Returns: ! 1136: * TRUE if the printf window is empty, FALSE if there is at least ! 1137: * one line in the window. ! 1138: * ! 1139: \*****************************************************************************/ ! 1140: ! 1141: BOOL ! 1142: IsPrintfEmpty( ! 1143: VOID ! 1144: ) ! 1145: { ! 1146: PTXT pTxt; ! 1147: ! 1148: pTxt = *(HTXT)GetWindowLong(ghwndPrintf, 0); ! 1149: ! 1150: // ! 1151: // It is empty if the line count is zero (doesn't currently happen) ! 1152: // or if there is only one line and it is NULL. ! 1153: // ! 1154: return (pTxt->iCount == 0 || ! 1155: (pTxt->iCount == 1 && pTxt->arLines[FIRST(pTxt)].hText == NULL)) ! 1156: ? TRUE : FALSE; ! 1157: } ! 1158:
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.