dll/cpl/powercfg/advanced.c

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