![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to bob.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [WindowsNT SDKs] / q_a / samples / bob|
Return to bob.c CVS log | Up to [WindowsNT SDKs] / q_a / samples / bob |
1.1 root 1: /****************************************************************************\
2: ** **
3: ** Microsoft Developer Support **
4: ** Copyright (c) 1992, 1993 Microsoft Corporation **
5: ** **
6: ** MODULE: BOB **
7: ** **
8: ** **
9: ** PURPOSE: Demonstrates the steps needed to programmatically **
10: ** log off/reboot the machine. Note these features should **
11: ** only be used after you've notified the user what you **
12: ** are about to do. Windows itself will not provide any **
13: ** other warnings to the user. **
14: ** **
15: ** **
16: ** **
17: ** **
18: ** COMMENTS: Reads a file asynchronously writes to another synchronously **
19: ** **
20: ** **
21: \***************************************************************************/
22:
23:
24:
25: /* To enable NT's Reboot feature enable the below
26: * manifest constants. By default the program will
27: * log the user off only.
28: */
29:
30: // #define REBOOT
31:
32: #define WIN32S 0x80000000l // no manifest constance yet???
33:
34: #define STRICT
35:
36: #include <stddef.h>
37: #include <stdlib.h>
38:
39:
40: #define OEMRESOURCE
41: #include "windows.h" /* required for all Windows applications */
42:
43: #include "BOB.H" /* specific to this program */
44:
45: HINSTANCE ghInst; /* current instance */
46: HWND ghWnd;
47: WNDPROC OldButtonProc;
48:
49: /****************************************************************************
50:
51: FUNCTION: WinMain(HANDLE, HANDLE, LPSTR, int)
52:
53: PURPOSE: calls initialization function, processes message loop
54:
55: COMMENTS:
56:
57: Windows recognizes this function by name as the initial entry point
58: for the program. This function calls the application initialization
59: routine, if no other instance of the program is running, and always
60: calls the instance initialization routine. It then executes a message
61: retrieval and dispatch loop that is the top-level control structure
62: for the remainder of execution. The loop is terminated when a WM_QUIT
63: message is received, at which time this function exits the application
64: instance by returning the value passed by PostQuitMessage().
65:
66: If this function must abort before entering the message loop, it
67: returns the conventional value NULL.
68:
69: ****************************************************************************/
70:
71: int PASCAL WinMain(HINSTANCE hInstance, /* current instance */
72: HINSTANCE hPrevInstance, /* previous instance */
73: LPSTR lpCmdLine, /* command line */
74: int nCmdShow) /* show-window type (open/icon) */
75: {
76: MSG msg; /* message */
77:
78: if (!hPrevInstance) /* Other instances of app running? */
79: if (!InitApplication(hInstance)) /* Initialize shared things */
80: return (FALSE); /* Exits if unable to initialize */
81:
82: /* Perform initializations that apply to a specific instance */
83:
84: if (!InitInstance(hInstance, nCmdShow))
85: return (FALSE);
86:
87: /* Acquire and dispatch messages until a WM_QUIT message is received. */
88:
89: while (GetMessage(&msg, /* message structure */
90: NULL, /* handle of window receiving the message */
91: 0, /* lowest message to examine */
92: 0)) /* highest message to examine */
93: {
94: TranslateMessage(&msg); /* Translates virtual key codes */
95: DispatchMessage(&msg); /* Dispatches message to window */
96:
97: }
98: return (msg.wParam); /* Returns the value from PostQuitMessage */
99: UNREFERENCED_PARAMETER(lpCmdLine);
100: }
101:
102:
103: /****************************************************************************
104:
105: FUNCTION: InitApplication(HANDLE)
106:
107: PURPOSE: Initializes window data and registers window class
108:
109: COMMENTS:
110:
111: This function is called at initialization time only if no other
112: instances of the application are running. This function performs
113: initialization tasks that can be done once for any number of running
114: instances.
115:
116: In this case, we initialize a window class by filling out a data
117: structure of type WNDCLASS and calling the Windows RegisterClass()
118: function. Since all instances of this application use the same window
119: class, we only need to do this when the first instance is initialized.
120:
121:
122: ****************************************************************************/
123:
124: BOOL InitApplication(HANDLE hInstance) /* current instance */
125: {
126: WNDCLASS wc;
127:
128: /* Fill in window class structure with parameters that describe the */
129: /* main window. */
130:
131: wc.style = 0; /* Class style(s). */
132: wc.lpfnWndProc = (WNDPROC)MainWndProc; /* Function to retrieve messages for */
133: /* windows of this class. */
134: wc.cbClsExtra = 0; /* No per-class extra data. */
135: wc.cbWndExtra = 0; /* No per-window extra data. */
136: wc.hInstance = hInstance; /* Application that owns the class. */
137: wc.hIcon = LoadIcon(NULL, IDI_APPLICATION);
138: wc.hCursor = LoadCursor(NULL, IDC_ARROW);
139: wc.hbrBackground = GetStockObject(WHITE_BRUSH);
140: wc.lpszMenuName = "BOBMenu"; /* Name of menu resource in .RC file. */
141: wc.lpszClassName = "BOBWClass"; /* Name used in call to CreateWindow. */
142:
143: /* Register the window class and return success/failure code. */
144:
145:
146: if ( !RegisterClass(&wc) )
147: return( FALSE );
148:
149:
150: }
151:
152:
153: /****************************************************************************
154:
155: FUNCTION: InitInstance(HANDLE, int)
156:
157: PURPOSE: Saves instance handle and creates main window
158:
159: COMMENTS:
160:
161: This function is called at initialization time for every instance of
162: this application. This function performs initialization tasks that
163: cannot be shared by multiple instances.
164:
165: In this case, we save the instance handle in a static variable and
166: create and display the main program window.
167:
168: ****************************************************************************/
169:
170: BOOL InitInstance(HANDLE hInstance, /* Current instance identifier. */
171: int nCmdShow ) /* Param for first ShowWindow() call. */
172: {
173: HWND hWnd; /* Main window handle. */
174: HWND hWndDeskTop;
175: RECT rcDeskTop;
176:
177:
178: /* Save the instance handle in static variable, which will be used in */
179: /* many subsequence calls from this application to Windows. */
180:
181: ghInst = hInstance;
182:
183: /* Create a main window for this application instance. */
184:
185:
186:
187: hWndDeskTop = GetDesktopWindow();
188: GetWindowRect( hWndDeskTop, &rcDeskTop );
189:
190: hWnd = CreateWindow(
191: "BOBWClass", /* See RegisterClass() call. */
192: "BOB", /* Text for window title bar. */
193: WS_OVERLAPPED, /* Window style. */
194: rcDeskTop.left+50, /* horizontal position. */
195: rcDeskTop.bottom-200, /* vertical position. */
196: 150, /* width. */
197: 100, /* height. */
198: NULL, /* Overlapped windows have no parent. */
199: NULL, /* Use the window class menu. */
200: hInstance, /* This instance owns this window. */
201: NULL /* Pointer to Createion Parameters */
202: );
203:
204: /* If window could not be created, return "failure" */
205:
206: if (!hWnd)
207: return (FALSE);
208:
209: ShowWindow(hWnd, nCmdShow); /* Show the window */
210: UpdateWindow(hWnd); /* Sends WM_PAINT message */
211: ghWnd = hWnd;
212:
213: }
214:
215: /****************************************************************************
216:
217: FUNCTION: MainWndProc(HWND, WORD, WPARAM, LPARAM)
218:
219: PURPOSE: Processes messages
220:
221: MESSAGES:
222:
223: WM_COMMAND - application menu (About dialog box)
224: WM_DESTROY - destroy window
225:
226: COMMENTS:
227:
228: To process the IDM_ABOUT message, call MakeProcInstance() to get the
229: current instance address of the About() function. Then call Dialog
230: box which will create the box according to the information in your
231: BOB.RC file and turn control over to the About() function. When
232: it returns, free the intance address.
233:
234: ****************************************************************************/
235:
236: long WINAPI MainWndProc(HWND hWnd, /* window handle */
237: UINT message, /* type of message */
238: WPARAM wParam, /* additional information */
239: LPARAM lParam ) /* additional information */
240: {
241: DLGPROC lpProcAbout;
242: CHAR buffer[80];
243:
244: HANDLE hToken;
245: TOKEN_PRIVILEGES tkp;
246:
247: static CONTROLTEXT CtlText;
248: static TCHAR szTitle[10];
249: static RECT FocusRect, SelectRect;
250:
251: switch (message) {
252:
253: case WM_CREATE: {
254:
255: HWND hWndButton;
256: CREATESTRUCT createStruct;
257: RECT rcClient;
258:
259: int cbTitle;
260: SIZE size;
261: HDC hDC;
262: int nSpaceWidth, nSpaceHeight;
263:
264: createStruct = *(LPCREATESTRUCT)lParam;
265: GetClientRect( hWnd,&rcClient );
266:
267: hWndButton = CreateWindow(
268: "BUTTON", /* See RegisterClass() call. */
269: TEXT("B. O. B."), /* Text for window title bar. */
270: WS_VISIBLE | WS_CHILD |
271: BS_PUSHBUTTON |
272: BS_OWNERDRAW,
273: rcClient.left,
274: rcClient.top,
275: rcClient.right,
276: rcClient.bottom,
277: hWnd, /* Parent */
278: (HMENU)BOB, /* Child ID */
279: createStruct.hInstance, /* This instance owns this window. */
280: NULL /* Pointer to Createion Parameters */
281: );
282:
283: wsprintf( buffer, "hWndButton is %#x and hWnd is %#x\r\n",
284: hWndButton, hWnd );
285: OutputDebugString ( buffer );
286:
287: if ( !hWndButton ) {
288: MessageBox( hWnd, "Error creating Window", NULL, MB_OK );
289: SendMessage( hWnd, WM_DESTROY, 0, 0 );
290: }
291:
292: SetFocus( hWndButton );
293:
294: OldButtonProc = SubclassWindow( hWndButton, ButtonProc );
295:
296: // define size of dashed rectangles around text in both bitmaps
297: hDC = GetDC( hWndButton );
298: cbTitle = SendMessage( hWndButton,
299: WM_GETTEXT,
300: (WPARAM) sizeof(szTitle),
301: (LPARAM)(LPTSTR)szTitle );
302: GetTextExtentPoint( hDC,
303: szTitle,
304: cbTitle,
305: &size );
306: ReleaseDC( hWndButton, hDC);
307:
308: CtlText.ptPosition.x = (rcClient.right - size.cx) >> 1;
309: CtlText.ptPosition.y = (rcClient.bottom - size.cy) >> 1;
310: CtlText.szTitle = szTitle;
311: CtlText.cbTitle = cbTitle;
312:
313: // load bitmap
314:
315: CtlText.hDefaultButton = LoadBitmap(
316: createStruct.hInstance, /* This instance owns this window. */
317: MAKEINTRESOURCE( DEFAULTBUTTON )
318: );
319:
320: if ( !CtlText.hDefaultButton ) {
321: wsprintf( buffer, "Error loading BUTTONBITMAP %d",
322: GetLastError() );
323: MessageBox( hWnd, "Error creating Window", NULL, MB_OK );
324: SendMessage( hWnd, WM_DESTROY, 0, 0 );
325: }
326:
327: CtlText.hSelectButton = LoadBitmap(
328: createStruct.hInstance, /* This instance owns this window. */
329: MAKEINTRESOURCE(SELECTEDBUTTON) // pushed state
330: );
331:
332: if ( !CtlText.hSelectButton ) {
333: wsprintf( buffer, "Error loading BUTTONBITMAP %d",
334: GetLastError() );
335: MessageBox( hWnd, "Error creating Window", NULL, MB_OK );
336: SendMessage( hWnd, WM_DESTROY, 0, 0 );
337: }
338:
339:
340:
341:
342: nSpaceWidth = GetSystemMetrics(SM_CXBORDER) << 1;
343: nSpaceHeight = GetSystemMetrics(SM_CYBORDER) << 1;
344:
345: FocusRect.top = CtlText.ptPosition.y - nSpaceHeight;
346: FocusRect.bottom = FocusRect.top + size.cy + (nSpaceHeight << 1);
347: FocusRect.left = CtlText.ptPosition.x - nSpaceWidth;
348: FocusRect.right = FocusRect.left + size.cx + (nSpaceWidth << 1);
349:
350: SelectRect.top = 2 + FocusRect.top;
351: SelectRect.bottom = 2 + FocusRect.bottom;
352: SelectRect.left = 2 + FocusRect.left;
353: SelectRect.right = 2 + FocusRect.right;
354:
355: return ( TRUE );
356: }
357: case WM_DRAWITEM:
358: {
359: LPDRAWITEMSTRUCT lpdisCtrl;
360:
361: if ( (int)wParam == BOB ) {
362: lpdisCtrl = (LPDRAWITEMSTRUCT)lParam;
363: switch (lpdisCtrl->itemAction)
364: {
365: // handle normal drawing of button, but check if its
366: // selected or focus
367:
368: case ODA_DRAWENTIRE:
369: OutputDebugString("WM_DRAWITEM: Action is ODA_DRAWENTIRE\r\n");
370: // this handles both button down and button up
371: HandleSelectedState(lpdisCtrl, &CtlText);
372:
373: // this handles focus rectangle around Button text
374: HandleFocusState(lpdisCtrl, &FocusRect, &SelectRect);
375: return TRUE;
376:
377: // handle drawing selection if needed
378: // selected is button down, not selected is button up
379: // focus will occur when button is pressed.
380:
381: case ODA_SELECT:
382: OutputDebugString("WM_DRAWITEM: Action is ODA_SELECT\r\n");
383: HandleSelectedState(lpdisCtrl, &CtlText);
384: HandleFocusState(lpdisCtrl, &FocusRect, &SelectRect);
385: return TRUE;
386:
387: // handle focus drawing if needed
388: case ODA_FOCUS:
389: OutputDebugString("WM_DRAWITEM: Action is ODA_FOCUS\r\n");
390: HandleFocusState(lpdisCtrl, &FocusRect, &SelectRect);
391: return TRUE;
392: }
393: }
394: break;
395: }
396: case WM_COMMAND: /* message: command from application menu */
397:
398: if ( HIWORD(wParam) == BN_CLICKED &&
399: LOWORD(wParam) == BOB ) {
400: /*
401: * Below are the steps needed to reboot the machine.
402: */
403: lpProcAbout = (DLGPROC)MakeProcInstance((FARPROC)About, ghInst );
404: #if defined(REBOOT)
405: DialogBox (ghInst, TEXT("AboutBox"), hWnd, lpProcAbout);
406: #else
407: DialogBox (ghInst, TEXT("AboutBox"), hWnd, lpProcAbout);
408: #endif
409:
410: /* Get a token for this process. */
411:
412: if ( !(GetVersion() & WIN32S) )
413: {
414:
415: OutputDebugString("Setting token");
416: // Running on NT so need to change privileges
417:
418: if (!OpenProcessToken(GetCurrentProcess(),
419: TOKEN_ADJUST_PRIVILEGES | TOKEN_QUERY, &hToken)) {
420: wsprintf ( buffer, "OpenProcessToken Error #%d", GetLastError ());
421: MessageBox(hWnd, buffer, NULL, MB_OK);
422: }
423: /* Get the LUID for shutdown privilege */
424:
425: LookupPrivilegeValue(NULL, TEXT("SeShutdownPrivilege"),
426: &tkp.Privileges[0].Luid);
427:
428: tkp.PrivilegeCount = 1; /* one privilege to set */
429: tkp.Privileges[0].Attributes = SE_PRIVILEGE_ENABLED;
430:
431: /* Get shutdown privilege for this process. */
432:
433: if (!AdjustTokenPrivileges(hToken, FALSE, &tkp, 0,
434: (PTOKEN_PRIVILEGES)NULL, 0)) {
435: wsprintf ( buffer, "AdjustTokenPrivileges Error #%d", GetLastError ());
436: MessageBox(hWnd, buffer, NULL, MB_OK);
437: }
438: }
439:
440: #if defined(REBOOT)
441: /* Shut down the system, and reboot the system. */
442:
443: if ( !ExitWindowsEx( EWX_REBOOT, 0 )) {
444: wsprintf ( buffer, "Error ExitWindows Error #%d", GetLastError ());
445: MessageBox(hWnd, buffer, NULL, MB_OK);
446: }
447: #else
448: /* Shut down the system, and force all applications closed. */
449:
450: if (!ExitWindowsEx(EWX_SHUTDOWN | EWX_FORCE, 0)) {
451: wsprintf ( buffer, "Error ExitWindows Error #%d", GetLastError ());
452: MessageBox(hWnd, buffer, NULL, MB_OK);
453: }
454: #endif
455: break;
456: }
457: else /* Lets Windows process it */
458: return (DefWindowProc(hWnd, message, wParam, lParam));
459:
460: case WM_DESTROY: /* message: window being destroyed */
461: DeleteObject(CtlText.hDefaultButton);
462: DeleteObject(CtlText.hSelectButton);
463: PostQuitMessage(0);
464: break;
465:
466: default: /* Passes it on if unproccessed */
467: return (DefWindowProc(hWnd, message, wParam, lParam));
468: }
469: return ( 0 );
470: }
471:
472:
473: /****************************************************************************
474:
475: FUNCTION: About(HWND, unsigned, WORD, LONG)
476:
477: PURPOSE: Processes messages for "About" dialog box
478:
479: MESSAGES:
480:
481: WM_INITDIALOG - initialize dialog box
482: WM_COMMAND - Input received
483:
484: COMMENTS:
485:
486: No initialization is needed for this particular dialog box, but TRUE
487: must be returned to Windows.
488:
489: Wait for user to click on "Ok" button, then close the dialog box.
490:
491: ****************************************************************************/
492:
493: BOOL WINAPI About(HWND hDlg, /* window handle of the dialog box */
494: UINT message, /* type of message */
495: WPARAM wParam, /* message-specific information */
496: LPARAM lParam )
497: {
498: switch (message) {
499: case WM_INITDIALOG: /* message: initialize dialog box */
500: return (TRUE);
501:
502: case WM_COMMAND: /* message: received a command */
503: if (wParam == IDOK /* "OK" box selected? */
504: || wParam == IDCANCEL) { /* System menu close command? */
505: EndDialog(hDlg, TRUE); /* Exits the dialog box */
506: return (TRUE);
507: }
508: break;
509: }
510: return (FALSE); /* Didn't process a message */
511: UNREFERENCED_PARAMETER(lParam);
512: }
513:
514:
515:
516: /*****************************************************************************
517:
518: FUNCTION: HandleSelectedState
519:
520: PURPOSE: Draw button bitmaps and text:
521: if button selected, draw "down"/pressed button bitmap
522: with text shifted right and down 2 pixels
523: else draw "up"/unpressed button bitmap
524: with text centered in button
525:
526: *****************************************************************************/
527: void HandleSelectedState(LPDRAWITEMSTRUCT lpdisCtrl, LPCONTROLTEXT lpCtlText)
528: {
529:
530: int nOldBkMode;
531:
532: // handle button pressed down select state -- button down bitmap
533: // text is right & down 2 pixels
534: if (lpdisCtrl->itemState & ODS_SELECTED)
535: {
536: DrawBitmap(lpdisCtrl->hDC,
537: lpdisCtrl->rcItem,
538: lpCtlText->hSelectButton,
539: SRCCOPY);
540:
541: // put text 2 pixels right and down of center of bitmap
542: nOldBkMode = SetBkMode(lpdisCtrl->hDC,TRANSPARENT);
543:
544: TextOut( lpdisCtrl->hDC,
545: lpCtlText->ptPosition.x+2,
546: lpCtlText->ptPosition.y+2,
547: lpCtlText->szTitle,
548: lpCtlText->cbTitle );
549:
550: SetBkMode(lpdisCtrl->hDC,nOldBkMode);
551: }
552: // not selected -- button up; text is in normal position
553: else
554: {
555: DrawBitmap(lpdisCtrl->hDC,
556: lpdisCtrl->rcItem,
557: lpCtlText->hDefaultButton,
558: SRCCOPY);
559:
560: // center text in bitmap
561: nOldBkMode = SetBkMode(lpdisCtrl->hDC,TRANSPARENT);
562: TextOut( lpdisCtrl->hDC,
563: lpCtlText->ptPosition.x,
564: lpCtlText->ptPosition.y,
565: lpCtlText->szTitle,
566: lpCtlText->cbTitle );
567:
568: SetBkMode(lpdisCtrl->hDC,nOldBkMode);
569: }
570: }
571:
572: /*****************************************************************************
573:
574: FUNCTION: HandleFocusState
575:
576: PURPOSE: If button has focus, draw dashed rectangle around text in button
577:
578: *****************************************************************************/
579: void HandleFocusState(LPDRAWITEMSTRUCT lpdisCtrl, LPRECT lpFocusRect, LPRECT lpSelectRect )
580: {
581: // if focus state, draw a dashed rect around text
582: if (lpdisCtrl->itemState & ODS_FOCUS)
583: {
584: // if selected, shift focus rect right and down 2 pixels around text
585: if (lpdisCtrl->itemState & ODS_SELECTED) {
586: OutputDebugString("HandleFocusState: State is ODS_SELECTED\r\n");
587: DrawFocusRect(lpdisCtrl->hDC, lpSelectRect);
588: }
589: // else text centered, so focus rect will be too
590: else {
591: DrawFocusRect(lpdisCtrl->hDC, lpFocusRect);
592: OutputDebugString("HandleFocusState: State is ODS_FOCUS\r\n");
593: }
594:
595: }
596: else
597: if (lpdisCtrl->itemState & ODS_SELECTED)
598: OutputDebugString("Error HandleFocusState: State is ODS_SELECTED\r\n");
599: else {
600: char buffer[80];
601: wsprintf(buffer, "HandleFocusState: lpdisCtrl->itemState is %#x\r\n",
602: lpdisCtrl->itemState );
603: OutputDebugString(buffer);
604: }
605: }
606: /****************************************************************************
607:
608: FUNCTION: DrawBitmap
609:
610: PURPOSE: Draw default or pushed button bitmap
611:
612: ****************************************************************************/
613:
614: void DrawBitmap(HDC hDC, RECT rect, HBITMAP hBitmap, DWORD rop)
615: {
616: HDC hMemDC;
617: BITMAP bm;
618: hMemDC = CreateCompatibleDC(hDC);
619: SelectObject(hMemDC, hBitmap);
620: // BitBlt(hDC, rect.left, rect.top, rect.right, rect.bottom, hMemDC, 0, 0, rop);
621: GetObject(hBitmap, sizeof (BITMAP), (LPVOID) &bm);
622: StretchBlt( hDC, rect.left, rect.top, rect.right, rect.bottom,
623: hMemDC, 0, 0, bm.bmWidth, bm.bmHeight, rop);
624: DeleteDC(hMemDC);
625: }
626:
627: long WINAPI ButtonProc(HWND hWnd, /* window handle */
628: UINT message, /* type of message */
629: WPARAM wParam, /* additional information */
630: LPARAM lParam ) /* additional information */
631: {
632:
633: switch ( message )
634: {
635: case WM_CHAR:
636: OutputDebugString("ButtonProc: WM_CHAR received\r\n");
637: SendMessage( ghWnd, WM_COMMAND, MAKEWPARAM(BOB,BN_CLICKED), (LPARAM)(hWnd));
638:
639: default:
640: return CallWindowProc( OldButtonProc, hWnd, message, wParam, lParam );
641:
642: }
643:
644: return ( 0 );
645: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.