dll/cpl/powercfg/powershemes.c

   1 /*
   2  * PROJECT:         ReactOS Power Configuration Applet
   3  * LICENSE:         GPL - See COPYING in the top level directory
   4  * FILE:            dll/cpl/powercfg/powershemes.c
   5  * PURPOSE:         powerschemes 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
  15 typedef struct _POWER_SCHEME
  16 {
  17     LIST_ENTRY ListEntry;
  18     UINT uId;
  19     LPTSTR pszName;
  20     LPTSTR pszDescription;
  21     POWER_POLICY PowerPolicy;
  22 } POWER_SCHEME, *PPOWER_SCHEME;
  23
  24
  25 typedef struct _POWER_SCHEMES_PAGE_DATA
  26 {
  27     LIST_ENTRY PowerSchemesList;
  28     PPOWER_SCHEME pActivePowerScheme;
  29 } POWER_SCHEMES_PAGE_DATA, *PPOWER_SCHEMES_PAGE_DATA;
  30
  31
  32 UINT Sec[]=
  33 {
  34     60,
  35     120,
  36     180,
  37     300,
  38     600,
  39     900,
  40     1200,
  41     1500,
  42     1800,
  43     2700,
  44     3600,
  45     7200,
  46     10800,
  47     14400,
  48     18000,
  49     0
  50 };
  51
  52
  53 static
  54 PPOWER_SCHEME
  55 AddPowerScheme(
  56     PPOWER_SCHEMES_PAGE_DATA pPageData,
  57     UINT uId,
  58     DWORD dwName,
  59     LPTSTR pszName,
  60     DWORD dwDescription,
  61     LPWSTR pszDescription,
  62     PPOWER_POLICY pp)
  63 {
  64     PPOWER_SCHEME pScheme;
  65
  66     pScheme = HeapAlloc(GetProcessHeap(),
  67                         HEAP_ZERO_MEMORY,
  68                         sizeof(POWER_SCHEME));
  69     if (pScheme == NULL)
  70         return NULL;
  71
  72     pScheme->pszName = HeapAlloc(GetProcessHeap(),
  73                                  HEAP_ZERO_MEMORY,
  74                                  dwName + sizeof(TCHAR));
  75
  76     pScheme->pszDescription = HeapAlloc(GetProcessHeap(),
  77                                         HEAP_ZERO_MEMORY,
  78                                         dwDescription + sizeof(TCHAR));
  79     if (pScheme->pszName == NULL || pScheme->pszDescription == NULL)
  80     {
  81         if (pScheme->pszName)
  82             HeapFree(GetProcessHeap(), 0, pScheme->pszName);
  83
  84         if (pScheme->pszDescription)
  85             HeapFree(GetProcessHeap(), 0, pScheme->pszDescription);
  86
  87         HeapFree(GetProcessHeap(), 0, pScheme);
  88         return NULL;
  89     }
  90
  91     pScheme->uId = uId;
  92     _tcscpy(pScheme->pszName, pszName);
  93     _tcscpy(pScheme->pszDescription, pszDescription);
  94
  95     CopyMemory(&pScheme->PowerPolicy, pp, sizeof(POWER_POLICY));
  96
  97     InsertTailList(&pPageData->PowerSchemesList, &pScheme->ListEntry);
  98
  99     return pScheme;
 100 }
 101
 102
 103 static
 104 VOID
 105 DeletePowerScheme(
 106     PPOWER_SCHEME pScheme)
 107 {
 108     RemoveEntryList(&pScheme->ListEntry);
 109
 110     if (pScheme->pszName)
 111         HeapFree(GetProcessHeap(), 0, pScheme->pszName);
 112
 113     if (pScheme->pszDescription)
 114         HeapFree(GetProcessHeap(), 0, pScheme->pszDescription);
 115
 116     HeapFree(GetProcessHeap(), 0, pScheme);
 117 }
 118
 119
 120 static
 121 BOOLEAN
 122 CALLBACK
 123 EnumPowerSchemeCallback(
 124     UINT uiIndex,
 125     DWORD dwName,
 126     LPTSTR pszName,
 127     DWORD dwDesc,
 128     LPWSTR pszDesc,
 129     PPOWER_POLICY pp,
 130     LPARAM lParam)
 131 {
 132     if (ValidatePowerPolicies(0, pp))
 133     {
 134         AddPowerScheme((PPOWER_SCHEMES_PAGE_DATA)lParam,
 135                        uiIndex,
 136                        dwName,
 137                        pszName,
 138                        dwDesc,
 139                        pszDesc,
 140                        pp);
 141     }
 142
 143     return TRUE;
 144 }
 145
 146 static
 147 VOID
 148 BuildSchemesList(
 149     PPOWER_SCHEMES_PAGE_DATA pPageData)
 150 {
 151     InitializeListHead(&pPageData->PowerSchemesList);
 152
 153     EnumPwrSchemes(EnumPowerSchemeCallback, (LPARAM)pPageData);
 154 }
 155
 156
 157 static
 158 VOID
 159 DestroySchemesList(
 160     PPOWER_SCHEMES_PAGE_DATA pPageData)
 161 {
 162     PLIST_ENTRY ListEntry;
 163     PPOWER_SCHEME pScheme;
 164
 165     while (!IsListEmpty(&pPageData->PowerSchemesList))
 166     {
 167         ListEntry = pPageData->PowerSchemesList.Flink;
 168         pScheme = CONTAINING_RECORD(ListEntry, POWER_SCHEME, ListEntry);
 169         DeletePowerScheme(pScheme);
 170     }
 171
 172     pPageData->pActivePowerScheme = NULL;
 173 }
 174
 175
 176 BOOLEAN
 177 Pos_InitData(
 178     HWND hwndDlg)
 179 {
 180     SYSTEM_POWER_CAPABILITIES spc;
 181 /*
 182     RECT rectCtl, rectDlg, rectCtl2;
 183     LONG movetop = 0;
 184     LONG moveright = 0;
 185
 186     if (GetWindowRect(hwndDlg,&rectDlg))
 187         {
 188             if (GetWindowRect(GetDlgItem(hwndDlg, IDC_SAT),&rectCtl2))
 189             {
 190                 if (GetWindowRect(GetDlgItem(hwndDlg, IDC_MONITOR),&rectCtl))
 191                 {
 192                     movetop=rectCtl.top - rectCtl2.top;
 193                     MoveWindow(GetDlgItem(hwndDlg, IDC_MONITOR),rectCtl.left-rectDlg.left,rectCtl.top-rectDlg.top-movetop,rectCtl.right-rectCtl.left,rectCtl.bottom-rectCtl.top,FALSE);
 194                     if (GetWindowRect(GetDlgItem(hwndDlg, IDC_DISK),&rectCtl))
 195                     {
 196                         MoveWindow(GetDlgItem(hwndDlg, IDC_DISK),rectCtl.left-rectDlg.left,rectCtl.top-rectDlg.top-movetop,rectCtl.right-rectCtl.left,rectCtl.bottom-rectCtl.top,FALSE);
 197                     }
 198                     if (GetWindowRect(GetDlgItem(hwndDlg, IDC_STANDBY),&rectCtl))
 199                     {
 200                         MoveWindow(GetDlgItem(hwndDlg, IDC_STANDBY),rectCtl.left-rectDlg.left,rectCtl.top-rectDlg.top-movetop,rectCtl.right-rectCtl.left,rectCtl.bottom-rectCtl.top,FALSE);
 201                     }
 202                     if (GetWindowRect(GetDlgItem(hwndDlg, IDC_HIBERNATE),&rectCtl))
 203                     {
 204                         MoveWindow(GetDlgItem(hwndDlg, IDC_HIBERNATE),rectCtl.left-rectDlg.left,rectCtl.top-rectDlg.top-movetop,rectCtl.right-rectCtl.left,rectCtl.bottom-rectCtl.top,FALSE);
 205                     }
 206                     if (GetWindowRect(GetDlgItem(hwndDlg, IDC_MONITORDCLIST),&rectCtl2))
 207                     {
 208                         movetop=movetop-8;
 209                         if (GetWindowRect(GetDlgItem(hwndDlg, IDC_MONITORACLIST),&rectCtl))
 210                         {
 211                             moveright=rectCtl.right - rectCtl2.right;
 212                             MoveWindow(GetDlgItem(hwndDlg, IDC_MONITORACLIST),rectCtl.left-rectDlg.left,rectCtl.top-rectDlg.top-movetop,rectCtl.right-rectCtl.left-moveright,rectCtl.bottom-rectCtl.top,FALSE);
 213                             if (GetWindowRect(GetDlgItem(hwndDlg, IDC_DISKACLIST),&rectCtl))
 214                             {
 215                                 MoveWindow(GetDlgItem(hwndDlg, IDC_DISKACLIST),rectCtl.left-rectDlg.left,rectCtl.top-rectDlg.top-movetop,rectCtl.right-rectCtl.left-moveright,rectCtl.bottom-rectCtl.top,FALSE);
 216                             }
 217                             if (GetWindowRect(GetDlgItem(hwndDlg, IDC_STANDBYACLIST),&rectCtl))
 218                             {
 219                                 MoveWindow(GetDlgItem(hwndDlg, IDC_STANDBYACLIST),rectCtl.left-rectDlg.left,rectCtl.top-rectDlg.top-movetop,rectCtl.right-rectCtl.left-moveright,rectCtl.bottom-rectCtl.top,FALSE);
 220                             }
 221                             if (GetWindowRect(GetDlgItem(hwndDlg, IDC_HIBERNATEACLIST),&rectCtl))
 222                             {
 223                                 MoveWindow(GetDlgItem(hwndDlg, IDC_HIBERNATEACLIST),rectCtl.left-rectDlg.left,rectCtl.top-rectDlg.top-movetop,rectCtl.right-rectCtl.left-moveright,rectCtl.bottom-rectCtl.top,FALSE);
 224                             }
 225                         }
 226                         if (GetWindowRect(GetDlgItem(hwndDlg, IDC_GRPDETAIL),&rectCtl))
 227                         {
 228                             MoveWindow(GetDlgItem(hwndDlg, IDC_GRPDETAIL),rectCtl.left-rectDlg.left,rectCtl.top-rectDlg.top,rectCtl.right-rectCtl.left,rectCtl.bottom-rectCtl.top,FALSE);
 229                         }
 230                     }
 231                 }
 232             }
 233         }
 234     }
 235 */
 236
 237     if (!GetPwrCapabilities(&spc))
 238     {
 239         return FALSE;
 240     }
 241
 242     if (!spc.SystemBatteriesPresent)
 243     {
 244         ShowWindow(GetDlgItem(hwndDlg, IDC_SAT), SW_HIDE);
 245         ShowWindow(GetDlgItem(hwndDlg, IDC_IAC), SW_HIDE);
 246         ShowWindow(GetDlgItem(hwndDlg, IDC_SAC), SW_HIDE);
 247         ShowWindow(GetDlgItem(hwndDlg, IDC_IDC), SW_HIDE);
 248         ShowWindow(GetDlgItem(hwndDlg, IDC_SDC), SW_HIDE);
 249         ShowWindow(GetDlgItem(hwndDlg, IDC_MONITORDCLIST), SW_HIDE);
 250         ShowWindow(GetDlgItem(hwndDlg, IDC_DISKDCLIST), SW_HIDE);
 251         ShowWindow(GetDlgItem(hwndDlg, IDC_STANDBYDCLIST), SW_HIDE);
 252         ShowWindow(GetDlgItem(hwndDlg, IDC_HIBERNATEDCLIST), SW_HIDE);
 253     }
 254
 255     if (!(spc.SystemS1 || spc.SystemS2 || spc.SystemS3))
 256     {
 257         ShowWindow(GetDlgItem(hwndDlg, IDC_STANDBY), SW_HIDE);
 258         ShowWindow(GetDlgItem(hwndDlg, IDC_STANDBYACLIST), SW_HIDE);
 259         ShowWindow(GetDlgItem(hwndDlg, IDC_STANDBYDCLIST), SW_HIDE);
 260     }
 261
 262     if (!spc.HiberFilePresent)
 263     {
 264         ShowWindow(GetDlgItem(hwndDlg, IDC_HIBERNATE), SW_HIDE);
 265         ShowWindow(GetDlgItem(hwndDlg, IDC_HIBERNATEACLIST), SW_HIDE);
 266         ShowWindow(GetDlgItem(hwndDlg, IDC_HIBERNATEDCLIST), SW_HIDE);
 267     }
 268
 269     return TRUE;
 270 }
 271
 272
 273 static
 274 VOID
 275 LoadConfig(
 276     HWND hwndDlg)
 277 {
 278     PPOWER_SCHEME pScheme;
 279     INT i = 0, iCurSel = 0;
 280     TCHAR szTemp[MAX_PATH];
 281     TCHAR szConfig[MAX_PATH];
 282     PPOWER_POLICY pp;
 283
 284     iCurSel = (INT)SendDlgItemMessage(hwndDlg,
 285                                       IDC_ENERGYLIST,
 286                                       CB_GETCURSEL,
 287                                       0,
 288                                       0);
 289     if (iCurSel == CB_ERR)
 290         return;
 291
 292     pScheme = (PPOWER_SCHEME)SendDlgItemMessage(hwndDlg,
 293                                                 IDC_ENERGYLIST,
 294                                                 CB_GETITEMDATA,
 295                                                 (WPARAM)iCurSel,
 296                                                 0);
 297     if (pScheme == (PPOWER_SCHEME)CB_ERR)
 298         return;
 299
 300     if (LoadString(hApplet, IDS_CONFIG1, szTemp, MAX_PATH))
 301     {
 302         _stprintf(szConfig, szTemp, pScheme->pszName);
 303         SetWindowText(GetDlgItem(hwndDlg, IDC_GRPDETAIL), szConfig);
 304     }
 305
 306     pp = &pScheme->PowerPolicy;
 307
 308     for (i = 0; i < 16; i++)
 309     {
 310         if (Sec[i] == pp->user.VideoTimeoutAc)
 311         {
 312             SendDlgItemMessage(hwndDlg, IDC_MONITORACLIST,
 313                         CB_SETCURSEL,
 314                         i,
 315                         (LPARAM)0);
 316         }
 317
 318         if (Sec[i] == pp->user.VideoTimeoutDc)
 319         {
 320             SendDlgItemMessage(hwndDlg, IDC_MONITORDCLIST,
 321                         CB_SETCURSEL,
 322                          i,
 323                          (LPARAM)0);
 324         }
 325
 326         if (Sec[i] == pp->user.SpindownTimeoutAc)
 327         {
 328             SendDlgItemMessage(hwndDlg, IDC_DISKACLIST,
 329                        CB_SETCURSEL,
 330                        i - 2,
 331                        (LPARAM)0);
 332         }
 333
 334         if (Sec[i] == pp->user.SpindownTimeoutDc)
 335         {
 336             SendDlgItemMessage(hwndDlg, IDC_DISKDCLIST,
 337                        CB_SETCURSEL,
 338                        i - 2,
 339                        (LPARAM)0);
 340         }
 341
 342         if (Sec[i] == pp->user.IdleTimeoutAc)
 343         {
 344             SendDlgItemMessage(hwndDlg, IDC_STANDBYACLIST,
 345                        CB_SETCURSEL,
 346                        i,
 347                        (LPARAM)0);
 348         }
 349
 350         if (Sec[i] == pp->user.IdleTimeoutDc)
 351         {
 352             SendDlgItemMessage(hwndDlg, IDC_STANDBYDCLIST,
 353                        CB_SETCURSEL,
 354                        i,
 355                        (LPARAM)0);
 356         }
 357
 358         if (Sec[i] == pp->mach.DozeS4TimeoutAc)
 359         {
 360             SendDlgItemMessage(hwndDlg, IDC_HIBERNATEACLIST,
 361                        CB_SETCURSEL,
 362                        i,
 363                     (LPARAM)0);
 364         }
 365
 366         if (Sec[i] == pp->mach.DozeS4TimeoutDc)
 367         {
 368             SendDlgItemMessage(hwndDlg, IDC_HIBERNATEDCLIST,
 369                        CB_SETCURSEL,
 370                        i,
 371                        (LPARAM)0);
 372         }
 373     }
 374 }
 375
 376
 377 static VOID
 378 Pos_InitPage(HWND hwndDlg)
 379 {
 380     int ifrom = 0, i = 0, imin = 0;
 381     HWND hwnd = NULL;
 382     TCHAR szName[MAX_PATH];
 383     LRESULT index;
 384
 385     for (i = 1; i < 9; i++)
 386     {
 387         switch (i)
 388         {
 389             case 1:
 390                 hwnd = GetDlgItem(hwndDlg, IDC_MONITORACLIST);
 391                 imin = IDS_TIMEOUT1;
 392                 break;
 393
 394             case 2:
 395                 hwnd = GetDlgItem(hwndDlg, IDC_STANDBYACLIST);
 396                 imin = IDS_TIMEOUT1;
 397                 break;
 398
 399             case 3:
 400                 hwnd = GetDlgItem(hwndDlg, IDC_DISKACLIST);
 401                 imin = IDS_TIMEOUT3;
 402                 break;
 403
 404             case 4:
 405                 hwnd = GetDlgItem(hwndDlg, IDC_HIBERNATEACLIST);
 406                 imin = IDS_TIMEOUT3;
 407                 break;
 408
 409             case 5:
 410                 hwnd = GetDlgItem(hwndDlg, IDC_MONITORDCLIST);
 411                 imin = IDS_TIMEOUT1;
 412                 break;
 413
 414             case 6:
 415                 hwnd = GetDlgItem(hwndDlg, IDC_STANDBYDCLIST);
 416                 imin = IDS_TIMEOUT1;
 417                 break;
 418
 419             case 7:
 420                 hwnd = GetDlgItem(hwndDlg, IDC_DISKDCLIST);
 421                 imin = IDS_TIMEOUT3;
 422                 break;
 423
 424             case 8:
 425                 hwnd = GetDlgItem(hwndDlg, IDC_HIBERNATEDCLIST);
 426                 imin = IDS_TIMEOUT3;
 427                 break;
 428
 429             default:
 430                 return;
 431         }
 432
 433         for (ifrom = imin; ifrom < (IDS_TIMEOUT15 + 1); ifrom++)
 434         {
 435             if (LoadString(hApplet, ifrom, szName, MAX_PATH))
 436             {
 437                 index = SendMessage(hwnd,
 438                                      CB_ADDSTRING,
 439                                      0,
 440                                     (LPARAM)szName);
 441                 if (index == CB_ERR)
 442                     return;
 443
 444                 SendMessage(hwnd,
 445                              CB_SETITEMDATA,
 446                              index,
 447                              (LPARAM)Sec[ifrom - IDS_TIMEOUT16]);
 448             }
 449         }
 450
 451         if (LoadString(hApplet, IDS_TIMEOUT16, szName, MAX_PATH))
 452         {
 453             index = SendMessage(hwnd,
 454                                  CB_ADDSTRING,
 455                                  0,
 456                                  (LPARAM)szName);
 457             if (index == CB_ERR)
 458                 return;
 459
 460             SendMessage(hwnd,
 461                          CB_SETITEMDATA,
 462                          index,
 463                          (LPARAM)Sec[0]);
 464         }
 465     }
 466 }
 467
 468
 469 static VOID
 470 Pos_SaveData(HWND hwndDlg)
 471 {
 472     PPOWER_SCHEME pScheme;
 473     INT iCurSel, tmp;
 474
 475     iCurSel = (INT)SendDlgItemMessage(hwndDlg,
 476                                       IDC_ENERGYLIST,
 477                                       CB_GETCURSEL,
 478                                       0,
 479                                       0);
 480     if (iCurSel == CB_ERR)
 481         return;
 482
 483     pScheme = (PPOWER_SCHEME)SendDlgItemMessage(hwndDlg,
 484                                                 IDC_ENERGYLIST,
 485                                                 CB_GETITEMDATA,
 486                                                 (WPARAM)iCurSel,
 487                                                 0);
 488     if (pScheme == (PPOWER_SCHEME)CB_ERR)
 489         return;
 490
 491     tmp = (INT)SendDlgItemMessage(hwndDlg, IDC_MONITORACLIST,
 492                    CB_GETCURSEL,
 493                    0,
 494                    (LPARAM)0);
 495     if (tmp > 0 && tmp < 16)
 496     {
 497         pScheme->PowerPolicy.user.VideoTimeoutAc = Sec[tmp];
 498     }
 499
 500     tmp = (INT)SendDlgItemMessage(hwndDlg, IDC_MONITORDCLIST,
 501                    CB_GETCURSEL,
 502                    0,
 503                    (LPARAM)0);
 504     if (tmp > 0 && tmp < 16)
 505     {
 506         pScheme->PowerPolicy.user.VideoTimeoutDc = Sec[tmp];
 507     }
 508
 509     tmp = (INT)SendDlgItemMessage(hwndDlg, IDC_DISKACLIST,
 510                    CB_GETCURSEL,
 511                    0,
 512                    (LPARAM)0);
 513     if (tmp > 0 && tmp < 16)
 514     {
 515         pScheme->PowerPolicy.user.SpindownTimeoutAc = Sec[tmp + 2];
 516     }
 517
 518     tmp = (INT)SendDlgItemMessage(hwndDlg, IDC_DISKDCLIST,
 519                    CB_GETCURSEL,
 520                    0,
 521                    (LPARAM)0);
 522     if (tmp > 0 && tmp < 16)
 523     {
 524         pScheme->PowerPolicy.user.SpindownTimeoutDc = Sec[tmp + 2];
 525     }
 526
 527     tmp = (INT)SendDlgItemMessage(hwndDlg, IDC_STANDBYACLIST,
 528                    CB_GETCURSEL,
 529                    0,
 530                    (LPARAM)0);
 531     if (tmp > 0 && tmp < 16)
 532     {
 533         pScheme->PowerPolicy.user.IdleTimeoutAc = Sec[tmp];
 534     }
 535
 536     tmp = (INT)SendDlgItemMessage(hwndDlg, IDC_STANDBYDCLIST,
 537                    CB_GETCURSEL,
 538                    0,
 539                    (LPARAM)0);
 540     if (tmp > 0 && tmp < 16)
 541     {
 542         pScheme->PowerPolicy.user.IdleTimeoutDc = Sec[tmp];
 543     }
 544
 545     tmp = (INT)SendDlgItemMessage(hwndDlg, IDC_HIBERNATEACLIST,
 546                    CB_GETCURSEL,
 547                    0,
 548                    (LPARAM)0);
 549     if (tmp > 0 && tmp < 16)
 550     {
 551         pScheme->PowerPolicy.mach.DozeS4TimeoutAc = Sec[tmp];
 552     }
 553
 554     tmp = (INT)SendDlgItemMessage(hwndDlg, IDC_HIBERNATEDCLIST,
 555                    CB_GETCURSEL,
 556                    0,
 557                    (LPARAM)0);
 558     if (tmp > 0 && tmp < 16)
 559     {
 560         pScheme->PowerPolicy.mach.DozeS4TimeoutDc = Sec[tmp];
 561     }
 562
 563     SetActivePwrScheme(iCurSel, NULL, &pScheme->PowerPolicy);
 564     LoadConfig(hwndDlg);
 565 }
 566
 567
 568 static BOOL
 569 DelScheme(HWND hwnd)
 570 {
 571     WCHAR szTitleBuffer[256];
 572     WCHAR szRawBuffer[256], szCookedBuffer[512];
 573     INT iCurSel;
 574     HWND hList;
 575     PPOWER_SCHEME pScheme;
 576
 577     hList = GetDlgItem(hwnd, IDC_ENERGYLIST);
 578
 579     iCurSel = SendMessage(hList, CB_GETCURSEL, 0, 0);
 580     if (iCurSel == CB_ERR)
 581         return FALSE;
 582
 583     SendMessage(hList, CB_SETCURSEL, iCurSel, 0);
 584
 585     pScheme = (PPOWER_SCHEME)SendMessage(hList, CB_GETITEMDATA, (WPARAM)iCurSel, 0);
 586     if (pScheme == (PPOWER_SCHEME)CB_ERR)
 587         return FALSE;
 588
 589     LoadStringW(hApplet, IDS_DEL_SCHEME_TITLE, szTitleBuffer, ARRAYSIZE(szTitleBuffer));
 590     LoadStringW(hApplet, IDS_DEL_SCHEME, szRawBuffer, ARRAYSIZE(szRawBuffer));
 591     StringCchPrintfW(szCookedBuffer, ARRAYSIZE(szCookedBuffer), szRawBuffer, pScheme->pszName);
 592
 593     if (MessageBoxW(hwnd, szCookedBuffer, szTitleBuffer, MB_YESNO | MB_ICONQUESTION | MB_DEFBUTTON2) == IDYES)
 594     {
 595         UINT Current;
 596
 597         if (GetActivePwrScheme(&Current))
 598         {
 599             SendMessage(hList, CB_SETCURSEL, (WPARAM)0, 0);
 600             SendMessage(hList, CB_DELETESTRING, (WPARAM)iCurSel, 0);
 601             if (Current == pScheme->uId)
 602                 Pos_SaveData(hwnd);
 603         }
 604
 605         if (DeletePwrScheme(pScheme->uId) != 0)
 606             return TRUE;
 607     }
 608
 609     return FALSE;
 610 }
 611
 612
 613 static BOOL
 614 CreateEnergyList(
 615     HWND hwndDlg,
 616     PPOWER_SCHEMES_PAGE_DATA pPageData)
 617 {
 618     PLIST_ENTRY ListEntry;
 619     PPOWER_SCHEME pScheme;
 620     INT index;
 621     POWER_POLICY pp;
 622     SYSTEM_POWER_CAPABILITIES spc;
 623     HWND hwndList;
 624     unsigned aps = 0;
 625
 626     hwndList = GetDlgItem(hwndDlg, IDC_ENERGYLIST);
 627
 628     if (!GetActivePwrScheme(&aps))
 629         return FALSE;
 630
 631     if (!ReadGlobalPwrPolicy(&gGPP))
 632         return FALSE;
 633
 634     if (!ReadPwrScheme(aps, &pp))
 635         return FALSE;
 636
 637     if (!ValidatePowerPolicies(&gGPP, 0))
 638         return FALSE;
 639
 640 /*
 641     if (!SetActivePwrScheme(aps, &gGPP, &pp))
 642         return FALSE;
 643 */
 644
 645     if (!GetPwrCapabilities(&spc))
 646         return FALSE;
 647
 648     if (CanUserWritePwrScheme())
 649     {
 650         // TODO:
 651         // Enable write / delete powerscheme button
 652     }
 653
 654     Pos_InitPage(hwndDlg);
 655
 656     if (!GetActivePwrScheme(&aps))
 657         return FALSE;
 658
 659     ListEntry = pPageData->PowerSchemesList.Flink;
 660     while (ListEntry != &pPageData->PowerSchemesList)
 661     {
 662         pScheme = CONTAINING_RECORD(ListEntry, POWER_SCHEME, ListEntry);
 663
 664         index = (int)SendMessage(hwndList,
 665                                  CB_ADDSTRING,
 666                                  0,
 667                                  (LPARAM)pScheme->pszName);
 668         if (index == CB_ERR)
 669             break;
 670
 671         SendMessage(hwndList,
 672                     CB_SETITEMDATA,
 673                     index,
 674                     (LPARAM)pScheme);
 675
 676         if (aps == pScheme->uId)
 677         {
 678             SendMessage(hwndList,
 679                         CB_SELECTSTRING,
 680                         TRUE,
 681                         (LPARAM)pScheme->pszName);
 682
 683             LoadConfig(hwndDlg);
 684         }
 685
 686         ListEntry = ListEntry->Flink;
 687     }
 688
 689     if (SendMessage(hwndList, CB_GETCOUNT, 0, 0) > 0)
 690     {
 691         EnableWindow(GetDlgItem(hwndDlg, IDC_DELETE_BTN), TRUE);
 692         EnableWindow(GetDlgItem(hwndDlg, IDC_SAVEAS_BTN), TRUE);
 693     }
 694
 695     return TRUE;
 696 }
 697
 698
 699 /* Property page dialog callback */
 700 INT_PTR CALLBACK
 701 PowerSchemesDlgProc(
 702     HWND hwndDlg,
 703     UINT uMsg,
 704     WPARAM wParam,
 705     LPARAM lParam)
 706 {
 707     PPOWER_SCHEMES_PAGE_DATA pPageData;
 708
 709     pPageData = (PPOWER_SCHEMES_PAGE_DATA)GetWindowLongPtr(hwndDlg, DWLP_USER);
 710
 711     switch (uMsg)
 712     {
 713         case WM_INITDIALOG:
 714             pPageData = (PPOWER_SCHEMES_PAGE_DATA)HeapAlloc(GetProcessHeap(),
 715                                                             0,
 716                                                             sizeof(PPOWER_SCHEMES_PAGE_DATA));
 717             SetWindowLongPtr(hwndDlg, DWLP_USER, (LONG_PTR)pPageData);
 718
 719             BuildSchemesList(pPageData);
 720
 721             if (!Pos_InitData(hwndDlg))
 722             {
 723                 // TODO:
 724                 // Initialization failed
 725                 // Handle error
 726                 MessageBox(hwndDlg,_T("Pos_InitData failed\n"), NULL, MB_OK);
 727             }
 728
 729             if (!CreateEnergyList(hwndDlg, pPageData))
 730             {
 731                 // TODO:
 732                 // Initialization failed
 733                 // Handle error
 734                 MessageBox(hwndDlg,_T("CreateEnergyList failed\n"), NULL, MB_OK);
 735             }
 736             return TRUE;
 737
 738         case WM_DESTROY:
 739             if (pPageData)
 740             {
 741                 DestroySchemesList(pPageData);
 742                 HeapFree(GetProcessHeap(), 0, pPageData);
 743                 SetWindowLongPtr(hwndDlg, DWLP_USER, (LONG_PTR)NULL);
 744             }
 745             break;
 746
 747         case WM_COMMAND:
 748             switch(LOWORD(wParam))
 749             {
 750                 case IDC_ENERGYLIST:
 751                     if (HIWORD(wParam) == CBN_SELCHANGE)
 752                     {
 753                         LoadConfig(hwndDlg);
 754                         PropSheet_Changed(GetParent(hwndDlg), hwndDlg);
 755                     }
 756                     break;
 757
 758                 case IDC_DELETE_BTN:
 759                     DelScheme(hwndDlg);
 760                     break;
 761
 762                 case IDC_SAVEAS_BTN:
 763                     break;
 764
 765                 case IDC_MONITORACLIST:
 766                 case IDC_MONITORDCLIST:
 767                 case IDC_DISKACLIST:
 768                 case IDC_DISKDCLIST:
 769                 case IDC_STANDBYACLIST:
 770                 case IDC_STANDBYDCLIST:
 771                 case IDC_HIBERNATEACLIST:
 772                 case IDC_HIBERNATEDCLIST:
 773                     if (HIWORD(wParam) == CBN_SELCHANGE)
 774                     {
 775                         PropSheet_Changed(GetParent(hwndDlg), hwndDlg);
 776                     }
 777                     break;
 778             }
 779             break;
 780
 781         case WM_NOTIFY:
 782             {
 783                 LPNMHDR lpnm = (LPNMHDR)lParam;
 784                 if (lpnm->code == (UINT)PSN_APPLY)
 785                 {
 786                     Pos_SaveData(hwndDlg);
 787                 }
 788                 return TRUE;
 789             }
 790             break;
 791     }
 792
 793     return FALSE;
 794 }