dll/cpl/powercfg/advanced.c

   1 /*
   2  * PROJECT:         ReactOS Power Configuration Applet
   3  * LICENSE:         GPL - See COPYING in the top level directory
   4  * FILE:            dll/cpl/powercfg/advanced.c
   5  * PURPOSE:         advanced tab of applet
   6  * PROGRAMMERS:     Alexander Wurzinger (Lohnegrim at gmx dot net)
   7  *                  Johannes Anderwald (johannes.anderwald@reactos.org)
   8  *                  Martin Rottensteiner
   9  *                  Dmitry Chapyshev (lentind@yandex.ru)
  10  */
  11
  12 //#ifndef NSTATUS
  13 //typedef long NTSTATUS;
  14 //#endif
  15
  16 #include "powercfg.h"
  17
  18 HWND hAdv = 0;
  19
  20 static POWER_ACTION g_SystemBatteries[3];
  21 static POWER_ACTION g_PowerButton[5];
  22 static POWER_ACTION g_SleepButton[5];
  23
  24
  25 static VOID
  26 AddItem(HWND hDlgCtrl, INT ResourceId, LPARAM lParam, POWER_ACTION * lpAction)
  27 {
  28   TCHAR szBuffer[MAX_PATH];
  29   LRESULT Index;
  30   if (LoadString(hApplet, ResourceId, szBuffer, MAX_PATH) < MAX_PATH)
  31   {
  32         Index = SendMessage(hDlgCtrl, CB_ADDSTRING, 0, (LPARAM)szBuffer);
  33     if (Index != CB_ERR)
  34         {
  35                 SendMessage(hDlgCtrl, CB_SETITEMDATA, (WPARAM)Index, lParam);
  36                 lpAction[Index] = (POWER_ACTION)lParam;
  37         }
  38   }
  39 }
  40
  41 static INT
  42 FindActionIndex(POWER_ACTION * lpAction, DWORD dwActionSize, POWER_ACTION poAction)
  43 {
  44   INT Index;
  45
  46   for (Index = 0; Index < (INT)dwActionSize; Index++)
  47   {
  48         if (lpAction[Index] == poAction)
  49             return Index;
  50   }
  51
  52   return -1;
  53 }
  54
  55 static BOOLEAN
  56 IsBatteryUsed(VOID)
  57 {
  58         SYSTEM_BATTERY_STATE sbs;
  59
  60         if (CallNtPowerInformation(SystemBatteryState,NULL, (ULONG)0, &sbs, sizeof(SYSTEM_BATTERY_STATE)) == STATUS_SUCCESS)
  61         {
  62                 if (sbs.BatteryPresent)
  63                 {
  64                         if (sbs.AcOnLine)
  65                         {
  66                                 return FALSE;
  67                         }
  68                         return TRUE;
  69                 }
  70         }
  71
  72         return FALSE;
  73 }
  74
  75 POWER_ACTION
  76 GetPowerActionFromPolicy(POWER_ACTION_POLICY *Policy)
  77 {
  78         POWER_ACTION poAction = PowerActionNone;
  79         /*
  80
  81         TCHAR szBuffer[MAX_PATH];
  82
  83         // Note: Windows XP SP2+ does not return the PowerAction code
  84         // for PowerActionWarmEject + PowerActionShutdown but sets it
  85         // to PowerActionNone and sets the Flags & EventCode
  86
  87
  88          _stprintf(szBuffer, L"Action: %x EventCode %x Flags %x",Policy->Action, Policy->EventCode, Policy->Flags);
  89          MessageBoxW(NULL, szBuffer, NULL, MB_OK);
  90
  91         */
  92
  93         if (Policy->Action == PowerActionNone)
  94         {
  95                 if (Policy->Flags == (POWER_ACTION_UI_ALLOWED | POWER_ACTION_QUERY_ALLOWED))
  96                 {
  97                         if (Policy->EventCode  == POWER_FORCE_TRIGGER_RESET)
  98                         {
  99                                 poAction = PowerActionNone;
 100                         }
 101                         else if (Policy->EventCode  == POWER_USER_NOTIFY_BUTTON)
 102                         {
 103                                 poAction = PowerActionWarmEject;
 104                         }
 105                         else if (Policy->EventCode == POWER_USER_NOTIFY_SHUTDOWN)
 106                         {
 107                                 poAction = PowerActionShutdown;
 108                         }
 109                 }
 110         }
 111         else
 112         {
 113                 poAction = Policy->Action;
 114         }
 115
 116         return poAction;
 117 }
 118
 119 VOID
 120 ShowCurrentPowerActionPolicy(HWND hDlgCtrl,
 121                              POWER_ACTION *lpAction,
 122                              DWORD dwActionSize,
 123                              POWER_ACTION_POLICY *Policy)
 124 {
 125         int poActionIndex;
 126         POWER_ACTION poAction;
 127
 128         poAction = GetPowerActionFromPolicy(Policy);
 129         poActionIndex = FindActionIndex(lpAction, dwActionSize, poAction);
 130
 131         if (poActionIndex < 0)
 132         {
 133                 return;
 134         }
 135
 136         SendMessage(hDlgCtrl, CB_SETCURSEL, (WPARAM)poActionIndex, (LPARAM)0);
 137 }
 138
 139 BOOLEAN
 140 SaveCurrentPowerActionPolicy(IN HWND hDlgCtrl,
 141                              OUT POWER_ACTION_POLICY *Policy)
 142 {
 143         LRESULT Index;
 144         LRESULT ItemData;
 145
 146         Index = SendMessage(hDlgCtrl, CB_GETCURSEL, 0, 0);
 147         if (Index == CB_ERR)
 148                 return FALSE;
 149
 150         ItemData = SendMessage(hDlgCtrl, CB_GETITEMDATA, (WPARAM)Index, 0);
 151         if (ItemData == CB_ERR)
 152                 return FALSE;
 153
 154         switch(ItemData)
 155         {
 156         case PowerActionNone:
 157                 Policy->Action = PowerActionNone;
 158                 Policy->EventCode  = POWER_FORCE_TRIGGER_RESET;
 159                 break;
 160         case PowerActionWarmEject:
 161                 Policy->Action = PowerActionNone;
 162                 Policy->EventCode  = POWER_USER_NOTIFY_BUTTON;
 163                 break;
 164         case PowerActionShutdown:
 165                 Policy->Action = PowerActionNone;
 166                 Policy->EventCode = POWER_USER_NOTIFY_SHUTDOWN;
 167                 break;
 168         case PowerActionSleep:
 169         case PowerActionHibernate:
 170                 Policy->Action = (POWER_ACTION)ItemData;
 171                 Policy->EventCode = 0;
 172                 break;
 173         default:
 174                 return FALSE;
 175         }
 176         Policy->Flags = (POWER_ACTION_UI_ALLOWED | POWER_ACTION_QUERY_ALLOWED);
 177
 178         return TRUE;
 179 }
 180
 181
 182 //-------------------------------------------------------------------
 183
 184 VOID
 185 ShowCurrentPowerActionPolicies(HWND hwndDlg)
 186 {
 187         TCHAR szAction[MAX_PATH];
 188
 189         if (!IsBatteryUsed())
 190         {
 191 #if 0
 192                 /* expiremental code */
 193 //              ShowCurrentPowerButtonAcAction(hList2,
 194                 ShowCurrentPowerActionPolicy(GetDlgItem(hwndDlg, IDC_POWERBUTTON),
 195                                                                            g_SystemBatteries,
 196                                                                            sizeof(g_SystemBatteries) / sizeof(POWER_ACTION),
 197                                                                            &gGPP.user.LidCloseAc);
 198 #else
 199                 if (LoadString(hApplet, IDS_PowerActionNone1+gGPP.user.LidCloseAc.Action, szAction, MAX_PATH))
 200                 {
 201                         SendDlgItemMessage(hwndDlg, IDC_LIDCLOSE,
 202                                                  CB_SELECTSTRING,
 203                                                  TRUE,
 204                                                  (LPARAM)szAction);
 205                 }
 206 #endif
 207                 ShowCurrentPowerActionPolicy(GetDlgItem(hwndDlg, IDC_POWERBUTTON),
 208                                                                            g_PowerButton,
 209                                                                            sizeof(g_PowerButton) / sizeof(POWER_ACTION),
 210                                                                            &gGPP.user.PowerButtonAc);
 211
 212 #if 0
 213                         /* expiremental code */
 214                 ShowCurrentPowerActionPolicy(GetDlgItem(hwndDlg, IDC_SLEEPBUTTON),
 215                                                                            g_SleepButton,
 216                                                                            sizeof(g_SleepButton) / sizeof(POWER_ACTION),
 217                                                                            &gGPP.user.SleepButtonAc);
 218 #else
 219                 if (LoadString(hApplet, IDS_PowerActionNone1+gGPP.user.SleepButtonAc.Action, szAction, MAX_PATH))
 220                 {
 221                         SendDlgItemMessage(hwndDlg, IDC_SLEEPBUTTON,
 222                                                  CB_SELECTSTRING,
 223                                                  TRUE,
 224                                                  (LPARAM)szAction);
 225                 }
 226 #endif
 227         }
 228         else
 229         {
 230 #if 0
 231
 232                 ShowCurrentPowerActionPolicy(GetDlgItem(hwndDlg, IDC_LIDCLOSE),
 233                                                                            g_SleepButton,
 234                                                                            sizeof(g_SleepButton) / sizeof(POWER_ACTION),
 235                                                                            &gGPP.user.LidCloseDc);
 236
 237                 ShowCurrentPowerActionPolicy(GetDlgItem(hwndDlg, IDC_POWERBUTTON),
 238                                                                            g_SleepButton,
 239                                                                            sizeof(g_SleepButton) / sizeof(POWER_ACTION),
 240                                                                            &gGPP.user.PowerButtonDc);
 241
 242                 ShowCurrentPowerActionPolicy(GetDlgItem(hwndDlg, IDC_SLEEPBUTTON),
 243                                                                            g_SleepButton,
 244                                                                            sizeof(g_SleepButton) / sizeof(POWER_ACTION),
 245                                                                            &gGPP.user.SleepButtonDc);
 246 #else
 247                 if (LoadString(hApplet, IDS_PowerActionNone1+gGPP.user.LidCloseDc.Action, szAction, MAX_PATH))
 248                 {
 249                         SendDlgItemMessage(hwndDlg, IDC_LIDCLOSE,
 250                                                  CB_SELECTSTRING,
 251                                                  TRUE,
 252                                                  (LPARAM)szAction);
 253                 }
 254                 if (LoadString(hApplet, IDS_PowerActionNone1+gGPP.user.PowerButtonDc.Action, szAction, MAX_PATH))
 255                 {
 256                         SendDlgItemMessage(hwndDlg, IDC_POWERBUTTON,
 257                                                  CB_SELECTSTRING,
 258                                                  TRUE,
 259                                                  (LPARAM)szAction);
 260                 }
 261                 if (LoadString(hApplet, IDS_PowerActionNone1+gGPP.user.SleepButtonDc.Action, szAction, MAX_PATH))
 262                 {
 263                         SendDlgItemMessage(hwndDlg, IDC_SLEEPBUTTON,
 264                                                  CB_SELECTSTRING,
 265                                                  TRUE,
 266                                                  (LPARAM)szAction);
 267                 }
 268 #endif
 269         }
 270 }
 271
 272 VOID
 273 Adv_InitDialog(VOID)
 274 {
 275         HWND hList1;
 276         HWND hList2;
 277         HWND hList3;
 278
 279         BOOLEAN bSuspend = FALSE;
 280         BOOLEAN bHibernate;
 281         BOOLEAN bShutdown;
 282
 283         SYSTEM_POWER_CAPABILITIES spc;
 284
 285         CheckDlgButton(hAdv,
 286                 IDC_SYSTRAYBATTERYMETER,
 287                 gGPP.user.GlobalFlags & EnableSysTrayBatteryMeter ? BST_CHECKED : BST_UNCHECKED);
 288         CheckDlgButton(hAdv,
 289                 IDC_PASSWORDLOGON,
 290                 gGPP.user.GlobalFlags & EnablePasswordLogon ? BST_CHECKED : BST_UNCHECKED);
 291         CheckDlgButton(hAdv,
 292                 IDC_VIDEODIMDISPLAY,
 293                 gGPP.user.GlobalFlags & EnableVideoDimDisplay ? BST_CHECKED : BST_UNCHECKED);
 294
 295         GetPwrCapabilities(&spc);
 296
 297         if (spc.SystemS1 || spc.SystemS2 || spc.SystemS3)
 298                 bSuspend=TRUE;
 299
 300         bHibernate = spc.HiberFilePresent;
 301         bShutdown = spc.SystemS5;
 302
 303         hList1 = GetDlgItem(hAdv, IDC_LIDCLOSE);
 304         SendMessage(hList1, CB_RESETCONTENT, 0, 0);
 305
 306         memset(g_SystemBatteries, 0x0, sizeof(g_SystemBatteries));
 307         if (spc.SystemBatteriesPresent)
 308         {
 309                 AddItem(hList1, IDS_PowerActionNone1, (LPARAM)PowerActionNone, g_SystemBatteries);
 310
 311                 if (bSuspend)
 312                 {
 313                         AddItem(hList1, IDS_PowerActionSleep, (LPARAM)PowerActionSleep, g_SystemBatteries);
 314                 }
 315
 316                 if (bHibernate)
 317                 {
 318                         AddItem(hList1, IDS_PowerActionHibernate, (LPARAM)PowerActionHibernate, g_SystemBatteries);
 319                 }
 320         }
 321         else
 322         {
 323                 ShowWindow(GetDlgItem(hAdv, IDC_VIDEODIMDISPLAY), FALSE);
 324                 ShowWindow(GetDlgItem(hAdv, IDC_SLIDCLOSE), FALSE);
 325                 ShowWindow(hList1, FALSE);
 326         }
 327
 328         hList2 = GetDlgItem(hAdv, IDC_POWERBUTTON);
 329         SendMessage(hList2, CB_RESETCONTENT, 0, 0);
 330
 331         memset(g_PowerButton, 0x0, sizeof(g_PowerButton));
 332         if (spc.PowerButtonPresent)
 333         {
 334                 AddItem(hList2, IDS_PowerActionNone1, (LPARAM)PowerActionNone, g_PowerButton);
 335                 AddItem(hList2, IDS_PowerActionWarmEject, (LPARAM)PowerActionWarmEject, g_PowerButton);
 336
 337                 if (bSuspend)
 338                 {
 339                         AddItem(hList2, IDS_PowerActionSleep, (LPARAM)PowerActionSleep, g_PowerButton);
 340                 }
 341
 342                 if (bHibernate)
 343                 {
 344                         AddItem(hList2, IDS_PowerActionHibernate, (LPARAM)PowerActionHibernate, g_PowerButton);
 345
 346                 }
 347                 if (bShutdown)
 348                 {
 349                         AddItem(hList2, IDS_PowerActionShutdown, (LPARAM)PowerActionShutdown, g_PowerButton);
 350                 }
 351         }
 352         else
 353         {
 354                 ShowWindow(GetDlgItem(hAdv, IDC_SPOWERBUTTON), FALSE);
 355                 ShowWindow(hList2, FALSE);
 356         }
 357
 358         hList3=GetDlgItem(hAdv, IDC_SLEEPBUTTON);
 359         SendMessage(hList3, CB_RESETCONTENT, 0, 0);
 360     memset(g_SleepButton, 0x0, sizeof(g_SleepButton));
 361
 362         if (spc.SleepButtonPresent)
 363         {
 364                 AddItem(hList3, IDS_PowerActionNone1, (LPARAM)PowerActionNone, g_SleepButton);
 365                 AddItem(hList3, IDS_PowerActionWarmEject, (LPARAM)PowerActionWarmEject, g_SleepButton);
 366
 367                 if (bSuspend)
 368                 {
 369                         AddItem(hList3, IDS_PowerActionSleep, (LPARAM)PowerActionSleep, g_SleepButton);
 370                 }
 371
 372                 if (bHibernate)
 373                 {
 374                         AddItem(hList3, IDS_PowerActionHibernate, (LPARAM)PowerActionHibernate, g_SleepButton);
 375                 }
 376
 377                 if (bShutdown)
 378                 {
 379                         AddItem(hList3, IDS_PowerActionShutdown, (LPARAM)PowerActionShutdown, g_SleepButton);
 380                 }
 381         }
 382         else
 383         {
 384                 ShowWindow(GetDlgItem(hAdv, IDC_SSLEEPBUTTON), FALSE);
 385                 ShowWindow(hList3, FALSE);
 386         }
 387
 388         if (ReadGlobalPwrPolicy(&gGPP))
 389         {
 390                 ShowCurrentPowerActionPolicies(hAdv);
 391         }
 392 }
 393
 394 static VOID
 395 Adv_SaveData(HWND hwndDlg)
 396 {
 397         BOOL bSystrayBatteryMeter;
 398         BOOL bPasswordLogon;
 399         BOOL bVideoDimDisplay;
 400
 401         bSystrayBatteryMeter =
 402                 (IsDlgButtonChecked(hwndDlg, IDC_SYSTRAYBATTERYMETER) == BST_CHECKED);
 403
 404         bPasswordLogon =
 405                 (IsDlgButtonChecked(hwndDlg, IDC_PASSWORDLOGON) == BST_CHECKED);
 406
 407         bVideoDimDisplay =
 408                 (IsDlgButtonChecked(hwndDlg, IDC_VIDEODIMDISPLAY) == BST_CHECKED);
 409
 410         if (bSystrayBatteryMeter)
 411         {
 412                 if (!(gGPP.user.GlobalFlags & EnableSysTrayBatteryMeter))
 413                 {
 414                         gGPP.user.GlobalFlags = gGPP.user.GlobalFlags + EnableSysTrayBatteryMeter;
 415                 }
 416         }
 417         else
 418         {
 419                 if ((gGPP.user.GlobalFlags & EnableSysTrayBatteryMeter))
 420                 {
 421                         gGPP.user.GlobalFlags = gGPP.user.GlobalFlags - EnableSysTrayBatteryMeter;
 422                 }
 423         }
 424
 425         if (bPasswordLogon)
 426         {
 427                 if (!(gGPP.user.GlobalFlags & EnablePasswordLogon))
 428                 {
 429                         gGPP.user.GlobalFlags = gGPP.user.GlobalFlags + EnablePasswordLogon;
 430                 }
 431         }
 432         else
 433         {
 434                 if ((gGPP.user.GlobalFlags & EnablePasswordLogon))
 435                 {
 436                         gGPP.user.GlobalFlags = gGPP.user.GlobalFlags - EnablePasswordLogon;
 437                 }
 438         }
 439
 440         if (bVideoDimDisplay)
 441         {
 442                 if (!(gGPP.user.GlobalFlags & EnableVideoDimDisplay))
 443                 {
 444                         gGPP.user.GlobalFlags = gGPP.user.GlobalFlags + EnableVideoDimDisplay;
 445                 }
 446         }
 447         else
 448         {
 449                 if ((gGPP.user.GlobalFlags & EnableVideoDimDisplay))
 450                 {
 451                         gGPP.user.GlobalFlags = gGPP.user.GlobalFlags - EnableVideoDimDisplay;
 452                 }
 453         }
 454
 455         if (!IsBatteryUsed())
 456         {
 457                 SaveCurrentPowerActionPolicy(GetDlgItem(hwndDlg, IDC_POWERBUTTON), &gGPP.user.PowerButtonAc);
 458 #if 0
 459                 SaveCurrentPowerActionPolicy(GetDlgItem(hwndDlg, IDC_LIDCLOSE), &gGPP.user.LidCloseAc);
 460                 SaveCurrentPowerActionPolicy(GetDlgItem(hwndDlg, IDC_SLEEPBUTTON), &gGPP.user.SleepButtonAc);
 461 #endif
 462         }
 463         else
 464         {
 465 #if 0
 466                 SaveCurrentPowerActionPolicy(GetDlgItem(hwndDlg, IDC_POWERBUTTON), &gGPP.user.PowerButtonDc);
 467                 SaveCurrentPowerActionPolicy(GetDlgItem(hwndDlg, IDC_LIDCLOSE), &gGPP.user.LidCloseDc);
 468                 SaveCurrentPowerActionPolicy(GetDlgItem(hwndDlg, IDC_SLEEPBUTTON), &gGPP.user.SleepButtonDc);
 469 #endif
 470         }
 471
 472         if (!WriteGlobalPwrPolicy(&gGPP))
 473         {
 474                 MessageBox(hwndDlg, L"WriteGlobalPwrPolicy failed", NULL, MB_OK);
 475         }
 476
 477         Adv_InitDialog();
 478 }
 479
 480 /* Property page dialog callback */
 481 INT_PTR CALLBACK
 482 AdvancedDlgProc(HWND hwndDlg,
 483                 UINT uMsg,
 484                 WPARAM wParam,
 485                 LPARAM lParam)
 486 {
 487   switch(uMsg)
 488   {
 489     case WM_INITDIALOG:
 490                 hAdv = hwndDlg;
 491                 Adv_InitDialog();
 492                 return TRUE;
 493       break;
 494         case WM_COMMAND:
 495                 switch(LOWORD(wParam))
 496                 {
 497                 case IDC_SYSTRAYBATTERYMETER:
 498                 case IDC_PASSWORDLOGON:
 499                 case IDC_VIDEODIMDISPLAY:
 500                         if (HIWORD(wParam) == BN_CLICKED)
 501                         {
 502                                 PropSheet_Changed(GetParent(hwndDlg), hwndDlg);
 503                         }
 504                         break;
 505                 case IDC_LIDCLOSE:
 506                 case IDC_POWERBUTTON:
 507                 case IDC_SLEEPBUTTON:
 508                         if (HIWORD(wParam) == CBN_SELCHANGE)
 509                         {
 510                                 PropSheet_Changed(GetParent(hwndDlg), hwndDlg);
 511                         }
 512                         break;
 513                 }
 514                 break;
 515         case WM_NOTIFY:
 516                 {
 517                         LPNMHDR lpnm = (LPNMHDR)lParam;
 518                         if (lpnm->code == (UINT)PSN_APPLY)
 519                         {
 520                                 Adv_SaveData(hwndDlg);
 521                         }
 522                         return TRUE;
 523                 }
 524   }
 525   return FALSE;
 526 }