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