![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to output.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [WindowsNT SDKs] / q_a / samples / output|
Return to output.c CVS log | Up to [WindowsNT SDKs] / q_a / samples / output |
1.1 root 1:
2: /******************************************************************************\
3: * This is a part of the Microsoft Source Code Samples.
4: * Copyright (C) 1993 Microsoft Corporation.
5: * All rights reserved.
6: * This source code is only intended as a supplement to
7: * Microsoft Development Tools and/or WinHelp documentation.
8: * See these sources for detailed information regarding the
9: * Microsoft samples programs.
10: \******************************************************************************/
11:
12: /****************************************************************************
13:
14: PROGRAM: Output.c
15:
16: PURPOSE: Output template for Windows applications
17:
18: FUNCTIONS:
19:
20: WinMain() - calls initialization function, processes message loop
21: InitApplication() - initializes window data and registers window
22: InitInstance() - saves instance handle and creates main window
23: MainWndProc() - processes messages
24: About() - processes messages for "About" dialog box
25:
26: ****************************************************************************/
27:
28: #include "windows.h"
29: #include "string.h"
30: #include "output.h"
31:
32: HANDLE hInst;
33:
34: HPEN hDashPen; /* "---" pen handle */
35: HPEN hDotPen; /* "..." pen handle */
36: HBRUSH hOldBrush; /* old brush handle */
37: HBRUSH hRedBrush; /* red brush handle */
38: HBRUSH hGreenBrush; /* green brush handle */
39: HBRUSH hBlueBrush; /* blue brush handle */
40:
41:
42: /****************************************************************************
43:
44: FUNCTION: WinMain(HANDLE, HANDLE, LPSTR, int)
45:
46: PURPOSE: calls initialization function, processes message loop
47:
48: ****************************************************************************/
49:
50: int APIENTRY WinMain(
51: HANDLE hInstance,
52: HANDLE hPrevInstance,
53: LPSTR lpCmdLine,
54: int nCmdShow
55: )
56: {
57: MSG msg;
58:
59: UNREFERENCED_PARAMETER( lpCmdLine );
60:
61: if (!hPrevInstance)
62: if (!InitApplication(hInstance))
63: return (FALSE);
64:
65: if (!InitInstance(hInstance, nCmdShow))
66: return (FALSE);
67:
68: while (GetMessage(&msg, NULL, 0, 0)) {
69: TranslateMessage(&msg);
70: DispatchMessage(&msg);
71: }
72: return (msg.wParam);
73: }
74:
75:
76: /****************************************************************************
77:
78: FUNCTION: InitApplication(HANDLE)
79:
80: PURPOSE: Initializes window data and registers window class
81:
82: ****************************************************************************/
83: BOOL InitApplication(HANDLE hInstance)
84: {
85: WNDCLASS wc;
86:
87: wc.style = 0;
88: wc.lpfnWndProc = (WNDPROC) MainWndProc;
89: wc.cbClsExtra = 0;
90: wc.cbWndExtra = 0;
91: wc.hInstance = hInstance;
92: wc.hIcon = LoadIcon(NULL, IDI_APPLICATION);
93: wc.hCursor = LoadCursor(NULL, IDC_ARROW);
94: wc.hbrBackground = GetStockObject(WHITE_BRUSH);
95: wc.lpszMenuName = "OutputMenu";
96: wc.lpszClassName = "OutputWClass";
97:
98: return (RegisterClass(&wc));
99: }
100:
101:
102: /****************************************************************************
103:
104: FUNCTION: InitInstance(HANDLE, int)
105:
106: PURPOSE: Saves instance handle and creates main window
107:
108: ****************************************************************************/
109:
110: BOOL InitInstance(
111: HANDLE hInstance,
112: INT nCmdShow)
113: {
114: HWND hWnd;
115:
116: hInst = hInstance;
117:
118: hWnd = CreateWindow(
119: "OutputWClass",
120: "Output Sample Application",
121: WS_OVERLAPPEDWINDOW,
122: 0,
123: 0,
124: GetSystemMetrics(SM_CXSCREEN),
125: GetSystemMetrics(SM_CYSCREEN),
126: NULL,
127: NULL,
128: hInstance,
129: NULL
130: );
131:
132: if (!hWnd)
133: return (FALSE);
134:
135: ShowWindow(hWnd, nCmdShow);
136: UpdateWindow(hWnd);
137: return (TRUE);
138:
139: }
140:
141: /****************************************************************************
142:
143: FUNCTION: MainWndProc(HWND, unsigned, WORD, LONG)
144:
145: PURPOSE: Processes messages
146:
147: MESSAGES:
148:
149: WM_COMMAND - application menu (About dialog box)
150: WM_CREATE - create window and objects
151: WM_PAINT - update window, draw objects
152: WM_DESTROY - destroy window
153:
154: COMMENTS:
155:
156: Handles to the objects you will use are obtained when the WM_CREATE
157: message is received, and deleted when the WM_DESTROY message is
158: received. The actual drawing is done whenever a WM_PAINT message is
159: received.
160:
161: ****************************************************************************/
162:
163: LONG APIENTRY MainWndProc(
164: HWND hWnd,
165: UINT message,
166: UINT wParam,
167: LONG lParam)
168: {
169: FARPROC lpProcAbout;
170:
171: HDC hDC; /* display-context variable */
172: PAINTSTRUCT ps; /* paint structure */
173: RECT rcTextBox; /* rectangle around the text */
174: HPEN hOldPen; /* old pen handle */
175:
176:
177:
178: switch (message) {
179: case WM_COMMAND:
180: if (LOWORD(wParam) == IDM_ABOUT) {
181: lpProcAbout = MakeProcInstance((FARPROC)About, hInst);
182:
183: DialogBox(hInst,
184: "AboutBox",
185: hWnd,
186: lpProcAbout);
187:
188: FreeProcInstance(lpProcAbout);
189: break;
190: }
191: else
192: return (DefWindowProc(hWnd, message, wParam, lParam));
193:
194: case WM_CREATE:
195:
196: /* Create the brush objects */
197:
198: hRedBrush = CreateSolidBrush(RGB(255, 0, 0));
199: hGreenBrush = CreateSolidBrush(RGB( 0, 255, 0));
200: hBlueBrush = CreateSolidBrush(RGB( 0, 0, 255));
201:
202: /* Create the "---" pen */
203:
204: hDashPen = CreatePen(PS_DASH, /* style */
205: 1, /* width */
206: RGB(0, 0, 0)); /* color */
207:
208: /* Create the "..." pen */
209:
210: hDotPen = CreatePen(2, /* style */
211: 1, /* width */
212: RGB(0, 0, 0)); /* color */
213: break;
214:
215: case WM_PAINT:
216: {
217: TEXTMETRIC textmetric;
218: INT nDrawX;
219: INT nDrawY;
220: CHAR szText[300];
221:
222: /* Set up a display context to begin painting */
223:
224: hDC = BeginPaint (hWnd, &ps);
225:
226: /* Get the size characteristics of the current font. */
227: /* This information will be used for determining the */
228: /* vertical spacing of text on the screen. */
229:
230: GetTextMetrics (hDC, &textmetric);
231:
232: /* Initialize drawing position to 1/4 inch from the top */
233: /* and from the left of the top, left corner of the */
234: /* client area of the main windows. */
235:
236: nDrawX = GetDeviceCaps(hDC, LOGPIXELSX) / 4; /* 1/4 inch */
237: nDrawY = GetDeviceCaps(hDC, LOGPIXELSY) / 4; /* 1/4 inch */
238:
239: /* Send characters to the screen. After displaying each */
240: /* line of text, advance the vertical position for the */
241: /* next line of text. The pixel distance between the top */
242: /* of each line of text is equal to the standard height of */
243: /* the font characters (tmHeight), plus the standard */
244: /* amount of spacing (tmExternalLeading) between adjacent */
245: /* lines. */
246:
247: strcpy (szText, "These characters are being painted using ");
248: TextOut (hDC, nDrawX, nDrawY, szText, strlen (szText));
249: nDrawY += textmetric.tmExternalLeading + textmetric.tmHeight;
250:
251: strcpy (szText, "the TextOut() function, which is fast and ");
252: TextOut (hDC, nDrawX, nDrawY, szText, strlen (szText));
253: nDrawY += textmetric.tmExternalLeading + textmetric.tmHeight;
254:
255: strcpy (szText, "allows programmer control of placement and ");
256: TextOut (hDC, nDrawX, nDrawY, szText, strlen (szText));
257: nDrawY += textmetric.tmExternalLeading + textmetric.tmHeight;
258:
259: strcpy (szText, "formatting details. However, TextOut() ");
260: TextOut (hDC, nDrawX, nDrawY, szText, strlen (szText));
261: nDrawY += textmetric.tmExternalLeading + textmetric.tmHeight;
262:
263: strcpy (szText, "does not provide any automatic formatting.");
264: TextOut (hDC, nDrawX, nDrawY, szText, strlen (szText));
265: nDrawY += textmetric.tmExternalLeading + textmetric.tmHeight;
266:
267: /* Put text in a 5-inch by 1-inch rectangle and display it. */
268: /* First define the size of the rectangle around the text */
269:
270: nDrawY += GetDeviceCaps(hDC, LOGPIXELSY) / 4; /* 1/4 inch */
271: SetRect (
272: &rcTextBox
273: , nDrawX
274: , nDrawY
275: , nDrawX + (5 * GetDeviceCaps(hDC, LOGPIXELSX)) /* 5" */
276: , nDrawY + (1 * GetDeviceCaps(hDC, LOGPIXELSY)) /* 1" */
277: );
278:
279: /* Draw the text within the bounds of the above rectangle */
280:
281: strcpy (szText, "This text is being displayed with a single "
282: "call to DrawText(). DrawText() isn't as fast "
283: "as TextOut(), and it is somewhat more "
284: "constrained, but it provides numerous optional "
285: "formatting features, such as the centering and "
286: "line breaking used in this example.");
287: DrawText (
288: hDC
289: , szText
290: , strlen (szText)
291: , &rcTextBox
292: , DT_CENTER | DT_EXTERNALLEADING | DT_NOCLIP
293: | DT_NOPREFIX | DT_WORDBREAK
294: );
295:
296: /* Paint the next object immediately below the bottom of */
297: /* the above rectangle in which the text was drawn. */
298:
299: nDrawY = rcTextBox.bottom;
300:
301: /* The (x,y) pixel coordinates of the objects about to be */
302: /* drawn are below, and to the right of, the current */
303: /* coordinate (nDrawX,nDrawY). */
304:
305: /* Draw a red rectangle.. */
306:
307: hOldBrush = SelectObject(hDC, hRedBrush);
308: Rectangle (
309: hDC
310: , nDrawX
311: , nDrawY
312: , nDrawX + 50
313: , nDrawY + 30
314: );
315:
316: /* Draw a green ellipse */
317:
318: SelectObject(hDC, hGreenBrush);
319: Ellipse (
320: hDC
321: , nDrawX + 150
322: , nDrawY
323: , nDrawX + 150 + 50
324: , nDrawY + 30
325: );
326:
327: /* Draw a blue pie shape */
328:
329: SelectObject(hDC, hBlueBrush);
330: Pie (
331: hDC
332: , nDrawX + 300
333: , nDrawY
334: , nDrawX + 300 + 50
335: , nDrawY + 50
336: , nDrawX + 300 + 50
337: , nDrawY
338: , nDrawX + 300 + 50
339: , nDrawY + 50
340: );
341:
342: nDrawY += 50;
343:
344: /* Restore the old brush */
345:
346: SelectObject(hDC, hOldBrush);
347:
348: /* Select a "---" pen, save the old value */
349:
350: nDrawY += GetDeviceCaps(hDC, LOGPIXELSY) / 4; /* 1/4 inch */
351: hOldPen = SelectObject(hDC, hDashPen);
352:
353: /* Move to a specified point */
354:
355: MoveToEx(hDC, nDrawX, nDrawY, NULL );
356:
357: /* Draw a line */
358:
359: LineTo(hDC, nDrawX + 350, nDrawY);
360:
361: /* Select a "..." pen */
362:
363: SelectObject(hDC, hDotPen);
364:
365: /* Draw an arc connecting the line */
366:
367: Arc (
368: hDC
369: , nDrawX
370: , nDrawY - 20
371: , nDrawX + 350
372: , nDrawY + 20
373: , nDrawX
374: , nDrawY
375: , nDrawX + 350
376: , nDrawY
377: );
378:
379: /* Restore the old pen */
380:
381: SelectObject(hDC, hOldPen);
382:
383: /* Tell Windows you are done painting */
384:
385: EndPaint (hWnd, &ps);
386: }
387: break;
388:
389: case WM_DESTROY:
390: DeleteObject(hRedBrush);
391: DeleteObject(hGreenBrush);
392: DeleteObject(hBlueBrush);
393: DeleteObject(hDashPen);
394: DeleteObject(hDotPen);
395: PostQuitMessage(0);
396: break;
397:
398: default:
399: return (DefWindowProc(hWnd, message, wParam, lParam));
400: }
401: return (0);
402: }
403:
404:
405: /****************************************************************************
406:
407: FUNCTION: About(HWND, unsigned, WORD, LONG)
408:
409: PURPOSE: Processes messages for "About" dialog box
410:
411: MESSAGES:
412:
413: WM_INITDIALOG - initialize dialog box
414: WM_COMMAND - Input received
415:
416: ****************************************************************************/
417:
418: BOOL APIENTRY About(
419: HWND hDlg,
420: UINT message,
421: UINT wParam,
422: LONG lParam)
423: {
424: switch (message) {
425: case WM_INITDIALOG:
426: return (TRUE);
427:
428: case WM_COMMAND:
429: if (LOWORD(wParam) == IDOK
430: || LOWORD(wParam) == IDCANCEL) {
431: EndDialog(hDlg, TRUE);
432: return (TRUE);
433: }
434: break;
435: }
436: return (FALSE);
437: UNREFERENCED_PARAMETER(lParam);
438: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.