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