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