![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to dialog.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [WindowsNT SDKs] / mstools / samples / ddeml / client|
Return to dialog.c CVS log | Up to [WindowsNT SDKs] / mstools / samples / ddeml / client |
1.1 root 1: /***************************************************************************
2: * *
3: * MODULE : dialog.c *
4: * *
5: * PURPOSE : Contains all dialog procedures and related functions. *
6: * *
7: ***************************************************************************/
8: #include "client.h"
9: #include "infoctrl.h"
10: #include <string.h>
11: #include <stdio.h>
12: #include "huge.h"
13:
14: #define MAX_NAME 100 // max size for edit controls with app/topic/item names.
15: CHAR szWild[] = "*"; // used to indicate wild names ("" is also cool)
16: CHAR szT[MAX_NAME]; // temp buf for munging names.
17:
18:
19:
20: /****************************************************************************
21: * *
22: * FUNCTION : DoDialog() *
23: * *
24: * PURPOSE : Generic dialog invocation routine. Handles procInstance *
25: * stuff, focus management and param passing. *
26: * RETURNS : result of dialog procedure. *
27: * *
28: ****************************************************************************/
29: INT FAR DoDialog(
30: LPSTR lpTemplateName,
1.1.1.2 ! root 31: DLGPROC lpDlgProc,
1.1 root 32: LONG param,
33: BOOL fRememberFocus)
34: {
1.1.1.2 ! root 35: INT iRet;
1.1 root 36: HWND hwndFocus;
37:
38: if (fRememberFocus)
39: hwndFocus = GetFocus();
40: lpDlgProc = MakeProcInstance(lpDlgProc, hInst);
1.1.1.2 ! root 41: iRet = DialogBoxParam(hInst, lpTemplateName, hwndFrame, lpDlgProc, param);
1.1 root 42: FreeProcInstance(lpDlgProc);
43: if (fRememberFocus)
44: SetFocus(hwndFocus);
1.1.1.2 ! root 45: return iRet;
1.1 root 46: }
47:
48:
49:
50: /****************************************************************************
51: * *
52: * FUNCTION : *
53: * *
54: * PURPOSE : *
55: * *
56: * RETURNS : *
57: * *
58: ****************************************************************************/
59: BOOL APIENTRY AboutDlgProc ( hwnd, msg, wParam, lParam )
60: HWND hwnd;
61: UINT msg;
62: WPARAM wParam;
63: LPARAM lParam;
64: {
65: switch (msg){
66: case WM_INITDIALOG:
67: /* nothing to initialize */
68: break;
69:
70: case WM_COMMAND:
1.1.1.2 ! root 71: switch (LOWORD(wParam)) {
1.1 root 72: case IDOK:
73: case IDCANCEL:
74: EndDialog(hwnd, 0);
75: break;
76:
77: default:
78: return FALSE;
79: }
80: break;
81:
82: default:
83: return(FALSE);
84: }
85:
86: return TRUE;
87: }
88:
89:
90:
91:
92: /****************************************************************************
93: * *
94: * FUNCTION : *
95: * *
96: * PURPOSE : *
97: * *
98: * RETURNS : *
99: * *
100: ****************************************************************************/
101: BOOL APIENTRY ConnectDlgProc(
102: HWND hwnd,
103: UINT msg,
104: WPARAM wParam,
105: LPARAM lParam)
106: {
107: static BOOL fReconnect;
108: CHAR szT[MAX_NAME];
109: HSZ hszApp, hszTopic;
110: MYCONVINFO *pmci;
111:
112: switch (msg){
113: case WM_INITDIALOG:
114: SendDlgItemMessage(hwnd, IDEF_APPLICATION, EM_LIMITTEXT, MAX_NAME, 0);
115: SendDlgItemMessage(hwnd, IDEF_TOPIC, EM_LIMITTEXT, MAX_NAME, 0);
116: fReconnect = (BOOL)lParam;
117: if (fReconnect) {
118: PSTR psz;
119:
120: pmci = (MYCONVINFO *)GetWindowLong(hwndActive, 0);
121: SetWindowText(hwnd, "DDE Reconnect List");
122: psz = GetHSZName(pmci->hszApp);
123: SetDlgItemText(hwnd, IDEF_APPLICATION, psz);
124: MyFree(psz);
125: psz = GetHSZName(pmci->hszTopic);
126: SetDlgItemText(hwnd, IDEF_TOPIC, psz);
127: MyFree(psz);
128: ShowWindow(GetDlgItem(hwnd, IDCH_CONNECTLIST), SW_HIDE);
129: }
130: break;
131:
132: case WM_COMMAND:
1.1.1.2 ! root 133: switch (LOWORD(wParam)) {
1.1 root 134: case IDOK:
135: GetDlgItemText(hwnd, IDEF_APPLICATION, szT, MAX_NAME);
136: if (!strcmp(szT, szWild))
137: szT[0] = '\0';
138: hszApp = DdeCreateStringHandle(idInst, szT, 0);
139:
140: GetDlgItemText(hwnd, IDEF_TOPIC, szT, MAX_NAME);
141: if (!strcmp(szT, szWild))
142: szT[0] = '\0';
143: hszTopic = DdeCreateStringHandle(idInst, szT, 0);
144:
145: if (fReconnect) {
146: HCONV hConv;
147: CONVINFO ci;
148: DWORD cHwnd;
149: HWND *aHwnd, *pHwnd, hwndSave;
150:
151: ci.cb = sizeof(CONVINFO);
152: pmci = (MYCONVINFO *)GetWindowLong(hwndActive, 0);
153: hwndSave = hwndActive;
154:
155: // count the existing conversations and allocate aHwnd
156:
157: cHwnd = 0;
158: hConv = NULL;
159: while (hConv = DdeQueryNextServer((HCONVLIST)pmci->hConv, hConv))
160: cHwnd++;
161: aHwnd = (HWND *)MyAlloc(cHwnd * sizeof(HWND));
162:
163: // save all the old conversation windows into aHwnd.
164:
165: pHwnd = aHwnd;
166: hConv = NULL;
167: while (hConv = DdeQueryNextServer((HCONVLIST)pmci->hConv, hConv)) {
168: DdeQueryConvInfo(hConv, QID_SYNC, &ci);
169: *pHwnd++ = (HWND)ci.hUser;
170: }
171:
172: // reconnect
173:
174: if (!(hConv = DdeConnectList(idInst, hszApp, hszTopic, pmci->hConv, &CCFilter))) {
175: MPError(MB_OK, IDS_DDEMLERR, (LPSTR)Error2String(DdeGetLastError(idInst)));
176: DdeFreeStringHandle(idInst, hszApp);
177: DdeFreeStringHandle(idInst, hszTopic);
178: return 0;
179: }
180:
181: // fixup windows corresponding to the new conversations.
182:
183: pmci->hConv = hConv;
184: hConv = NULL;
185: while (hConv = DdeQueryNextServer((HCONVLIST)pmci->hConv, hConv)) {
186: DdeQueryConvInfo(hConv, QID_SYNC, &ci);
187: // preserve corresponding window by setting its list
188: // entry to 0
189: for (pHwnd = aHwnd; pHwnd < &aHwnd[cHwnd]; pHwnd++) {
190: if (*pHwnd == (HWND)ci.hUser) {
191: *pHwnd = NULL;
192: break;
193: }
194: }
195: }
196:
197: // destroy all windows left in the old list
198:
199: for (pHwnd = aHwnd; pHwnd < &aHwnd[cHwnd]; pHwnd++)
200: if (*pHwnd) {
201: SendMessage(hwndMDIClient, WM_MDIDESTROY,
202: (WPARAM)*pHwnd, 0L);
203: }
204: MyFree((PSTR)aHwnd);
205:
206: // create any new windows needed
207:
208: hConv = NULL;
209: while (hConv = DdeQueryNextServer((HCONVLIST)pmci->hConv, hConv)) {
210: DdeQueryConvInfo(hConv, QID_SYNC, &ci);
211: if (ci.hUser) {
212: InvalidateRect((HWND)ci.hUser, NULL, TRUE);
213: } else {
214: AddConv(ci.hszSvcPartner, ci.hszTopic, hConv, FALSE);
215: }
216: }
217:
218: // make list window update itself
219:
220: InvalidateRect(hwndSave, NULL, TRUE);
221: SetFocus(hwndSave);
222: } else {
223: if (!CreateConv(hszApp, hszTopic,
224: IsDlgButtonChecked(hwnd, IDCH_CONNECTLIST))) {
225: MPError(MB_OK, IDS_DDEMLERR, (LPSTR)Error2String(DdeGetLastError(idInst)));
226: return 0;
227: }
228: }
229: DdeFreeStringHandle(idInst, hszApp);
230: DdeFreeStringHandle(idInst, hszTopic);
231: // fall through
232: case IDCANCEL:
233: EndDialog(hwnd, 0);
234: break;
235:
236: default:
237: return(FALSE);
238: }
239: break;
240:
241: default:
242: return(FALSE);
243: }
244: }
245:
246:
247:
248:
249: /*
250: * Fills a XACT structure and calls ProcessTransaction.
251: *
252: * On initiation lParam == hConv.
253: */
254: /****************************************************************************
255: * *
256: * FUNCTION : *
257: * *
258: * PURPOSE : *
259: * *
260: * RETURNS : *
261: * *
262: ****************************************************************************/
263: BOOL APIENTRY TransactDlgProc(
264: HWND hwnd,
265: UINT msg,
266: WPARAM wParam,
267: LPARAM lParam)
268: {
269: static DWORD id2type[] = {
270: XTYP_REQUEST, // IDCH_REQUEST
271: XTYP_ADVSTART, // IDCH_ADVISE
272: XTYP_ADVSTOP, // IDCH_UNADVISE
273: XTYP_POKE, // IDCH_POKE
274: XTYP_EXECUTE, // IDCH_EXECUTE
275: };
276: static XACT *pxact; // ONLY ONE AT A TIME!
277: INT i;
278:
279: switch (msg){
280: case WM_INITDIALOG:
281: pxact = (XACT *)MyAlloc(sizeof(XACT));
282: pxact->hConv = (HCONV)lParam;
283: pxact->fsOptions = DefOptions;
284: pxact->ulTimeout = DefTimeout;
285:
286: // The item index == the index to the format atoms in aFormats[].
287: for (i = 0; i < CFORMATS; i++)
288: SendDlgItemMessage(hwnd, IDCB_FORMAT, CB_INSERTSTRING, i,
289: (DWORD)(LPSTR)aFormats[i].sz);
290: SendDlgItemMessage(hwnd, IDCB_FORMAT, CB_INSERTSTRING, i,
291: (DWORD)(LPSTR)"NULL");
292: SendDlgItemMessage(hwnd, IDCB_FORMAT, CB_SETCURSEL, 0, 0);
293: CheckRadioButton(hwnd, IDCH_REQUEST, IDCH_EXECUTE, IDCH_REQUEST);
294: SendDlgItemMessage(hwnd, IDEF_ITEM, EM_LIMITTEXT, MAX_NAME, 0);
295:
296: // If there is a top transaction window, use its contents to
297: // anticipate what the user will want to do.
298:
299: if (IsWindow(hwndActive)) {
300: HWND hwndXaction;
301: XACT *pxact;
302: PSTR pszItem;
303:
304: hwndXaction = GetWindow(hwndActive, GW_CHILD);
305: if (IsWindow(hwndXaction)) {
306: pxact = (XACT *)GetWindowLong(hwndXaction, GWL_USER);
307: pszItem = GetHSZName(pxact->hszItem);
308: if ((pxact->wType & XTYP_ADVSTART) == XTYP_ADVSTART ||
309: pxact->wType == XTYP_ADVDATA) {
310: CheckRadioButton(hwnd, IDCH_REQUEST, IDCH_EXECUTE, IDCH_UNADVISE);
311: }
312: SetDlgItemText(hwnd, IDEF_ITEM, pszItem);
313: for (i = 0; i < CFORMATS; i++) {
314: if (aFormats[i].fmt == pxact->wFmt) {
315: SendDlgItemMessage(hwnd, IDCB_FORMAT, CB_SETCURSEL, i, 0);
316: break;
317: }
318: }
319: MyFree(pszItem);
320: }
321: }
322: break;
323:
324: case WM_COMMAND:
1.1.1.2 ! root 325: switch (LOWORD(wParam)) {
1.1 root 326: case IDCH_EXECUTE:
327: SetDlgItemText(hwnd, IDEF_ITEM, "");
328: case IDCH_REQUEST:
329: case IDCH_ADVISE:
330: case IDCH_UNADVISE:
331: case IDCH_POKE:
1.1.1.2 ! root 332: EnableWindow(GetDlgItem(hwnd, IDEF_ITEM), LOWORD(wParam) != IDCH_EXECUTE);
! 333: EnableWindow(GetDlgItem(hwnd, IDTX_ITEM), LOWORD(wParam) != IDCH_EXECUTE);
1.1 root 334: break;
335:
336: case IDOK:
337: case IDBN_OPTIONS:
338: {
339: INT id;
340:
341: // set pxact->wType
342:
343: for (id = IDCH_REQUEST; id <= IDCH_EXECUTE; id++) {
344: if (IsDlgButtonChecked(hwnd, id)) {
345: pxact->wType = id2type[id - IDCH_REQUEST];
346: break;
347: }
348: }
349:
1.1.1.2 ! root 350: if (LOWORD(wParam) == IDBN_OPTIONS) {
1.1 root 351: DoDialog(MAKEINTRESOURCE(IDD_ADVISEOPTS),
1.1.1.2 ! root 352: (DLGPROC)AdvOptsDlgProc, (LONG)pxact, TRUE);
1.1 root 353: return 0;
354: }
355:
356: id = (INT)SendDlgItemMessage(hwnd, IDCB_FORMAT, CB_GETCURSEL, 0, 0);
357: if (id == LB_ERR) {
358: return 0;
359: }
360: if (id == CFORMATS)
361: pxact->wFmt = 0;
362: else
363: pxact->wFmt = aFormats[id].fmt;
364:
365: if (pxact->wType == XTYP_ADVSTART) {
366: if (pxact->fsOptions & XOPT_NODATA)
367: pxact->wType |= XTYPF_NODATA;
368: if (pxact->fsOptions & XOPT_ACKREQ)
369: pxact->wType |= XTYPF_ACKREQ;
370: }
371:
372: GetDlgItemText(hwnd, IDEF_ITEM, szT, MAX_NAME);
373: pxact->hszItem = DdeCreateStringHandle(idInst, szT, NULL);
374:
375: pxact->hDdeData = 0;
376: /*
377: * If this transaction needs data, invoke data input dialog.
378: */
379: if (pxact->wType == XTYP_POKE || pxact->wType == XTYP_EXECUTE) {
380: if (!DoDialog(MAKEINTRESOURCE(IDD_TEXTENTRY),
1.1.1.2 ! root 381: (DLGPROC)TextEntryDlgProc, (DWORD)(LPSTR)pxact,
1.1 root 382: TRUE))
383: return 0;
384: }
385:
386: // now start the transaction
387:
388: ProcessTransaction(pxact);
389: MyFree((PSTR)pxact);
390: }
391: EndDialog(hwnd, 1);
392: break;
393:
394: case IDCANCEL:
395: MyFree((PSTR)pxact);
396: EndDialog(hwnd, 0);
397: break;
398:
399: default:
400: return(FALSE);
401: }
402: break;
403:
404: case WM_DESTROY:
405: break;
406:
407: default:
408: return(FALSE);
409: }
410: return 0;
411: }
412:
413:
414:
415:
416:
417:
418:
419: /****************************************************************************
420: * *
421: * FUNCTION : AdvOptsDlgProc *
422: * *
423: * LIMITATIONS: Because we use Get/SetDlgItemInt() the timeout value used *
424: * can't be greater than 65K ms. *
425: * *
426: * RETURNS : *
427: * *
428: ****************************************************************************/
429: BOOL APIENTRY AdvOptsDlgProc(
430: HWND hwnd,
431: UINT msg,
432: WPARAM wParam,
433: LPARAM lParam)
434: {
435: static struct {
436: DWORD id;
437: DWORD opt;
438: } id2Opt[] = {
439: { IDCH_NODATA , XOPT_NODATA } ,
440: { IDCH_ACKREQ , XOPT_ACKREQ } ,
441: { IDCH_DISABLEFIRST , XOPT_DISABLEFIRST } ,
442: { IDCH_ABANDON , XOPT_ABANDONAFTERSTART } ,
443: { IDCH_BLOCKRESULT , XOPT_BLOCKRESULT } ,
444: { IDCH_ASYNC , XOPT_ASYNC } ,
445: };
446: #define CCHBOX 6
447: INT i;
448: static XACT *pxact; // only one instance at a time!!
449:
450: switch (msg){
451: case WM_INITDIALOG:
452: pxact = (XACT *)lParam;
453:
454: for (i = 0; i < CCHBOX; i++) {
455: CheckDlgButton(hwnd, id2Opt[i].id, pxact->fsOptions & id2Opt[i].opt);
456: }
457: SetDlgItemInt(hwnd, IDEF_TIMEOUT, (DWORD)pxact->ulTimeout, FALSE);
458: if (pxact->wType != XTYP_ADVSTART) {
459: EnableWindow(GetDlgItem(hwnd, IDCH_NODATA), FALSE);
460: EnableWindow(GetDlgItem(hwnd, IDCH_ACKREQ), FALSE);
461: }
1.1.1.2 ! root 462: SendMessage(hwnd, WM_COMMAND, (WPARAM)MAKELONG(IDCH_ASYNC, 0), (LONG)(0)); // enable async checkboxes
1.1 root 463: break;
464:
465: case WM_COMMAND:
1.1.1.2 ! root 466: switch (LOWORD(wParam)) {
1.1 root 467: case IDCH_ASYNC:
468: {
469: BOOL fEnable;
470:
471: fEnable = IsDlgButtonChecked(hwnd, IDCH_ASYNC);
472: EnableWindow(GetDlgItem(hwnd, IDCH_DISABLEFIRST), fEnable);
473: EnableWindow(GetDlgItem(hwnd, IDCH_ABANDON), fEnable);
474: EnableWindow(GetDlgItem(hwnd, IDCH_BLOCKRESULT), fEnable);
475: EnableWindow(GetDlgItem(hwnd, IDEF_TIMEOUT), !fEnable);
476: }
477: break;
478:
479: case IDOK:
480: pxact->fsOptions = 0;
481: for (i = 0; i < CCHBOX; i++) {
482: if (IsDlgButtonChecked(hwnd, id2Opt[i].id))
483: pxact->fsOptions |= id2Opt[i].opt;
484: }
485: if (!(pxact->fsOptions & XOPT_ASYNC))
486: pxact->ulTimeout = (DWORD)GetDlgItemInt(hwnd, IDEF_TIMEOUT,
1.1.1.2 ! root 487: (BOOL *)&i, FALSE);
1.1 root 488: // fall through
489: case IDCANCEL:
490: EndDialog(hwnd, 0);
491: break;
492: }
493: break;
494:
495: default:
496: return(FALSE);
497: }
498: return 0;
499: #undef CCHBOX
500: }
501:
502:
503:
504:
505:
506:
507: /****************************************************************************
508: * *
509: * FUNCTION : TextEntryDlgProc *
510: * *
511: * PURPOSE : Allows user to enter text data which is to be sent to a *
512: * server. The user can opt to have a huge text piece of *
513: * data created automaticlly. *
514: * It uses the XACT structure for passing info in and out. *
515: * Must have wFmt and hszItem set on entry. *
516: * Sets hDDEData on return if TRUE was returned. *
517: * *
518: * RETURNS : TRUE on success, FALSE on failure or cancel *
519: * *
520: ****************************************************************************/
521: BOOL APIENTRY TextEntryDlgProc(
522: HWND hwnd,
523: UINT msg,
524: WPARAM wParam,
525: LPARAM lParam)
526: {
527: static XACT FAR *pxact;
528: DWORD cb;
529: LONG length;
530: LPBYTE pData;
531: BOOL fOwned;
532: INT id, i;
533:
534: switch (msg){
535: case WM_INITDIALOG:
536: pxact = (XACT FAR *)lParam;
537: fOwned = FALSE;
538: for (i = 0; i < (INT)cOwned; i++) {
539: if (aOwned[i].wFmt == pxact->wFmt &&
540: aOwned[i].hszItem == pxact->hszItem) {
541: fOwned = TRUE;
542: break;
543: }
544: }
545: EnableWindow(GetDlgItem(hwnd, IDBN_USEOWNED), fOwned);
546: CheckDlgButton(hwnd, IDCH_MAKEOWNED, 0);
547: EnableWindow(GetDlgItem(hwnd, IDCH_MAKEOWNED), cOwned < MAX_OWNED);
548: break;
549:
550: case WM_COMMAND:
1.1.1.2 ! root 551: switch (LOWORD(wParam)) {
1.1 root 552: case IDOK:
553: case IDBN_GENHUGE:
554: fOwned = IsDlgButtonChecked(hwnd, IDCH_MAKEOWNED);
555: cb = SendDlgItemMessage(hwnd, IDEF_DATA, WM_GETTEXTLENGTH, 0, 0) + 1;
556: pxact->hDdeData = DdeCreateDataHandle(idInst, NULL, 0, cb, pxact->hszItem,
557: pxact->wFmt, fOwned ? HDATA_APPOWNED : 0);
558: if (pxact->hDdeData == 0) {
559: MessageBeep(0);
560: return(0);
561: }
562: //
563: // Note that at this time we have not yet given the data handle
564: // to DDEML for transmission to any application, therefore, we
565: // are at liberty to write to it using DdeAccessData() or any
566: // other DDEML api. It is only data handles received from DDEML
567: // or given to DDEML for transmission that are readonly.
568: //
569: pData = DdeAccessData(pxact->hDdeData, NULL);
570: if (pData == NULL) {
571: MessageBeep(0);
572: return(0);
573: }
574: GetDlgItemText(hwnd, IDEF_DATA, pData, (DWORD)cb);
575: DdeUnaccessData(pxact->hDdeData);
1.1.1.2 ! root 576: if (LOWORD(wParam) == IDBN_GENHUGE) {
1.1 root 577: CHAR szT[40];
578:
579: /*
580: * we assume in this case that the text entered is the decimal
581: * value of the size of the huge object desired. We parse
582: * this string and create a randomly generated huge block
583: * of text data and place it into pxact->hDdeData.
584: */
1.1.1.2 ! root 585: memcpy(szT, pData, min((DWORD)cb, 40));
1.1 root 586: szT[39] = '\0';
587: if (sscanf(szT, "%ld", &length) == 1) {
588: DdeFreeDataHandle(pxact->hDdeData);
589: pxact->hDdeData = CreateHugeDataHandle(length, 4325,
590: 345, 5, pxact->hszItem, pxact->wFmt,
591: fOwned ? HDATA_APPOWNED : 0);
592: } else {
593: /*
594: * The string cannot be parsed. Inform the user of
595: * what is expected.
596: */
597: MPError(MB_OK, IDS_BADLENGTH);
598: return 0;
599: }
600: }
601: if (fOwned) {
602: aOwned[cOwned].hData = pxact->hDdeData;
603: aOwned[cOwned].hszItem = pxact->hszItem;
604: aOwned[cOwned].wFmt = pxact->wFmt;
605: cOwned++;
606: }
607: EndDialog(hwnd, TRUE);
608: break;
609:
610: case IDBN_USEOWNED:
611: /*
612: * the user has chosen to use an existing owned data for sending
613: * to the server.
614: */
1.1.1.2 ! root 615: id = DoDialog(MAKEINTRESOURCE(IDD_HDATAVIEW), (DLGPROC)ViewHandleDlgProc,
! 616: (LONG)pxact, TRUE);
1.1 root 617:
618: switch (id) {
619: case IDCANCEL:
620: return(0);
621:
622: case IDOK:
623: EndDialog(hwnd, TRUE);
624:
625: case IDBN_VIEW:
626: pData = DdeAccessData(pxact->hDdeData, NULL);
627: SetDlgItemText(hwnd, IDEF_DATA, pData);
628: DdeUnaccessData(pxact->hDdeData);
629: break;
630: }
631: break;
632:
633: case IDCANCEL:
634: EndDialog(hwnd, FALSE);
635: break;
636: }
637: break;
638:
639: default:
640: return(FALSE);
641: }
642: }
643:
644:
645:
646: BOOL APIENTRY ViewHandleDlgProc(
647: HWND hwnd,
648: UINT msg,
649: WPARAM wParam,
650: LPARAM lParam)
651: {
652: static XACT FAR *pxact;
653: INT i, itm;
654:
655: switch (msg){
656: case WM_INITDIALOG:
657: pxact = (XACT FAR *)lParam;
658: // load listbox with handles that fit pxact constraints
659:
660: for (i = 0; i < (INT)cOwned; i++) {
661: if (aOwned[i].hszItem == pxact->hszItem &&
662: aOwned[i].wFmt == pxact->wFmt) {
663: wsprintf(szT, "[%d] %lx : length=%ld", i, aOwned[i].hData,
664: DdeGetData(aOwned[i].hData, NULL, 0, 0));
665: SendDlgItemMessage(hwnd, IDLB_HANDLES, LB_ADDSTRING, 0, (LONG)(LPSTR)szT);
666: }
667: }
668: SendDlgItemMessage(hwnd, IDLB_HANDLES, LB_SETCURSEL, 0, 0);
669: break;
670:
671: case WM_COMMAND:
1.1.1.2 ! root 672: switch (LOWORD(wParam)) {
1.1 root 673: case IDOK: // use selectted handle
674: case IDBN_DELETE: // delete selected handle
675: case IDBN_VIEW: // view selected handle
676: itm = (INT)SendDlgItemMessage(hwnd, IDLB_HANDLES, LB_GETCURSEL, 0, 0);
677: if (itm != LB_ERR) {
678: SendDlgItemMessage(hwnd, IDLB_HANDLES, LB_GETTEXT, itm, (LONG)(LPSTR)szT);
679: sscanf(szT, "[%d]", &i);
680: pxact->hDdeData = aOwned[i].hData;
1.1.1.2 ! root 681: switch (LOWORD(wParam)) {
1.1 root 682: case IDOK: // use selectted handle
1.1.1.2 ! root 683: EndDialog(hwnd, LOWORD(wParam));
1.1 root 684: break;
685:
686: case IDBN_DELETE: // delete selected handle
687: DdeFreeDataHandle(aOwned[i].hData);
688: aOwned[i] = aOwned[--cOwned];
689: SendDlgItemMessage(hwnd, IDLB_HANDLES, LB_DELETESTRING, itm, 0);
690: if (SendDlgItemMessage(hwnd, IDLB_HANDLES, LB_GETCOUNT, 0, 0) == 0)
691: EndDialog(hwnd, IDCANCEL);
692: break;
693:
694: case IDBN_VIEW: // view selected handle
1.1.1.2 ! root 695: EndDialog(hwnd, LOWORD(wParam));
1.1 root 696: }
697: }
698: break;
699:
700: case IDCANCEL:
701: EndDialog(hwnd, FALSE);
702: break;
703: }
704: break;
705:
706: default:
707: return(FALSE);
708: }
709: }
710:
711:
712:
713: BOOL APIENTRY DelayDlgProc(
714: HWND hwnd,
715: UINT msg,
716: WPARAM wParam,
717: LPARAM lParam)
718: {
719: switch (msg){
720: case WM_INITDIALOG:
721: SetWindowText(hwnd, "Advise data response time");
722: SetDlgItemInt(hwnd, IDEF_VALUE, wDelay, FALSE);
723: SetDlgItemText(hwnd, IDTX_VALUE, "Delay in milliseconds:");
724: break;
725:
726: case WM_COMMAND:
1.1.1.2 ! root 727: switch (LOWORD(wParam)) {
1.1 root 728: case IDOK:
729: wDelay = (DWORD)GetDlgItemInt(hwnd, IDEF_VALUE, NULL, FALSE);
730: case IDCANCEL:
731: EndDialog(hwnd, 0);
732: break;
733:
734: default:
735: return(FALSE);
736: }
737: break;
738:
739: default:
740: return(FALSE);
741: }
742: }
743:
744:
745:
746:
747:
748: /****************************************************************************
749: * *
750: * FUNCTION : TimeoutDlgProc() *
751: * *
752: * PURPOSE : Allows user to alter the synchronous timeout value. *
753: * *
754: * RETURNS : TRUE on success, FALSE on cancel or failure. *
755: * *
756: ****************************************************************************/
757: BOOL APIENTRY TimeoutDlgProc(
758: HWND hwnd,
759: UINT msg,
760: WPARAM wParam,
761: LPARAM lParam)
762: {
763: switch (msg){
764: case WM_INITDIALOG:
765: SetWindowText(hwnd, "Synchronous transaction timeout");
766: SetDlgItemInt(hwnd, IDEF_VALUE, (INT)DefTimeout, FALSE);
767: SetDlgItemText(hwnd, IDTX_VALUE, "Timeout in milliseconds:");
768: break;
769:
770: case WM_COMMAND:
1.1.1.2 ! root 771: switch (LOWORD(wParam)) {
1.1 root 772: case IDOK:
773: DefTimeout = GetDlgItemInt(hwnd, IDEF_VALUE, NULL, FALSE);
774: case IDCANCEL:
775: EndDialog(hwnd, 0);
776: break;
777:
778: default:
779: return(FALSE);
780: }
781: break;
782:
783: default:
784: return(FALSE);
785: }
786: }
787:
788:
789:
790:
791: BOOL APIENTRY ContextDlgProc(
792: HWND hwnd,
793: UINT msg,
794: WPARAM wParam,
795: LPARAM lParam)
796: {
797: BOOL fSuccess;
798:
799: switch (msg){
800: case WM_INITDIALOG:
801: SetDlgItemInt(hwnd, IDEF_FLAGS, CCFilter.wFlags, FALSE);
802: SetDlgItemInt(hwnd, IDEF_COUNTRY, CCFilter.wCountryID, FALSE);
803: SetDlgItemInt(hwnd, IDEF_CODEPAGE, CCFilter.iCodePage, TRUE);
804: SetDlgItemInt(hwnd, IDEF_LANG, CCFilter.dwLangID, FALSE);
805: SetDlgItemInt(hwnd, IDEF_SECURITY, CCFilter.dwSecurity, FALSE);
806: return(1);
807: break;
808:
809: case WM_COMMAND:
1.1.1.2 ! root 810: switch (LOWORD(wParam)) {
1.1 root 811: case IDOK:
812: CCFilter.wFlags = (WORD)GetDlgItemInt(hwnd, IDEF_FLAGS, &fSuccess, FALSE);
813: if (!fSuccess) return(0);
814: CCFilter.wCountryID = (WORD)GetDlgItemInt(hwnd, IDEF_COUNTRY, &fSuccess, FALSE);
815: if (!fSuccess) return(0);
816: CCFilter.iCodePage = GetDlgItemInt(hwnd, IDEF_CODEPAGE, &fSuccess, TRUE);
817: if (!fSuccess) return(0);
818: CCFilter.dwLangID = (DWORD)GetDlgItemInt(hwnd, IDEF_LANG, &fSuccess, FALSE);
819: if (!fSuccess) return(0);
820: CCFilter.dwSecurity = (DWORD)GetDlgItemInt(hwnd, IDEF_SECURITY, &fSuccess, FALSE);
821: if (!fSuccess) return(0);
822: // fall through
823: case IDCANCEL:
824: EndDialog(hwnd, 0);
825: break;
826:
827: default:
828: return(FALSE);
829: }
830: break;
831: }
832: return(FALSE);
833: }
834:
835:
836: VOID Delay(
837: DWORD delay)
838: {
839: MSG msg;
840:
841: delay = GetCurrentTime() + delay;
842: while (GetCurrentTime() < delay) {
843: if (PeekMessage(&msg,NULL,NULL,NULL,PM_REMOVE)) {
844: TranslateMessage(&msg);
845: DispatchMessage(&msg);
846: }
847: }
848: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.