gdiplus: Add test for ImageLockModeUserInputBuf.
[wine] / dlls / shell32 / dialogs.c
1 /*
2  *      common shell dialogs
3  *
4  * Copyright 2000 Juergen Schmied
5  *
6  * This library is free software; you can redistribute it and/or
7  * modify it under the terms of the GNU Lesser General Public
8  * License as published by the Free Software Foundation; either
9  * version 2.1 of the License, or (at your option) any later version.
10  *
11  * This library is distributed in the hope that it will be useful,
12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
14  * Lesser General Public License for more details.
15  *
16  * You should have received a copy of the GNU Lesser General Public
17  * License along with this library; if not, write to the Free Software
18  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
19  */
20
21 #include "config.h"
22 #include "wine/port.h"
23
24 #include <string.h>
25 #include <stdarg.h>
26 #include <stdio.h>
27 #include "winerror.h"
28 #include "windef.h"
29 #include "winbase.h"
30 #include "winreg.h"
31 #include "wingdi.h"
32 #include "winuser.h"
33 #include "commdlg.h"
34 #include "wine/debug.h"
35
36 #include "shellapi.h"
37 #include "shlobj.h"
38 #include "shell32_main.h"
39 #include "shresdef.h"
40 #include "undocshell.h"
41
42 typedef struct
43     {
44         HWND hwndOwner ;
45         HICON hIcon ;
46         LPCWSTR lpstrDirectory ;
47         LPCWSTR lpstrTitle ;
48         LPCWSTR lpstrDescription ;
49         UINT uFlags ;
50     } RUNFILEDLGPARAMS ;
51
52 typedef BOOL (WINAPI * LPFNOFN) (OPENFILENAMEW *) ;
53
54 WINE_DEFAULT_DEBUG_CHANNEL(shell);
55 static INT_PTR CALLBACK RunDlgProc (HWND, UINT, WPARAM, LPARAM) ;
56 static void FillList (HWND, char *, BOOL) ;
57
58
59 /*************************************************************************
60  * PickIconDlg                                  [SHELL32.62]
61  *
62  */
63 INT WINAPI PickIconDlg(
64         HWND hwndOwner,
65         LPSTR lpstrFile,
66         DWORD nMaxFile,
67         LPDWORD lpdwIconIndex)
68 {
69         FIXME("(%p,%s,%08x,%p):stub.\n",
70           hwndOwner, lpstrFile, nMaxFile,lpdwIconIndex);
71         return 0xffffffff;
72 }
73
74 /*************************************************************************
75  * RunFileDlgW                                  [internal]
76  *
77  * The Unicode function that is available as ordinal 61 on Windows NT/2000/XP/...
78  *
79  * SEE ALSO
80  *   RunFileDlgAW
81  */
82 static void RunFileDlgW(
83         HWND hwndOwner,
84         HICON hIcon,
85         LPCWSTR lpstrDirectory,
86         LPCWSTR lpstrTitle,
87         LPCWSTR lpstrDescription,
88         UINT uFlags)
89 {
90     static const WCHAR resnameW[] = {'S','H','E','L','L','_','R','U','N','_','D','L','G',0};
91     RUNFILEDLGPARAMS rfdp;
92     HRSRC hRes;
93     LPVOID template;
94     TRACE("\n");
95
96     rfdp.hwndOwner        = hwndOwner;
97     rfdp.hIcon            = hIcon;
98     rfdp.lpstrDirectory   = lpstrDirectory;
99     rfdp.lpstrTitle       = lpstrTitle;
100     rfdp.lpstrDescription = lpstrDescription;
101     rfdp.uFlags           = uFlags;
102
103     if (!(hRes = FindResourceW(shell32_hInstance, resnameW, (LPWSTR)RT_DIALOG)) ||
104         !(template = LoadResource(shell32_hInstance, hRes)))
105     {
106         ERR("Couldn't load SHELL_RUN_DLG resource\n");
107         ShellMessageBoxW(shell32_hInstance, hwndOwner, MAKEINTRESOURCEW(IDS_RUNDLG_ERROR), NULL, MB_OK | MB_ICONERROR);
108         return;
109     }
110
111     DialogBoxIndirectParamW(shell32_hInstance,
112                             template, hwndOwner, RunDlgProc, (LPARAM)&rfdp);
113
114 }
115
116 /* find the directory that contains the file being run */
117 static LPWSTR RunDlg_GetParentDir(LPCWSTR cmdline)
118 {
119     const WCHAR *src;
120     WCHAR *dest, *result, *result_end=NULL;
121     static const WCHAR dotexeW[] = {'.','e','x','e',0};
122
123     result = HeapAlloc(GetProcessHeap(), 0, sizeof(WCHAR)*(strlenW(cmdline)+5));
124
125     src = cmdline;
126     dest = result;
127
128     if (*src == '"')
129     {
130         src++;
131         while (*src && *src != '"')
132         {
133             if (*src == '\\')
134                 result_end = dest;
135             *dest++ = *src++;
136         }
137     }
138     else {
139         while (*src)
140         {
141             if (isspaceW(*src))
142             {
143                 *dest = 0;
144                 if (INVALID_FILE_ATTRIBUTES != GetFileAttributesW(result))
145                     break;
146                 strcatW(dest, dotexeW);
147                 if (INVALID_FILE_ATTRIBUTES != GetFileAttributesW(result))
148                     break;
149             }
150             else if (*src == '\\')
151                 result_end = dest;
152             *dest++ = *src++;
153         }
154     }
155
156     if (result_end)
157     {
158         *result_end = 0;
159         return result;
160     }
161     else
162     {
163         HeapFree(GetProcessHeap(), 0, result);
164         return NULL;
165     }
166 }
167
168 /* Dialog procedure for RunFileDlg */
169 static INT_PTR CALLBACK RunDlgProc (HWND hwnd, UINT message, WPARAM wParam, LPARAM lParam)
170     {
171     RUNFILEDLGPARAMS *prfdp = (RUNFILEDLGPARAMS *)GetWindowLongPtrW(hwnd, DWLP_USER);
172
173     switch (message)
174         {
175         case WM_INITDIALOG :
176             prfdp = (RUNFILEDLGPARAMS *)lParam ;
177             SetWindowLongPtrW(hwnd, DWLP_USER, (LONG_PTR)prfdp);
178
179             if (prfdp->lpstrTitle)
180                 SetWindowTextW(hwnd, prfdp->lpstrTitle);
181             if (prfdp->lpstrDescription)
182                 SetWindowTextW(GetDlgItem(hwnd, IDC_RUNDLG_DESCRIPTION), prfdp->lpstrDescription);
183             if (prfdp->uFlags & RFF_NOBROWSE)
184             {
185                 HWND browse = GetDlgItem(hwnd, IDC_RUNDLG_BROWSE);
186                 ShowWindow(browse, SW_HIDE);
187                 EnableWindow(browse, FALSE);
188             }
189             if (prfdp->uFlags & RFF_NOLABEL)
190                 ShowWindow(GetDlgItem(hwnd, IDC_RUNDLG_LABEL), SW_HIDE);
191             if (prfdp->uFlags & RFF_CALCDIRECTORY)
192                 FIXME("RFF_CALCDIRECTORY not supported\n");
193
194             if (prfdp->hIcon == NULL)
195                 prfdp->hIcon = LoadIconW(NULL, (LPCWSTR)IDI_WINLOGO);
196             SendMessageW(hwnd, WM_SETICON, ICON_BIG, (LPARAM)prfdp->hIcon);
197             SendMessageW(hwnd, WM_SETICON, ICON_SMALL, (LPARAM)prfdp->hIcon);
198             SendMessageW(GetDlgItem(hwnd, IDC_RUNDLG_ICON), STM_SETICON, (WPARAM)prfdp->hIcon, 0);
199
200             FillList (GetDlgItem (hwnd, IDC_RUNDLG_EDITPATH), NULL, (prfdp->uFlags & RFF_NODEFAULT) == 0) ;
201             SetFocus (GetDlgItem (hwnd, IDC_RUNDLG_EDITPATH)) ;
202             return TRUE ;
203
204         case WM_COMMAND :
205             switch (LOWORD (wParam))
206                 {
207                 case IDOK :
208                     {
209                     int ic ;
210                     HWND htxt = GetDlgItem (hwnd, IDC_RUNDLG_EDITPATH);
211                     if ((ic = GetWindowTextLengthW (htxt)))
212                         {
213                         WCHAR *psz, *parent=NULL ;
214                         SHELLEXECUTEINFOW sei ;
215
216                         ZeroMemory (&sei, sizeof(sei)) ;
217                         sei.cbSize = sizeof(sei) ;
218                         psz = HeapAlloc( GetProcessHeap(), 0, (ic + 1)*sizeof(WCHAR) );
219                         GetWindowTextW (htxt, psz, ic + 1) ;
220
221                         /* according to http://www.codeproject.com/KB/shell/runfiledlg.aspx we should send a
222                          * WM_NOTIFY before execution */
223
224                         sei.hwnd = hwnd;
225                         sei.nShow = SW_SHOWNORMAL;
226                         sei.lpFile = psz;
227
228                         if (prfdp->lpstrDirectory)
229                             sei.lpDirectory = prfdp->lpstrDirectory;
230                         else
231                             sei.lpDirectory = parent = RunDlg_GetParentDir(sei.lpFile);
232
233                         if (!ShellExecuteExW( &sei ))
234                         {
235                             HeapFree(GetProcessHeap(), 0, psz);
236                             HeapFree(GetProcessHeap(), 0, parent);
237                             SendMessageA (htxt, CB_SETEDITSEL, 0, MAKELPARAM (0, -1)) ;
238                             return TRUE ;
239                         }
240
241                         /* FillList is still ANSI */
242                         GetWindowTextA (htxt, (LPSTR)psz, ic + 1) ;
243                         FillList (htxt, (LPSTR)psz, FALSE) ;
244
245                         HeapFree(GetProcessHeap(), 0, psz);
246                         HeapFree(GetProcessHeap(), 0, parent);
247                         EndDialog (hwnd, 0);
248                         }
249                     }
250
251                 case IDCANCEL :
252                     EndDialog (hwnd, 0) ;
253                     return TRUE ;
254
255                 case IDC_RUNDLG_BROWSE :
256                     {
257                     static const WCHAR filterW[] = {'%','s','%','c','*','.','e','x','e','%','c','%','s','%','c','*','.','*','%','c',0};
258                     HMODULE hComdlg = NULL ;
259                     LPFNOFN ofnProc = NULL ;
260                     static const WCHAR comdlg32W[] = {'c','o','m','d','l','g','3','2',0};
261                     WCHAR szFName[1024] = {0};
262                     WCHAR filter_exe[256], filter_all[256], filter[MAX_PATH], szCaption[MAX_PATH];
263                     OPENFILENAMEW ofn;
264
265                     LoadStringW(shell32_hInstance, IDS_RUNDLG_BROWSE_FILTER_EXE, filter_exe, 256);
266                     LoadStringW(shell32_hInstance, IDS_RUNDLG_BROWSE_FILTER_ALL, filter_all, 256);
267                     LoadStringW(shell32_hInstance, IDS_RUNDLG_BROWSE_CAPTION, szCaption, MAX_PATH);
268                     snprintfW( filter, MAX_PATH, filterW, filter_exe, 0, 0, filter_all, 0 );
269
270                     ZeroMemory(&ofn, sizeof(ofn));
271                     ofn.lStructSize = sizeof(OPENFILENAMEW);
272                     ofn.hwndOwner = hwnd;
273                     ofn.lpstrFilter = filter;
274                     ofn.lpstrFile = szFName;
275                     ofn.nMaxFile = 1023;
276                     ofn.lpstrTitle = szCaption;
277                     ofn.Flags = OFN_ENABLESIZING | OFN_FILEMUSTEXIST | OFN_HIDEREADONLY | OFN_PATHMUSTEXIST;
278                     ofn.lpstrInitialDir = prfdp->lpstrDirectory;
279
280                     if (NULL == (hComdlg = LoadLibraryExW (comdlg32W, NULL, 0)) ||
281                         NULL == (ofnProc = (LPFNOFN)GetProcAddress (hComdlg, "GetOpenFileNameW")))
282                     {
283                         ERR("Couldn't get GetOpenFileName function entry (lib=%p, proc=%p)\n", hComdlg, ofnProc);
284                         ShellMessageBoxW(shell32_hInstance, hwnd, MAKEINTRESOURCEW(IDS_RUNDLG_BROWSE_ERROR), NULL, MB_OK | MB_ICONERROR);
285                         return TRUE ;
286                     }
287
288                     if (ofnProc(&ofn))
289                     {
290                         SetFocus (GetDlgItem (hwnd, IDOK)) ;
291                         SetWindowTextW (GetDlgItem (hwnd, IDC_RUNDLG_EDITPATH), szFName) ;
292                         SendMessageW (GetDlgItem (hwnd, IDC_RUNDLG_EDITPATH), CB_SETEDITSEL, 0, MAKELPARAM (0, -1)) ;
293                         SetFocus (GetDlgItem (hwnd, IDOK)) ;
294                     }
295
296                     FreeLibrary (hComdlg) ;
297
298                     return TRUE ;
299                     }
300                 }
301             return TRUE ;
302         }
303     return FALSE ;
304     }
305
306 /* This grabs the MRU list from the registry and fills the combo for the "Run" dialog above */
307 /* fShowDefault ignored if pszLatest != NULL */
308 static void FillList (HWND hCb, char *pszLatest, BOOL fShowDefault)
309     {
310     HKEY hkey ;
311 /*    char szDbgMsg[256] = "" ; */
312     char *pszList = NULL, *pszCmd = NULL, cMatch = 0, cMax = 0x60, szIndex[2] = "-" ;
313     DWORD icList = 0, icCmd = 0 ;
314     UINT Nix ;
315
316     SendMessageA (hCb, CB_RESETCONTENT, 0, 0) ;
317
318     if (ERROR_SUCCESS != RegCreateKeyExA (
319         HKEY_CURRENT_USER, "Software\\Microsoft\\Windows\\CurrentVersion\\Explorer\\RunMRU",
320         0, NULL, REG_OPTION_NON_VOLATILE, KEY_ALL_ACCESS, NULL, &hkey, NULL))
321         MessageBoxA (hCb, "Unable to open registry key !", "Nix", MB_OK) ;
322
323     RegQueryValueExA (hkey, "MRUList", NULL, NULL, NULL, &icList) ;
324
325     if (icList > 0)
326         {
327         pszList = HeapAlloc( GetProcessHeap(), 0, icList) ;
328         if (ERROR_SUCCESS != RegQueryValueExA (hkey, "MRUList", NULL, NULL, (LPBYTE)pszList, &icList))
329             MessageBoxA (hCb, "Unable to grab MRUList !", "Nix", MB_OK) ;
330         }
331     else
332         {
333         icList = 1 ;
334         pszList = HeapAlloc( GetProcessHeap(), 0, icList) ;
335         pszList[0] = 0 ;
336         }
337
338     for (Nix = 0 ; Nix < icList - 1 ; Nix++)
339         {
340         if (pszList[Nix] > cMax)
341             cMax = pszList[Nix] ;
342
343         szIndex[0] = pszList[Nix] ;
344
345         if (ERROR_SUCCESS != RegQueryValueExA (hkey, szIndex, NULL, NULL, NULL, &icCmd))
346             MessageBoxA (hCb, "Unable to grab size of index", "Nix", MB_OK) ;
347         if( pszCmd )
348             pszCmd = HeapReAlloc(GetProcessHeap(), 0, pszCmd, icCmd) ;
349         else
350             pszCmd = HeapAlloc(GetProcessHeap(), 0, icCmd) ;
351         if (ERROR_SUCCESS != RegQueryValueExA (hkey, szIndex, NULL, NULL, (LPBYTE)pszCmd, &icCmd))
352             MessageBoxA (hCb, "Unable to grab index", "Nix", MB_OK) ;
353
354         if (NULL != pszLatest)
355             {
356             if (!lstrcmpiA(pszCmd, pszLatest))
357                 {
358                 /*
359                 sprintf (szDbgMsg, "Found existing (%d).\n", Nix) ;
360                 MessageBoxA (hCb, szDbgMsg, "Nix", MB_OK) ;
361                 */
362                 SendMessageA (hCb, CB_INSERTSTRING, 0, (LPARAM)pszCmd) ;
363                 SetWindowTextA (hCb, pszCmd) ;
364                 SendMessageA (hCb, CB_SETEDITSEL, 0, MAKELPARAM (0, -1)) ;
365
366                 cMatch = pszList[Nix] ;
367                 memmove (&pszList[1], pszList, Nix) ;
368                 pszList[0] = cMatch ;
369                 continue ;
370                 }
371             }
372
373         if (26 != icList - 1 || icList - 2 != Nix || cMatch || NULL == pszLatest)
374             {
375             /*
376             sprintf (szDbgMsg, "Happily appending (%d).\n", Nix) ;
377             MessageBoxA (hCb, szDbgMsg, "Nix", MB_OK) ;
378             */
379             SendMessageA (hCb, CB_ADDSTRING, 0, (LPARAM)pszCmd) ;
380             if (!Nix && fShowDefault)
381                 {
382                 SetWindowTextA (hCb, pszCmd) ;
383                 SendMessageA (hCb, CB_SETEDITSEL, 0, MAKELPARAM (0, -1)) ;
384                 }
385
386             }
387         else
388             {
389             /*
390             sprintf (szDbgMsg, "Doing loop thing.\n") ;
391             MessageBoxA (hCb, szDbgMsg, "Nix", MB_OK) ;
392             */
393             SendMessageA (hCb, CB_INSERTSTRING, 0, (LPARAM)pszLatest) ;
394             SetWindowTextA (hCb, pszLatest) ;
395             SendMessageA (hCb, CB_SETEDITSEL, 0, MAKELPARAM (0, -1)) ;
396
397             cMatch = pszList[Nix] ;
398             memmove (&pszList[1], pszList, Nix) ;
399             pszList[0] = cMatch ;
400             szIndex[0] = cMatch ;
401             RegSetValueExA (hkey, szIndex, 0, REG_SZ, (LPBYTE)pszLatest, strlen (pszLatest) + 1) ;
402             }
403         }
404
405     if (!cMatch && NULL != pszLatest)
406         {
407         /*
408         sprintf (szDbgMsg, "Simply inserting (increasing list).\n") ;
409         MessageBoxA (hCb, szDbgMsg, "Nix", MB_OK) ;
410         */
411         SendMessageA (hCb, CB_INSERTSTRING, 0, (LPARAM)pszLatest) ;
412         SetWindowTextA (hCb, pszLatest) ;
413         SendMessageA (hCb, CB_SETEDITSEL, 0, MAKELPARAM (0, -1)) ;
414
415         cMatch = ++cMax ;
416         if( pszList )
417             pszList = HeapReAlloc(GetProcessHeap(), 0, pszList, ++icList) ;
418         else
419             pszList = HeapAlloc(GetProcessHeap(), 0, ++icList) ;
420         memmove (&pszList[1], pszList, icList - 1) ;
421         pszList[0] = cMatch ;
422         szIndex[0] = cMatch ;
423         RegSetValueExA (hkey, szIndex, 0, REG_SZ, (LPBYTE)pszLatest, strlen (pszLatest) + 1) ;
424         }
425
426     RegSetValueExA (hkey, "MRUList", 0, REG_SZ, (LPBYTE)pszList, strlen (pszList) + 1) ;
427
428     HeapFree( GetProcessHeap(), 0, pszCmd) ;
429     HeapFree( GetProcessHeap(), 0, pszList) ;
430     }
431
432 /*************************************************************************
433  * RunFileDlgA                                  [internal]
434  *
435  * The ANSI function that is available as ordinal 61 on Windows 9x/Me
436  *
437  * SEE ALSO
438  *   RunFileDlgAW
439  */
440 static void RunFileDlgA(
441         HWND hwndOwner,
442         HICON hIcon,
443         LPCSTR lpstrDirectory,
444         LPCSTR lpstrTitle,
445         LPCSTR lpstrDescription,
446         UINT uFlags)
447 {
448     WCHAR title[MAX_PATH];       /* longer string wouldn't be visible in the dialog anyway */
449     WCHAR description[MAX_PATH];
450     WCHAR directory[MAX_PATH];
451
452     MultiByteToWideChar(CP_ACP, 0, lpstrTitle, -1, title, MAX_PATH);
453     title[MAX_PATH - 1] = 0;
454     MultiByteToWideChar(CP_ACP, 0, lpstrDescription, -1, description, MAX_PATH);
455     description[MAX_PATH - 1] = 0;
456     if (!MultiByteToWideChar(CP_ACP, 0, lpstrDirectory, -1, directory, MAX_PATH))
457         directory[0] = 0;
458
459     RunFileDlgW(hwndOwner, hIcon,
460         lpstrDirectory ? directory : NULL,
461         lpstrTitle ? title : NULL,
462         lpstrDescription ? description : NULL,
463         uFlags);
464 }
465
466 /*************************************************************************
467  * RunFileDlgAW                                 [SHELL32.61]
468  *
469  * An undocumented way to open the Run File dialog. A documented way is to use
470  * CLSID_Shell, IID_IShellDispatch (as of Wine 1.0, not implemented under Wine)
471  *
472  * Exported by ordinal. ANSI on Windows 9x and Unicode on Windows NT/2000/XP/etc
473  *
474  */
475 void WINAPI RunFileDlgAW(
476         HWND hwndOwner,
477         HICON hIcon,
478         LPCVOID lpstrDirectory,
479         LPCVOID lpstrTitle,
480         LPCVOID lpstrDescription,
481         UINT uFlags)
482 {
483     if (SHELL_OsIsUnicode())
484         RunFileDlgW(hwndOwner, hIcon, lpstrDirectory, lpstrTitle, lpstrDescription, uFlags);
485     else
486         RunFileDlgA(hwndOwner, hIcon, lpstrDirectory, lpstrTitle, lpstrDescription, uFlags);
487 }
488
489
490 /*************************************************************************
491  * ConfirmDialog                                [internal]
492  *
493  * Put up a confirm box, return TRUE if the user confirmed
494  */
495 static BOOL ConfirmDialog(HWND hWndOwner, UINT PromptId, UINT TitleId)
496 {
497   WCHAR Prompt[256];
498   WCHAR Title[256];
499
500   LoadStringW(shell32_hInstance, PromptId, Prompt, sizeof(Prompt) / sizeof(WCHAR));
501   LoadStringW(shell32_hInstance, TitleId, Title, sizeof(Title) / sizeof(WCHAR));
502   return MessageBoxW(hWndOwner, Prompt, Title, MB_YESNO|MB_ICONQUESTION) == IDYES;
503 }
504
505
506 /*************************************************************************
507  * RestartDialogEx                              [SHELL32.730]
508  */
509
510 int WINAPI RestartDialogEx(HWND hWndOwner, LPCWSTR lpwstrReason, DWORD uFlags, DWORD uReason)
511 {
512     TRACE("(%p)\n", hWndOwner);
513
514     /* FIXME: use lpwstrReason */
515     if (ConfirmDialog(hWndOwner, IDS_RESTART_PROMPT, IDS_RESTART_TITLE))
516     {
517         HANDLE hToken;
518         TOKEN_PRIVILEGES npr;
519
520         /* enable the shutdown privilege for the current process */
521         if (OpenProcessToken(GetCurrentProcess(), TOKEN_ADJUST_PRIVILEGES, &hToken))
522         {
523             LookupPrivilegeValueA(0, "SeShutdownPrivilege", &npr.Privileges[0].Luid);
524             npr.PrivilegeCount = 1;
525             npr.Privileges[0].Attributes = SE_PRIVILEGE_ENABLED;
526             AdjustTokenPrivileges(hToken, FALSE, &npr, 0, 0, 0);
527             CloseHandle(hToken);
528         }
529         ExitWindowsEx(EWX_REBOOT, uReason);
530     }
531
532     return 0;
533 }
534
535
536 /*************************************************************************
537  * RestartDialog                                [SHELL32.59]
538  */
539
540 int WINAPI RestartDialog(HWND hWndOwner, LPCWSTR lpstrReason, DWORD uFlags)
541 {
542     return RestartDialogEx(hWndOwner, lpstrReason, uFlags, 0);
543 }
544
545
546 /*************************************************************************
547  * ExitWindowsDialog                            [SHELL32.60]
548  *
549  * NOTES
550  *     exported by ordinal
551  */
552 void WINAPI ExitWindowsDialog (HWND hWndOwner)
553 {
554     TRACE("(%p)\n", hWndOwner);
555
556     if (ConfirmDialog(hWndOwner, IDS_SHUTDOWN_PROMPT, IDS_SHUTDOWN_TITLE))
557     {
558         HANDLE hToken;
559         TOKEN_PRIVILEGES npr;
560
561         /* enable shutdown privilege for current process */
562         if (OpenProcessToken(GetCurrentProcess(), TOKEN_ADJUST_PRIVILEGES, &hToken))
563         {
564             LookupPrivilegeValueA(0, "SeShutdownPrivilege", &npr.Privileges[0].Luid);
565             npr.PrivilegeCount = 1;
566             npr.Privileges[0].Attributes = SE_PRIVILEGE_ENABLED;
567             AdjustTokenPrivileges(hToken, FALSE, &npr, 0, 0, 0);
568             CloseHandle(hToken);
569         }
570         ExitWindowsEx(EWX_SHUTDOWN, 0);
571     }
572 }