ReactOS Development > Doxygen

00001 /*
00002  * COPYRIGHT:       See COPYING in the top level directory
00003  * PROJECT:         ReactOS Display Control Panel
00004  * FILE:            dll/cpl/desk/screensaver.c
00005  * PURPOSE:         Screen saver property page
00006  *
00007  * PROGRAMMERS:     Trevor McCort (lycan359@gmail.com)
00008  *                  Ged Murphy (gedmurphy@reactos.org)
00009  */
00010 
00011 #include "desk.h"
00012 
00013 #define MAX_SCREENSAVERS 100
00014 
00015 typedef struct
00016 {
00017     BOOL  bIsScreenSaver; /* Is this background a wallpaper */
00018     TCHAR szFilename[MAX_PATH];
00019     TCHAR szDisplayName[256];
00020 } ScreenSaverItem;
00021 
00022 
00023 typedef struct _DATA
00024 {
00025     ScreenSaverItem     ScreenSaverItems[MAX_SCREENSAVERS];
00026     PROCESS_INFORMATION PrevWindowPi;
00027     int                 Selection;
00028     UINT                ScreenSaverCount;
00029 } DATA, *PDATA;
00030 
00031 
00032 static LPTSTR
00033 GetCurrentScreenSaverValue(LPTSTR lpValue)
00034 {
00035     HKEY hKey;
00036     LPTSTR lpBuf = NULL;
00037     DWORD BufSize, Type = REG_SZ;
00038     LONG Ret;
00039 
00040     Ret = RegOpenKeyEx(HKEY_CURRENT_USER,
00041                        _T("Control Panel\\Desktop"),
00042                        0,
00043                        KEY_READ,
00044                        &hKey);
00045     if (Ret != ERROR_SUCCESS)
00046         return NULL;
00047 
00048     Ret = RegQueryValueEx(hKey,
00049                           lpValue,
00050                           0,
00051                           &Type,
00052                           NULL,
00053                           &BufSize);
00054     if (Ret == ERROR_SUCCESS)
00055     {
00056         lpBuf = HeapAlloc(GetProcessHeap(),
00057                           0,
00058                           BufSize);
00059         if (lpBuf)
00060         {
00061             Ret = RegQueryValueEx(hKey,
00062                                   lpValue,
00063                                   0,
00064                                   &Type,
00065                                   (LPBYTE)lpBuf,
00066                                   &BufSize);
00067             if (Ret != ERROR_SUCCESS)
00068                 lpBuf = NULL;
00069         }
00070     }
00071 
00072     RegCloseKey(hKey);
00073 
00074     return lpBuf;
00075 }
00076 
00077 
00078 static VOID
00079 SelectionChanged(HWND hwndDlg, PDATA pData)
00080 {
00081     HWND hwndCombo;
00082     BOOL bEnable;
00083     INT i;
00084 
00085     hwndCombo = GetDlgItem(hwndDlg, IDC_SCREENS_LIST);
00086 
00087     i = (INT)SendMessage(hwndCombo, CB_GETCURSEL, 0, 0);
00088     i = (INT)SendMessage(hwndCombo, CB_GETITEMDATA, i, 0);
00089 
00090     pData->Selection = i;
00091 
00092     bEnable = (i != 0);
00093 
00094     EnableWindow(GetDlgItem(hwndDlg, IDC_SCREENS_SETTINGS), bEnable);
00095     EnableWindow(GetDlgItem(hwndDlg, IDC_SCREENS_TESTSC), bEnable);
00096     EnableWindow(GetDlgItem(hwndDlg, IDC_SCREENS_USEPASSCHK), bEnable);
00097     EnableWindow(GetDlgItem(hwndDlg, IDC_SCREENS_TIMEDELAY), bEnable);
00098     EnableWindow(GetDlgItem(hwndDlg, IDC_SCREENS_TIME), bEnable);
00099     EnableWindow(GetDlgItem(hwndDlg, IDC_WAITTEXT), bEnable);
00100     EnableWindow(GetDlgItem(hwndDlg, IDC_MINTEXT), bEnable);
00101 }
00102 
00103 
00104 static VOID
00105 SetScreenSaverPreviewBox(HWND hwndDlg, PDATA pData)
00106 {
00107     HWND hPreview = GetDlgItem(hwndDlg, IDC_SCREENS_PREVIEW);
00108     STARTUPINFO si;
00109     TCHAR szCmdline[2048];
00110 
00111     /* Kill off the previous preview process */
00112     if (pData->PrevWindowPi.hProcess)
00113     {
00114         TerminateProcess(pData->PrevWindowPi.hProcess, 0);
00115         CloseHandle(pData->PrevWindowPi.hProcess);
00116         CloseHandle(pData->PrevWindowPi.hThread);
00117         pData->PrevWindowPi.hThread = pData->PrevWindowPi.hProcess = NULL;
00118     }
00119 
00120     if (pData->Selection > 0)
00121     {
00122         _stprintf(szCmdline,
00123                   _T("%s /p %u"),
00124                   pData->ScreenSaverItems[pData->Selection].szFilename,
00125                   hPreview);
00126 
00127         ZeroMemory(&si, sizeof(si));
00128         si.cb = sizeof(si);
00129         ZeroMemory(&pData->PrevWindowPi, sizeof(pData->PrevWindowPi));
00130 
00131         if (!CreateProcess(NULL,
00132                            szCmdline,
00133                            NULL,
00134                            NULL,
00135                            FALSE,
00136                            0,
00137                            NULL,
00138                            NULL,
00139                            &si,
00140                            &pData->PrevWindowPi))
00141         {
00142             pData->PrevWindowPi.hThread = pData->PrevWindowPi.hProcess = NULL;
00143         }
00144     }
00145 }
00146 
00147 static BOOL
00148 WaitForSettingsDialog(HWND hwndDlg,
00149                       HANDLE hProcess)
00150 {
00151     DWORD dwResult;
00152     MSG msg;
00153 
00154     while (TRUE)
00155     {
00156         dwResult = MsgWaitForMultipleObjects(1,
00157                                              &hProcess,
00158                                              FALSE,
00159                                              INFINITE,
00160                                              QS_ALLINPUT);
00161         if (dwResult == WAIT_OBJECT_0 + 1)
00162         {
00163             if (PeekMessage(&msg, NULL, 0, 0, PM_REMOVE))
00164             {
00165                 if (msg.message == WM_QUIT)
00166                 {
00167                     return FALSE;
00168                 }
00169                 if (IsDialogMessage(hwndDlg, &msg))
00170                 {
00171                     TranslateMessage(&msg);
00172                     DispatchMessage(&msg);
00173                 }
00174             }
00175         }
00176         else
00177         {
00178             return TRUE;
00179         }
00180     }
00181 }
00182 
00183 
00184 static VOID
00185 ScreensaverConfig(HWND hwndDlg, PDATA pData)
00186 {
00187     /*
00188        /c:<hwnd>  Run configuration, hwnd is handle of calling window
00189     */
00190 
00191     TCHAR szCmdline[2048];
00192     STARTUPINFO si;
00193     PROCESS_INFORMATION pi;
00194 
00195     if (pData->Selection < 1)
00196         return;
00197 
00198     _stprintf(szCmdline,
00199               _T("%s /c:%u"),
00200               pData->ScreenSaverItems[pData->Selection].szFilename,
00201               hwndDlg);
00202 
00203     ZeroMemory(&si, sizeof(si));
00204     si.cb = sizeof(si);
00205     ZeroMemory(&pi, sizeof(pi));
00206     if(CreateProcess(NULL,
00207                      szCmdline,
00208                      NULL,
00209                      NULL,
00210                      FALSE,
00211                      0,
00212                      NULL,
00213                      NULL,
00214                      &si,
00215                      &pi))
00216     {
00217         /* Kill off the previous preview process */
00218         if (pData->PrevWindowPi.hProcess)
00219         {
00220             TerminateProcess(pData->PrevWindowPi.hProcess, 0);
00221             CloseHandle(pData->PrevWindowPi.hProcess);
00222             CloseHandle(pData->PrevWindowPi.hThread);
00223             pData->PrevWindowPi.hThread = pData->PrevWindowPi.hProcess = NULL;
00224         }
00225 
00226         if (WaitForSettingsDialog(hwndDlg, pi.hProcess))
00227             SetScreenSaverPreviewBox(hwndDlg, pData);
00228     }
00229 }
00230 
00231 
00232 static VOID
00233 ScreensaverPreview(HWND hwndDlg, PDATA pData)
00234 {
00235     /*
00236        /s         Run normal
00237     */
00238 
00239     TCHAR szCmdline[2048];
00240     STARTUPINFO si;
00241     PROCESS_INFORMATION pi;
00242 
00243     if (pData->Selection < 1)
00244         return;
00245 
00246     /* Kill off the previous preview process */
00247     if (pData->PrevWindowPi.hProcess)
00248     {
00249         TerminateProcess(pData->PrevWindowPi.hProcess, 0);
00250         CloseHandle(pData->PrevWindowPi.hProcess);
00251         CloseHandle(pData->PrevWindowPi.hThread);
00252         pData->PrevWindowPi.hThread = pData->PrevWindowPi.hProcess = NULL;
00253     }
00254 
00255     _stprintf(szCmdline,
00256               _T("%s /s"),
00257               pData->ScreenSaverItems[pData->Selection].szFilename);
00258 
00259     ZeroMemory(&si, sizeof(si));
00260     si.cb = sizeof(si);
00261     ZeroMemory(&pi, sizeof(pi));
00262     if(CreateProcess(NULL,
00263                      szCmdline,
00264                      NULL,
00265                      NULL,
00266                      FALSE,
00267                      0,
00268                      NULL,
00269                      NULL,
00270                      &si,
00271                      &pi))
00272     {
00273         WaitForSingleObject(pi.hProcess, INFINITE);
00274         CloseHandle(pi.hProcess);
00275         CloseHandle(pi.hThread);
00276     }
00277 }
00278 
00279 
00280 static VOID
00281 CheckRegScreenSaverIsSecure(HWND hwndDlg)
00282 {
00283     HKEY hKey;
00284     TCHAR szBuffer[2];
00285     DWORD bufferSize = sizeof(szBuffer);
00286     DWORD varType = REG_SZ;
00287     LONG result;
00288 
00289     if (RegOpenKeyEx(HKEY_CURRENT_USER,
00290                      _T("Control Panel\\Desktop"),
00291                      0,
00292                      KEY_ALL_ACCESS,
00293                      &hKey) == ERROR_SUCCESS)
00294     {
00295         result = RegQueryValueEx(hKey,
00296                                 _T("ScreenSaverIsSecure"),
00297                                 0,
00298                                 &varType,
00299                                 (LPBYTE)szBuffer,
00300                                 &bufferSize);
00301         RegCloseKey(hKey);
00302 
00303         if (result == ERROR_SUCCESS)
00304         {
00305             if (_ttoi(szBuffer) == 1)
00306             {
00307                 SendDlgItemMessage(hwndDlg,
00308                                    IDC_SCREENS_USEPASSCHK,
00309                                    BM_SETCHECK,
00310                                    (WPARAM)BST_CHECKED,
00311                                    0);
00312                 return;
00313             }
00314         }
00315 
00316         SendDlgItemMessage(hwndDlg,
00317                            IDC_SCREENS_USEPASSCHK,
00318                            BM_SETCHECK,
00319                            (WPARAM)BST_UNCHECKED,
00320                            0);
00321     }
00322 }
00323 
00324 
00325 static VOID
00326 SearchScreenSavers(HWND hwndScreenSavers,
00327                    LPCTSTR pszSearchPath,
00328                    PDATA pData)
00329 {
00330     WIN32_FIND_DATA  fd;
00331     TCHAR            szSearchPath[MAX_PATH];
00332     HANDLE           hFind;
00333     ScreenSaverItem *ScreenSaverItem;
00334     HANDLE           hModule;
00335     UINT             i, ScreenSaverCount;
00336 
00337     ScreenSaverCount = pData->ScreenSaverCount;
00338 
00339     _tcscpy(szSearchPath, pszSearchPath);
00340     _tcscat(szSearchPath, TEXT("\\*.scr"));
00341 
00342     hFind = FindFirstFile(szSearchPath, &fd);
00343 
00344     if (hFind == INVALID_HANDLE_VALUE)
00345         return;
00346 
00347     while (ScreenSaverCount < MAX_SCREENSAVERS)
00348     {
00349         /* Don't add any hidden screensavers */
00350         if ((fd.dwFileAttributes & FILE_ATTRIBUTE_HIDDEN) == 0)
00351         {
00352             TCHAR filename[MAX_PATH];
00353 
00354             _tcscpy(filename, pszSearchPath);
00355             _tcscat(filename, _T("\\"));
00356             _tcscat(filename, fd.cFileName);
00357 
00358             ScreenSaverItem = pData->ScreenSaverItems + ScreenSaverCount;
00359 
00360             ScreenSaverItem->bIsScreenSaver = TRUE;
00361 
00362             hModule = LoadLibraryEx(filename,
00363                                     NULL,
00364                                     DONT_RESOLVE_DLL_REFERENCES | LOAD_LIBRARY_AS_DATAFILE);
00365             if (hModule)
00366             {
00367                 if (0 == LoadString(hModule,
00368                           1,
00369                           ScreenSaverItem->szDisplayName,
00370                           sizeof(ScreenSaverItem->szDisplayName) / sizeof(TCHAR)))
00371                 {
00372                     // If the string does not exists, copy the name of the file
00373                     _tcscpy(ScreenSaverItem->szDisplayName, fd.cFileName);
00374                     ScreenSaverItem->szDisplayName[_tcslen(fd.cFileName)-4] = '\0';
00375                 }
00376                 FreeLibrary(hModule);
00377             }
00378             else
00379             {
00380                _tcscpy(ScreenSaverItem->szDisplayName, _T("Unknown"));
00381             }
00382 
00383             _tcscpy(ScreenSaverItem->szFilename, filename);
00384 
00385             i = SendMessage(hwndScreenSavers,
00386                             CB_ADDSTRING,
00387                             0,
00388                             (LPARAM)ScreenSaverItem->szDisplayName);
00389 
00390             SendMessage(hwndScreenSavers,
00391                         CB_SETITEMDATA,
00392                         i,
00393                         (LPARAM)ScreenSaverCount);
00394 
00395             ScreenSaverCount++;
00396         }
00397 
00398         if (!FindNextFile(hFind, &fd))
00399             break;
00400     }
00401 
00402     FindClose(hFind);
00403 
00404     pData->ScreenSaverCount = ScreenSaverCount;
00405 }
00406 
00407 
00408 static VOID
00409 AddScreenSavers(HWND hwndDlg, PDATA pData)
00410 {
00411     HWND hwndScreenSavers = GetDlgItem(hwndDlg, IDC_SCREENS_LIST);
00412     TCHAR szSearchPath[MAX_PATH];
00413     TCHAR szLocalPath[MAX_PATH];
00414     INT i;
00415     ScreenSaverItem *ScreenSaverItem = NULL;
00416     LPTSTR lpBackSlash;
00417 
00418     /* Add the "None" item */
00419     ScreenSaverItem = pData->ScreenSaverItems;
00420 
00421     ScreenSaverItem->bIsScreenSaver = FALSE;
00422 
00423     LoadString(hApplet,
00424                IDS_NONE,
00425                ScreenSaverItem->szDisplayName,
00426                sizeof(ScreenSaverItem->szDisplayName) / sizeof(TCHAR));
00427 
00428     i = SendMessage(hwndScreenSavers,
00429                     CB_ADDSTRING,
00430                     0,
00431                     (LPARAM)ScreenSaverItem->szDisplayName);
00432 
00433     SendMessage(hwndScreenSavers,
00434                 CB_SETITEMDATA,
00435                 i,
00436                 (LPARAM)0);
00437 
00438     // Initialize number of items into the list
00439     pData->ScreenSaverCount = 1;
00440 
00441     // Add all the screensavers where the applet is stored.
00442     GetModuleFileName(hApplet, szLocalPath, MAX_PATH);
00443     lpBackSlash = _tcsrchr(szLocalPath, _T('\\'));
00444     if (lpBackSlash != NULL)
00445     {
00446         *lpBackSlash = '\0';
00447         SearchScreenSavers(hwndScreenSavers, szLocalPath, pData);
00448     }
00449 
00450     // Add all the screensavers in the C:\ReactOS\System32 directory.
00451     GetSystemDirectory(szSearchPath, MAX_PATH);
00452     if (lpBackSlash != NULL && _tcsicmp(szSearchPath, szLocalPath) != 0)
00453         SearchScreenSavers(hwndScreenSavers, szSearchPath, pData);
00454 
00455     // Add all the screensavers in the C:\ReactOS directory.
00456     GetWindowsDirectory(szSearchPath, MAX_PATH);
00457     if (lpBackSlash != NULL && _tcsicmp(szSearchPath, szLocalPath) != 0)
00458         SearchScreenSavers(hwndScreenSavers, szSearchPath, pData);
00459 }
00460 
00461 
00462 static VOID
00463 SetScreenSaver(HWND hwndDlg, PDATA pData)
00464 {
00465     HKEY regKey;
00466     BOOL DeleteMode = FALSE;
00467 
00468     if (RegOpenKeyEx(HKEY_CURRENT_USER,
00469                      _T("Control Panel\\Desktop"),
00470                      0,
00471                      KEY_ALL_ACCESS,
00472                      &regKey) == ERROR_SUCCESS)
00473     {
00474         INT Time;
00475         BOOL bRet;
00476         TCHAR szTime[256], Sec;
00477         UINT Ret;
00478 
00479         /* Set the screensaver */
00480         if (pData->ScreenSaverItems[pData->Selection].bIsScreenSaver)
00481         {
00482             RegSetValueEx(regKey,
00483                           _T("SCRNSAVE.EXE"),
00484                           0,
00485                           REG_SZ,
00486                           (PBYTE)pData->ScreenSaverItems[pData->Selection].szFilename,
00487                           _tcslen(pData->ScreenSaverItems[pData->Selection].szFilename) * sizeof(TCHAR));
00488         }
00489         else
00490         {
00491             /* Windows deletes the value if no screensaver is set */
00492             RegDeleteValue(regKey, _T("SCRNSAVE.EXE"));
00493             DeleteMode = TRUE;
00494         }
00495 
00496         /* set the screensaver time delay */
00497         Time = GetDlgItemInt(hwndDlg,
00498                              IDC_SCREENS_TIMEDELAY,
00499                              &bRet,
00500                              FALSE);
00501         if (Time == 0)
00502             Time = 60;
00503         else
00504             Time *= 60;
00505 
00506         _itot(Time, szTime, 10);
00507         RegSetValueEx(regKey,
00508                       _T("ScreenSaveTimeOut"),
00509                       0,
00510                       REG_SZ,
00511                       (PBYTE)szTime,
00512                       _tcslen(szTime) * sizeof(TCHAR));
00513 
00514         if (DeleteMode) Time = 0;
00515 
00516         SystemParametersInfoW(SPI_SETSCREENSAVETIMEOUT, Time, 0, SPIF_SENDCHANGE);
00517 
00518         /* Set the secure value */
00519         Ret = SendDlgItemMessage(hwndDlg,
00520                                  IDC_SCREENS_USEPASSCHK,
00521                                  BM_GETCHECK,
00522                                  0,
00523                                  0);
00524         Sec = (Ret == BST_CHECKED) ? _T('1') : _T('0');
00525         RegSetValueEx(regKey,
00526                       _T("ScreenSaverIsSecure"),
00527                       0,
00528                       REG_SZ,
00529                       (PBYTE)&Sec,
00530                       sizeof(TCHAR));
00531 
00532         RegCloseKey(regKey);
00533     }
00534 }
00535 
00536 
00537 static BOOL
00538 OnInitDialog(HWND hwndDlg, PDATA pData)
00539 {
00540     LPTSTR lpCurSs;
00541     HWND hwndSSCombo = GetDlgItem(hwndDlg, IDC_SCREENS_LIST);
00542     INT Num;
00543 
00544     pData = HeapAlloc(GetProcessHeap(),
00545                             HEAP_ZERO_MEMORY,
00546                             sizeof(DATA));
00547     if (!pData)
00548     {
00549         EndDialog(hwndDlg, -1);
00550         return FALSE;
00551     }
00552 
00553     SetWindowLongPtr(hwndDlg,
00554                      DWLP_USER,
00555                      (LONG_PTR)pData);
00556 
00557     pData->Selection = -1;
00558 
00559     SendDlgItemMessage(hwndDlg,
00560                        IDC_SCREENS_TIME,
00561                        UDM_SETRANGE,
00562                        0,
00563                        MAKELONG
00564                        ((short) 240, (short) 1));
00565 
00566     AddScreenSavers(hwndDlg,
00567                     pData);
00568 
00569     CheckRegScreenSaverIsSecure(hwndDlg);
00570 
00571     /* Set the current screensaver in the combo box */
00572     lpCurSs = GetCurrentScreenSaverValue(_T("SCRNSAVE.EXE"));
00573     if (lpCurSs)
00574     {
00575         BOOL bFound = FALSE;
00576         INT i;
00577 
00578         for (i = 0; i < MAX_SCREENSAVERS; i++)
00579         {
00580             if (!_tcscmp(lpCurSs, pData->ScreenSaverItems[i].szFilename))
00581             {
00582                 bFound = TRUE;
00583                 break;
00584             }
00585         }
00586 
00587         if (bFound)
00588         {
00589             Num = SendMessage(hwndSSCombo,
00590                               CB_FINDSTRINGEXACT,
00591                               -1,
00592                               (LPARAM)pData->ScreenSaverItems[i].szDisplayName);
00593             if (Num != CB_ERR)
00594                 SendMessage(hwndSSCombo,
00595                             CB_SETCURSEL,
00596                             Num,
00597                             0);
00598         }
00599         else
00600         {
00601             SendMessage(hwndSSCombo,
00602                         CB_SETCURSEL,
00603                         0,
00604                         0);
00605         }
00606 
00607         HeapFree(GetProcessHeap(),
00608                  0,
00609                  lpCurSs);
00610     }
00611     else
00612     {
00613         /* Set screensaver to (none) */
00614         SendMessage(hwndSSCombo,
00615                     CB_SETCURSEL,
00616                     0,
00617                     0);
00618     }
00619 
00620     /* Set the current timeout */
00621     lpCurSs = GetCurrentScreenSaverValue(_T("ScreenSaveTimeOut"));
00622     if (lpCurSs)
00623     {
00624         UINT Time = _ttoi(lpCurSs);
00625 
00626         Time /= 60;
00627 
00628         SendDlgItemMessage(hwndDlg,
00629                            IDC_SCREENS_TIME,
00630                            UDM_SETPOS32,
00631                            0,
00632                            Time);
00633 
00634         HeapFree(GetProcessHeap(),
00635                  0,
00636                  lpCurSs);
00637 
00638     }
00639 
00640     SelectionChanged(hwndDlg,
00641                      pData);
00642 
00643     return TRUE;
00644 }
00645 
00646 
00647 INT_PTR CALLBACK
00648 ScreenSaverPageProc(HWND hwndDlg,
00649                     UINT uMsg,
00650                     WPARAM wParam,
00651                     LPARAM lParam)
00652 {
00653     PDATA pData;
00654 
00655     pData = (PDATA)GetWindowLongPtr(hwndDlg, DWLP_USER);
00656 
00657     switch (uMsg)
00658     {
00659         case WM_INITDIALOG:
00660         {
00661             OnInitDialog(hwndDlg, pData);
00662             break;
00663         }
00664 
00665         case WM_DESTROY:
00666         {
00667             if (pData->PrevWindowPi.hProcess)
00668             {
00669                 TerminateProcess(pData->PrevWindowPi.hProcess, 0);
00670                 CloseHandle(pData->PrevWindowPi.hProcess);
00671                 CloseHandle(pData->PrevWindowPi.hThread);
00672             }
00673             HeapFree(GetProcessHeap(),
00674                      0,
00675                      pData);
00676             break;
00677         }
00678 
00679         case WM_ENDSESSION:
00680         {
00681             SetScreenSaverPreviewBox(hwndDlg,
00682                                      pData);
00683             break;
00684         }
00685 
00686         case WM_COMMAND:
00687         {
00688             DWORD controlId = LOWORD(wParam);
00689             DWORD command   = HIWORD(wParam);
00690 
00691             switch (controlId)
00692             {
00693                 case IDC_SCREENS_LIST:
00694                 {
00695                     if (HIWORD(wParam) == CBN_SELCHANGE)
00696                     {
00697                         SelectionChanged(hwndDlg, pData);
00698                         SetScreenSaverPreviewBox(hwndDlg, pData);
00699                         PropSheet_Changed(GetParent(hwndDlg), hwndDlg);
00700                     }
00701                     break;
00702                 }
00703 
00704                 case IDC_SCREENS_TIMEDELAY:
00705                 {
00706                     PropSheet_Changed(GetParent(hwndDlg), hwndDlg);
00707                     break;
00708                 }
00709 
00710                 case IDC_SCREENS_POWER_BUTTON: // Start Powercfg.Cpl
00711                 {
00712                     if (command == BN_CLICKED)
00713                         WinExec("rundll32 shell32.dll,Control_RunDLL powercfg.cpl",SW_SHOWNORMAL);
00714                     break;
00715                 }
00716 
00717                 case IDC_SCREENS_TESTSC: // Screensaver Preview
00718                 {
00719                     if(command == BN_CLICKED)
00720                     {
00721                         ScreensaverPreview(hwndDlg, pData);
00722                         SetScreenSaverPreviewBox(hwndDlg, pData);
00723                     }
00724                     break;
00725                 }
00726 
00727                 case IDC_SCREENS_SETTINGS: // Screensaver Settings
00728                 {
00729                     if (command == BN_CLICKED)
00730                         ScreensaverConfig(hwndDlg, pData);
00731                     break;
00732                 }
00733 
00734                 case IDC_SCREENS_USEPASSCHK: // Screensaver Is Secure
00735                 {
00736                     if (command == BN_CLICKED)
00737                     {
00738                         MessageBox(NULL, TEXT("Feature not yet implemented"), TEXT("Sorry"), MB_OK);
00739                         PropSheet_Changed(GetParent(hwndDlg), hwndDlg);
00740                     }
00741                     break;
00742                 }
00743             }
00744             break;
00745         }
00746 
00747         case WM_NOTIFY:
00748         {
00749             LPNMHDR lpnm = (LPNMHDR)lParam;
00750 
00751             switch(lpnm->code)
00752             {
00753                 case PSN_APPLY:
00754                 {
00755                     SetScreenSaver(hwndDlg, pData);
00756                     return TRUE;
00757                 }
00758 
00759                 case PSN_SETACTIVE:
00760                 {
00761                     /* Activate screen saver support */
00762                     SystemParametersInfoW(SPI_SETSCREENSAVEACTIVE, TRUE, 0, SPIF_SENDCHANGE);
00763                     SetScreenSaverPreviewBox(hwndDlg, pData);
00764                     break;
00765                 }
00766 
00767                 case PSN_KILLACTIVE:
00768                 {
00769                     /* Disable screensaver support */
00770                     SystemParametersInfoW(SPI_SETSCREENSAVEACTIVE, FALSE, 0, SPIF_SENDCHANGE);
00771                     if (pData->PrevWindowPi.hProcess)
00772                     {
00773                         TerminateProcess(pData->PrevWindowPi.hProcess, 0);
00774                         CloseHandle(pData->PrevWindowPi.hProcess);
00775                         CloseHandle(pData->PrevWindowPi.hThread);
00776                         pData->PrevWindowPi.hThread = pData->PrevWindowPi.hProcess = NULL;
00777                     }
00778                     break;
00779                 }
00780             }
00781         }
00782         break;
00783     }
00784 
00785     return FALSE;
00786 }
Generated on Sat May 26 2012 04:17:45 for ReactOS by
1.7.6.1