dll/win32/msgina/shutdown.c

   1 /*
   2  * COPYRIGHT:       See COPYING in the top level directory
   3  * PROJECT:         ReactOS msgina.dll
   4  * FILE:            lib/msgina/shutdown.c
   5  * PURPOSE:         Shutdown Dialog Box (GUI only)
   6  * PROGRAMMERS:     Lee Schroeder (spaceseel at gmail dot com)
   7  *                  Hermes Belusca-Maito (hermes.belusca@sfr.fr)
   8  */
   9
  10 #include "msgina.h"
  11 #include <powrprof.h>
  12 #include <wingdi.h>
  13
  14 /* Shutdown state flags */
  15 #define WLX_SHUTDOWN_STATE_LOGOFF       0x01
  16 #define WLX_SHUTDOWN_STATE_POWER_OFF    0x02
  17 #define WLX_SHUTDOWN_STATE_REBOOT       0x04
  18 // 0x08
  19 #define WLX_SHUTDOWN_STATE_SLEEP        0x10
  20 // 0x20
  21 #define WLX_SHUTDOWN_STATE_HIBERNATE    0x40
  22 // 0x80
  23
  24 typedef struct _SHUTDOWN_DLG_CONTEXT
  25 {
  26     PGINA_CONTEXT pgContext;
  27     HBITMAP hBitmap;
  28     DWORD ShutdownOptions;
  29     BOOL bCloseDlg;
  30     BOOL bReasonUI;
  31 } SHUTDOWN_DLG_CONTEXT, *PSHUTDOWN_DLG_CONTEXT;
  32
  33
  34 static
  35 BOOL
  36 GetShutdownReasonUI(VOID)
  37 {
  38     OSVERSIONINFOEX VersionInfo;
  39     DWORD dwValue, dwSize;
  40     HKEY hKey;
  41     LONG lRet;
  42
  43     /* Query the policy value */
  44     lRet = RegOpenKeyExW(HKEY_LOCAL_MACHINE,
  45                          L"Software\\Policies\\Microsoft\\Windows NT\\Reliability",
  46                          0,
  47                          KEY_QUERY_VALUE,
  48                          &hKey);
  49     if (lRet == ERROR_SUCCESS)
  50     {
  51         dwValue = 0;
  52         dwSize = sizeof(dwValue);
  53         RegQueryValueExW(hKey,
  54                          L"ShutdownReasonUI",
  55                          NULL,
  56                          NULL,
  57                          (LPBYTE)&dwValue,
  58                          &dwSize);
  59         RegCloseKey(hKey);
  60
  61         return (dwValue != 0) ? TRUE : FALSE;
  62     }
  63
  64     /* Query the machine value */
  65     lRet = RegOpenKeyExW(HKEY_LOCAL_MACHINE,
  66                          L"Software\\Microsoft\\Windows\\CurrentVersion\\Reliability",
  67                          0,
  68                          KEY_QUERY_VALUE,
  69                          &hKey);
  70     if (lRet == ERROR_SUCCESS)
  71     {
  72         dwValue = 0;
  73         dwSize = sizeof(dwValue);
  74         RegQueryValueExW(hKey,
  75                          L"ShutdownReasonUI",
  76                          NULL,
  77                          NULL,
  78                          (LPBYTE)&dwValue,
  79                          &dwSize);
  80         RegCloseKey(hKey);
  81
  82         return (dwValue != 0) ? TRUE : FALSE;
  83     }
  84
  85     /* Return the default value */
  86     VersionInfo.dwOSVersionInfoSize = sizeof(VersionInfo);
  87     if (!GetVersionEx((POSVERSIONINFO)&VersionInfo))
  88         return FALSE;
  89
  90     return FALSE;
  91 //    return (VersionInfo.wProductType == VER_NT_WORKSTATION) ? FALSE : TRUE;
  92 }
  93
  94 DWORD
  95 GetDefaultShutdownSelState(VOID)
  96 {
  97     return WLX_SAS_ACTION_SHUTDOWN_POWER_OFF;
  98 }
  99
 100 DWORD
 101 LoadShutdownSelState(VOID)
 102 {
 103     LONG lRet;
 104     HKEY hKeyCurrentUser, hKey;
 105     DWORD dwValue, dwTemp, dwSize;
 106
 107     /* Default to shutdown */
 108     dwValue = WLX_SAS_ACTION_SHUTDOWN_POWER_OFF;
 109
 110     /* Open the current user HKCU key */
 111     lRet = RegOpenCurrentUser(MAXIMUM_ALLOWED, &hKeyCurrentUser);
 112     if (lRet == ERROR_SUCCESS)
 113     {
 114         /* Open the subkey */
 115         lRet = RegOpenKeyExW(hKeyCurrentUser,
 116                              L"Software\\Microsoft\\Windows\\CurrentVersion\\Explorer",
 117                              0, KEY_QUERY_VALUE, &hKey);
 118         RegCloseKey(hKeyCurrentUser);
 119     }
 120     if (lRet != ERROR_SUCCESS)
 121         return dwValue;
 122
 123     /* Read the value */
 124     dwSize = sizeof(dwTemp);
 125     lRet = RegQueryValueExW(hKey,
 126                             L"Shutdown Setting",
 127                             NULL, NULL,
 128                             (LPBYTE)&dwTemp, &dwSize);
 129     RegCloseKey(hKey);
 130
 131     if (lRet == ERROR_SUCCESS)
 132     {
 133         switch (dwTemp)
 134         {
 135             case WLX_SHUTDOWN_STATE_LOGOFF:
 136                 dwValue = WLX_SAS_ACTION_LOGOFF;
 137                 break;
 138
 139             case WLX_SHUTDOWN_STATE_POWER_OFF:
 140                 dwValue = WLX_SAS_ACTION_SHUTDOWN_POWER_OFF;
 141                 break;
 142
 143             case WLX_SHUTDOWN_STATE_REBOOT:
 144                 dwValue = WLX_SAS_ACTION_SHUTDOWN_REBOOT;
 145                 break;
 146
 147             // 0x08
 148
 149             case WLX_SHUTDOWN_STATE_SLEEP:
 150                 dwValue = WLX_SAS_ACTION_SHUTDOWN_SLEEP;
 151                 break;
 152
 153             // 0x20
 154
 155             case WLX_SHUTDOWN_STATE_HIBERNATE:
 156                 dwValue = WLX_SAS_ACTION_SHUTDOWN_HIBERNATE;
 157                 break;
 158
 159             // 0x80
 160         }
 161     }
 162
 163     return dwValue;
 164 }
 165
 166 VOID
 167 SaveShutdownSelState(
 168     IN DWORD ShutdownCode)
 169 {
 170     LONG lRet;
 171     HKEY hKeyCurrentUser, hKey;
 172     DWORD dwValue = 0;
 173
 174     /* Open the current user HKCU key */
 175     lRet = RegOpenCurrentUser(MAXIMUM_ALLOWED, &hKeyCurrentUser);
 176     if (lRet == ERROR_SUCCESS)
 177     {
 178         /* Create the subkey */
 179         lRet = RegCreateKeyExW(hKeyCurrentUser,
 180                                L"Software\\Microsoft\\Windows\\CurrentVersion\\Explorer",
 181                                0, NULL,
 182                                REG_OPTION_NON_VOLATILE,
 183                                KEY_SET_VALUE,
 184                                NULL, &hKey, NULL);
 185         RegCloseKey(hKeyCurrentUser);
 186     }
 187     if (lRet != ERROR_SUCCESS)
 188         return;
 189
 190     switch (ShutdownCode)
 191     {
 192         case WLX_SAS_ACTION_LOGOFF:
 193             dwValue = WLX_SHUTDOWN_STATE_LOGOFF;
 194             break;
 195
 196         case WLX_SAS_ACTION_SHUTDOWN_POWER_OFF:
 197             dwValue = WLX_SHUTDOWN_STATE_POWER_OFF;
 198             break;
 199
 200         case WLX_SAS_ACTION_SHUTDOWN_REBOOT:
 201             dwValue = WLX_SHUTDOWN_STATE_REBOOT;
 202             break;
 203
 204         case WLX_SAS_ACTION_SHUTDOWN_SLEEP:
 205             dwValue = WLX_SHUTDOWN_STATE_SLEEP;
 206             break;
 207
 208         case WLX_SAS_ACTION_SHUTDOWN_HIBERNATE:
 209             dwValue = WLX_SHUTDOWN_STATE_HIBERNATE;
 210             break;
 211     }
 212
 213     RegSetValueExW(hKey,
 214                    L"Shutdown Setting",
 215                    0, REG_DWORD,
 216                    (LPBYTE)&dwValue, sizeof(dwValue));
 217     RegCloseKey(hKey);
 218 }
 219
 220 DWORD
 221 GetDefaultShutdownOptions(VOID)
 222 {
 223     return WLX_SHUTDOWN_STATE_POWER_OFF | WLX_SHUTDOWN_STATE_REBOOT;
 224 }
 225
 226 DWORD
 227 GetAllowedShutdownOptions(VOID)
 228 {
 229     DWORD Options = 0;
 230
 231     // FIXME: Compute those options accordings to current user's rights!
 232     Options |= WLX_SHUTDOWN_STATE_LOGOFF | WLX_SHUTDOWN_STATE_POWER_OFF | WLX_SHUTDOWN_STATE_REBOOT;
 233
 234     if (IsPwrSuspendAllowed())
 235         Options |= WLX_SHUTDOWN_STATE_SLEEP;
 236
 237     if (IsPwrHibernateAllowed())
 238         Options |= WLX_SHUTDOWN_STATE_HIBERNATE;
 239
 240     return Options;
 241 }
 242
 243 static VOID
 244 UpdateShutdownDesc(
 245     IN HWND hDlg,
 246     IN PSHUTDOWN_DLG_CONTEXT pContext) // HINSTANCE hInstance
 247 {
 248     UINT DescId = 0;
 249     DWORD ShutdownCode;
 250     WCHAR szBuffer[256];
 251
 252     ShutdownCode = SendDlgItemMessageW(hDlg, IDC_SHUTDOWN_ACTION, CB_GETCURSEL, 0, 0);
 253     if (ShutdownCode == CB_ERR) // Invalid selection
 254         return;
 255
 256     ShutdownCode = SendDlgItemMessageW(hDlg, IDC_SHUTDOWN_ACTION, CB_GETITEMDATA, ShutdownCode, 0);
 257
 258     switch (ShutdownCode)
 259     {
 260         case WLX_SAS_ACTION_LOGOFF:
 261             DescId = IDS_SHUTDOWN_LOGOFF_DESC;
 262             break;
 263
 264         case WLX_SAS_ACTION_SHUTDOWN_POWER_OFF:
 265             DescId = IDS_SHUTDOWN_SHUTDOWN_DESC;
 266             break;
 267
 268         case WLX_SAS_ACTION_SHUTDOWN_REBOOT:
 269             DescId = IDS_SHUTDOWN_RESTART_DESC;
 270             break;
 271
 272         case WLX_SAS_ACTION_SHUTDOWN_SLEEP:
 273             DescId = IDS_SHUTDOWN_SLEEP_DESC;
 274             break;
 275
 276         case WLX_SAS_ACTION_SHUTDOWN_HIBERNATE:
 277             DescId = IDS_SHUTDOWN_HIBERNATE_DESC;
 278             break;
 279
 280         default:
 281             break;
 282     }
 283
 284     LoadStringW(pContext->pgContext->hDllInstance, DescId, szBuffer, _countof(szBuffer));
 285     SetDlgItemTextW(hDlg, IDC_SHUTDOWN_DESCRIPTION, szBuffer);
 286
 287     if (pContext->bReasonUI)
 288     {
 289         EnableWindow(GetDlgItem(hDlg, IDC_REASON_PLANNED), (ShutdownCode != WLX_SAS_ACTION_LOGOFF));
 290         EnableWindow(GetDlgItem(hDlg, IDC_REASON_LIST), (ShutdownCode != WLX_SAS_ACTION_LOGOFF));
 291         EnableWindow(GetDlgItem(hDlg, IDC_REASON_COMMENT), (ShutdownCode != WLX_SAS_ACTION_LOGOFF));
 292     }
 293 }
 294
 295 static VOID
 296 ShutdownOnInit(
 297     IN HWND hDlg,
 298     IN PSHUTDOWN_DLG_CONTEXT pContext)
 299 {
 300     PGINA_CONTEXT pgContext = pContext->pgContext;
 301     HWND hwndList;
 302     INT idx, count, i;
 303     WCHAR szBuffer[256];
 304     WCHAR szBuffer2[256];
 305
 306     hwndList = GetDlgItem(hDlg, IDC_SHUTDOWN_ACTION);
 307
 308     /* Clear the content before it's used */
 309     SendMessageW(hwndList, CB_RESETCONTENT, 0, 0);
 310
 311     /* Log off */
 312     if (pContext->ShutdownOptions & WLX_SHUTDOWN_STATE_LOGOFF)
 313     {
 314         LoadStringW(pgContext->hDllInstance, IDS_SHUTDOWN_LOGOFF, szBuffer, _countof(szBuffer));
 315         StringCchPrintfW(szBuffer2, _countof(szBuffer2), szBuffer, pgContext->UserName);
 316         idx = SendMessageW(hwndList, CB_ADDSTRING, 0, (LPARAM)szBuffer2);
 317         if (idx != CB_ERR)
 318             SendMessageW(hwndList, CB_SETITEMDATA, idx, WLX_SAS_ACTION_LOGOFF);
 319     }
 320
 321     /* Shut down - DEFAULT */
 322     if (pContext->ShutdownOptions & WLX_SHUTDOWN_STATE_POWER_OFF)
 323     {
 324         LoadStringW(pgContext->hDllInstance, IDS_SHUTDOWN_SHUTDOWN, szBuffer, _countof(szBuffer));
 325         idx = SendMessageW(hwndList, CB_ADDSTRING, 0, (LPARAM)szBuffer);
 326         if (idx != CB_ERR)
 327             SendMessageW(hwndList, CB_SETITEMDATA, idx, WLX_SAS_ACTION_SHUTDOWN_POWER_OFF);
 328     }
 329
 330     /* Restart */
 331     if (pContext->ShutdownOptions & WLX_SHUTDOWN_STATE_REBOOT)
 332     {
 333         LoadStringW(pgContext->hDllInstance, IDS_SHUTDOWN_RESTART, szBuffer, _countof(szBuffer));
 334         idx = SendMessageW(hwndList, CB_ADDSTRING, 0, (LPARAM)szBuffer);
 335         if (idx != CB_ERR)
 336             SendMessageW(hwndList, CB_SETITEMDATA, idx, WLX_SAS_ACTION_SHUTDOWN_REBOOT);
 337     }
 338
 339     // if (pContext->ShutdownOptions & 0x08) {}
 340
 341     /* Sleep */
 342     if (pContext->ShutdownOptions & WLX_SHUTDOWN_STATE_SLEEP)
 343     {
 344         LoadStringW(pgContext->hDllInstance, IDS_SHUTDOWN_SLEEP, szBuffer, _countof(szBuffer));
 345         idx = SendMessageW(hwndList, CB_ADDSTRING, 0, (LPARAM)szBuffer);
 346         if (idx != CB_ERR)
 347             SendMessageW(hwndList, CB_SETITEMDATA, idx, WLX_SAS_ACTION_SHUTDOWN_SLEEP);
 348     }
 349
 350     // if (pContext->ShutdownOptions & 0x20) {}
 351
 352     /* Hibernate */
 353     if (pContext->ShutdownOptions & WLX_SHUTDOWN_STATE_HIBERNATE)
 354     {
 355         LoadStringW(pgContext->hDllInstance, IDS_SHUTDOWN_HIBERNATE, szBuffer, _countof(szBuffer));
 356         idx = SendMessageW(hwndList, CB_ADDSTRING, 0, (LPARAM)szBuffer);
 357         if (idx != CB_ERR)
 358             SendMessageW(hwndList, CB_SETITEMDATA, idx, WLX_SAS_ACTION_SHUTDOWN_HIBERNATE);
 359     }
 360
 361     // if (pContext->ShutdownOptions & 0x80) {}
 362
 363     /* Set the default shut down selection */
 364     count = SendMessageW(hwndList, CB_GETCOUNT, 0, 0);
 365     for (i = 0; i < count; i++)
 366     {
 367         if (SendMessageW(hwndList, CB_GETITEMDATA, i, 0) == pgContext->nShutdownAction)
 368         {
 369             SendMessageW(hwndList, CB_SETCURSEL, i, 0);
 370             break;
 371         }
 372     }
 373
 374     /* Update the choice description based on the current selection */
 375     UpdateShutdownDesc(hDlg, pContext);
 376 }
 377
 378 static VOID
 379 ShutdownOnOk(
 380     IN HWND hDlg,
 381     IN PGINA_CONTEXT pgContext)
 382 {
 383     INT idx;
 384
 385     idx = SendDlgItemMessageW(hDlg,
 386                               IDC_SHUTDOWN_ACTION,
 387                               CB_GETCURSEL,
 388                               0,
 389                               0);
 390     if (idx != CB_ERR)
 391     {
 392         pgContext->nShutdownAction =
 393             SendDlgItemMessageW(hDlg,
 394                                 IDC_SHUTDOWN_ACTION,
 395                                 CB_GETITEMDATA,
 396                                 idx,
 397                                 0);
 398     }
 399 }
 400
 401 static INT_PTR
 402 CALLBACK
 403 ShutdownDialogProc(
 404     HWND hDlg,
 405     UINT uMsg,
 406     WPARAM wParam,
 407     LPARAM lParam)
 408 {
 409     PSHUTDOWN_DLG_CONTEXT pContext;
 410
 411     pContext = (PSHUTDOWN_DLG_CONTEXT)GetWindowLongPtrW(hDlg, GWLP_USERDATA);
 412
 413     switch (uMsg)
 414     {
 415         case WM_INITDIALOG:
 416         {
 417             pContext = (PSHUTDOWN_DLG_CONTEXT)lParam;
 418             SetWindowLongPtrW(hDlg, GWLP_USERDATA, (LONG_PTR)pContext);
 419
 420             ShutdownOnInit(hDlg, pContext);
 421
 422             /* Draw the logo bitmap */
 423             pContext->hBitmap =
 424                 LoadImageW(pContext->pgContext->hDllInstance, MAKEINTRESOURCEW(IDI_ROSLOGO), IMAGE_BITMAP, 0, 0, LR_DEFAULTCOLOR);
 425             return TRUE;
 426         }
 427
 428         case WM_DESTROY:
 429             DeleteObject(pContext->hBitmap);
 430             return TRUE;
 431
 432         case WM_ACTIVATE:
 433         {
 434             /*
 435              * If the user deactivates the shutdown dialog (it loses its focus
 436              * while the dialog is not being closed), then destroy the dialog
 437              * and cancel shutdown.
 438              */
 439             if (LOWORD(wParam) == WA_INACTIVE)
 440             {
 441                 if (!pContext->bCloseDlg)
 442                 {
 443                     pContext->bCloseDlg = TRUE;
 444                     EndDialog(hDlg, 0);
 445                 }
 446             }
 447             return FALSE;
 448         }
 449
 450         case WM_PAINT:
 451         {
 452             PAINTSTRUCT ps;
 453             if (pContext->hBitmap)
 454             {
 455                 BeginPaint(hDlg, &ps);
 456                 DrawStateW(ps.hdc, NULL, NULL, (LPARAM)pContext->hBitmap, (WPARAM)0, 0, 0, 0, 0, DST_BITMAP);
 457                 EndPaint(hDlg, &ps);
 458             }
 459             return TRUE;
 460         }
 461
 462         case WM_CLOSE:
 463             pContext->bCloseDlg = TRUE;
 464             EndDialog(hDlg, IDCANCEL);
 465             break;
 466
 467         case WM_COMMAND:
 468             switch (LOWORD(wParam))
 469             {
 470                 case IDOK:
 471                     ShutdownOnOk(hDlg, pContext->pgContext);
 472
 473                 /* Fall back */
 474                 case IDCANCEL:
 475                 case IDHELP:
 476                     pContext->bCloseDlg = TRUE;
 477                     EndDialog(hDlg, LOWORD(wParam));
 478                     break;
 479
 480                 case IDC_SHUTDOWN_ACTION:
 481                     UpdateShutdownDesc(hDlg, pContext);
 482                     break;
 483             }
 484             break;
 485
 486         default:
 487             return FALSE;
 488     }
 489     return TRUE;
 490 }
 491
 492 INT_PTR
 493 ShutdownDialog(
 494     IN HWND hwndDlg,
 495     IN DWORD ShutdownOptions,
 496     IN PGINA_CONTEXT pgContext)
 497 {
 498     INT_PTR ret;
 499     SHUTDOWN_DLG_CONTEXT Context;
 500
 501 #if 0
 502     DWORD ShutdownOptions;
 503
 504     // FIXME: User impersonation!!
 505     pgContext->nShutdownAction = LoadShutdownSelState();
 506     ShutdownOptions = GetAllowedShutdownOptions();
 507 #endif
 508
 509     Context.pgContext = pgContext;
 510     Context.ShutdownOptions = ShutdownOptions;
 511     Context.bCloseDlg = FALSE;
 512     Context.bReasonUI = GetShutdownReasonUI();
 513
 514     if (pgContext->hWlx && pgContext->pWlxFuncs)
 515     {
 516         ret = pgContext->pWlxFuncs->WlxDialogBoxParam(pgContext->hWlx,
 517                                                       pgContext->hDllInstance,
 518                                                       MAKEINTRESOURCEW(Context.bReasonUI ? IDD_SHUTDOWN_REASON : IDD_SHUTDOWN),
 519                                                       hwndDlg,
 520                                                       ShutdownDialogProc,
 521                                                       (LPARAM)&Context);
 522     }
 523     else
 524     {
 525         ret = DialogBoxParamW(pgContext->hDllInstance,
 526                               MAKEINTRESOURCEW(Context.bReasonUI ? IDD_SHUTDOWN_REASON : IDD_SHUTDOWN),
 527                               hwndDlg,
 528                               ShutdownDialogProc,
 529                               (LPARAM)&Context);
 530     }
 531
 532 #if 0
 533     // FIXME: User impersonation!!
 534     if (ret == IDOK)
 535         SaveShutdownSelState(pgContext->nShutdownAction);
 536 #endif
 537
 538     return ret;
 539 }
 540
 541
 542 /*
 543  * NOTES:
 544  * - Based upon observations on the ShellShutdownDialog() function, the function doesn't actually
 545  *   do anything except show a dialog box and returning a value based upon the value chosen. That
 546  *   means that any code that calls the function has to execute the chosen action (shut down,
 547  *   restart, etc.).
 548  * - When this function is called in Windows XP, it shows the classic dialog box regardless if
 549  *   SOFTWARE\Microsoft\Windows NT\CurrentVersion\Winlogon\LogonType is enabled or not.
 550  * - When the Help button is pushed, it sends the same return value as IDCANCEL (0x00), but
 551  *   at the same time, it calls the help file directly from the dialog box.
 552  * - When the dialog is created, it doesn't disable all other input from the other windows.
 553  *   This is done elsewhere. When running the function ShellShutdownDialog() from XP/2K3, if the user clicks
 554  *   out of the window, it automatically closes itself.
 555  * - The parameter, lpUsername never seems to be used when calling the function from Windows XP. Either
 556  *   it was a parameter that was never used in the final version before release, or it has a use that
 557  *   is currently not known.
 558  */
 559 DWORD WINAPI
 560 ShellShutdownDialog(
 561     HWND   hParent,
 562     LPWSTR lpUsername,
 563     BOOL   bHideLogoff)
 564 {
 565     INT_PTR dlgValue;
 566     DWORD ShutdownOptions;
 567
 568     /*
 569      * As we are called by the shell itself, don't use
 570      * the cached GINA context but use a local copy here.
 571      */
 572     GINA_CONTEXT gContext = { 0 };
 573     DWORD BufferSize;
 574
 575     UNREFERENCED_PARAMETER(lpUsername);
 576
 577     ShutdownOptions = GetAllowedShutdownOptions();
 578     if (bHideLogoff)
 579         ShutdownOptions &= ~WLX_SHUTDOWN_STATE_LOGOFF;
 580
 581     /* Initialize our local GINA context */
 582     gContext.hDllInstance = hDllInstance;
 583     BufferSize = _countof(gContext.UserName);
 584     // NOTE: Only when this function is called, Win checks inside
 585     // HKLM\\Software\\Microsoft\\Windows\\CurrentVersion\\Explorer",
 586     // value "Logon User Name", and determines whether it will display
 587     // the user name.
 588     GetUserNameW(gContext.UserName, &BufferSize);
 589     gContext.nShutdownAction = LoadShutdownSelState();
 590
 591     /* Load the shutdown dialog box */
 592     dlgValue = ShutdownDialog(hParent, ShutdownOptions, &gContext);
 593
 594     /* Determine what to do based on user selection */
 595     if (dlgValue == IDOK)
 596     {
 597         SaveShutdownSelState(gContext.nShutdownAction);
 598
 599         switch (gContext.nShutdownAction)
 600         {
 601             case WLX_SAS_ACTION_LOGOFF:
 602                 return WLX_SHUTDOWN_STATE_LOGOFF;
 603
 604             case WLX_SAS_ACTION_SHUTDOWN_POWER_OFF:
 605                 return WLX_SHUTDOWN_STATE_POWER_OFF;
 606
 607             case WLX_SAS_ACTION_SHUTDOWN_REBOOT:
 608                 return WLX_SHUTDOWN_STATE_REBOOT;
 609
 610             // 0x08
 611
 612             case WLX_SAS_ACTION_SHUTDOWN_SLEEP:
 613                 return WLX_SHUTDOWN_STATE_SLEEP;
 614
 615             // 0x20
 616
 617             case WLX_SAS_ACTION_SHUTDOWN_HIBERNATE:
 618                 return WLX_SHUTDOWN_STATE_HIBERNATE;
 619
 620             // 0x80
 621         }
 622     }
 623     /* Help file is called directly here */
 624     else if (dlgValue == IDHELP)
 625     {
 626         FIXME("Help is not implemented yet.");
 627         MessageBoxW(hParent, L"Help is not implemented yet.", L"Message", MB_OK | MB_ICONEXCLAMATION);
 628     }
 629     else if (dlgValue == -1)
 630     {
 631         ERR("Failed to create dialog\n");
 632     }
 633
 634     return 0;
 635 }