![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to ddemlsv.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [WindowsNT SDKs] / mstools / samples / ddeml / server|
Return to ddemlsv.c CVS log | Up to [WindowsNT SDKs] / mstools / samples / ddeml / server |
1.1 root 1: /****************************************************************************
2:
3: PROGRAM: Server.c
4:
5: PURPOSE: Server template for Windows applications
6:
7: FUNCTIONS:
8:
9: WinMain() - calls initialization function, processes message loop
10: InitApplication() - initializes window data and registers window
11: InitInstance() - saves instance handle and creates main window
12: MainWndProc() - processes messages
13: About() - processes messages for "About" dialog box
14:
15: COMMENTS:
16:
17: Windows can have several copies of your application running at the
18: same time. The variable hInst keeps track of which instance this
19: application is so that processing will be to the correct window.
20:
21: ****************************************************************************/
22:
23: #include <stdio.h>
24: #include <stdlib.h>
25: #include <string.h>
26: #include "server.h" /* specific to this program */
27: #include "huge.h"
28:
29: DWORD idInst = 0;
30: CONVCONTEXT CCFilter = { sizeof(CONVCONTEXT), 0, 0, 0, 0L, 0L };
31: HANDLE hInst; /* current instance */
32: HWND hwndServer;
33: RECT rcRand;
34: RECT rcCount;
35: RECT rcComment;
36: RECT rcExec;
37: RECT rcConnCount;
38: RECT rcRndrDelay;
39: RECT rcRunaway;
40: RECT rcAllBlock;
41: RECT rcNextAction;
42: RECT rcHugeSize;
43: RECT rcAppowned;
44: BOOL fAllBlocked = FALSE;
45: BOOL fAllEnabled = TRUE;
46: BOOL fEnableOneCB = FALSE;
47: BOOL fBlockNextCB = FALSE;
48: BOOL fTermNextCB = FALSE;
49: BOOL fAppowned = FALSE;
50: WORD cRunaway = 0;
51: WORD RenderDelay = 0;
52: DWORD count = 0;
53: WORD seed = 0;
54: HSZ hszAppName = 0;
55: CHAR szClass[] = "ServerWClass";
56: CHAR szTopic[MAX_TOPIC] = "Test";
57: CHAR szServer[MAX_TOPIC] = "Server";
58: CHAR szComment[MAX_COMMENT] = "";
59: CHAR szExec[MAX_EXEC] = "";
60: CHAR *pszComment = szComment;
61: WORD cyText;
62: WORD cServers = 0;
63: HDDEDATA hDataHelp[CFORMATS] = {0};
64: HDDEDATA hDataCount[CFORMATS] = {0};
65: HDDEDATA hDataRand[CFORMATS] = {0};
66: HDDEDATA hDataHuge[CFORMATS] = {0};
67: DWORD cbHuge = 0;
68:
69: char szDdeHelp[] = "DDEML test server help:\r\n\n"\
70: "The 'Server'(service) and 'Test'(topic) names may change.\r\n\n"\
71: "Items supported under the 'Test' topic are:\r\n"\
72: "\tCount:\tThis value increments on each data change.\r\n"\
73: "\tRand:\tThis value is randomly generated each data change.\r\n"\
74: "\tHuge:\tThis is randomlly generated text data >64k that the\r\n"\
75: "\t\tDDEML test client can verify.\r\n"\
76: "The above items change after any request if in Runaway mode and \r\n"\
77: "can bo POKEed in order to change their values. POKEed Huge data \r\n"\
78: "must be in a special format to verify the correctness of the data \r\n"\
79: "or it will not be accepted.\r\n"\
80: "If the server is set to use app owned data handles, all data sent \r\n"\
81: "uses HDATA_APPOWNED data handles."\
82: ;
83:
84: FORMATINFO aFormats[CFORMATS] = {
85: { 0, "CF_TEXT" }, // exception! predefined format
86: { 0, "Dummy1" },
87: { 0, "Dummy2" },
88: };
89:
90:
91: /*
92: * Topic and Item tables supported by this application.
93: */
94:
95: /* HSZ PROCEDURE PSZ */
96:
97: ITEMLIST SystemTopicItemList[CSYSTEMITEMS] = {
98:
99: { 0, TopicListXfer, SZDDESYS_ITEM_TOPICS },
100: { 0, ItemListXfer, SZDDESYS_ITEM_SYSITEMS },
101: { 0, sysFormatsXfer, SZDDESYS_ITEM_FORMATS },
102: { 0, HelpXfer, SZDDESYS_ITEM_HELP},
103: };
104:
105:
106: ITEMLIST TestTopicItemList[CTESTITEMS] = {
107:
108: { 0, TestRandomXfer, "Rand" }, // 0 index
109: { 0, TestCountXfer, "Count"}, // 1 index
110: { 0, TestHugeXfer, "Huge" }, // 2 index
111: { 0, ItemListXfer, SZDDESYS_ITEM_SYSITEMS }, // 3 index
112: };
113:
114:
115: /* The system topic is always assumed to be first. */
116: /* HSZ PROCEDURE #ofITEMS PSZ */
117: TOPICLIST topicList[CTOPICS] = {
118:
119: { 0, SystemTopicItemList, CSYSTEMITEMS, SZDDESYS_TOPIC}, // 0 index
120: { 0, TestTopicItemList, CTESTITEMS, szTopic}, // 1 index
121: };
122:
123:
124:
125:
126:
127:
128: /****************************************************************************
129:
130: FUNCTION: WinMain(HANDLE, HANDLE, LPSTR, int)
131:
132: PURPOSE: calls initialization function, processes message loop
133:
134: COMMENTS:
135:
136: Windows recognizes this function by name as the initial entry point
137: for the program. This function calls the application initialization
138: routine, if no other instance of the program is running, and always
139: calls the instance initialization routine. It then executes a message
140: retrieval and dispatch loop that is the top-level control structure
141: for the remainder of execution. The loop is terminated when a WM_QUIT
142: message is received, at which time this function exits the application
143: instance by returning the value passed by PostQuitMessage().
144:
145: If this function must abort before entering the message loop, it
146: returns the conventional value NULL.
147:
148: ****************************************************************************/
149:
150: int APIENTRY WinMain(
151: HANDLE hInstance,
152: HANDLE hPrevInstance,
153: LPSTR lpCmdLine,
154: int nCmdShow
155: )
156: {
157: MSG msg; /* message */
158:
159: if (!hPrevInstance) /* Other instances of app running? */
160: if (!InitApplication(hInstance)) /* Initialize shared things */
161: return (FALSE); /* Exits if unable to initialize */
162:
163: /* Perform initializations that apply to a specific instance */
164:
165: if (!InitInstance(hInstance, nCmdShow))
166: return (FALSE);
167:
168: /* Acquire and dispatch messages until a WM_QUIT message is received. */
169:
170: while (GetMessage(&msg, /* message structure */
171: 0, /* handle of window receiving the message */
172: 0, /* lowest message to examine */
173: 0)) /* highest message to examine */
174: {
175: TranslateMessage(&msg); /* Translates virtual key codes */
176: DispatchMessage(&msg); /* Dispatches message to window */
177: }
178:
179: UnregisterClass(szClass, hInstance);
180: return (msg.wParam); /* Returns the value from PostQuitMessage */
181: }
182:
183:
184: /****************************************************************************
185:
186: FUNCTION: InitApplication(HANDLE)
187:
188: PURPOSE: Initializes window data and registers window class
189:
190: COMMENTS:
191:
192: This function is called at initialization time only if no other
193: instances of the application are running. This function performs
194: initialization tasks that can be done once for any number of running
195: instances.
196:
197: In this case, we initialize a window class by filling out a data
198: structure of type WNDCLASS and calling the Windows RegisterClass()
199: function. Since all instances of this application use the same window
200: class, we only need to do this when the first instance is initialized.
201:
202:
203: ****************************************************************************/
204:
205: BOOL InitApplication(hInstance)
206: HANDLE hInstance; /* current instance */
207: {
208: WNDCLASS wc;
209:
210: /* Fill in window class structure with parameters that describe the */
211: /* main window. */
212:
213: wc.style = 0; /* Class style(s). */
214: wc.lpfnWndProc = MainWndProc; /* Function to retrieve messages for */
215: /* windows of this class. */
216: wc.cbClsExtra = 0; /* No per-class extra data. */
217: wc.cbWndExtra = 0; /* No per-window extra data. */
218: wc.hInstance = hInstance; /* Application that owns the class. */
219: wc.hIcon = LoadIcon(hInstance, "server");
220: wc.hCursor = LoadCursor(NULL, IDC_ARROW);
221: wc.hbrBackground = (HANDLE)(COLOR_APPWORKSPACE+1);
222: wc.lpszMenuName = "ServerMenu"; /* Name of menu resource in .RC file. */
223: wc.lpszClassName = "ServerWClass"; /* Name used in call to CreateWindow. */
224:
225: /* Register the window class and return success/failure code. */
226:
227: return (RegisterClass(&wc));
228:
229: }
230:
231:
232: /****************************************************************************
233:
234: FUNCTION: InitInstance(HANDLE, int)
235:
236: PURPOSE: Saves instance handle and creates main window
237:
238: COMMENTS:
239:
240: This function is called at initialization time for every instance of
241: this application. This function performs initialization tasks that
242: cannot be shared by multiple instances.
243:
244: In this case, we save the instance handle in a static variable and
245: create and display the main program window.
246:
247: ****************************************************************************/
248:
249: BOOL InitInstance(hInstance, nCmdShow)
250: HANDLE hInstance; /* Current instance identifier. */
251: INT nCmdShow; /* Param for first ShowWindow() call. */
252: {
253: INT i;
254: RECT Rect;
255: TEXTMETRIC metrics;
256: HDC hdc;
257:
258: /* Save the instance handle in static variable, which will be used in */
259: /* many subsequence calls from this application to Windows. */
260:
261: hInst = hInstance;
262:
263:
264: /* Create a main window for this application instance. */
265:
266: hwndServer = CreateWindow(
267: "ServerWClass", /* See RegisterClass() call. */
268: "Server|Test",
269: WS_OVERLAPPEDWINDOW, /* Window style. */
270: CW_USEDEFAULT, /* Default horizontal position. */
271: CW_USEDEFAULT, /* Default vertical position. */
272: 400,
273: 200,
274: NULL, /* Overlapped windows have no parent. */
275: NULL, /* Use the window class menu. */
276: hInstance, /* This instance owns this window. */
277: NULL /* Pointer not needed. */
278: );
279:
280: GetClientRect(hwndServer, (LPRECT) &Rect);
281:
282: /* If window could not be created, return "failure" */
283:
284: if (!hwndServer)
285: return (FALSE);
286:
287: hdc = GetDC(hwndServer);
288: GetTextMetrics(hdc, &metrics);
289: cyText = (WORD)(metrics.tmHeight + metrics.tmExternalLeading);
290: ReleaseDC(hwndServer, hdc);
291:
292: aFormats[0].atom = CF_TEXT; // exception - predefined.
293: for (i = 1; i < CFORMATS; i++) {
294: aFormats[i].atom = RegisterClipboardFormat(aFormats[i].sz);
295: }
296:
297: /* Make the window visible; update its client area; and return "success" */
298:
299: ShowWindow(hwndServer, nCmdShow); /* Show the window */
300: UpdateWindow(hwndServer); /* Sends WM_PAINT message */
301: seed = 1;
302: srand(1);
303: CCFilter.iCodePage = CP_WINANSI; // initial default codepage
304: if (!DdeInitialize(&idInst, (PFNCALLBACK)MakeProcInstance((FARPROC)DdeCallback,
305: hInstance), APPCMD_FILTERINITS, 0)) {
306: Hszize();
307: DdeNameService(idInst, hszAppName, 0, DNS_REGISTER);
308: return(TRUE);
309: }
310: return (FALSE);
311:
312: }
313:
314: /****************************************************************************
315:
316: FUNCTION: MainWndProc(HWND, unsigned, WORD, LONG)
317:
318: PURPOSE: Processes messages
319:
320: MESSAGES:
321:
322: WM_COMMAND - application menu (About dialog box)
323: WM_DESTROY - destroy window
324:
325: COMMENTS:
326:
327: To process the IDM_ABOUT message, call MakeProcInstance() to get the
328: current instance address of the About() function. Then call Dialog
329: box which will create the box according to the information in your
330: server.rc file and turn control over to the About() function. When
331: it returns, free the intance address.
332:
333: ****************************************************************************/
334:
335: LONG APIENTRY MainWndProc(hWnd, message, wParam, lParam)
336: HWND hWnd; /* window handle */
337: UINT message; /* type of message */
338: WPARAM wParam; /* additional information */
339: LONG lParam; /* additional information */
340: {
341: switch (message) {
342: case WM_INITMENU:
343: if (GetMenu(hWnd) != (HMENU)wParam)
344: break;
345:
346: CheckMenuItem((HMENU)wParam, IDM_BLOCKALLCBS,
347: fAllBlocked ? MF_CHECKED : MF_UNCHECKED);
348: CheckMenuItem((HMENU)wParam, IDM_UNBLOCKALLCBS,
349: fAllEnabled ? MF_CHECKED : MF_UNCHECKED);
350: CheckMenuItem((HMENU)wParam, IDM_BLOCKNEXTCB,
351: fBlockNextCB ? MF_CHECKED : MF_UNCHECKED);
352: CheckMenuItem((HMENU)wParam, IDM_TERMNEXTCB,
353: fTermNextCB ? MF_CHECKED : MF_UNCHECKED);
354: CheckMenuItem((HMENU)wParam, IDM_RUNAWAY,
355: cRunaway ? MF_CHECKED : MF_UNCHECKED);
356: CheckMenuItem((HMENU)wParam, IDM_APPOWNED,
357: fAppowned ? MF_CHECKED : MF_UNCHECKED);
358: break;
359:
360: case WM_COMMAND: /* message: command from application menu */
361: switch (GET_WM_COMMAND_ID(wParam, lParam)) {
362: case IDM_ENABLEONECB:
363: DdeEnableCallback(idInst, 0, EC_ENABLEONE);
364: fAllBlocked = FALSE;
365: fAllEnabled = FALSE;
366: InvalidateRect(hwndServer, &rcAllBlock, TRUE);
367: break;
368:
369: case IDM_TERMNEXTCB:
370: fTermNextCB = !fTermNextCB;
371: InvalidateRect(hwndServer, &rcNextAction, TRUE);
372: break;
373:
374: case IDM_BLOCKNEXTCB:
375: fBlockNextCB = !fBlockNextCB;
376: InvalidateRect(hwndServer, &rcNextAction, TRUE);
377: break;
378:
379: case IDM_BLOCKALLCBS:
380: DdeEnableCallback(idInst, 0, EC_DISABLE);
381: fAllBlocked = TRUE;
382: fAllEnabled = FALSE;
383: InvalidateRect(hwndServer, &rcAllBlock, TRUE);
384: break;
385:
386: case IDM_UNBLOCKALLCBS:
387: DdeEnableCallback(idInst, 0, EC_ENABLEALL);
388: fAllEnabled = TRUE;
389: fAllBlocked = FALSE;
390: InvalidateRect(hwndServer, &rcAllBlock, TRUE);
391: break;
392:
393: case IDM_APPOWNED:
394: fAppowned = !fAppowned;
395: if (!fAppowned) {
396: WORD iFmt;
397: for (iFmt = 0; iFmt < CFORMATS; iFmt++) {
398: if (hDataHuge[iFmt]) {
399: DdeFreeDataHandle(hDataHuge[iFmt]);
400: hDataHuge[iFmt] = 0;
401: InvalidateRect(hwndServer, &rcHugeSize, TRUE);
402: }
403: if (hDataCount[iFmt]) {
404: DdeFreeDataHandle(hDataCount[iFmt]);
405: hDataCount[iFmt] = 0;
406: }
407: if (hDataRand[iFmt]) {
408: DdeFreeDataHandle(hDataRand[iFmt]);
409: hDataRand[iFmt] = 0;
410: }
411: if (hDataHelp[iFmt]) {
412: DdeFreeDataHandle(hDataHelp[iFmt]);
413: hDataHelp[iFmt] = 0;
414: }
415: }
416: }
417: InvalidateRect(hwndServer, &rcAppowned, TRUE);
418: break;
419:
420: case IDM_RUNAWAY:
421: cRunaway = !cRunaway;
422: InvalidateRect(hwndServer, &rcRunaway, TRUE);
423: if (!cRunaway) {
424: break;
425: }
426: // fall through
427:
428: case IDM_CHANGEDATA:
429: PostMessage(hwndServer, UM_CHGDATA, 1, 0); // rand
430: PostMessage(hwndServer, UM_CHGDATA, 1, 1); // count
431: break;
432:
433: case IDM_RENDERDELAY:
434: DoDialog("VALUEENTRY", (FARPROC)RenderDelayDlgProc, 0, TRUE);
435: InvalidateRect(hwndServer, &rcRndrDelay, TRUE);
436: break;
437:
438: case IDM_SETSERVER:
439: DoDialog("VALUEENTRY", (FARPROC)SetServerDlgProc, 0, TRUE);
440: break;
441:
442: case IDM_SETTOPIC:
443: DoDialog("VALUEENTRY", (FARPROC)SetTopicDlgProc, 0, TRUE);
444: break;
445:
446: case IDM_CONTEXT:
447: DoDialog("CONTEXT", (FARPROC)ContextDlgProc, 0, TRUE);
448: break;
449:
450: case IDM_ABOUT:
451: DoDialog("ABOUT", (FARPROC)About, 0, TRUE);
452: break;
453:
454: case IDM_HELP:
455: break;
456:
457: default:
458: return (DefWindowProc(hWnd, message, wParam, lParam));
459: }
460: break;
461:
462: case WM_PAINT:
463: PaintServer(hWnd);
464: break;
465:
466: case UM_CHGDATA:
467: {
468: WORD iFmt;
469:
470: // wParam = TopicIndex,
471: // LOWORD(lParam) = ItemIndex
472: // We asynchronously do DdePostAdvise() calls to prevent infinite
473: // loops when in runaway mode.
474: if (wParam == 1) { // test topic
475: if (lParam == 0) { // rand item
476: seed = rand();
477: for (iFmt = 0; iFmt < CFORMATS ; iFmt++) {
478: if (hDataRand[iFmt]) {
479: DdeFreeDataHandle(hDataRand[iFmt]);
480: hDataRand[iFmt] = 0;
481: }
482: }
483: InvalidateRect(hwndServer, &rcRand, TRUE);
484: DdePostAdvise(idInst, topicList[wParam].hszTopic,
485: (HSZ)topicList[wParam].pItemList[lParam].hszItem);
486: }
487: if (lParam == 1) { // count item
488: count++;
489: for (iFmt = 0; iFmt < CFORMATS ; iFmt++) {
490: if (hDataCount[iFmt]) {
491: DdeFreeDataHandle(hDataCount[iFmt]);
492: hDataCount[iFmt] = 0;
493: }
494: }
495: InvalidateRect(hwndServer, &rcCount, TRUE);
496: DdePostAdvise(idInst, topicList[wParam].hszTopic,
497: (HSZ)topicList[wParam].pItemList[lParam].hszItem);
498: }
499: // Huge item does not runaway - too slow.
500: }
501: if (cRunaway) {
502: Delay(50, TRUE);
503: // This gives enough time for the system to remain
504: // useable in runaway mode.
505: PostMessage(hwndServer, UM_CHGDATA, wParam, lParam);
506: }
507: }
508: break;
509:
510: case WM_DESTROY: /* message: window being destroyed */
511: if (fAppowned)
512: SendMessage(hwndServer, WM_COMMAND, GET_WM_COMMAND_MPS(IDM_APPOWNED, 0, 0));
513: DdeNameService(idInst, 0, 0, DNS_UNREGISTER); // unregister all services
514: UnHszize();
515: DdeUninitialize(idInst);
516: PostQuitMessage(0);
517: break;
518:
519: default:
520: return (DefWindowProc(hWnd, message, wParam, lParam));
521: }
522: return(0);
523: }
524:
525:
526:
527:
528:
529: VOID Delay(
530: DWORD delay,
531: BOOL fModal)
532: {
533: MSG msg;
534: delay = GetCurrentTime() + delay;
535: while (GetCurrentTime() < delay) {
536: if (fModal && PeekMessage(&msg, 0, 0, 0, PM_REMOVE)) {
537: TranslateMessage(&msg);
538: DispatchMessage(&msg);
539: }
540: }
541: }
542:
543:
544:
545: /*
546: * This function not only paints the server client area with current info,
547: * it also has the side effect of setting the global RECTs that bound each
548: * info area. This way flashing is reduced.
549: */
550: VOID PaintServer(
551: HWND hwnd)
552: {
553: PAINTSTRUCT ps;
554: RECT rc;
555: CHAR szT[MAX_COMMENT];
556:
557: BeginPaint(hwnd, &ps);
558: SetBkMode(ps.hdc, TRANSPARENT);
559: GetClientRect(hwnd, &rc);
560: rc.bottom = rc.top + cyText; // all rects are cyText in height.
561:
562: rcComment = rc;
563: DrawTextLine(ps.hdc, &ps.rcPaint, &rc, pszComment);
564:
565: wsprintf(szT, "# of connections:%d", cServers);
566: rcConnCount = rc;
567: DrawTextLine(ps.hdc, &ps.rcPaint, &rc, szT);
568:
569: szT[0] = '\0';
570: rcAllBlock = rc;
571: if (fAllEnabled)
572: DrawTextLine(ps.hdc, &ps.rcPaint, &rc, "All Conversations are Enabled.");
573: else if (fAllBlocked)
574: DrawTextLine(ps.hdc, &ps.rcPaint, &rc, "All Conversations are Blocked.");
575: else
576: DrawTextLine(ps.hdc, &ps.rcPaint, &rc, szT);
577:
578: rcNextAction = rc;
579: if (fBlockNextCB)
580: DrawTextLine(ps.hdc, &ps.rcPaint, &rc, "Next callback will block.");
581: else if (fTermNextCB)
582: DrawTextLine(ps.hdc, &ps.rcPaint, &rc, "Next callback will terminate.");
583: else
584: DrawTextLine(ps.hdc, &ps.rcPaint, &rc, szT);
585:
586: wsprintf(szT, "Count item = %ld", count);
587: rcCount = rc;
588: DrawTextLine(ps.hdc, &ps.rcPaint, &rc, szT);
589:
590: wsprintf(szT, "Rand item = %d", seed);
591: rcRand = rc;
592: DrawTextLine(ps.hdc, &ps.rcPaint, &rc, szT);
593:
594: wsprintf(szT, "Huge item size = %ld", cbHuge);
595: rcHugeSize = rc;
596: DrawTextLine(ps.hdc, &ps.rcPaint, &rc, szT);
597:
598: wsprintf(szT, "Render delay is %d milliseconds.", RenderDelay);
599: rcRndrDelay = rc;
600: DrawTextLine(ps.hdc, &ps.rcPaint, &rc, szT);
601:
602: rcExec = rc;
603: DrawTextLine(ps.hdc, &ps.rcPaint, &rc, szExec);
604:
605: rcRunaway = rc;
606: DrawTextLine(ps.hdc, &ps.rcPaint, &rc, cRunaway ? "Runaway active." : "");
607:
608: rcAppowned = rc;
609: DrawTextLine(ps.hdc, &ps.rcPaint, &rc, fAppowned ? "Using AppOwned Data Handles." : "");
610:
611: EndPaint(hwnd, &ps);
612: }
613:
614:
615: VOID DrawTextLine(
616: HDC hdc,
617: RECT *prcClip,
618: RECT *prcText,
619: PSTR psz)
620: {
621: RECT rc;
622:
623: if (IntersectRect(&rc, prcText, prcClip)) {
624: DrawText(hdc, psz, -1, prcText,
625: DT_LEFT | DT_EXTERNALLEADING | DT_SINGLELINE | DT_EXPANDTABS |
626: DT_NOCLIP | DT_NOPREFIX);
627: }
628: OffsetRect(prcText, 0, cyText);
629: }
630:
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.