![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to ddespy.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [WindowsNT SDKs] / mstools / samples / sdktools / ddespy|
Return to ddespy.c CVS log | Up to [WindowsNT SDKs] / mstools / samples / sdktools / ddespy |
1.1 root 1: /****************************************************************************
2:
3: PROGRAM: DdeSpy.c
4:
5: ****************************************************************************/
6:
7: #include <windows.h> /* required for all Windows applications */
8: #include <windowsx.h>
9: #include <shellapi.h>
10: #include <dde.h>
11: #include <stdio.h>
12: #include <io.h>
13: #include <errno.h>
14: #include <string.h>
15: #include <stdlib.h>
16: #include <ctype.h>
17: #include "ddespy.h"
18: #include "lists.h"
19:
20: /* GLOBAL Variables used for DDESPY */
21:
22: UINT idInst = 0;
23: HANDLE hInst;
24: HICON hIcon;
25: HWND hWndString = NULL;
26: HWND hwndSpy = NULL;
27: INT fhOutput = 0;
28: OFSTRUCT ofsOpen;
29: CHAR OpenName[MAX_FNAME + 1];
30: CHAR TBuf[BUFFER_SIZE];
31: CHAR TBuf2[BUFFER_SIZE];
32: CHAR szNULL[] = "";
33: PSTR apszResources[IDS_LAST + 1];
34: PFNCALLBACK pfnDdeCallback = NULL;
35: HWND hwndTrack[IT_COUNT] = { 0 };
36: PSTR TrackTitle[IT_COUNT];
37: BOOL fBlockMsg[WM_DDE_LAST - WM_DDE_FIRST + 1] = { 0 };
38: BOOL fBlockCb[15] = { 0 };
39: PSTR TrackHeading[IT_COUNT];
40: struct { /* profile data */
41: BOOL fOutput[IO_COUNT];
42: BOOL fFilter[IF_COUNT];
43: BOOL fTrack[IT_COUNT];
44: BOOL fTerse;
45: } pro;
46:
47:
48:
49: BOOL LoadResourceStrings()
50: {
51: int i, cbLeft, cbRes;
52: PSTR psz;
53:
54: cbLeft = 0x1000;
55: psz = LocalAlloc(LPTR, cbLeft);
56: for (i = 0; i <= IDS_LAST; i++) {
57: apszResources[i] = psz;
58: cbRes = LoadString(hInst, i, psz, cbLeft) + 1;
59: cbLeft -= cbRes;
60: psz += cbRes;
61: }
62: for (i = 0; i < IT_COUNT; i++) {
63: TrackTitle[i] = RefString(IDS_TRACKTITLE_1 + i);
64: TrackHeading[i] = RefString(IDS_TRACKHEADING_1 + i);
65: }
66: strcpy(TBuf, RefString(IDS_DEFAULT_OUTPUT_FNAME));
67: GetFullPathName(TBuf, sizeof(OpenName), OpenName, (LPTSTR *)TBuf2);
68: return(TRUE);
69: }
70:
71:
72:
73: int WINAPI WinMain(
74: HINSTANCE hInstance,
75: HINSTANCE hPrevInstance,
76: LPSTR lpCmdLine,
77: int nCmdShow)
78: {
79: MSG msg;
80:
81: UNREFERENCED_PARAMETER(lpCmdLine);
82:
83: hInst = hInstance;
84:
85: if (!LoadResourceStrings()) {
86: return (FALSE);
87: }
88:
89: if (!hPrevInstance)
90: if (!InitApplication(hInstance)) /* Initialize shared things */
91: return (FALSE); /* Exits if unable to initialize */
92:
93: /* Perform initializations that apply to a specific instance */
94:
95: if (!InitInstance(hInstance, nCmdShow)) {
96: CloseApp();
97: return (FALSE);
98: }
99:
100: /* Acquire and dispatch messages until a WM_QUIT message is received. */
101:
102: while (GetMessage(&msg, /* message structure */
103: NULL, /* handle of window receiving the message */
104: 0, /* lowest message to examine */
105: 0)) /* highest message to examine */
106: {
107: TranslateMessage(&msg); /* Translates virtual key codes */
108: DispatchMessage(&msg); /* Dispatches message to window */
109: }
110: CloseApp();
111: return (msg.wParam); /* Returns the value from PostQuitMessage */
112: }
113:
114:
115:
116: BOOL InitApplication(HINSTANCE hInstance)
117: {
118: WNDCLASS wc;
119:
120: if (!InitTestSubs())
121: return(FALSE);
122:
123: /* Fill in window class structure with parameters that describe the */
124: /* main window. */
125:
126: wc.style = 0; /* Class style(s). */
127: wc.lpfnWndProc = (WNDPROC)MainWndProc; /* Function to retrieve messages for */
128: /* windows of this class. */
129: wc.cbClsExtra = 0; /* No per-class extra data. */
130: wc.cbWndExtra = 0; /* No per-window extra data. */
131: wc.hInstance = hInstance; /* Application that owns the class. */
132: hIcon = wc.hIcon = LoadIcon(hInstance, RefString(IDS_TITLE));
133: wc.hCursor = LoadCursor(NULL, IDC_ARROW);
134: wc.hbrBackground = GetStockObject(WHITE_BRUSH);
135: wc.lpszMenuName = MAKEINTRESOURCE(IDR_MENU); /* Name of menu resource in .RC file. */
136: wc.lpszClassName = RefString(IDS_CLASS);
137:
138: /* Register the window class and return success/failure code. */
139:
140: return (RegisterClass(&wc));
141: }
142:
143:
144: BOOL InitInstance(HINSTANCE hInstance, int nCmdShow)
145: {
146: RECT Rect;
147: INT i;
148:
149: /* Save the instance handle in static variable, which will be used in */
150: /* many subsequence calls from this application to Windows. */
151:
152: pfnDdeCallback = (PFNCALLBACK)MakeProcInstance((FARPROC)DdeCallback,
153: hInstance);
154:
155: GetProfile();
156:
157: /* Create a main window for this application instance. */
158:
159: hwndSpy = CreateWindow(
160: RefString(IDS_CLASS),
161: RefString(IDS_TITLE),
162: WS_OVERLAPPEDWINDOW | WS_CLIPCHILDREN,
163: CW_USEDEFAULT, /* Default horizontal position. */
164: CW_USEDEFAULT, /* Default vertical position. */
165: CW_USEDEFAULT, /* Default width. */
166: CW_USEDEFAULT, /* Default height. */
167: NULL, /* Overlapped windows have no parent. */
168: NULL, /* Use the window class menu. */
169: hInstance, /* This instance owns this window. */
170: NULL /* Pointer not needed. */
171: );
172:
173:
174: GetClientRect(hwndSpy, (LPRECT) &Rect);
175:
176: hWndString = CreateWindow( /* String Window (class Registered in Teststubs)*/
177: RefString(IDS_STRINGCLASS),
178: szNULL,
179: WS_CHILD | WS_VISIBLE | WS_HSCROLL | WS_VSCROLL,
180: 0,
181: 0,
182: Rect.right - Rect.left,
183: Rect.bottom - Rect.top,
184: hwndSpy,
185: NULL,
186: hInst,
187: (LPSTR)MAKELONG(CCHARS, CLINES));
188:
189: for (i = 0; i < IT_COUNT; i++) {
190: if (pro.fTrack[i]) {
191: pro.fTrack[i] = FALSE;
192: SendMessage(hwndSpy, WM_COMMAND,
193: GET_WM_COMMAND_MPS(IDM_TRACK_FIRST + i, 0, 0));
194: }
195: }
196:
197: if (!hwndSpy || !hWndString) {
198: CloseApp();
199: return (FALSE);
200: }
201:
202: /* Make the window visible; update its client area; and return "success" */
203:
204: ShowWindow(hwndSpy, nCmdShow); /* Show the window */
205: UpdateWindow(hwndSpy); /* Sends WM_PAINT message */
206:
207: if (SetFilters()) {
208: return(FALSE);
209: }
210:
211: return(TRUE);
212: }
213:
214:
215: VOID CloseApp()
216: {
217: DdeUninitialize(idInst); /* perform cleanup and store profile */
218: SaveProfile();
219: if (fhOutput)
220: _lclose(fhOutput);
221: UnregisterClass(RefString(IDS_CLASS), hInst);
222: CloseTestSubs(hInst);
223: }
224:
225:
226:
227: LONG CALLBACK MainWndProc(HWND hWnd, UINT message, WPARAM wParam, LPARAM lParam)
228: {
229: int i;
230:
231: switch (message) {
232: case WM_CREATE:
233: LoadAccelerators(hInst, MAKEINTRESOURCE(IDR_ACCEL));
234: if (pro.fOutput[IO_FILE])
235: pro.fOutput[IO_FILE] = fhOutput =
236: DoDialog(MAKEINTRESOURCE(IDD_OPEN), (DLGPROC)OpenDlg, 0, TRUE, hWnd, hInst);
237: break;
238:
239: case WM_INITMENU:
240: if (GetMenu(hWnd) != (HMENU)wParam)
241: break;
242:
243: for (i = 0; i < IO_COUNT; i++) {
244: CheckMenuItem((HMENU)wParam, IDM_OUTPUT_FIRST + i,
245: pro.fOutput[i] ? MF_CHECKED : MF_UNCHECKED);
246: }
247:
248: for (i = 0; i < IF_COUNT; i++) {
249: CheckMenuItem((HMENU)wParam, IDM_FILTER_FIRST + i,
250: pro.fFilter[i] ? MF_CHECKED : MF_UNCHECKED);
251: }
252:
253: for (i = 0; i < IT_COUNT; i++) {
254: CheckMenuItem((HMENU)wParam, IDM_TRACK_FIRST + i,
255: pro.fTrack[i] ? MF_CHECKED : MF_UNCHECKED);
256: }
257: break;
258:
259: case WM_COMMAND: /* message: command from application menu */
260: switch (GET_WM_COMMAND_ID(wParam, lParam)) {
261: case IDM_OUTPUT_FILE:
262: case IDM_OUTPUT_DEBUG:
263: case IDM_OUTPUT_SCREEN:
264: switch (wParam) {
265: case IDM_OUTPUT_FILE:
266: if (fhOutput) {
267: wsprintf(TBuf, RefString(IDS_QCLOSEFILE_TEXT), OpenName);
268: if (IDYES != MessageBox(hWnd,
269: TBuf, RefString(IDS_QCLOSEFILE_CAPTION),
270: MB_YESNO | MB_ICONQUESTION)) {
271: break;
272: }
273: _lclose(fhOutput);
274: }
275: pro.fOutput[IO_FILE] = fhOutput =
276: DoDialog(MAKEINTRESOURCE(IDD_OPEN), (DLGPROC)OpenDlg, 0, TRUE, hWnd, hInst);
277: break;
278:
279: case IDM_OUTPUT_DEBUG:
280: pro.fOutput[IO_DEBUG] = !pro.fOutput[IO_DEBUG];
281: break;
282:
283: case IDM_OUTPUT_SCREEN:
284: pro.fOutput[IO_SCREEN] = !pro.fOutput[IO_SCREEN];
285: break;
286:
287: }
288: break;
289:
290: case IDM_CLEARSCREEN:
291: if (hWndString) {
292: HANDLE hpsw;
293: STRWND *psw;
294:
295: hpsw = (HANDLE)GetWindowLong(hWndString, 0);
296: psw = (STRWND *)LocalLock(hpsw);
297: ClearScreen(psw);
298: LocalUnlock(hpsw);
299: InvalidateRect(hWndString, NULL, TRUE);
300: }
301: break;
302:
303: case IDM_MARK:
304: DoDialog(MAKEINTRESOURCE(IDD_VALUEENTRY), (DLGPROC)MarkDlgProc, 0, TRUE, hWnd, hInst);
305: break;
306:
307: case IDM_FILTER_HSZINFO:
308: case IDM_FILTER_INIT_TERM:
309: case IDM_FILTER_DDEMSGS:
310: case IDM_FILTER_CALLBACKS:
311: case IDM_FILTER_ERRORS:
312: pro.fFilter[wParam - IDM_FILTER_FIRST] =
313: !pro.fFilter[wParam - IDM_FILTER_FIRST];
314: SetFilters();
315: break;
316:
317: case IDM_FILTER_DIALOG:
318: DoDialog(MAKEINTRESOURCE(IDD_MSGFILTERS), (DLGPROC)FilterDlgProc, 0, TRUE, hWnd, hInst);
319: break;
320:
321: case IDM_TRACK_HSZS:
322: case IDM_TRACK_CONVS:
323: case IDM_TRACK_LINKS:
324: case IDM_TRACK_SVRS:
325: pro.fTrack[wParam - IDM_TRACK_FIRST] =
326: !pro.fTrack[wParam - IDM_TRACK_FIRST];
327: if (pro.fTrack[wParam - IDM_TRACK_FIRST]) {
328: hwndTrack[wParam - IDM_TRACK_FIRST] = CreateMCLBFrame(
329: NULL,
330: TrackTitle[wParam - IDM_TRACK_FIRST],
331: WS_OVERLAPPEDWINDOW | WS_VISIBLE | WS_MINIMIZE,
332: hIcon, (HBRUSH)(COLOR_APPWORKSPACE + 1),
333: TrackHeading[wParam - IDM_TRACK_FIRST]);
334: } else {
335: DestroyWindow(hwndTrack[wParam - IDM_TRACK_FIRST]);
336: hwndTrack[wParam - IDM_TRACK_FIRST] = 0;
337: }
338: SetFilters();
339: break;
340:
341: case IDM_ABOUT:
342: DoDialog(MAKEINTRESOURCE(IDD_ABOUTBOX), (DLGPROC)About, 0, TRUE, hWnd, hInst);
343: break;
344:
345: default:
346: return (DefWindowProc(hWnd, message, wParam, lParam));
347: }
348: break;
349:
350: case WM_DESTROY: /* message: window being destroyed */
351: for (i = IDM_TRACK_FIRST; i <= IDM_TRACK_LAST; i++) {
352: if (pro.fTrack[i - IDM_TRACK_FIRST]) {
353: DestroyWindow(hwndTrack[i - IDM_TRACK_FIRST]);
354: hwndTrack[i - IDM_TRACK_FIRST] = 0;
355: }
356: }
357: PostQuitMessage(0);
358: break;
359:
360: case WM_SIZE:
361: if (hWndString) {
362: RECT rc;
363:
364: GetClientRect(hWnd, &rc);
365: MoveWindow(hWndString, 0, 0, rc.right, rc.bottom, TRUE);
366: }
367: // fall through
368: default:
369: return (DefWindowProc(hWnd, message, wParam, lParam));
370: }
371: return (0);
372: }
373:
374:
375:
376:
377:
378: BOOL CALLBACK About(
379: HWND hDlg,
380: UINT message,
381: WPARAM wParam,
382: LPARAM lParam)
383: {
384: switch (message) {
385: case WM_INITDIALOG: /* message: initialize dialog box */
386: return (TRUE);
387:
388: case WM_COMMAND: /* message: received a command */
389: if (GET_WM_COMMAND_ID(wParam, lParam) == IDOK
390: || GET_WM_COMMAND_ID(wParam, lParam) == IDCANCEL) {
391: EndDialog(hDlg, TRUE); /* Exits the dialog box */
392: return (TRUE);
393: }
394: break;
395: }
396: return (FALSE); /* Didn't process a message */
397: }
398:
399:
400: HDDEDATA CALLBACK DdeCallback(
401: UINT wType,
402: UINT wFmt,
403: HCONV hConv,
404: HSZ hsz1,
405: HSZ hsz2,
406: HDDEDATA hData,
407: UINT dwData1,
408: UINT dwData2)
409: {
410: LPVOID pData;
411: UINT cb;
412: CHAR *psz1, *psz2, *psz3;
413: CHAR *szAction;
414: INT i;
415: BOOL fInt = FALSE;
416: wFmt;
417: hConv;
418: dwData1;
419:
420: switch (wType) {
421: case XTYP_MONITOR:
422: if (pData = DdeAccessData(hData, (LPDWORD)&cb)) {
423: switch (dwData2) {
424: case MF_HSZ_INFO:
425: if (pro.fTrack[IT_HSZS]) {
426: switch (((MONHSZSTRUCT FAR *)pData)->fsAction) {
427: case MH_DELETE:
428: wsprintf(TBuf, fInt ? "0x%lx\t*\t%s(int)" : "0x%lx\t*\t%s",
429: ((MONHSZSTRUCT FAR *)pData)->hsz,
430: (LPSTR)((MONHSZSTRUCT FAR *)pData)->str);
431: i = GetMCLBColValue(TBuf, hwndTrack[IT_HSZS], 2);
432: if (i > 1) {
433: wsprintf(TBuf2, fInt ? "0x%lx\t%d\t%s(int)" : "0x%lx\t%d\t%s",
434: ((MONHSZSTRUCT FAR *)pData)->hsz,
435: i - 1,
436: (LPSTR)((MONHSZSTRUCT FAR *)pData)->str);
437: AddMCLBText(TBuf, TBuf2, hwndTrack[IT_HSZS]);
438: } else if (i == 1) {
439: DeleteMCLBText(TBuf, hwndTrack[IT_HSZS]);
440: }
441: break;
442:
443: case MH_KEEP:
444: case MH_CREATE:
445: wsprintf(TBuf, fInt ? "0x%lx\t*\t%s(int)" : "0x%lx\t*\t%s",
446: ((MONHSZSTRUCT FAR *)pData)->hsz,
447: (LPSTR)((MONHSZSTRUCT FAR *)pData)->str);
448: i = GetMCLBColValue(TBuf, hwndTrack[IT_HSZS], 2) + 1;
449: wsprintf(TBuf2, fInt ? "0x%lx\t%d\t%s(int)" : "0x%lx\t%d\t%s",
450: ((MONHSZSTRUCT FAR *)pData)->hsz,
451: i,
452: (LPSTR)((MONHSZSTRUCT FAR *)pData)->str);
453: AddMCLBText(TBuf, TBuf2, hwndTrack[IT_HSZS]);
454: }
455: }
456:
457: if (!pro.fFilter[IF_HSZ]) {
458: return(0);
459: }
460:
461: switch (((MONHSZSTRUCT FAR *)pData)->fsAction) {
462: case MH_CLEANUP:
463: szAction = RefString(IDS_ACTION_CLEANEDUP);
464: break;
465:
466: case MH_DELETE:
467: szAction = RefString(IDS_ACTION_DESTROYED);
468: break;
469:
470: case MH_KEEP:
471: szAction = RefString(IDS_ACTION_INCREMENTED);
472: break;
473:
474: case MH_CREATE:
475: szAction = RefString(IDS_ACTION_CREATED);
476: break;
477:
478: default:
479: DdeUnaccessData(hData);
480: return(0);
481: }
482: if (pro.fTerse) {
483: wsprintf(TBuf, "[%x:%ld] HSZ %s: %lx(%s)",
484: ((MONHSZSTRUCT FAR *)pData)->hTask,
485: ((MONHSZSTRUCT FAR *)pData)->dwTime,
486: (LPSTR)szAction,
487: ((MONHSZSTRUCT FAR *)pData)->hsz,
488: (LPSTR)((MONHSZSTRUCT FAR *)pData)->str);
489: } else {
490: wsprintf(TBuf, "Task:0x%x, Time:%ld, String Handle %s: %lx(%s)",
491: ((MONHSZSTRUCT FAR *)pData)->hTask,
492: ((MONHSZSTRUCT FAR *)pData)->dwTime,
493: (LPSTR)szAction,
494: ((MONHSZSTRUCT FAR *)pData)->hsz,
495: (LPSTR)((MONHSZSTRUCT FAR *)pData)->str);
496: }
497: break;
498:
499:
500: case MF_SENDMSGS:
501: case MF_POSTMSGS:
502: if (fBlockMsg[((MONMSGSTRUCT FAR *)pData)->wMsg - WM_DDE_FIRST]) {
503: return(0);
504: }
505: if (pro.fTerse) {
506: wsprintf(TBuf, RefString(IDS_FMT_TRS_MSG1),
507: ((MONMSGSTRUCT FAR *)pData)->hTask,
508: ((MONMSGSTRUCT FAR *)pData)->dwTime,
509: ((MONMSGSTRUCT FAR *)pData)->wParam,
510: ((MONMSGSTRUCT FAR *)pData)->hwndTo,
511: (dwData2 == MF_SENDMSGS) ? RefString(IDS_SENT) : RefString(IDS_POSTED),
512: (LPSTR)DdeMsg2String(((MONMSGSTRUCT FAR *)pData)->wMsg));
513: } else {
514: wsprintf(TBuf, RefString(IDS_FMT_MSG1),
515: ((MONMSGSTRUCT FAR *)pData)->hTask,
516: ((MONMSGSTRUCT FAR *)pData)->dwTime,
517: ((MONMSGSTRUCT FAR *)pData)->hwndTo,
518: (dwData2 == MF_SENDMSGS) ? RefString(IDS_SENT) : RefString(IDS_POSTED),
519: (LPSTR)DdeMsg2String(((MONMSGSTRUCT FAR *)pData)->wMsg));
520: }
521: OutputString(TBuf);
522: wsprintf(TBuf, pro.fTerse ? RefString(IDS_FMT_TRS_MSG2) : RefString(IDS_FMT_MSG2),
523: ((MONMSGSTRUCT FAR *)pData)->wParam);
524: DisectMsgLP(((MONMSGSTRUCT FAR *)pData)->wMsg,
525: ((MONMSGSTRUCT FAR *)pData),
526: &TBuf[strlen(TBuf)]);
527: break;
528:
529:
530: case MF_CALLBACKS:
531: if (fBlockCb[(((MONCBSTRUCT FAR *)pData)->wType & XTYP_MASK) >> XTYP_SHIFT]) {
532: return(0);
533: }
534: wsprintf(TBuf,
535: pro.fTerse ? RefString(IDS_FMT_TRS_CB1) : RefString(IDS_FMT_CB1),
536: ((MONCBSTRUCT FAR *)pData)->hTask,
537: ((MONCBSTRUCT FAR *)pData)->dwTime,
538: (LPSTR)Type2String(((MONCBSTRUCT FAR *)pData)->wType));
539: wsprintf(DumpFormat(((MONCBSTRUCT FAR *)pData)->wFmt, &TBuf[strlen(TBuf)]),
540: pro.fTerse ? RefString(IDS_FMT_TRS_CB2) : RefString(IDS_FMT_CB2),
541: (UINT)((MONCBSTRUCT FAR *)pData)->hConv,
542: ((MONCBSTRUCT FAR *)pData)->hsz1,
543: (LPSTR)(psz1 = GetHszName(((MONCBSTRUCT FAR *)pData)->hsz1)),
544: ((MONCBSTRUCT FAR *)pData)->hsz2,
545: (LPSTR)(psz2 = GetHszName(((MONCBSTRUCT FAR *)pData)->hsz2)),
546: ((MONCBSTRUCT FAR *)pData)->hData,
547: ((MONCBSTRUCT FAR *)pData)->dwData1,
548: ((MONCBSTRUCT FAR *)pData)->dwData2,
549: ((MONCBSTRUCT FAR *)pData)->dwRet);
550: MyFree(psz1);
551: MyFree(psz2);
552: OutputString(TBuf);
553: if (((MONCBSTRUCT FAR *)pData)->dwData1 &&
554: (((MONCBSTRUCT FAR *)pData)->wType == XTYP_CONNECT ||
555: ((MONCBSTRUCT FAR *)pData)->wType == XTYP_WILDCONNECT)) {
556: // display proposed context
557: wsprintf(TBuf,
558: pro.fTerse ? RefString(IDS_FMT_TRS_CTXT1) : RefString(IDS_FMT_CTXT1),
559: ((MONCBSTRUCT FAR *)pData)->cc.wFlags,
560: ((MONCBSTRUCT FAR *)pData)->cc.wCountryID,
561: ((MONCBSTRUCT FAR *)pData)->cc.iCodePage,
562: ((MONCBSTRUCT FAR *)pData)->cc.dwLangID,
563: ((MONCBSTRUCT FAR *)pData)->cc.dwSecurity,
564: ((MONCBSTRUCT FAR *)pData)->cc.qos.ImpersonationLevel,
565: ((MONCBSTRUCT FAR *)pData)->cc.qos.ContextTrackingMode,
566: ((MONCBSTRUCT FAR *)pData)->cc.qos.EffectiveOnly);
567: OutputString(TBuf);
568: }
569: if (((MONCBSTRUCT FAR *)pData)->hData && ((MONCBSTRUCT FAR *)pData)->cbData) {
570: wsprintf(TBuf, RefString(IDS_INPUT_DATA));
571: OutputString(TBuf);
572: DumpData((LPBYTE)((MONCBSTRUCT FAR *)pData)->Data,
573: ((MONCBSTRUCT FAR *)pData)->cbData,
574: TBuf,
575: ((MONCBSTRUCT FAR *)pData)->wFmt);
576: OutputString(TBuf);
577: if (cb > MAX_DISPDATA)
578: OutputString(RefString(IDS_TABDDD));
579: DdeUnaccessData(((MONCBSTRUCT FAR *)pData)->hData);
580: }
581: if ((((MONCBSTRUCT FAR *)pData)->wType & XCLASS_DATA) &&
582: ((MONCBSTRUCT FAR *)pData)->dwRet &&
583: ((MONCBSTRUCT FAR *)pData)->cbData) {
584: wsprintf(TBuf, RefString(IDS_OUTPUT_DATA));
585: OutputString(TBuf);
586: DumpData((LPBYTE)((MONCBSTRUCT FAR *)pData)->Data,
587: ((MONCBSTRUCT FAR *)pData)->cbData,
588: TBuf,
589: ((MONCBSTRUCT FAR *)pData)->wFmt);
590: OutputString(TBuf);
591: if (cb > MAX_DISPDATA)
592: OutputString(RefString(IDS_TABDDD));
593: DdeUnaccessData(((MONCBSTRUCT FAR *)pData)->dwRet);
594: }
595: DdeUnaccessData(hData);
596: return(0);
597: break;
598:
599: case MF_ERRORS:
600: wsprintf(TBuf, pro.fTerse ? RefString(IDS_FMT_TRS_ER1) : RefString(IDS_FMT_ER1),
601: ((MONERRSTRUCT FAR *)pData)->hTask,
602: ((MONERRSTRUCT FAR *)pData)->dwTime,
603: ((MONERRSTRUCT FAR *)pData)->wLastError,
604: (LPSTR)Error2String(((MONERRSTRUCT FAR *)pData)->wLastError));
605: break;
606:
607:
608: case MF_LINKS:
609: psz1 = GetHszName(((MONLINKSTRUCT FAR *)pData)->hszSvc);
610: psz2 = GetHszName(((MONLINKSTRUCT FAR *)pData)->hszTopic);
611: psz3 = GetHszName(((MONLINKSTRUCT FAR *)pData)->hszItem);
612: if (!GetClipboardFormatName(((MONLINKSTRUCT FAR *)pData)->wFmt, TBuf2, BUFFER_SIZE))
613: strcpy(TBuf2, pdf(((MONLINKSTRUCT FAR *)pData)->wFmt));
614: if (!strcmp(RefString(IDS_HUH), TBuf2)) {
615: wsprintf(TBuf2, "%d", ((MONLINKSTRUCT FAR *)pData)->wFmt);
616: }
617:
618: wsprintf(TBuf, "%s\t%s\t%s\t%s\t%s\t%lx\t%lx",
619: (LPSTR)psz1, (LPSTR)psz2, (LPSTR)psz3,
620: (LPSTR)TBuf2,
621: ((MONLINKSTRUCT FAR *)pData)->fNoData ?
622: RefString(IDS_WARM) : RefString(IDS_HOT),
623: ((MONLINKSTRUCT FAR *)pData)->hConvClient,
624: ((MONLINKSTRUCT FAR *)pData)->hConvServer);
625:
626: if (((MONLINKSTRUCT FAR *)pData)->fEstablished) {
627: AddMCLBText(TBuf, TBuf, hwndTrack[IT_LINKS]);
628: } else {
629: DeleteMCLBText(TBuf, hwndTrack[IT_LINKS]);
630: }
631:
632: MyFree(psz1);
633: MyFree(psz2);
634: MyFree(psz3);
635: DdeUnaccessData(hData);
636: return(0);
637:
638:
639: case MF_CONV:
640: psz1 = GetHszName(((MONCONVSTRUCT FAR *)pData)->hszSvc);
641: psz2 = GetHszName(((MONCONVSTRUCT FAR *)pData)->hszTopic);
642:
643: wsprintf(TBuf, "%s\t%s\t%lx\t%lx",
644: (LPSTR)psz1, (LPSTR)psz2,
645: ((MONCONVSTRUCT FAR *)pData)->hConvClient,
646: ((MONCONVSTRUCT FAR *)pData)->hConvServer);
647:
648: if (((MONCONVSTRUCT FAR *)pData)->fConnect) {
649: AddMCLBText(TBuf, TBuf, hwndTrack[IT_CONVS]);
650: } else {
651: DeleteMCLBText(TBuf, hwndTrack[IT_CONVS]);
652: }
653:
654: MyFree(psz1);
655: MyFree(psz2);
656: DdeUnaccessData(hData);
657: return(0);
658:
659:
660: default:
661: strcpy(TBuf, RefString(IDS_UNKNOWN_CALLBACK));
662: }
663: DdeUnaccessData(hData);
664: OutputString(TBuf);
665: }
666: break;
667:
668: case XTYP_REGISTER:
669: case XTYP_UNREGISTER:
670: if (!pro.fTrack[IT_SVRS]) {
671: return(0);
672: }
673: psz1 = GetHszName(hsz1);
674: psz2 = GetHszName(hsz2);
675: wsprintf(TBuf, "%s\t%s", (LPSTR)psz1, (LPSTR)psz2);
676: if (wType == XTYP_REGISTER) {
677: AddMCLBText(NULL, TBuf, hwndTrack[IT_SVRS]);
678: } else {
679: DeleteMCLBText(TBuf, hwndTrack[IT_SVRS]);
680: }
681: MyFree(psz1);
682: MyFree(psz2);
683: break;
684: }
685: return(0);
686: }
687:
688:
689: PSTR DisectMsgLP(UINT msg, MONMSGSTRUCT *pmms, PSTR pszBuf)
690: {
691: static LONG m2t[] = {
692:
693: /* LOW HIGH */
694:
695: MAKELONG(T_APP | T_ATOM, T_TOPIC | T_ATOM), // WM_DDE_INITIATE
696: 0, // WM_DDE_TERMINATE
697: MAKELONG(T_OPTIONHANDLE, T_ITEM | T_ATOM), // WM_DDE_ADVISE
698: MAKELONG(T_FORMAT, T_ITEM | T_ATOM), // WM_DDE_UNADVISE
699: MAKELONG(T_APP | T_ATOM | T_OR | T_STATUS,
700: T_TOPIC | T_ITEM | T_ATOM | T_OR | T_STRINGHANDLE),
701: // WM_DDE_ACK
702: MAKELONG(T_DATAHANDLE, T_ITEM | T_ATOM), // WM_DDE_DATA
703: MAKELONG(T_FORMAT, T_ITEM | T_ATOM), // WM_DDE_REQUEST
704: MAKELONG(T_DATAHANDLE, T_ITEM | T_ATOM), // WM_DDE_POKE
705: MAKELONG(0, T_STRINGHANDLE), // WM_DDE_EXECUTE
706: };
707:
708: // ASSUMED: msg is a valid DDE message!!!
709:
710: pszBuf = DisectWord(LOWORD(m2t[msg - WM_DDE_FIRST]),
711: pmms->dmhd.uiLo, &pmms->dmhd, pszBuf);
712: *pszBuf++ = '\r';
713: *pszBuf++ = '\n';
714: *pszBuf++ = '\t';
715: return(DisectWord(HIWORD(m2t[msg - WM_DDE_FIRST]),
716: pmms->dmhd.uiHi, &pmms->dmhd, pszBuf));
717: }
718:
719:
720:
721:
722: /*
723: * Allocates local memory for and retrieves the string form of an HSZ.
724: * Returns a pointer to the local memory or NULL if failure.
725: * The string must be freed via MyFree().
726: */
727: PSTR GetHszName(HSZ hsz)
728: {
729: PSTR psz;
730: UINT cb;
731:
732: cb = (UINT)DdeQueryString(idInst, hsz, NULL, 0, 0) + 1;
733: psz = MyAlloc(cb);
734: DdeQueryString(idInst, hsz, psz, cb, 0);
735: return(psz);
736: }
737:
738:
739:
740:
741: PSTR DisectWord( UINT type,
742: UINT data,
743: DDEML_MSG_HOOK_DATA *pdmhd,
744: PSTR pstr)
745: {
746: UINT wT;
747: CHAR szData[32]; // for truncating strings w/o disturbing the hDdeData
748:
749: *pstr = '\0'; // in case we do nothing.
750:
751: if (type & T_ATOM) {
752: wT = GlobalGetAtomName((ATOM)data, (LPSTR)pstr, 25);
753: if (wT || data == 0) {
754: if (type & T_APP) {
755: strcpy(pstr, RefString(IDS_APPIS));
756: pstr += strlen(pstr);
757: }
758:
759: if (type & T_TOPIC) {
760: strcpy(pstr, RefString(IDS_TOPICIS));
761: pstr += strlen(pstr);
762: }
763:
764: if (type & T_ITEM) {
765: strcpy(pstr, RefString(IDS_ITEMIS));
766: pstr += strlen(pstr);
767: }
768: }
769: if (wT) {
770: wsprintf(pstr, "0x%x(\"", data);
771: pstr += strlen(pstr);
772: GlobalGetAtomName((ATOM)data, (LPSTR)pstr, 25);
773: pstr += wT;
774: if (wT == 25) {
775: *pstr++ = '.';
776: *pstr++ = '.';
777: *pstr++ = '.';
778: }
779: *pstr++ = '\"';
780: *pstr++ = ')';
781: *pstr = '\0';
782: type &= ~(T_OR | T_STRINGHANDLE); // its an atom, so its not an object!
783: } else if (data == 0) { // could be a wild atom
784: *pstr++ = '*';
785: *pstr = '\0';
786: } else if (type & T_OR) {
787: type &= ~T_OR; // not an atom, must be somthin else.
788: } else {
789: wsprintf(pstr, "Bad Atom (0x%x)", data);
790: pstr += strlen(pstr);
791: }
792: }
793:
794: if (type & T_OR) {
795: strcpy(pstr, RefString(IDS_OR));
796: pstr += strlen(pstr);
797: }
798:
799:
800: if (type & T_OPTIONHANDLE) {
801: if (pdmhd->cbData >= 4) {
802: wsprintf(pstr, pro.fTerse ? RefString(IDS_FMT_TRS_STATUSIS) : RefString(IDS_FMT_STATUSIS), LOWORD(pdmhd->Data[0]));
803: pstr += strlen(pstr);
804: if (LOWORD(pdmhd->Data[0]) & DDE_FACKREQ) {
805: strcpy(pstr, RefString(IDS_FACKREQ));
806: pstr += strlen(pstr);
807: }
808: if (LOWORD(pdmhd->Data[0]) & DDE_FDEFERUPD) {
809: strcpy(pstr, RefString(IDS_DEFERUPD));
810: pstr += strlen(pstr);
811: }
812: *pstr++ = ')';
813: *pstr++ = ' ';
814: pstr = DumpFormat((UINT)HIWORD(pdmhd->Data[0]), pstr);
815: }
816: }
817:
818: if (type & T_FORMAT) {
819: pstr = DumpFormat(data, pstr);
820: }
821:
822: if (type & T_STATUS) {
823: wsprintf(pstr, pro.fTerse ? RefString(IDS_FMT_TRS_STATUSIS) : RefString(IDS_FMT_STATUSIS), LOWORD(data));
824: pstr += strlen(pstr);
825: if (data & DDE_FACK) {
826: strcpy(pstr, RefString(IDS_FACK));
827: pstr += strlen(pstr);
828: }
829: if (data & DDE_FBUSY) {
830: strcpy(pstr, RefString(IDS_FBUSY));
831: pstr += strlen(pstr);
832: }
833: *pstr++ = ')';
834: *pstr = '\0';
835: }
836:
837: if (type & T_STRINGHANDLE && pdmhd->cbData) {
838: memcpy(szData, pdmhd->Data, min(32, pdmhd->cbData));
839: szData[31] = '\0';
840: wsprintf(pstr, pro.fTerse ?
841: RefString(IDS_FMT_TRS_EXEC1) : RefString(IDS_FMT_EXEC1), szData);
842: pstr += strlen(pstr);
843: *pstr = '\0';
844: }
845:
846: if (type & T_DATAHANDLE && pdmhd->cbData) {
847: wsprintf(pstr, pro.fTerse ?
848: RefString(IDS_FMT_TRS_STATUSIS) : RefString(IDS_FMT_STATUSIS),
849: LOWORD(pdmhd->Data[0]));
850: pstr += strlen(pstr);
851: if (LOWORD(pdmhd->Data[0]) & DDE_FRELEASE) {
852: strcpy(pstr, RefString(IDS_FRELEASE));
853: pstr += strlen(pstr);
854: }
855: if (LOWORD(pdmhd->Data[0]) & DDE_FREQUESTED) {
856: lstrcpy(pstr, RefString(IDS_FREQUESTED));
857: pstr += strlen(pstr);
858: }
859: *pstr++ = ')';
860: *pstr++ = ' ';
861: pstr = DumpFormat(HIWORD(pdmhd->Data[0]), pstr);
862: strcpy(pstr, pro.fTerse ? RefString(IDS_FMT_TRS_DATAIS1) : RefString(IDS_FMT_DATAIS1));
863: pstr += strlen(pstr);
864: pstr = DumpData((LPBYTE)&pdmhd->Data[1], min(28, pdmhd->cbData - 4),
865: pstr, HIWORD(pdmhd->Data[0]));
866: }
867: return(pstr);
868: }
869:
870:
871: PSTR pdf(UINT fmt)
872: {
873: INT i;
874: static struct {
875: UINT fmt;
876: PSTR psz;
877: } fmts[] = {
878: { CF_TEXT , "CF_TEXT" } ,
879: { CF_BITMAP , "CF_BITMAP" } ,
880: { CF_METAFILEPICT , "CF_METAFILEPICT" } ,
881: { CF_ENHMETAFILE , "CF_ENHMETAFILE" } ,
882: { CF_SYLK , "CF_SYLK" } ,
883: { CF_DIF , "CF_DIF" } ,
884: { CF_TIFF , "CF_TIFF" } ,
885: { CF_OEMTEXT , "CF_OEMTEXT" } ,
886: { CF_DIB , "CF_DIB" } ,
887: { CF_PALETTE , "CF_PALETTE" } ,
888: };
889: for (i = 0; i < 10; i++)
890: if (fmts[i].fmt == fmt)
891: return(fmts[i].psz);
892: return(RefString(IDS_HUH));
893: }
894:
895:
896:
897: PSTR DumpFormat(UINT fmt, PSTR pstr)
898: {
899: UINT cb;
900:
901: wsprintf(pstr, "fmt=0x%x(\"", (WORD)fmt);
902: pstr += strlen(pstr);
903: if (cb = GetClipboardFormatName(fmt, pstr, 25)) {
904: pstr += cb;
905: *pstr++ = '\"';
906: *pstr++ = ')';
907: } else {
908: wsprintf(pstr, "%s\")", (LPSTR)pdf(fmt));
909: pstr += strlen(pstr);
910: }
911: return(pstr);
912: }
913:
914:
915:
916: PSTR DumpData(LPBYTE pData, UINT cb, CHAR *szBuf, UINT fmt)
917: {
918: register INT i;
919: PSTR psz = szBuf;
920:
921:
922: while (cb) {
923: if (fmt == CF_TEXT) {
924: *szBuf++ = '\t';
925: *szBuf++ = '\"';
926: _fmemcpy(szBuf, pData, cb);
927: szBuf[cb - 2] = '\0';
928: _fstrcat(szBuf, "\"");
929: cb = 0;
930: } else {
931: memset(szBuf, ' ', 80);
932: szBuf[0] = '\t';
933: i = 0;
934: while (cb && (i < 16)) {
935: wsprintf(&szBuf[i * 3 + 1], "%02x ", pData[0]);
936: wsprintf(&szBuf[17 * 3 + i + 1], "%c", MPRT(pData[0]));
937: pData++;
938: cb--;
939: i++;
940: }
941: szBuf[i * 3 + 1] = ' ';
942: szBuf[17 * 3 + i + 1] = ' ';
943: szBuf[68] = '\0';
944: }
945: szBuf += _fstrlen(szBuf);
946: }
947: return(szBuf);
948: }
949:
950:
951:
952: PSTR Error2String(UINT error)
953: {
954: static CHAR szErr[23];
955:
956: if (error == 0) {
957: strcpy(szErr, RefString(IDS_ZERO));
958: } else if (error > DMLERR_LAST || error < DMLERR_FIRST) {
959: strcpy(szErr, RefString(IDS_HUH));
960: } else {
961: strcpy(szErr, apszResources[IDS_ERRST0 + error - DMLERR_FIRST]);
962: }
963: return(szErr);
964: }
965:
966:
967:
968: PSTR DdeMsg2String(UINT msg)
969: {
970: static CHAR szBadMsg[10];
971:
972: if (msg < WM_DDE_FIRST || msg > WM_DDE_LAST) {
973: return((PSTR)itoa(msg, szBadMsg, 10));
974: } else {
975: return(apszResources[IDS_MSG0 + msg - WM_DDE_FIRST]);
976: }
977: }
978:
979:
980:
981: VOID OutputString(PSTR pstr)
982: {
983: if (pro.fOutput[IO_FILE] & fhOutput) {
984: _lwrite(fhOutput, pstr, strlen(pstr));
985: _lwrite(fhOutput, RefString(IDS_CRLF), 2);
986: flushall();
987: }
988: if (pro.fOutput[IO_DEBUG]) {
989: OutputDebugString((LPSTR)pstr);
990: OutputDebugString(RefString(IDS_CRLF));
991: }
992: if (pro.fOutput[IO_SCREEN]) {
993: if (IsWindow(hWndString))
994: DrawString(hWndString, pstr);
995: }
996: }
997:
998:
999:
1000: BOOL SetFilters()
1001: {
1002: UINT cbf;
1003:
1004: cbf = 0;
1005: if (pro.fTrack[IT_HSZS] || pro.fFilter[IF_HSZ])
1006: cbf |= MF_HSZ_INFO;
1007: if (pro.fTrack[IT_LINKS])
1008: cbf |= MF_LINKS;
1009: if (pro.fTrack[IT_CONVS])
1010: cbf |= MF_CONV;
1011: if (pro.fFilter[IF_SEND])
1012: cbf |= MF_SENDMSGS;
1013: if (pro.fFilter[IF_POST])
1014: cbf |= MF_POSTMSGS;
1015: if (pro.fFilter[IF_CB])
1016: cbf |= MF_CALLBACKS;
1017: if (pro.fFilter[IF_ERR])
1018: cbf |= MF_ERRORS;
1019: return((BOOL)DdeInitialize(&idInst, pfnDdeCallback, APPCLASS_MONITOR | cbf, 0));
1020: }
1021:
1022:
1023:
1024:
1025:
1026: /*
1027: * This dialog returns a file handle to the opened file name given or NULL
1028: * if cancel.
1029: */
1030:
1031: BOOL CALLBACK OpenDlg(HWND hDlg, UINT message, WPARAM wParam, LPARAM lParam)
1032: {
1033: HFILE fh;
1034: lParam;
1035:
1036: switch (message) {
1037: case WM_INITDIALOG:
1038: SetDlgItemText(hDlg, IDC_EDIT, (LPSTR)OpenName);
1039: SendDlgItemMessage(hDlg, IDC_EDIT, EM_SETSEL,
1040: GET_EM_SETSEL_MPS(0, 0x7fff));
1041: SetFocus(GetDlgItem(hDlg, IDC_EDIT));
1042: return (FALSE); /* Indicates the focus is set to a control */
1043: break;
1044:
1045: case WM_COMMAND:
1046: switch (GET_WM_COMMAND_ID(wParam, lParam)) {
1047: case IDOK:
1048: GetDlgItemText(hDlg, IDC_EDIT, TBuf, MAX_FNAME);
1049: GetFullPathName(TBuf, sizeof(OpenName), OpenName, (LPTSTR *)TBuf2);
1050: fh = _lcreat(OpenName, 0);
1051: if (fh == -1) {
1052: MessageBox(hDlg, RefString(IDS_INVALID_FNAME),
1053: NULL, MB_OK | MB_ICONHAND);
1054: return (TRUE);
1055: }
1056:
1057: EndDialog(hDlg, (INT)fh);
1058: return (TRUE);
1059:
1060: case IDCANCEL:
1061: EndDialog(hDlg, 0);
1062: return (FALSE);
1063: }
1064: break;
1065: }
1066: return FALSE;
1067: }
1068:
1069: BOOL CALLBACK FilterDlgProc(HWND hDlg, UINT message, WPARAM wParam, LPARAM lParam)
1070: {
1071: int i;
1072: lParam;
1073:
1074: switch (message) {
1075: case WM_INITDIALOG:
1076: for (i = IDRB_WM_DDE_INITIATE; i <= IDRB_WM_DDE_EXECUTE; i++) {
1077: CheckDlgButton(hDlg, i, !fBlockMsg[i - IDRB_WM_DDE_INITIATE]);
1078: }
1079: for (i = IDRB_XTYP_ERROR; i <= IDRB_XTYP_WILDCONNECT; i++) {
1080: CheckDlgButton(hDlg, i, !fBlockCb[i - IDRB_XTYP_ERROR]);
1081: }
1082: CheckDlgButton(hDlg, IDRB_TERSE, pro.fTerse);
1083: break;
1084:
1085: case WM_COMMAND:
1086: switch (GET_WM_COMMAND_ID(wParam, lParam)) {
1087: case IDOK:
1088: for (i = IDRB_WM_DDE_INITIATE; i <= IDRB_WM_DDE_EXECUTE; i++) {
1089: fBlockMsg[i - IDRB_WM_DDE_INITIATE] = !IsDlgButtonChecked(hDlg, i);
1090: }
1091: for (i = IDRB_XTYP_ERROR; i <= IDRB_XTYP_WILDCONNECT; i++) {
1092: fBlockCb[i - IDRB_XTYP_ERROR] = !IsDlgButtonChecked(hDlg, i);
1093: }
1094: pro.fTerse = IsDlgButtonChecked(hDlg, IDRB_TERSE);
1095: EndDialog(hDlg, TRUE);
1096: break;
1097:
1098: case IDCANCEL:
1099: EndDialog(hDlg, 0);
1100: break;
1101: }
1102: break;
1103: }
1104: return FALSE;
1105: }
1106:
1107:
1108:
1109:
1110: VOID GetProfile()
1111: {
1112: pro.fOutput[IO_FILE] = GetProfileBoolean(RefString(IDS_PROF_OUT_FILE),FALSE);
1113: pro.fOutput[IO_DEBUG] = GetProfileBoolean(RefString(IDS_PROF_OUT_DEBUG),FALSE);
1114: pro.fOutput[IO_SCREEN] = GetProfileBoolean(RefString(IDS_PROF_OUT_SCREEN),FALSE);
1115:
1116: pro.fFilter[IF_HSZ] = GetProfileBoolean(RefString(IDS_PROF_MONITOR_STRINGHANDLES),FALSE);
1117: pro.fFilter[IF_SEND] = GetProfileBoolean(RefString(IDS_PROF_MONITOR_INITIATES), FALSE);
1118: pro.fFilter[IF_POST] = GetProfileBoolean(RefString(IDS_PROF_MONITOR_DDE_MESSAGES), FALSE);
1119: pro.fFilter[IF_CB] = GetProfileBoolean(RefString(IDS_PROF_MONITOR_CALLBACKS), FALSE);
1120: pro.fFilter[IF_ERR] = GetProfileBoolean(RefString(IDS_PROF_MONITOR_ERRORS),FALSE);
1121:
1122: pro.fTrack[IT_HSZS] = GetProfileBoolean(RefString(IDS_PROF_TRACK_STRINGHANDLES), FALSE);
1123: pro.fTrack[IT_LINKS] = GetProfileBoolean(RefString(IDS_PROF_TRACK_LINKS), FALSE);
1124: pro.fTrack[IT_CONVS] = GetProfileBoolean(RefString(IDS_PROF_TRACK_CONVERSATIONS), FALSE);
1125: pro.fTrack[IT_SVRS] = GetProfileBoolean(RefString(IDS_PROF_TRACK_SERVICES), FALSE);
1126:
1127: pro.fTerse = GetProfileBoolean(RefString(IDS_PROF_TERSE), FALSE);
1128: }
1129:
1130:
1131:
1132: VOID SaveProfile()
1133: {
1134: SetProfileBoolean(RefString(IDS_PROF_OUT_FILE), pro.fOutput[IO_FILE] );
1135: SetProfileBoolean(RefString(IDS_PROF_OUT_DEBUG), pro.fOutput[IO_DEBUG] );
1136: SetProfileBoolean(RefString(IDS_PROF_OUT_SCREEN), pro.fOutput[IO_SCREEN]);
1137:
1138: SetProfileBoolean(RefString(IDS_PROF_MONITOR_STRINGHANDLES), pro.fFilter[IF_HSZ] );
1139: SetProfileBoolean(RefString(IDS_PROF_MONITOR_INITIATES), pro.fFilter[IF_SEND] );
1140: SetProfileBoolean(RefString(IDS_PROF_MONITOR_DDE_MESSAGES), pro.fFilter[IF_POST] );
1141: SetProfileBoolean(RefString(IDS_PROF_MONITOR_CALLBACKS), pro.fFilter[IF_CB] );
1142: SetProfileBoolean(RefString(IDS_PROF_MONITOR_ERRORS), pro.fFilter[IF_ERR] );
1143:
1144: SetProfileBoolean(RefString(IDS_PROF_TRACK_STRINGHANDLES), pro.fTrack[IT_HSZS] );
1145: SetProfileBoolean(RefString(IDS_PROF_TRACK_LINKS), pro.fTrack[IT_LINKS] );
1146: SetProfileBoolean(RefString(IDS_PROF_TRACK_CONVERSATIONS), pro.fTrack[IT_CONVS] );
1147: SetProfileBoolean(RefString(IDS_PROF_TRACK_SERVICES), pro.fTrack[IT_SVRS] );
1148:
1149: SetProfileBoolean(RefString(IDS_PROF_TERSE), pro.fTerse );
1150: }
1151:
1152:
1153:
1154:
1155: BOOL GetProfileBoolean(LPSTR pszKey, BOOL fDefault)
1156: {
1157: GetPrivateProfileString(RefString(IDS_TITLE), pszKey,
1158: fDefault ? RefString(IDS_YES) : RefString(IDS_NO), TBuf,
1159: sizeof(TBuf), RefString(IDS_INIFNAME));
1160: return(stricmp(RefString(IDS_NO), TBuf));
1161: }
1162:
1163:
1164:
1165: VOID SetProfileBoolean(LPSTR pszKey, BOOL fSet)
1166: {
1167: WritePrivateProfileString(RefString(IDS_TITLE), pszKey,
1168: fSet ? RefString(IDS_YES) : RefString(IDS_NO),
1169: RefString(IDS_INIFNAME));
1170: }
1171:
1172: /*
1173: * Generic dialog invocation routine. Handles procInstance stuff and param
1174: * passing.
1175: */
1176: INT FAR DoDialog(
1177: LPSTR lpTemplateName,
1178: DLGPROC lpDlgProc,
1179: UINT param,
1180: BOOL fRememberFocus,
1181: HWND hwndParent,
1182: HANDLE hInst)
1183: {
1184: UINT wRet;
1185: HWND hwndFocus;
1186:
1187: if (fRememberFocus)
1188: hwndFocus = GetFocus();
1189: lpDlgProc = (DLGPROC)MakeProcInstance(lpDlgProc, hInst);
1190: wRet = DialogBoxParam(hInst, (LPCSTR)lpTemplateName, hwndParent,
1191: lpDlgProc, param);
1192: FreeProcInstance((FARPROC)lpDlgProc);
1193: if (fRememberFocus)
1194: SetFocus(hwndFocus);
1195: return wRet;
1196: }
1197:
1198:
1199: BOOL CALLBACK MarkDlgProc(
1200: HWND hwnd,
1201: UINT msg,
1202: WPARAM wParam,
1203: LPARAM lParam)
1204: {
1205: CHAR szT[MAX_MARK + 1];
1206: lParam;
1207:
1208: switch (msg){
1209: case WM_INITDIALOG:
1210: SetWindowText(hwnd, RefString(IDS_MARKDLGTITLE));
1211: SendDlgItemMessage(hwnd, IDEF_VALUE, EM_LIMITTEXT, MAX_MARK, 0);
1212: SetDlgItemText(hwnd, IDEF_VALUE, RefString(IDS_SEPERATOR));
1213: SetDlgItemText(hwnd, IDTX_VALUE, RefString(IDS_MARKTEXT));
1214: return(1);
1215: break;
1216:
1217: case WM_COMMAND:
1218: switch (GET_WM_COMMAND_ID(wParam, lParam)) {
1219: case IDOK:
1220: GetDlgItemText(hwnd, IDEF_VALUE, szT, MAX_MARK);
1221: OutputString(szT);
1222: // fall through
1223: case IDCANCEL:
1224: EndDialog(hwnd, 0);
1225: break;
1226:
1227: default:
1228: return(FALSE);
1229: }
1230: break;
1231: }
1232: return(FALSE);
1233: }
1234:
1235:
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.