![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to ddemo.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [WindowsNT SDKs] / mstools / samples / ddeml / ddemo|
Return to ddemo.c CVS log | Up to [WindowsNT SDKs] / mstools / samples / ddeml / ddemo |
1.1 root 1: /*****************************************************************************\
2: *
3: * DDEMO.C
4: *
5: * This file implements a simple DDEML sample application that demonstrates
6: * some of the ways the DDEML APIs can be used.
7: *
8: * Each instance of this application becomes both a DDE client and a DDE
9: * server with any other instances of this application that are found.
10: *
11: * Since it assumes it is talking to itself, this program takes some liberties
12: * to simplify things. For instance, this application does not support the
13: * standard SysTopic topic and does not use any standard formats.
14: *
15: * The basic concepts this application will show you are:
16: *
17: * How to use lists of conversations properly
18: * How to handle links
19: * How to handle simple asynchronous transactions
20: * How to use your own custom formats
21: *
22: \*****************************************************************************/
23: #include <windows.h>
24: #include <ddeml.h>
25: #include <stdlib.h>
26: #include <string.h>
27:
28: HDDEDATA CALLBACK DdeCallback(WORD wType, WORD wFmt, HCONV hConv, HSZ hszTopic,
29: HSZ hszItem, HDDEDATA hData, DWORD lData1, DWORD lData2);
30: VOID PaintDemo(HWND hwnd);
31: LONG APIENTRY MainWndProc(HWND hwnd, UINT message, WPARAM wParam,
32: LONG lParam);
33:
34: /*
35: * Define this value to limit how fast data changes. If we just let data
36: * change as fast a possible, we might bog down the system with DDE
37: * messages.
38: */
39: #define BASE_TIMEOUT 100
40:
41: BOOL fActive; // indicates data is changing
42: DWORD idInst = 0; // our DDEML instance object
43: HANDLE hInst; // our instance/module handle
44: HCONVLIST hConvList = 0; // the list of all convs we have open
45: HSZ hszAppName = 0; // the generic hsz for everything
46: HWND hwndMain; // our main window handle
47: TCHAR szT[20]; // static buffer for painting
48: TCHAR szTitle[] = "DDEmo"; // the generic string for everything
49: UINT OurFormat; // our custom registered format
50: int InCount = 0; // static buffer to hold incomming data
51: int cConvs = 0; // number of active conversations
52: int count = 0; // our data
53: int cyText, cxText, cyTitle; // sizes for painting
54:
55: int WINAPI WinMain(
56: HANDLE hInstance,
57: HANDLE hPrevInstance,
58: LPSTR lpCmdLine,
59: INT nCmdShow)
60: {
61: MSG msg;
62: WNDCLASS wc;
63: TEXTMETRIC metrics;
64: HDC hdc;
65:
66: wc.style = 0;
67: wc.lpfnWndProc = MainWndProc;
68: wc.cbClsExtra = 0;
69: wc.cbWndExtra = 0;
70: wc.hInstance = hInstance;
71: wc.hIcon = NULL;
72: wc.hCursor = LoadCursor(NULL, IDC_ARROW);
73: wc.hbrBackground = NULL;
74: wc.lpszMenuName = NULL;
75: wc.lpszClassName = szTitle;
76:
77: if (!RegisterClass(&wc))
78: return(FALSE);
79:
80: /*
81: * Here we tell DDEML what we will be doing.
82: *
83: * 1) We let it know our callback proc address - MakeProcInstance
84: * is called just to be more portable.
85: * 2) Filter-inits - don't accept any WM_DDE_INITIATE messages for
86: * anything but our registered service name.
87: * 3) Don't bother to notify us of confirmed connections
88: * 4) Don't allow connections with ourselves.
89: * 5) Don't bother us with XTYP_POKE transactions.
90: */
91: if (DdeInitialize(&idInst,
92: (PFNCALLBACK)MakeProcInstance((FARPROC)DdeCallback, hInstance),
93: APPCMD_FILTERINITS |
94: CBF_SKIP_CONNECT_CONFIRMS |
95: CBF_FAIL_SELFCONNECTIONS |
96: CBF_FAIL_POKES,
97: 0))
98: return(FALSE);
99:
100: hInst = hInstance;
101: hwndMain = CreateWindow(
102: szTitle,
103: szTitle,
104: WS_CAPTION | WS_BORDER | WS_SYSMENU,
105: CW_USEDEFAULT,
106: CW_USEDEFAULT,
107: 0,
108: 0,
109: NULL,
110: NULL,
111: hInstance,
112: NULL
113: );
114:
115: if (!hwndMain) {
116: DdeUninitialize(idInst);
117: return(FALSE);
118: }
119:
120: hdc = GetDC(hwndMain);
121: GetTextMetrics(hdc, &metrics);
122: cyText = metrics.tmHeight + metrics.tmExternalLeading;
123: cxText = metrics.tmMaxCharWidth * 8;
124: cyTitle = GetSystemMetrics(SM_CYCAPTION);
125: ReleaseDC(hwndMain, hdc);
126:
127: SetWindowPos(hwndMain, 0, 0, 0, cxText, cyText + cyTitle,
128: SWP_NOMOVE | SWP_NOZORDER | SWP_NOREDRAW | SWP_NOACTIVATE);
129: ShowWindow(hwndMain, nCmdShow);
130: UpdateWindow(hwndMain);
131:
132: /*
133: * Initialize all our string handles for lookups later
134: */
135: hszAppName = DdeCreateStringHandle(idInst, szTitle, 0);
136: /*
137: * Register our formats
138: */
139: OurFormat = RegisterClipboardFormat(szTitle);
140: /*
141: * Connect to any other instances of ourselves that may already be
142: * running.
143: */
144: hConvList = DdeConnectList(idInst, hszAppName, hszAppName, hConvList, NULL);
145: /*
146: * Register our service -
147: * This will cause DDEML to notify DDEML clients about the existance
148: * of a new DDE service.
149: */
150: DdeNameService(idInst, hszAppName, 0, DNS_REGISTER);
151:
152: while (GetMessage(&msg, 0, 0, 0)) {
153: TranslateMessage(&msg);
154: DispatchMessage(&msg);
155: }
156:
157: DestroyWindow(hwndMain);
158: UnregisterClass(szTitle, hInstance);
159: return(FALSE);
160: }
161:
162:
163: /*
164: * BroadcastTransaction
165: *
166: * Does the specified transaction on all conversations in hConvList
167: */
168: VOID BroadcastTransaction(
169: PBYTE pSrc,
170: DWORD cbData,
171: UINT fmt,
172: UINT xtyp)
173: {
174: HCONV hConv;
175: DWORD dwResult;
176: int cConvsOrg;
177:
178: cConvsOrg = cConvs;
179: cConvs = 0;
180: if (hConvList) {
181: /*
182: * Enumerate all the conversations within this list - note that
183: * DDEML will only return active conversations. Inactive conversations
184: * are automatically removed.
185: */
186: hConv = DdeQueryNextServer(hConvList, NULL);
187: while (hConv) {
188: /*
189: * Count the active conversations while we're at it.
190: */
191: cConvs++;
192: /*
193: * Spawn an asynchronous transaction - this was chosen because
194: * we have not particular action if an error ocurrs so we just
195: * don't care too much about the results - this technique will
196: * NOT do for XTYP_REQUEST transactions though.
197: */
198: if (DdeClientTransaction(pSrc, cbData, hConv, hszAppName, fmt,
199: xtyp, TIMEOUT_ASYNC, &dwResult)) {
200: /*
201: * We immediately abandon the transaction so we don't get
202: * a bothersome XTYP_XACT_COMPLETE callback which we don't
203: * care about.
204: */
205: DdeAbandonTransaction(idInst, hConv, dwResult);
206: }
207:
208: hConv = DdeQueryNextServer(hConvList, hConv);
209: }
210: }
211: if (cConvs != cConvsOrg) {
212: /*
213: * Oh, the number of active conversations has changed. Time to
214: * repaint!
215: */
216: InvalidateRect(hwndMain, NULL, TRUE);
217: }
218: }
219:
220:
221: /*
222: * MyProcessKey
223: *
224: * We demonstrate the robustness of NT here by forcing a GP anytime the
225: * 'B' key is pressed while this window has the focus. NT should properly
226: * fake termination to all other apps connected to us.
227: */
228: VOID MyProcessKey(
229: TCHAR tchCode,
230: LONG lKeyData)
231: {
232: switch (tchCode) {
233: case TEXT('B'):
234: case TEXT('b'):
235: *((PBYTE)(-1)) = 0; // Cause GP fault!
236: break;
237: }
238: }
239:
240:
241:
242: LONG APIENTRY MainWndProc(
243: HWND hwnd,
244: UINT message,
245: WPARAM wParam,
246: LONG lParam)
247: {
248: RECT rc;
249:
250: switch (message) {
251: case WM_CREATE:
252: /*
253: * initially we are inactive - this reduces some of the message
254: * traffic while we are initializing - but we could start active fine.
255: */
256: fActive = FALSE;
257: break;
258:
259: case WM_RBUTTONDOWN:
260: if (GetKeyState(VK_CONTROL) & 0x8000) {
261: /*
262: * A CTRL R_BUTTON click will cause ALL instances of this app
263: * to become inactive.
264: */
265: BroadcastTransaction("PAUSE", 6, 0, XTYP_EXECUTE);
266: MessageBeep(0);
267: }
268: /*
269: * A R_BUTTON click makes us inactive. Repaint to show state change.
270: * We do a synchronous update in case there is too much DDE message
271: * activity to allow the WM_PAINT messages through. Remember DDE
272: * messages have priority over others!
273: */
274: KillTimer(hwndMain, 1);
275: fActive = FALSE;
276: InvalidateRect(hwnd, NULL, TRUE);
277: UpdateWindow(hwnd);
278: break;
279:
280: case WM_LBUTTONDOWN:
281: if (GetKeyState(VK_CONTROL) & 0x8000) {
282: /*
283: * A CTRL L_BUTTON click will cause ALL instances of this app
284: * to become active.
285: */
286: BroadcastTransaction("RESUME", 7, 0, XTYP_EXECUTE);
287: MessageBeep(0);
288: }
289: /*
290: * An L_BUTTON click makes us active. Repaint to show state change.
291: */
292: SetTimer(hwndMain, 1, BASE_TIMEOUT + (rand() & 0xff), NULL);
293: fActive = TRUE;
294: InvalidateRect(hwnd, NULL, TRUE);
295: UpdateWindow(hwnd);
296: break;
297:
298: case WM_CHAR:
299: MyProcessKey((TCHAR)wParam, lParam);
300: break;
301:
302: case WM_TIMER:
303: /*
304: * We use timers for simplicity. On Win3.1 we could run out of
305: * timers easily but we don't have this worry on NT.
306: *
307: * Each tick, we increment our data and call DdePostAdvise() to
308: * update any links there may be on this data. DDEML makes link
309: * updates on specific items quite easy.
310: */
311: count++;
312: DdePostAdvise(idInst, hszAppName, hszAppName);
313: /*
314: * Invalidate the part of ourselves that shows our data and
315: * synchronously update it in case DDE message activity is blocking
316: * paints.
317: */
318: SetRect(&rc, 0, 0, cxText, cyText);
319: InvalidateRect(hwndMain, &rc, TRUE);
320: UpdateWindow(hwndMain);
321: break;
322:
323: case WM_PAINT:
324: PaintDemo(hwnd);
325: break;
326:
327: case WM_CLOSE:
328: KillTimer(hwnd, 1);
329: /*
330: * We do DDE cleanup here. It is best to do DDE cleanup while
331: * still in the message loop to allow DDEML to recieve messages
332: * while shutting down.
333: */
334: DdeDisconnectList(hConvList);
335: DdeNameService(idInst, 0, 0, DNS_UNREGISTER);
336: DdeFreeStringHandle(idInst, hszAppName);
337: DdeUninitialize(idInst);
338: PostQuitMessage(0);
339: break;
340:
341: default:
342: return (DefWindowProc(hwnd, message, wParam, lParam));
343: }
344: return(0);
345: }
346:
347:
348: VOID PaintDemo(
349: HWND hwnd)
350: {
351: PAINTSTRUCT ps;
352: RECT rc;
353: HCONV hConv;
354: CONVINFO ci;
355: int cConvsOrg = cConvs;
356:
357: BeginPaint(hwnd, &ps);
358: /*
359: * Draw our data on top - Black for active, Grey for inactive.
360: */
361: SetRect(&rc, 0, 0, cxText, cyText);
362: SetBkMode(ps.hdc, TRANSPARENT);
363: SetTextColor(ps.hdc, 0x00FFFFFF); // white text
364: FillRect(ps.hdc, &rc, GetStockObject(fActive ? BLACK_BRUSH : GRAY_BRUSH));
365: DrawText(ps.hdc, itoa(count, szT, 10), -1, &rc, DT_CENTER | DT_VCENTER);
366:
367: /*
368: * Now draw the most recently recieved data from each server we are
369: * connected to.
370: */
371: if (hConvList) {
372: OffsetRect(&rc, 0, cyText);
373: SetTextColor(ps.hdc, 0); // draw black text
374: cConvs = 0;
375: hConv = DdeQueryNextServer(hConvList, NULL);
376: while (hConv) {
377: cConvs++;
378: /*
379: * count how many conversations are active while we're at it.
380: */
381: ci.cb = sizeof(CONVINFO);
382: DdeQueryConvInfo(hConv, QID_SYNC, &ci);
383: FillRect(ps.hdc, &rc, GetStockObject(WHITE_BRUSH)); // white bkgnd
384: DrawText(ps.hdc, itoa(ci.hUser, szT, 10), -1, &rc,
385: DT_CENTER | DT_VCENTER);
386: OffsetRect(&rc, 0, cyText);
387: hConv = DdeQueryNextServer(hConvList, hConv);
388: }
389: }
390: EndPaint(hwnd, &ps);
391: if (cConvsOrg != cConvs) {
392: /*
393: * The number of active conversations changed! Resize to fit.
394: */
395: SetWindowPos(hwndMain, 0, 0, 0, cxText,
396: (cyText * (cConvs + 1)) + cyTitle,
397: SWP_NOMOVE | SWP_NOZORDER | SWP_NOACTIVATE);
398: }
399: }
400:
401:
402:
403: /*
404: * This is the main DDEML callback proc. It handles all interaction with
405: * DDEML that is DDEML originated.
406: */
407: HDDEDATA CALLBACK DdeCallback(
408: WORD wType,
409: WORD wFmt,
410: HCONV hConv,
411: HSZ hszTopic,
412: HSZ hszItem,
413: HDDEDATA hData,
414: DWORD lData1,
415: DWORD lData2)
416: {
417: LPTSTR pszExec;
418:
419: switch (wType) {
420: case XTYP_CONNECT:
421: /*
422: * Only allow connections to us. We can always return TRUE because
423: * the CBF_FILTERINITS bit given to DdeInitialize() told DDEML to
424: * never bother us with connections to any service names other than
425: * what we have registered.
426: *
427: * Note that we do not handle the XTYP_WILD_CONNECT transaction.
428: * This means that no wild-card initiates to us will work.
429: */
430: return(TRUE);
431:
432: case XTYP_ADVREQ:
433: case XTYP_REQUEST:
434: /*
435: * These two transactions are the only ones that require us to
436: * render our data. By using a custom format, we don't have to
437: * convert our count to text form to support CF_TEXT.
438: */
439: return(DdeCreateDataHandle(idInst, (PBYTE)&count, sizeof(count), 0,
440: hszAppName, OurFormat, 0));
441:
442: case XTYP_ADVSTART:
443: /*
444: * Only allow links to our Item in our format.
445: */
446: return(wFmt == OurFormat && hszItem == hszAppName);
447:
448: case XTYP_ADVDATA:
449: /*
450: * Data is comming in. We don't bother with XTYP_POKE transactions,
451: * but if we did, they would go here. Since we only allow links
452: * on our item and our format, we need not check these here.
453: */
454: if (DdeGetData(hData, (PBYTE)&InCount, sizeof(InCount), 0)) {
455: DdeSetUserHandle(hConv, QID_SYNC, InCount);
456: }
457: /*
458: * update ourselves to reflect the new incomming data.
459: */
460: InvalidateRect(hwndMain, NULL, TRUE);
461: /*
462: * This transaction requires a flag return value. We could also
463: * stick other status bits here if needed but its not recommended.
464: */
465: return(DDE_FACK);
466:
467: case XTYP_EXECUTE:
468: /*
469: * Another instance wants us to do something. DdeAccessData()
470: * makes parsing of execute strings easy. Also note, that DDEML
471: * will automatically give us the string in the right form
472: * (UNICODE vs ASCII) depending on which form of DdeInitialize()
473: * we called.
474: */
475: pszExec = DdeAccessData(hData, NULL);
476: if (pszExec) {
477: if (fActive && !stricmp("PAUSE", pszExec)) {
478: KillTimer(hwndMain, 1);
479: fActive = FALSE;
480: InvalidateRect(hwndMain, NULL, TRUE);
481: UpdateWindow(hwndMain);
482: } else if (!fActive && !stricmp("RESUME", pszExec)) {
483: SetTimer(hwndMain, 1, BASE_TIMEOUT + (rand() & 0xff), NULL);
484: fActive = TRUE;
485: InvalidateRect(hwndMain, NULL, TRUE);
486: UpdateWindow(hwndMain);
487: }
488: /*
489: * The beep gives good feedback on how fast the execute was.
490: */
491: MessageBeep(0);
492: }
493: break;
494:
495: case XTYP_DISCONNECT:
496: /*
497: * Somebody went away, repaint so we update our cConvs count.
498: */
499: InvalidateRect(hwndMain, NULL, TRUE);
500: break;
501:
502: case XTYP_REGISTER:
503: /*
504: * Since a new server just arrived, lets make sure our links are
505: * up to date. Note that only one link on a
506: * conversation/topic/item/format set will work anyway so we don't
507: * worry about duplicate links.
508: *
509: * Note also that we are using hszItem - which is the InstanceSpecific
510: * name of the server that is registering. This greatly reduces the
511: * number of messages that go flying around.
512: */
513: hConvList = DdeConnectList(idInst, hszItem, hszAppName, hConvList, NULL);
514: BroadcastTransaction(NULL, 0, OurFormat, XTYP_ADVSTART);
515: SetWindowPos(hwndMain, 0, 0, 0, cxText,
516: (cyText * (cConvs + 1)) + cyTitle, SWP_NOMOVE | SWP_NOZORDER);
517: UpdateWindow(hwndMain);
518: return(TRUE);
519: }
520: return(0);
521: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.