/*****************************************************************************\ FILE: ScreenSaverPg.cpp DESCRIPTION: This file contains the COM object implementation that will display the ScreenSaver tab in the Display Control Panel. 18-Feb-94 (Tracy Sharpe) Added power management functionality. Commented out several pieces of code that weren't being used. 5/30/2000 (Bryan Starbuck) BryanSt: Turned into C++ and COM. Exposed as an API so other tabs can communicate with it. This enables the Plus! Theme page to modify the screen saver. 11/08/2000 (Bryan Starbuck) BryanSt: Moved from \nt\shell\cpls\desknt5 to \nt\shell\themes\themeui\. Copyright (C) Microsoft Corp 1994-2000. All rights reserved. \*****************************************************************************/ #include "priv.h" #pragma hdrstop #include #include "exe.h" #include "ScreenSaverPg.h" #include // for ShellIsFriendlyUIActive, etc.. #define SFSE_SYSTEM 0 #define SFSE_PRG 1 #define SFSE_WINDOWS 2 #define SFSE_FILE 3 #define MAX_METHODS 100 #define MIN_MINUTES 1 #define MAX_MINUTES 9999 //The UI will allow upto four digits. #define BUFFER_SIZE 400 #define WMUSER_SETINITSS (WM_USER + 1) /* Local funcprototypes... */ void SearchForScrEntries ( UINT, LPCTSTR ); BOOL FreeScrEntries ( void ); int lstrncmp ( LPTSTR, LPTSTR, int ); LPTSTR FileName ( LPTSTR szPath); LPTSTR StripPathName ( LPTSTR szPath); LPTSTR NiceName ( LPTSTR szPath); void AddBackslash(LPTSTR pszPath); void AppendPath(LPTSTR pszPath, LPTSTR pszSpec); PTSTR PerformCheck(LPTSTR, BOOL); void DoScreenSaver(HWND hDlg, BOOL b); void ScreenSaver_AdjustTimeouts(HWND hWnd,int BaseControlID); void EnableDisablePowerDelays(HWND hDlg); TCHAR g_szSaverName[MAX_PATH]; // Screen Saver EXE HICON hDefaultIcon = NULL; HICON hIdleWildIcon; BOOL bWasConfig=0; // We were configing the screen saver HWND g_hwndTestButton; HWND g_hwndLastFocus; BOOL g_fPasswordWasPreviouslyEnabled = FALSE; BOOL g_fPasswordDirty = FALSE; // tells us if the user has actually changed the state of the password combobox BOOL g_fFriendlyUI = FALSE; // is winlogon going to switch back to the welcome screen, or call LockWorkStation for real? BOOL g_fPasswordBoxDeterminedByPolicy = FALSE; BOOL g_fSettingsButtonOffByPolicy = FALSE; BOOL g_fTimeoutDeterminedByPolicy = FALSE; BOOL g_fScreenSaverExecutablePolicy = FALSE; // Local global variables HICON hIcons[MAX_METHODS]; UINT wNumMethods = 0; PTSTR aszMethods[MAX_METHODS]; PTSTR aszFiles[MAX_METHODS]; static const TCHAR c_szDemoParentClass[] = TEXT("SSDemoParent"); // static TCHAR szFileNameCopy[MAX_PATH]; static int g_iMethod; static BOOL g_fPreviewActive; static BOOL g_fAdapPwrMgnt = FALSE; /* * Registry value for the "Password Protected" check box * * These are different for NT and Win95 to keep screen * savers built exclusivly for Win95 from trying to * handle password checks. (NT does all password checking * in the built in security system to maintain C2 * level security) */ # define SZ_USE_PASSWORD TEXT("ScreenSaverIsSecure") # define PWRD_REG_TYPE REG_SZ # define CCH_USE_PWRD_VALUE 2 # define CB_USE_PWRD_VALUE (CCH_USE_PWRD_VALUE * SIZEOF(TCHAR)) TCHAR gpwdRegYes[CCH_USE_PWRD_VALUE] = TEXT("1"); TCHAR gpwdRegNo[CCH_USE_PWRD_VALUE] = TEXT("0"); #define PasswdRegData(f) ((f) ? (PBYTE)gpwdRegYes : (PBYTE)gpwdRegNo) UDACCEL udAccel[] = {{0,1},{2,5},{4,30},{8,60}}; #include "help.h" #define IDH_DESK_LOWPOWERCFG IDH_SCRSAVER_GRAPHIC // To simplify some things, the base control ID of a time control is associated // with its corresponding ClassicSystemParametersInfo action codes. typedef struct { int taBaseControlID; UINT taGetTimeoutAction; UINT taSetTimeoutAction; UINT taGetActiveAction; UINT taSetActiveAction; } TIMEOUT_ASSOCIATION; // Except for the case of the "screen save" delay, each time grouping has three // controls-- a switch to determine whether that time should be used or not and // an edit box and an updown control to change the delay time. ("Screen save" // is turned off my choosing (None) from the screen saver list) These three // controls must be organized as follows: #define BCI_DELAY 0 #define BCI_ARROW 1 #define BCI_SWITCH 2 // Associations between base control IDs and ClassicSystemParametersInfo action codes. // The TA_* #defines are used as symbolic indexes into this array. Note that // TA_SCREENSAVE is a special case-- it does NOT have a BCI_SWITCH. #define TA_SCREENSAVE 0 TIMEOUT_ASSOCIATION g_TimeoutAssociation[] = { IDC_SCREENSAVEDELAY, SPI_GETSCREENSAVETIMEOUT, SPI_SETSCREENSAVETIMEOUT, SPI_GETSCREENSAVEACTIVE, SPI_SETSCREENSAVEACTIVE, }; int g_Timeout[] = { 0, 0, 0, }; HBITMAP g_hbmDemo = NULL; HBITMAP g_hbmEnergyStar = NULL; BOOL g_bInitSS = TRUE; // assume we are in initialization process BOOL g_bChangedSS = FALSE; // changes have been made class CScreenSaverPg : public CObjectWithSite , public CObjectCLSID , public IBasePropPage , public IPropertyBag { public: ////////////////////////////////////////////////////// // Public Interfaces ////////////////////////////////////////////////////// // *** IUnknown *** virtual STDMETHODIMP QueryInterface(REFIID riid, LPVOID * ppvObj); virtual STDMETHODIMP_(ULONG) AddRef(void); virtual STDMETHODIMP_(ULONG) Release(void); // *** IBasePropPage *** virtual STDMETHODIMP GetAdvancedDialog(OUT IAdvancedDialog ** ppAdvDialog); virtual STDMETHODIMP OnApply(IN PROPPAGEONAPPLY oaAction); // *** IShellPropSheetExt *** virtual STDMETHODIMP AddPages(IN LPFNSVADDPROPSHEETPAGE pfnAddPage, IN LPARAM lParam); virtual STDMETHODIMP ReplacePage(IN EXPPS uPageID, IN LPFNSVADDPROPSHEETPAGE pfnReplaceWith, IN LPARAM lParam) {return E_NOTIMPL;} // *** IPropertyBag *** virtual STDMETHODIMP Read(IN LPCOLESTR pszPropName, IN VARIANT * pVar, IN IErrorLog *pErrorLog); virtual STDMETHODIMP Write(IN LPCOLESTR pszPropName, IN VARIANT *pVar); protected: private: CScreenSaverPg(); virtual ~CScreenSaverPg(void); // Private Member Variables int m_cRef; BOOL m_fSecure; BOOL m_fUIInitialized; // Have we activated the UI tab and loaded the UI controls with state? BOOL m_fScreenSavePolicy; BOOL m_fScreenSaveActive; LONG m_lWaitTime; HWND m_hDlg; // Private Member Functions HRESULT _InitState(void); BOOL _InitSSDialog(HWND hDlg); HRESULT _OnSetActive(void); HRESULT _OnApply(void); HRESULT _OnSelectionChanged(void); HRESULT _SaveIni(HWND hDlg); HRESULT _SetByPath(LPCWSTR pszPath); INT_PTR _ScreenSaverDlgProc(HWND hDlg, UINT uMessage, WPARAM wParam, LPARAM lParam); friend INT_PTR CALLBACK ScreenSaverDlgProc(HWND hDlg, UINT wMsg, WPARAM wParam, LPARAM lParam); friend HRESULT CScreenSaverPage_CreateInstance(IN IUnknown * punkOuter, IN REFIID riid, OUT LPVOID * ppvObj); }; //=========================== // *** Class Internals & Helpers *** //=========================== const DWORD aSaverHelpIds[] = { IDC_NO_HELP_1, NO_HELP, IDC_CHOICES, IDH_DISPLAY_SCREENSAVER_SCREENSAVER_LISTBOX, IDC_SSDELAYLABEL, IDH_DISPLAY_SCREENSAVER_SCREENSAVER_WAIT, IDC_SSDELAYSCALE, IDH_DISPLAY_SCREENSAVER_SCREENSAVER_WAIT, IDC_SCREENSAVEDELAY, IDH_DISPLAY_SCREENSAVER_SCREENSAVER_WAIT, IDC_SCREENSAVEARROW, IDH_DISPLAY_SCREENSAVER_SCREENSAVER_WAIT, IDC_TEST, IDH_DISPLAY_SCREENSAVER_SCREENSAVER_PREVIEW, IDC_SETTING, IDH_DISPLAY_SCREENSAVER_SCREENSAVER_SETTINGS, IDC_BIGICONSS, IDH_DISPLAY_SCREENSAVER_SCREENSAVER_MONITOR, IDC_ENERGY_TEXT, NO_HELP, IDC_ENERGYSTAR_BMP, IDH_DISPLAY_SCREENSAVER_ENERGYSAVE_GRAPHIC, IDC_USEPASSWORD, IDH_DISPLAY_SCREENSAVER_SCREENSAVER_PASSWORD_CHECKBOX, // IDC_SETPASSWORD, IDH_COMM_PASSWDBUTT, IDC_LOWPOWERCONFIG, IDH_DISPLAY_SCREENSAVER_POWER_BUTTON, IDC_ENERGY_TEXT2, NO_HELP, 0, 0 }; // are we going to return to the welcome dialog in the friendly UI case? BOOL WillReturnToWelcome() { HKEY hkey; BOOL bRet = TRUE; if (RegOpenKeyEx(HKEY_CURRENT_USER, REGSTR_PATH_SCREENSAVE, 0, KEY_QUERY_VALUE, &hkey) == ERROR_SUCCESS) { TCHAR szTemp[4]; DWORD dwType; DWORD dwSize = sizeof(szTemp); if ((RegQueryValueEx(hkey, TEXT("NoAutoReturnToWelcome"), NULL, &dwType, (BYTE*)szTemp, &dwSize) == ERROR_SUCCESS) && (dwType == REG_SZ)) { bRet = !(StrToInt(szTemp)); } RegCloseKey(hkey); } return bRet; } /* * Win95 and NT store different values in different places of the registry to * determine if the screen saver is secure or not. * * We can't really consolidate the two because the screen savers do different * actions based on which key is set. Win95 screen savers do their own * password checking, but NT must let the secure desktop winlogon code do it. * * Therefore to keep Win95 screen savers from requesting the password twice on * NT, we use REGSTR_VALUE_USESCRPASSWORD == (REG_DWORD)1 on Win95 to indicate * that a screen saver should check for the password, and * "ScreenSaverIsSecure" == (REG_SZ)"1" on NT to indicate that WinLogon should * check for a password. * * This function will deal with the differences. */ static BOOL IsPasswdSecure(HKEY hKey) { union { DWORD dw; TCHAR asz[4]; } uData; DWORD dwSize, dwType; BOOL fSecure = FALSE; dwSize = SIZEOF(uData); if (RegQueryValueEx(hKey,SZ_USE_PASSWORD,NULL, &dwType, (BYTE *)&uData, &dwSize) == ERROR_SUCCESS) { switch (dwType) { case REG_DWORD: fSecure = (uData.dw == 1); break; case REG_SZ: fSecure = (uData.asz[0] == TEXT('1')); break; } } // if we are in friendly UI mode, we might want to treat this as secure even if SZ_USE_PASSWORD is not set if (g_fFriendlyUI && !fSecure) { fSecure = WillReturnToWelcome(); } return fSecure; } static void NEAR EnableDlgChild( HWND dlg, HWND kid, BOOL val ) { if( !val && ( kid == GetFocus() ) ) { // give prev tabstop focus SendMessage( dlg, WM_NEXTDLGCTL, 1, 0L ); } EnableWindow( kid, val ); } static void NEAR EnableDlgItem( HWND dlg, int idkid, BOOL val ) { EnableDlgChild( dlg, GetDlgItem( dlg, idkid ), val ); } HWND GetSSDemoParent( HWND page ) { static HWND parent = NULL; if (!parent || !IsWindow(parent)) { parent = CreateWindowEx( 0, c_szDemoParentClass, TEXT(""), WS_CHILD | WS_CLIPCHILDREN, 0, 0, 0, 0, GetDlgItem(page, IDC_BIGICONSS), NULL, HINST_THISDLL, NULL ); } return parent; } void ForwardSSDemoMsg(HWND hwnd, UINT uMessage, WPARAM wParam, LPARAM lParam) { HWND hwndChild; hwnd = GetSSDemoParent(hwnd); if (hwnd) { for (hwndChild = GetWindow(hwnd, GW_CHILD); hwnd && (hwndChild != NULL); hwndChild = GetWindow(hwndChild, GW_HWNDNEXT)) { SendMessage(hwndChild, uMessage, wParam, lParam); } } } void ParseSaverName( LPTSTR lpszName ) { if( *lpszName == TEXT('\"') ) { LPTSTR lpcSrc = lpszName + 1; while( *lpcSrc && *lpcSrc != TEXT('\"') ) { *lpszName++ = *lpcSrc++; } *lpszName = 0; // clear second quote } } // YUCK: // since our screen saver preview is in a different process, // it is possible that we paint in the wrong order. // this ugly hack makes sure the demo always paints AFTER the dialog WNDPROC g_lpOldStaticProc = NULL; LRESULT StaticSubclassProc(HWND wnd, UINT msg, WPARAM wp, LPARAM lp) { LRESULT result = CallWindowProc(g_lpOldStaticProc, wnd, msg, wp, lp); if (msg == WM_PAINT) { HWND demos = GetSSDemoParent(GetParent(wnd)); if (demos) { RedrawWindow(demos, NULL, NULL, RDW_INVALIDATE | RDW_ERASE | RDW_ALLCHILDREN); } } return result; } HRESULT CScreenSaverPg::_InitState(void) { HRESULT hr = S_OK; HKEY hKey; int Counter; int nActive; int Timeout; m_fScreenSavePolicy = FALSE; m_fScreenSaveActive = TRUE; // Fetch the timeout value from the win.ini and adjust between 1:00-60:00 for (Counter = 0; Counter < ARRAYSIZE(g_TimeoutAssociation); Counter++) { // Fetch the timeout value from the win.ini and adjust between 1:00-60:00 ClassicSystemParametersInfo(g_TimeoutAssociation[Counter].taGetTimeoutAction, 0, &Timeout, 0); // The Win 3.1 guys decided that 0 is a valid ScreenSaveTimeOut value. // This causes our screen savers not to kick in (who cares?). In any // case, I changed this to allow 0 to go through. In this way, the // user immediately sees that the value entered is not valid to fire // off the screen saver--the OK button is disabled. I don't know if // I fully agree with this solution--it is just the minimal amount of // code. The optimal solution would be to ask the 3.1 guys why 0 is // valid? -cjp Timeout = min(max(Timeout, 1), MAX_MINUTES * 60); // Convert Timeout to minutes, rounding up. Timeout = (Timeout + 59) / 60; g_Timeout[Counter] = Timeout; ClassicSystemParametersInfo(g_TimeoutAssociation[Counter].taGetActiveAction, 0, &nActive, SPIF_UPDATEINIFILE); if (Counter == TA_SCREENSAVE) { // I found that NTUSER will return random values so we don't use them. If people want to set the policy, // they should do in the registry. // m_fScreenSaveActive = nActive; } } // Find the name of the exe used as a screen saver. "" means that the // default screen saver will be used. First check the system policies if (RegOpenKey(HKEY_CURRENT_USER, TEXT("Software\\Policies\\Microsoft\\Windows\\Control Panel\\Desktop"), &hKey) == ERROR_SUCCESS) { BOOL fSettings; ULONG cbSize; cbSize = ARRAYSIZE(g_szSaverName); if (RegQueryValueEx(hKey, TEXT("SCRNSAVE.EXE"), NULL, NULL, (LPBYTE)g_szSaverName, &cbSize) == ERROR_SUCCESS) { g_fScreenSaverExecutablePolicy = TRUE; LogStatus("POLICY ENABLED: ScreenSaver selection is forced to a certain SS file."); } cbSize = SIZEOF(m_fSecure); if (RegQueryValueEx(hKey, TEXT("ScreenSaverIsSecure"), NULL, NULL, (LPBYTE)&m_fSecure, &cbSize) == ERROR_SUCCESS) { g_fPasswordBoxDeterminedByPolicy = TRUE; LogStatus("POLICY ENABLED: ScreenSaverIsSecure is on."); } cbSize = SIZEOF( fSettings ); if (RegQueryValueEx(hKey, TEXT("ScreenSaverSettingsButton"), NULL, NULL, (LPBYTE)&fSettings, &cbSize) == ERROR_SUCCESS) { g_fSettingsButtonOffByPolicy = TRUE; LogStatus("POLICY ENABLED: ScreenSaver settings button is disabled."); } TCHAR szTemp[20]; if (SUCCEEDED(HrRegGetValueString(hKey, NULL, SZ_POLICY_SCREENSAVETIMEOUT, szTemp, ARRAYSIZE(szTemp))) && szTemp[0]) { m_lWaitTime = StrToInt(szTemp); g_fTimeoutDeterminedByPolicy = TRUE; LogStatus("POLICY ENABLED: ScreenSaver timeout value is set."); } if (SUCCEEDED(HrRegGetValueString(hKey, NULL, TEXT("ScreenSaveActive"), szTemp, ARRAYSIZE(szTemp))) && szTemp[0]) { m_fScreenSavePolicy = TRUE; m_fScreenSaveActive = StrToInt(szTemp); LogStatus("POLICY ENABLED: ScreenSaver Active is set."); } RegCloseKey(hKey); } if (!g_fScreenSaverExecutablePolicy) { if (FAILED(HrRegGetPath(HKEY_CURRENT_USER, SZ_REGKEY_CPDESKTOP, SZ_INIKEY_SCREENSAVER, g_szSaverName, ARRAYSIZE(g_szSaverName)))) { TCHAR szTempPath[MAX_PATH]; GetPrivateProfileString(SZ_INISECTION_SCREENSAVER, SZ_INIKEY_SCREENSAVER, TEXT(""), g_szSaverName, ARRAYSIZE(g_szSaverName), SZ_INISECTION_SYSTEMINI); StrCpyN(szTempPath, g_szSaverName, ARRAYSIZE(szTempPath)); SHExpandEnvironmentStrings(szTempPath, g_szSaverName, ARRAYSIZE(g_szSaverName)); } } ParseSaverName(g_szSaverName); // remove quotes and params // Call will fail if monitor or adapter don't support DPMS. int dummy; g_fAdapPwrMgnt = ClassicSystemParametersInfo(SPI_GETLOWPOWERACTIVE, 0, &dummy, 0); if (!g_fAdapPwrMgnt) { g_fAdapPwrMgnt = ClassicSystemParametersInfo(SPI_GETPOWEROFFACTIVE, 0, &dummy, 0); } // initialize the password checkbox if (RegOpenKey(HKEY_CURRENT_USER,REGSTR_PATH_SCREENSAVE,&hKey) == ERROR_SUCCESS) { if (IsPasswdSecure(hKey)) { g_fPasswordWasPreviouslyEnabled = TRUE; } RegCloseKey(hKey); } return hr; } BOOL CScreenSaverPg::_InitSSDialog(HWND hDlg) { WNDCLASS wc; PTSTR pszMethod; UINT wTemp,wLoop; BOOL fContinue; UINT Counter; int ControlID; int wMethod; DWORD dwUserCount; HKEY hKey; HWND hwnd; int nActive; TCHAR szBuffer[MAX_PATH]; m_hDlg = hDlg; m_fUIInitialized = TRUE; HINSTANCE hInstDeskCPL = LoadLibrary(TEXT("desk.cpl")); if (!GetClassInfo(HINST_THISDLL, c_szDemoParentClass, &wc)) { // if two pages put one up, share one dc wc.style = 0; wc.lpfnWndProc = DefWindowProc; wc.cbClsExtra = wc.cbWndExtra = 0; wc.hInstance = HINST_THISDLL; wc.hIcon = (HICON)( wc.hCursor = NULL ); wc.hbrBackground = (HBRUSH) GetStockObject( BLACK_BRUSH ); wc.lpszMenuName = NULL; wc.lpszClassName = c_szDemoParentClass; if( !RegisterClass( &wc ) ) return FALSE; } // Fetch the timeout value from the win.ini and adjust between 1:00-60:00 for (Counter = 0; Counter < ARRAYSIZE(g_TimeoutAssociation); Counter++) { // The base control id specifies the edit control id. ControlID = g_TimeoutAssociation[Counter].taBaseControlID; // Set the maximum length of all of the fields... SendDlgItemMessage(hDlg, ControlID, EM_LIMITTEXT, 4, 0); //Allow four digits. ClassicSystemParametersInfo(g_TimeoutAssociation[Counter].taGetActiveAction, 0, &nActive, SPIF_UPDATEINIFILE); if (Counter != TA_SCREENSAVE) { CheckDlgButton(hDlg, ControlID + BCI_SWITCH, nActive); } else { // m_fScreenSaveActive = nActive; } SetDlgItemInt(hDlg, ControlID, g_Timeout[Counter], FALSE); // The associated up/down control id must be one after the edit control id. ControlID++; SendDlgItemMessage(hDlg, ControlID, UDM_SETRANGE, 0, MAKELPARAM(MAX_MINUTES, MIN_MINUTES)); SendDlgItemMessage(hDlg, ControlID, UDM_SETACCEL, 4, (LPARAM)(LPUDACCEL)udAccel); } // Find the name of the exe used as a screen saver. "" means that the // default screen saver will be used. First check the system policies if (RegOpenKey(HKEY_CURRENT_USER, TEXT("Software\\Policies\\Microsoft\\Windows\\Control Panel\\Desktop"), &hKey) == ERROR_SUCCESS) { BOOL fPower; ULONG cbSize; cbSize = SIZEOF(fPower); if (RegQueryValueEx(hKey, TEXT("ScreenSaverPowerButton"), NULL, NULL, (LPBYTE)&fPower, &cbSize) == ERROR_SUCCESS) { EnableWindow(GetDlgItem(hDlg, IDC_LOWPOWERCONFIG), FALSE); } RegCloseKey(hKey); } if (g_fPasswordBoxDeterminedByPolicy) { CheckDlgButton(hDlg, IDC_USEPASSWORD, m_fSecure); EnableWindow(GetDlgItem(hDlg, IDC_USEPASSWORD), FALSE); } // if we are running with the new friendly UI w/ multiple users on the system, then we switch to text from "Password protect" // to "Return to the Welcome screen" because winlogon will do a switch user instead of a LockWorkStation in this case if (ShellIsFriendlyUIActive() && ShellIsMultipleUsersEnabled() && (ERROR_SUCCESS == ShellGetUserList(TRUE, &dwUserCount, NULL)) && (dwUserCount > 1)) { if (LoadString(HINST_THISDLL, IDS_RETURNTOWELCOME, szBuffer, ARRAYSIZE(szBuffer))) { SetDlgItemText(hDlg, IDC_USEPASSWORD, szBuffer); g_fFriendlyUI = TRUE; if (WillReturnToWelcome()) { g_fPasswordWasPreviouslyEnabled = TRUE; } } } if (g_fSettingsButtonOffByPolicy) { EnableWindow(GetDlgItem(hDlg, IDC_SETTING), FALSE); } if (g_fTimeoutDeterminedByPolicy) { SetDlgItemInt(hDlg, IDC_SCREENSAVEDELAY, (UINT) m_lWaitTime / 60, FALSE); EnableWindow(GetDlgItem(hDlg, IDC_SCREENSAVEDELAY), FALSE); } if (m_fScreenSavePolicy && !m_fScreenSaveActive) { EnableWindow(GetDlgItem(hDlg, IDC_CHOICES), FALSE); EnableWindow(GetDlgItem(hDlg, IDC_SETTING), FALSE); EnableWindow(GetDlgItem(hDlg, IDC_SSDELAYLABEL), FALSE); EnableWindow(GetDlgItem(hDlg, IDC_SCREENSAVEDELAY), FALSE); EnableWindow(GetDlgItem(hDlg, IDC_SCREENSAVEARROW), FALSE); EnableWindow(GetDlgItem(hDlg, IDC_SSDELAYSCALE), FALSE); EnableWindow(GetDlgItem(hDlg, IDC_USEPASSWORD), FALSE); } if (g_fScreenSaverExecutablePolicy) { EnableWindow(GetDlgItem(hDlg, IDC_CHOICES), FALSE); } // Copy all of the variables into their copies... // lstrcpy(szFileNameCopy, g_szSaverName); // Load in the default icon... if (hInstDeskCPL) { hDefaultIcon = LoadIcon(hInstDeskCPL, MAKEINTRESOURCE(IDS_ICON)); } // Find the methods to save the screen. If the method that was // selected is not found, the program will assume that the // first method in the list will be the one that is elected... wNumMethods = 0; wMethod = -1; SearchForScrEntries(SFSE_PRG,NULL); SearchForScrEntries(SFSE_SYSTEM,NULL); SearchForScrEntries(SFSE_WINDOWS,NULL); SearchForScrEntries(SFSE_FILE,g_szSaverName); szBuffer[0] = 0; TCHAR szNone[MAX_PATH]; LoadString(HINST_THISDLL, IDS_NONE, szNone, ARRAYSIZE(szNone)); // Set up the combo box for the different fields... SendDlgItemMessage(hDlg, IDC_CHOICES, CB_ADDSTRING, 0, (LPARAM)szNone); for (wTemp = 0; (wTemp < wNumMethods) && (ARRAYSIZE(aszFiles) > wTemp) && (ARRAYSIZE(aszMethods) > wTemp); wTemp++) { // Lock down the information and pass it to the combo box... pszMethod = aszMethods[wTemp]; wLoop = (UINT)SendDlgItemMessage(hDlg,IDC_CHOICES,CB_ADDSTRING,0, (LPARAM)(pszMethod+1)); SendDlgItemMessage(hDlg, IDC_CHOICES, CB_SETITEMDATA, wLoop, wTemp); // If we have the correct item, keep a copy so we can select it out of the combo box... // check for filename only as well as full path name if (!lstrcmpi(FileName(aszFiles[wTemp]), FileName(g_szSaverName))) { wMethod = wTemp; StrCpyN(szBuffer, pszMethod + 1, ARRAYSIZE(szBuffer)); } } if (m_fScreenSavePolicy && !m_fScreenSaveActive) { wMethod = -1; } // Attempt to select the string we recieved from the // system.ini entry. If there is no match, select the // first item from the list... if ((wMethod == -1) || (wNumMethods == 0)) { fContinue = TRUE; } else { if (SendDlgItemMessage(hDlg, IDC_CHOICES, CB_SELECTSTRING, (WPARAM)-1, (LPARAM)szBuffer) == CB_ERR) fContinue = TRUE; else fContinue = FALSE; } if (fContinue) { SendDlgItemMessage(hDlg,IDC_CHOICES,CB_SETCURSEL,0,0l); StrCpyN(g_szSaverName, TEXT(""), ARRAYSIZE(g_szSaverName)); wMethod = -1; } g_hbmDemo = LoadMonitorBitmap( TRUE ); if (g_hbmDemo) { SendDlgItemMessage(hDlg,IDC_BIGICONSS,STM_SETIMAGE, IMAGE_BITMAP,(LPARAM)g_hbmDemo); } if (hInstDeskCPL) { g_hbmEnergyStar = (HBITMAP) LoadImage(HINST_THISDLL, MAKEINTRESOURCE(IDB_ENERGYSTAR), IMAGE_BITMAP, 0, 0, LR_LOADTRANSPARENT | LR_LOADMAP3DCOLORS); if (g_hbmEnergyStar) { SendDlgItemMessage(hDlg, IDC_ENERGYSTAR_BMP, STM_SETIMAGE, IMAGE_BITMAP, (LPARAM)g_hbmEnergyStar); } } // Hide/Disable the energy related controls if the adaptor/monitor does not // support power mgnt. EnableDisablePowerDelays(hDlg); // subclass the static control so we can synchronize painting hwnd = GetDlgItem(hDlg, IDC_BIGICONSS); if (hwnd) { g_lpOldStaticProc = (WNDPROC)GetWindowLongPtr(hwnd, GWLP_WNDPROC); SetWindowLongPtr(hwnd, GWLP_WNDPROC, (LONG_PTR)(WNDPROC)StaticSubclassProc); // Turn off the mirroring style for this control to allow the screen saver preview to work. SetWindowLong(hwnd, GWL_EXSTYLE, GetWindowLong(hwnd, GWL_EXSTYLE) & ~RTL_MIRRORED_WINDOW); } if (hInstDeskCPL) { FreeLibrary(hInstDeskCPL); } return TRUE; } // Build a command line in a format suitable for passing as the second // parameter to CreateProcess. void _PathBuildArgs(LPTSTR pszBuf, DWORD cchBuf, LPCTSTR pszExe, LPCTSTR pszFormat, ...) { StrCpyN(pszBuf, pszExe, cchBuf); PathQuoteSpaces(pszBuf); int cchBufUsed = lstrlen(pszBuf); pszBuf += cchBufUsed; cchBuf -= cchBufUsed; va_list ap; va_start(ap, pszFormat); wvnsprintf(pszBuf, cchBuf, pszFormat, ap); va_end(ap); } #define SS_WINDOWCLOSE_WAIT_LIMIT 5000 BOOL CALLBACK EnumSSChildWindowsProc(HWND hwndC, LPARAM lParam) { HWND hwndDemo = (HWND)lParam; TraceMsg(TF_FUNC, "hwndDemo = %08x hwndC = %08x", hwndDemo, hwndC); if (IsWindow(hwndDemo) && (hwndDemo == GetParent(hwndC))) { DWORD dwStart = GetTickCount(); TraceMsg(TF_FUNC, "dwStart = %08x", dwStart); while (IsWindow(hwndC)) { DWORD_PTR dwResult; TraceMsg(TF_FUNC, "Sending WM_CLOSE tickcount = %08x", GetTickCount()); BOOL fShouldEndTask = !SendMessageTimeout(hwndC, WM_CLOSE, 0, 0, SMTO_ABORTIFHUNG | SMTO_NOTIMEOUTIFNOTHUNG | SMTO_NORMAL, 2000, &dwResult); TraceMsg(TF_FUNC, "Return from sending WM_CLOSE tickcount = %08x fShouldEndTask = %d", GetTickCount(), fShouldEndTask); if (!fShouldEndTask) { DWORD dwWait = dwStart + SS_WINDOWCLOSE_WAIT_LIMIT - GetTickCount(); TraceMsg(TF_FUNC, "dwWait = %d", dwWait); if (dwWait > SS_WINDOWCLOSE_WAIT_LIMIT) { TraceMsg(TF_FUNC, "Wait exceeded, ending task"); fShouldEndTask = TRUE; } } if (fShouldEndTask) { TraceMsg(TF_FUNC, "Call EndTask task for %08x", hwndC); EndTask(hwndC, FALSE, FALSE); TraceMsg(TF_FUNC, "Return from EndTask task for %08x", hwndC); break; } } } return TRUE; } void SetNewSSDemo(HWND hDlg, int iMethod) { HBITMAP hbmOld; POINT ptIcon; HWND hwndDemo; HICON hicon; RECT rc = {MON_X, MON_Y, MON_X+MON_DX, MON_Y+MON_DY}; hwndDemo = GetSSDemoParent(hDlg); if (hwndDemo) { // blank out the background with dialog color hbmOld = (HBITMAP) SelectObject(g_hdcMem, g_hbmDemo); FillRect(g_hdcMem, &rc, GetSysColorBrush(COLOR_DESKTOP)); SelectObject(g_hdcMem, hbmOld); // make sure the old window is gone EnumChildWindows(hwndDemo, EnumSSChildWindowsProc, (LPARAM)hwndDemo); Yield(); // paranoid Yield(); // really paranoid ShowWindow(hwndDemo, SW_HIDE); g_fPreviewActive = FALSE; if (iMethod >= 0 && aszMethods[iMethod][0] == TEXT('P')) { RECT rc; BITMAP bm; UpdateWindow(hDlg); //UpdateWindow(GetDlgItem(hDlg, IDC_BIGICONSS)); TCHAR szArgs[MAX_PATH]; GetObject(g_hbmDemo, sizeof(bm), &bm); GetClientRect(GetDlgItem(hDlg, IDC_BIGICONSS), &rc); rc.left = ( rc.right - bm.bmWidth ) / 2 + MON_X; rc.top = ( rc.bottom - bm.bmHeight ) / 2 + MON_Y; MoveWindow(hwndDemo, rc.left, rc.top, MON_DX, MON_DY, FALSE); _PathBuildArgs(szArgs, ARRAYSIZE(szArgs), g_szSaverName, TEXT(" /p %d"), hwndDemo); if (WinExecN(g_szSaverName, szArgs, SW_NORMAL) > 32) { ShowWindow(hwndDemo, SW_SHOWNA); g_fPreviewActive = TRUE; return; } } if (iMethod != -1) { ptIcon.x = ClassicGetSystemMetrics(SM_CXICON); ptIcon.y = ClassicGetSystemMetrics(SM_CYICON); // draw the icon double size ASSERT(ptIcon.y*2 <= MON_DY); ASSERT(ptIcon.x*2 <= MON_DX); hicon = hIcons[iMethod]; if (hicon == NULL && aszMethods[iMethod][0] == TEXT('I')) hicon = hIdleWildIcon; if (hicon == NULL) hicon = hDefaultIcon; hbmOld = (HBITMAP) SelectObject(g_hdcMem, g_hbmDemo); DrawIconEx(g_hdcMem, MON_X + (MON_DX-ptIcon.x*2)/2, MON_Y + (MON_DY-ptIcon.y*2)/2, hicon, ptIcon.x*2, ptIcon.y*2, 0, NULL, DI_NORMAL); SelectObject(g_hdcMem, hbmOld); } } InvalidateRect(GetDlgItem(hDlg, IDC_BIGICONSS), NULL, FALSE); } static void SS_SomethingChanged(HWND hDlg) { if (!g_bInitSS) { SendMessage(GetParent(hDlg), PSM_CHANGED, (WPARAM)hDlg, 0L); } } static void SetScreenSaverPassword(HWND hDlg, int iMethod) { if (iMethod >= 0 && aszMethods[iMethod][0] == TEXT('P')) { TCHAR szArgs[MAX_PATH]; _PathBuildArgs(szArgs, ARRAYSIZE(szArgs), g_szSaverName, TEXT(" /a %u"), GetParent(hDlg)); WinExecN(g_szSaverName, szArgs, SW_NORMAL); } } INT_PTR CALLBACK ScreenSaverDlgProc(HWND hDlg, UINT wMsg, WPARAM wParam, LPARAM lParam) { CScreenSaverPg * pThis = (CScreenSaverPg *)GetWindowLongPtr(hDlg, DWLP_USER); if (WM_INITDIALOG == wMsg) { PROPSHEETPAGE * pPropSheetPage = (PROPSHEETPAGE *) lParam; if (pPropSheetPage) { SetWindowLongPtr(hDlg, DWLP_USER, pPropSheetPage->lParam); pThis = (CScreenSaverPg *)pPropSheetPage->lParam; } } if (pThis) return pThis->_ScreenSaverDlgProc(hDlg, wMsg, wParam, lParam); return DefWindowProc(hDlg, wMsg, wParam, lParam); } BOOL SelectSSFromList(HWND hDlg) { HWND hwndSSList = GetDlgItem(hDlg, IDC_CHOICES); BOOL fExistsInList = FALSE; // Select the current item in the list since another tab // may have changed this value. for (UINT nIndex = 0; nIndex < wNumMethods; nIndex++) { if (!StrCmpI(g_szSaverName, aszFiles[nIndex])) { int nItem = ComboBox_FindString(hwndSSList, 0, &(aszMethods[nIndex][1])); if (-1 != nItem) { ComboBox_SetCurSel(hwndSSList, nItem); } fExistsInList = TRUE; break; } } return fExistsInList; } HRESULT CScreenSaverPg::_OnSetActive(void) { EnableDisablePowerDelays(m_hDlg); if (!SelectSSFromList(m_hDlg)) { UINT wTemp; UINT wLoop; // We couldn't find it, so add it to aszMethods[]. SearchForScrEntries(SFSE_FILE, g_szSaverName); // Now add it to the Drop Down. for (wTemp = 0; (wTemp < wNumMethods) && (ARRAYSIZE(aszFiles) > wTemp) && (ARRAYSIZE(aszMethods) > wTemp); wTemp++) { // Did we find the correct index? if (!StrCmpI(FileName(aszFiles[wTemp]), FileName(g_szSaverName))) { // Yes, so set the index. wLoop = (UINT)SendDlgItemMessage(m_hDlg, IDC_CHOICES, CB_ADDSTRING, 0, (LPARAM)(aszMethods[wTemp]+1)); SendDlgItemMessage(m_hDlg, IDC_CHOICES, CB_SETITEMDATA, wLoop, wTemp); break; } } SelectSSFromList(m_hDlg); // Try again now that we added it. Another tab or API may have asked for us to use this SS. } if (!g_fPreviewActive) { g_bInitSS = TRUE; SendMessage(m_hDlg, WM_COMMAND, MAKELONG(IDC_CHOICES, CBN_SELCHANGE), (LPARAM)GetDlgItem(m_hDlg, IDC_CHOICES)); g_bInitSS = FALSE; } return S_OK; } HRESULT CScreenSaverPg::_OnApply(void) { // Our parent dialog will be notified of the Apply event and will call our // IBasePropPage::OnApply() to do the real work. return S_OK; } HRESULT CScreenSaverPg::_OnSelectionChanged(void) { HRESULT hr = E_FAIL; PTSTR pszMethod; int wMethod; BOOL fEnable; // Dump the name of the current selection into the buffer... int wTemp = (int)SendDlgItemMessage(m_hDlg, IDC_CHOICES, CB_GETCURSEL,0,0l); if (wTemp) { wMethod = (int)SendDlgItemMessage(m_hDlg, IDC_CHOICES, CB_GETITEMDATA, wTemp, 0l); // Grey the button accordingly... pszMethod = aszMethods[wMethod]; if ((pszMethod[0] == TEXT('C') || // can config pszMethod[0] == TEXT('I') || // IdleWild pszMethod[0] == TEXT('P')) && !g_fSettingsButtonOffByPolicy) // can preview EnableDlgItem(m_hDlg, IDC_SETTING, TRUE); else EnableDlgItem(m_hDlg, IDC_SETTING, FALSE); if (!g_fPasswordBoxDeterminedByPolicy) { EnableDlgItem(m_hDlg, IDC_USEPASSWORD, TRUE); CheckDlgButton(m_hDlg, IDC_USEPASSWORD, g_fPasswordWasPreviouslyEnabled); } // For fun, create an extra copy of g_szSaverName... pszMethod = aszFiles[wMethod]; StrCpyN(g_szSaverName, pszMethod, ARRAYSIZE(g_szSaverName)); fEnable = TRUE; } else { wMethod = -1; StrCpyN(g_szSaverName, TEXT(""), ARRAYSIZE(g_szSaverName)); EnableDlgItem(m_hDlg, IDC_SETTING, FALSE); EnableDlgItem(m_hDlg, IDC_USEPASSWORD, FALSE); fEnable = FALSE; } // Following are enabled as a group... (oh really?) EnableDlgItem(m_hDlg, IDC_SSDELAYLABEL, fEnable); EnableDlgItem(m_hDlg, IDC_SCREENSAVEDELAY, !g_fTimeoutDeterminedByPolicy && fEnable); EnableDlgItem(m_hDlg, IDC_SCREENSAVEARROW, fEnable); EnableDlgItem(m_hDlg, IDC_SSDELAYSCALE, fEnable); EnableDlgItem(m_hDlg, IDC_TEST, fEnable); g_iMethod = (int)wMethod; SetNewSSDemo(m_hDlg, wMethod); SS_SomethingChanged(m_hDlg); return hr; } INT_PTR CScreenSaverPg::_ScreenSaverDlgProc(HWND hDlg, UINT message , WPARAM wParam, LPARAM lParam) { NMHDR *lpnm; switch(message) { case WM_NOTIFY: lpnm = (NMHDR *)lParam; switch(lpnm->code) { case PSN_APPLY: _OnApply(); break; // nothing to do on cancel... case PSN_RESET: if (g_fPreviewActive) SetNewSSDemo(hDlg, -1); break; case PSN_KILLACTIVE: if (g_fPreviewActive) SetNewSSDemo(hDlg, -1); break; case PSN_SETACTIVE: _OnSetActive(); break; } break; case WM_INITDIALOG: g_bInitSS = TRUE; _InitSSDialog(hDlg); g_bInitSS = FALSE; break; case WM_DISPLAYCHANGE: case WM_SYSCOLORCHANGE: { HBITMAP hbm; hbm = g_hbmDemo; g_hbmDemo = LoadMonitorBitmap( TRUE ); if (g_hbmDemo) { // Got a new bitmap, use it and delete the old one. SendDlgItemMessage(hDlg,IDC_BIGICONSS,STM_SETIMAGE, IMAGE_BITMAP,(LPARAM)g_hbmDemo); if (hbm) { DeleteObject(hbm); } } else { // Couldn't get a new bitmap, just reuse the old one g_hbmDemo = hbm; } break; } case WM_DESTROY: FreeScrEntries(); if (g_fPreviewActive) SetNewSSDemo(hDlg, -1); if (g_hbmDemo) { SendDlgItemMessage(hDlg,IDC_BIGICONSS,STM_SETIMAGE,IMAGE_BITMAP, (LPARAM)NULL); DeleteObject(g_hbmDemo); } if (g_hbmEnergyStar) { SendDlgItemMessage(hDlg,IDC_ENERGYSTAR_BMP,STM_SETIMAGE, IMAGE_BITMAP, (LPARAM)NULL); DeleteObject(g_hbmEnergyStar); } break; case WM_VSCROLL: if (LOWORD(wParam) == SB_THUMBPOSITION) ScreenSaver_AdjustTimeouts(hDlg, GetDlgCtrlID((HWND)lParam) - BCI_ARROW); break; case WM_HELP: WinHelp((HWND) ((LPHELPINFO) lParam)->hItemHandle, TEXT("display.hlp"), HELP_WM_HELP, (DWORD_PTR)aSaverHelpIds); break; case WM_CONTEXTMENU: // right mouse click WinHelp((HWND) wParam, TEXT("display.hlp"), HELP_CONTEXTMENU, (DWORD_PTR) aSaverHelpIds); break; case WM_QUERYNEWPALETTE: case WM_PALETTECHANGED: ForwardSSDemoMsg(hDlg, message, wParam, lParam); break; case WMUSER_SETINITSS: g_bInitSS = (BOOL) lParam; break; case WM_COMMAND: switch(LOWORD(wParam)) { /* Check for a selection change in the combo box. If there is one, then update the method number as well as the configure button... */ case IDC_CHOICES: if(HIWORD(wParam) == CBN_SELCHANGE) { _OnSelectionChanged(); } break; /* If the edit box loses focus, translate... */ case IDC_SCREENSAVEDELAY: if (HIWORD(wParam) == EN_KILLFOCUS) ScreenSaver_AdjustTimeouts(hDlg, LOWORD(wParam)); else //check if initdialog is finished if((FALSE == g_bInitSS) && (EN_CHANGE == (HIWORD(wParam)))) SS_SomethingChanged(hDlg); break; case IDC_LOWPOWERCONFIG: // Configure the low power timeout event. WinExec("rundll32 shell32.dll,Control_RunDLL powercfg.cpl,,", SW_SHOWNORMAL); break; /* If the user wishes to test... */ case IDC_TEST: switch( HIWORD( wParam ) ) { case BN_CLICKED: DoScreenSaver(hDlg,TRUE); break; } break; /* Tell the DLL that it can do the configure... */ case IDC_SETTING: if (HIWORD(wParam) == BN_CLICKED) { DoScreenSaver(hDlg,FALSE); break; } case IDC_USEPASSWORD: if (HIWORD(wParam) == BN_CLICKED) { // the user actually toggled the checbox, so set our dirty flag g_fPasswordDirty = TRUE; g_fPasswordWasPreviouslyEnabled = IsDlgButtonChecked( hDlg, IDC_USEPASSWORD ); SS_SomethingChanged(hDlg); break; } case IDC_SETPASSWORD: if (HIWORD(wParam) == BN_CLICKED) { // ask new savers to change passwords int wTemp = (int)SendDlgItemMessage(hDlg,IDC_CHOICES, CB_GETCURSEL,0,0l); if (wTemp) { SetScreenSaverPassword(hDlg, (int)SendDlgItemMessage(hDlg,IDC_CHOICES, CB_GETITEMDATA,wTemp,0l)); } break; } } break; case WM_CTLCOLORSTATIC: if( (HWND)lParam == GetSSDemoParent( hDlg ) ) { return (INT_PTR)GetStockObject( NULL_BRUSH ); } break; } return FALSE; } /******************************************************************************* * * ScreenSaver_AdjustTimeouts * * DESCRIPTION: * Called whenever the user adjusts the delay of one of the time controls. * Adjusts the delays of the other time controls such that the screen saver * delay is less than the low power delay and that the low power delay is * less than the power off delay. * * PARAMETERS: * hWnd, handle of ScreenSaver window. * BaseControlID, base control ID of the radio, edit, and arrow time control * combination. * *******************************************************************************/ VOID NEAR PASCAL ScreenSaver_AdjustTimeouts(HWND hWnd, int BaseControlID) { BOOL fTranslated; int Timeout; // Get the new timeout for this time control and validate it's contents. Timeout = (int) GetDlgItemInt(hWnd, BaseControlID + BCI_DELAY, &fTranslated, FALSE); Timeout = min(max(Timeout, 1), MAX_MINUTES); SetDlgItemInt(hWnd, BaseControlID + BCI_DELAY, (UINT) Timeout, FALSE); // Check the new value of this time control against the other timeouts, // adjust their values if necessary. Be careful when changing the order // of these conditionals. // if (BaseControlID == IDC_SCREENSAVEDELAY) { if (g_Timeout[TA_SCREENSAVE] != Timeout) { g_Timeout[TA_SCREENSAVE] = Timeout; SS_SomethingChanged(hWnd); } } else { if (Timeout < g_Timeout[TA_SCREENSAVE]) { g_Timeout[TA_SCREENSAVE] = Timeout; SetDlgItemInt(hWnd, IDC_SCREENSAVEDELAY, (UINT) Timeout, FALSE); } } } void EnableDisablePowerDelays(HWND hDlg) { int i; static idCtrls[] = { IDC_ENERGY_TEXT, IDC_ENERGY_TEXT2, IDC_ENERGY_TEXT3, IDC_ENERGYSTAR_BMP, IDC_LOWPOWERCONFIG, 0 }; for (i = 0; idCtrls[i] != 0; i++) ShowWindow( GetDlgItem( hDlg, idCtrls[i] ), g_fAdapPwrMgnt ? SW_SHOWNA : SW_HIDE ); } /* This routine will search for entries that are screen savers. The directory searched is either the system directory (.. */ void SearchForScrEntries(UINT wDir, LPCTSTR file) { TCHAR szPath[MAX_PATH]; TCHAR szPath2[MAX_PATH]; HANDLE hfind; WIN32_FIND_DATA fd; // don't do any work if no space left if( wNumMethods >= MAX_METHODS ) return; /* Get the directory where the program resides... */ GetModuleFileName(HINST_THISDLL, szPath, ARRAYSIZE(szPath)); StripPathName(szPath); switch ( wDir ) { case SFSE_WINDOWS: /* Search the windows directory and place the path with the \ in the szPath variable... */ if (!GetWindowsDirectory(szPath2, ARRAYSIZE(szPath2))) { szPath2[0] = 0; } sfseSanityCheck: /* if same dir as where it was launched, don't search again */ if (!lstrcmpi(szPath, szPath2)) return; StrCpyN(szPath, szPath2, ARRAYSIZE(szPath)); break; case SFSE_SYSTEM: /* Search the system directory and place the path with the \ in the szPath variable... */ GetSystemDirectory(szPath2, ARRAYSIZE(szPath2)); goto sfseSanityCheck; case SFSE_FILE: /* Search the directory containing 'file' */ StrCpyN(szPath2, file, ARRAYSIZE(szPath2)); StripPathName(szPath2); goto sfseSanityCheck; } AppendPath(szPath, TEXT("*.scr")); if( ( hfind = FindFirstFile( szPath, &fd ) ) != INVALID_HANDLE_VALUE ) { StripPathName(szPath); do { PTSTR pszDesc; BOOL fLFN; fLFN = !(fd.cAlternateFileName[0] == 0 || lstrcmp(fd.cFileName, fd.cAlternateFileName) == 0); StrCpyN(szPath2, szPath, ARRAYSIZE(szPath2)); AppendPath(szPath2, fd.cFileName); // Note: PerformCheck does an alloc if( ( pszDesc = PerformCheck( szPath2, fLFN ) ) != NULL ) { BOOL bAdded = FALSE; UINT i; for( i = 0; i < wNumMethods; i++ ) { if( !lstrcmpi( pszDesc, aszMethods[ i ] ) ) { bAdded = TRUE; break; } } if( !bAdded ) { PTSTR pszEntries; // COMPATIBILITY: always use short name // otherwise some apps fault when peeking at SYSTEM.INI if( fLFN ) { StrCpyN(szPath2, szPath, ARRAYSIZE(szPath2)); AppendPath(szPath2, fd.cAlternateFileName); } if( ( pszEntries = StrDup( szPath2 ) ) != NULL ) { if (pszDesc[0] != TEXT('P')) hIcons[wNumMethods] = ExtractIcon(HINST_THISDLL, szPath2, 0); else hIcons[wNumMethods] = NULL; aszMethods[wNumMethods] = pszDesc; aszFiles[wNumMethods] = pszEntries; wNumMethods++; bAdded = TRUE; } } if( !bAdded ) LocalFree((HLOCAL)pszDesc); } } while( FindNextFile( hfind, &fd ) && ( wNumMethods < MAX_METHODS ) ); FindClose(hfind); } return; } // // This routine checks a given file to see if it is indeed a screen saver // executable... // // a valid screen saver exe has the following description line: // // SCRNSAVE [c] : description : // // SCRNSAVE is a required name that indicates a screen saver. // PTSTR PerformCheck(LPTSTR lpszFilename, BOOL fLFN) { int i; TCHAR chConfig=TEXT('C'); // assume configure LPTSTR pch; DWORD dw; WORD Version; WORD Magic; TCHAR szBuffer[MAX_PATH]; DWORD cchSizePch = (ARRAYSIZE(szBuffer)-1); // Get the description... pch = szBuffer + 1; // if we have a LFN (Long File Name) dont bother getting the // exe descrription dw = GetExeInfo(lpszFilename, pch, cchSizePch, fLFN ? GEI_EXPVER : GEI_DESCRIPTION); Version = HIWORD(dw); Magic = LOWORD(dw); if (dw == 0) return NULL; if (Magic == PEMAGIC || fLFN) { BOOL fGotName = FALSE; if (!fLFN) { HINSTANCE hSaver = LoadLibraryEx(lpszFilename, NULL, LOAD_LIBRARY_AS_DATAFILE); // We have a 32 bit screen saver with a short name, look for an NT style // decription in it's string table if (hSaver) { if (LoadString(hSaver, IDS_DESCRIPTION, pch, cchSizePch)) { fGotName = TRUE; } FreeLibrary(hSaver); } } if (!fGotName) { // we have a LFN (LongFileName) or a Win32 screen saver, // Win32 exe's in general dont have a description field so // we assume they can configure. We also try to build // a "nice" name for it. StrCpyN(pch, lpszFilename, cchSizePch); pch = FileName(pch); // strip path part if ( ((TCHAR)CharUpper((LPTSTR)(pch[0]))) == TEXT('S') && ((TCHAR)CharUpper((LPTSTR)(pch[1]))) == TEXT('S')) // map SSBEZIER.SCR to BEZIER.SCR pch+=2; pch = NiceName(pch); // map BEZIER.SCR to Bezier } } else { LPTSTR pchTemp; // we have a 8.3 file name 16bit screen saveer, parse the // description string from the exehdr /* Check to make sure that at least the 11 characters needed for info are there... */ if (lstrlen(pch) < 9) return NULL; /* Check the first 8 characters for the string... */ if (lstrncmp(TEXT("SCRNSAVE"), pch, 8)) return NULL; // If successful, allocate enough space for the string and copy the // string to the new one... pch = pch + 8; // skip over 'SCRNSAVE' while (*pch==TEXT(' ')) // advance over white space pch++; if (*pch==TEXT('C') || *pch==TEXT('c')) // parse the configure flag { chConfig = TEXT('C'); pch++; } if (*pch==TEXT('X') || *pch==TEXT('x')) // parse the don't configure flag chConfig = *pch++; // we might be pointing at a name or separation goop pchTemp = pch; // remember this spot while (*pch && *pch!=TEXT(':')) // find separator pch++; while (*pch==TEXT(':') || *pch==TEXT(' ')) // advance over whtspc/last colon pch++; // if we haven't found a name yet fall back on the saved location if (!*pch) pch = pchTemp; while (*pch==TEXT(':') || *pch==TEXT(' ')) // re-advance over whtspc pch++; /* In case the screen saver has version information information embedded after the name, check to see if there is a colon TEXT(':') in the description and replace it with a NULL... */ for (i=0; pch[i]; i++) // { #if defined(DBCS) || (defined(FE_SB) && !defined(UNICODE)) if (IsDBCSLeadByte(pch[i])) { i++; } else #endif if (pch[i]==TEXT(':')) pch[i]=0; } // Space is OK for DBCS (FE) while(i>0 && pch[i-1]==TEXT(' ')) // remove trailing space pch[--i]=0; } #ifdef DEBUG if (Magic != PEMAGIC) { lstrcat(pch, TEXT(" (16-bit)")); } if (Version == 0x030A) lstrcat(pch, TEXT(" (3.10)")); if (Version == 0x0400) lstrcat(pch, TEXT(" (4.00)")); #endif // // assume any Win32 4.0 screen saver can do Preview mode // if (chConfig == TEXT('C') && Version >= 0x0400 && Magic == PEMAGIC) chConfig = TEXT('P'); // mark as configurable/preview pch[-1] = chConfig; return StrDup(pch-1); } BOOL FreeScrEntries( void ) { UINT wLoop; for(wLoop = 0; wLoop < wNumMethods; wLoop++) { if(aszMethods[wLoop] != NULL) LocalFree((HANDLE)aszMethods[wLoop]); if(aszFiles[wLoop] != NULL) LocalFree((HANDLE)aszFiles[wLoop]); if(hIcons[wLoop] != NULL) FreeResource(hIcons[wLoop]); } if (hDefaultIcon) FreeResource(hDefaultIcon); if (hIdleWildIcon) FreeResource(hIdleWildIcon); hDefaultIcon=hIdleWildIcon=NULL; wNumMethods = 0; return TRUE; } int lstrncmp( LPTSTR lpszString1, LPTSTR lpszString2, int nNum ) { /* While we can still compare characters, compare. If the strings are of different lengths, characters will be different... */ while(nNum) { if(*lpszString1 != *lpszString2) return *lpszString1 - *lpszString2; lpszString1++; lpszString2++; nNum--; } return 0; } HRESULT CScreenSaverPg::_SaveIni(HWND hDlg) { HRESULT hr = S_OK; LPTSTR pszMethod = TEXT(""); BOOL bSSActive; int wMethod,wTemp; UINT Counter; HKEY hKey; TCHAR szBuffer[MAX_PATH]; if (m_fUIInitialized) { // Find the current method selection... wTemp = 0; if (wNumMethods) { // Dump the name of the current selection into the buffer... wTemp = (int)SendDlgItemMessage(hDlg, IDC_CHOICES, CB_GETCURSEL, 0, 0); if (wTemp) { wMethod = (int)SendDlgItemMessage(hDlg, IDC_CHOICES, CB_GETITEMDATA, wTemp, 0); // Dump the method name into the buffer... pszMethod = aszFiles[wMethod]; } } // since "(None)" is always the first entry in the combobox, we can use it to see if we have // a screensaver or not if (wTemp == 0) { // 0th inxed is "(None)" so the screensaver is disabled bSSActive = FALSE; } else { bSSActive = TRUE; } } else { TCHAR szNone[MAX_PATH]; LoadString(HINST_THISDLL, IDS_NONE, szNone, ARRAYSIZE(szNone)); if ((g_szSaverName[0] == TEXT('\0')) || (lstrcmpi(szNone, g_szSaverName) == 0)) { // screensaver was not set, OR it was set to "(None)" -- therefore it is not active bSSActive = FALSE; } else { bSSActive = TRUE; } pszMethod = g_szSaverName; } // Now quote any spaces BOOL hasspace = FALSE; LPTSTR pc; for (pc = pszMethod; *pc; pc++) { if (*pc == TEXT(' ')) { hasspace = TRUE; break; } } if (hasspace) { // if we need to add quotes we'll need two sets // because GetBlahBlahProfileBlah APIs strip quotes wnsprintf(szBuffer, ARRAYSIZE(szBuffer), TEXT("\"\"%s\"\""), pszMethod); } else { StrCpyN(szBuffer, pszMethod, ARRAYSIZE(szBuffer)); } // Save the buffer... if (!WritePrivateProfileString(SZ_INISECTION_SCREENSAVER, SZ_INIKEY_SCREENSAVER, (szBuffer[0] != TEXT('\0') ? szBuffer : NULL), SZ_INISECTION_SYSTEMINI)) { hr = HRESULT_FROM_WIN32(GetLastError()); } // In win2k we decided to leave the screensaver ALWAYS active so that when the policy changed, it would take // w/out rebooting. This has become a PITA so we now do it the right way. ClassicSystemParametersInfo(SPI_SETSCREENSAVEACTIVE, bSSActive, NULL, SPIF_UPDATEINIFILE); for (Counter = 0; Counter < (sizeof(g_TimeoutAssociation) / sizeof(TIMEOUT_ASSOCIATION)); Counter++) { ClassicSystemParametersInfo(g_TimeoutAssociation[Counter].taSetTimeoutAction, (UINT) (g_Timeout[Counter] * 60), NULL, SPIF_UPDATEINIFILE); if (Counter != TA_SCREENSAVE) { ClassicSystemParametersInfo(g_TimeoutAssociation[Counter].taSetActiveAction, IsDlgButtonChecked(hDlg, g_TimeoutAssociation[Counter].taBaseControlID + BCI_SWITCH), NULL, SPIF_UPDATEINIFILE); } } // save the state of the TEXT("use password") checkbox if (RegCreateKey(HKEY_CURRENT_USER, REGSTR_PATH_SCREENSAVE, &hKey) == ERROR_SUCCESS) { if (g_fPasswordDirty) { if (g_fFriendlyUI) { // the user actually toggled the value, so don't automatically return to the welcome screen since they have // now made their own decision on this subject RegSetValueEx(hKey, TEXT("NoAutoReturnToWelcome"), 0, REG_SZ, (BYTE*)TEXT("1"), sizeof(TEXT("1"))); RegSetValueEx(hKey, SZ_USE_PASSWORD, 0, PWRD_REG_TYPE, PasswdRegData(IsDlgButtonChecked(hDlg,IDC_USEPASSWORD)), CB_USE_PWRD_VALUE); } else { RegSetValueEx(hKey, SZ_USE_PASSWORD, 0, PWRD_REG_TYPE, PasswdRegData(IsDlgButtonChecked(hDlg,IDC_USEPASSWORD)), CB_USE_PWRD_VALUE); } } RegCloseKey(hKey); } // Broadcast a WM_WININICHANGE message... SendNotifyMessage(HWND_BROADCAST, WM_WININICHANGE, 0, (LPARAM)TEXT("Windows")); return hr; } /* * Thread for DoScreenSaver() */ typedef struct { HWND hDlg; TCHAR szPath[MAX_PATH]; TCHAR szArgs[MAX_PATH]; } SSRUNDATA, *LPSSRUNDATA; DWORD RunScreenSaverThread( LPVOID lpv ) { BOOL bSvrState; LPSSRUNDATA lpssrd; HWND hwndSettings, hwndPreview; STARTUPINFO StartupInfo; PROCESS_INFORMATION ProcessInformation; HINSTANCE hiThd; TCHAR szPath[MAX_PATH]; // Lock ourselves in mem so we don't fault if app unloads us GetModuleFileName(HINST_THISDLL, szPath, ARRAYSIZE(szPath)); hiThd = LoadLibrary( szPath ); lpssrd = (LPSSRUNDATA)lpv; hwndSettings = GetDlgItem( lpssrd->hDlg, IDC_SETTING); hwndPreview = GetDlgItem( lpssrd->hDlg, IDC_TEST); // Save previous screen saver state ClassicSystemParametersInfo( SPI_GETSCREENSAVEACTIVE,0, &bSvrState, FALSE); // Disable current screen saver if( bSvrState ) ClassicSystemParametersInfo( SPI_SETSCREENSAVEACTIVE,FALSE, NULL, FALSE ); // Stop the miniture preview screen saver if (g_fPreviewActive) SetNewSSDemo( lpssrd->hDlg, -1); // Exec the screen saver and wait for it to die ZeroMemory(&StartupInfo,sizeof(StartupInfo)); StartupInfo.cb = sizeof(StartupInfo); StartupInfo.dwFlags = STARTF_USESHOWWINDOW; StartupInfo.wShowWindow = (WORD)SW_NORMAL; if (CreateProcess(lpssrd->szPath, lpssrd->szArgs, NULL, NULL, FALSE, 0, NULL, NULL, &StartupInfo, &ProcessInformation)) { WaitForSingleObject( ProcessInformation.hProcess, INFINITE ); CloseHandle(ProcessInformation.hProcess); CloseHandle(ProcessInformation.hThread); } // Restore Screen saver state if( bSvrState ) ClassicSystemParametersInfo( SPI_SETSCREENSAVEACTIVE, bSvrState, NULL, FALSE ); // Restart miniture preview PostMessage(lpssrd->hDlg, WMUSER_SETINITSS, NULL, (LPARAM)TRUE); PostMessage(lpssrd->hDlg, WM_COMMAND, MAKELONG(IDC_CHOICES, CBN_SELCHANGE), (LPARAM)GetDlgItem( lpssrd->hDlg, IDC_CHOICES)); PostMessage(lpssrd->hDlg, WMUSER_SETINITSS, NULL, (LPARAM)FALSE); // Enable setting and preview buttons EnableWindow( hwndSettings, TRUE ); EnableWindow( hwndPreview, TRUE ); LocalFree( lpv ); if (hiThd) { FreeLibraryAndExitThread( hiThd, 0 ); } return 0; } // This routine actually calls the screen saver... void DoScreenSaver(HWND hWnd, BOOL fSaver) { if (g_szSaverName[0] != TEXT('\0')) { LPSSRUNDATA lpssrd = (LPSSRUNDATA) LocalAlloc(LMEM_FIXED, sizeof(*lpssrd)); if (lpssrd != NULL) { lpssrd->hDlg = hWnd; StrCpyN(lpssrd->szPath, g_szSaverName, ARRAYSIZE(lpssrd->szPath)); if (fSaver) { _PathBuildArgs(lpssrd->szArgs, ARRAYSIZE(lpssrd->szArgs), g_szSaverName, TEXT(" /s")); } else { _PathBuildArgs(lpssrd->szArgs, ARRAYSIZE(lpssrd->szArgs), g_szSaverName, TEXT(" /c:%lu"), (LPARAM)hWnd); } // Disable setting and preview buttons HWND hwndSettings = GetDlgItem(hWnd, IDC_SETTING); HWND hwndPreview = GetDlgItem(hWnd, IDC_TEST); EnableWindow(hwndSettings, FALSE); EnableWindow(hwndPreview, FALSE); DWORD id; HANDLE hThd = CreateThread(NULL, 0, RunScreenSaverThread, lpssrd, 0, &id); if (hThd != NULL) { CloseHandle(hThd); } else { // Exec failed, re-enable setting and preview buttons and clean up thread params EnableWindow(hwndSettings, TRUE); EnableWindow(hwndPreview, TRUE); LocalFree(lpssrd); } } } } #define SLASH(c) ((c) == TEXT('/') || (c) == TEXT('\\')) LPTSTR FileName(LPTSTR szPath) { LPTSTR sz; for (sz=szPath; *sz; sz++) { NULL; } #if defined(DBCS) || (defined(FE_SB) && !defined(UNICODE)) for (; sz>szPath && !SLASH(*sz) && *sz!=TEXT(':'); sz=CharPrev(szPath, sz)) #else for (; sz>=szPath && !SLASH(*sz) && *sz!=TEXT(':'); sz--) #endif { NULL; } #if defined(DBCS) || (defined(FE_SB) && !defined(UNICODE)) if ( !IsDBCSLeadByte(*sz) && (SLASH(*sz) || *sz == TEXT(':')) ) { sz = CharNext(sz); } return sz; #else return ++sz; #endif } void AddBackslash(LPTSTR pszPath) { #if defined(DBCS) || (defined(FE_SB) && !defined(UNICODE)) LPTSTR lpsz = &pszPath[lstrlen(pszPath)]; lpsz = CharPrev(pszPath, lpsz); if ( *lpsz != TEXT('\\') ) #else if( pszPath[ lstrlen( pszPath ) - 1 ] != TEXT('\\') ) #endif { lstrcat( pszPath, TEXT("\\") ); } } LPTSTR StripPathName(LPTSTR szPath) { LPTSTR sz; #if defined(DBCS) || (defined(FE_SB) && !defined(UNICODE)) LPTSTR szFile; #endif sz = FileName(szPath); #if defined(DBCS) || (defined(FE_SB) && !defined(UNICODE)) szFile = sz; if ( szFile >szPath+1 ) { szFile = CharPrev( szPath, szFile ); if (SLASH(*szFile)) { szFile = CharPrev(szPath, szFile); if (*szFile != TEXT(':')) { sz--; } } } #else if (sz > szPath+1 && SLASH(sz[-1]) && sz[-2] != TEXT(':')) { sz--; } #endif *sz = 0; return szPath; } void AppendPath(LPTSTR pszPath, LPTSTR pszSpec) { AddBackslash(pszPath); lstrcat(pszPath, pszSpec); } LPTSTR NiceName(LPTSTR szPath) { LPTSTR sz; LPTSTR lpsztmp; sz = FileName(szPath); for(lpsztmp = sz; *lpsztmp && *lpsztmp != TEXT('.'); lpsztmp = CharNext(lpsztmp)) { NULL; } *lpsztmp = TEXT('\0'); if (IsCharUpper(sz[0]) && IsCharUpper(sz[1])) { CharLower(sz); CharUpperBuff(sz, 1); } return sz; } HRESULT HrStrToVariant(IN LPCWSTR pszString, VARIANT * pVar) { HRESULT hr = E_INVALIDARG; if (pszString && pVar) { pVar->vt = VT_BSTR; hr = HrSysAllocStringW(pszString, &pVar->bstrVal); } return hr; } //=========================== // *** IBasePropPage Interface *** //=========================== HRESULT CScreenSaverPg::GetAdvancedDialog(OUT IAdvancedDialog ** ppAdvDialog) { HRESULT hr = E_INVALIDARG; if (ppAdvDialog) { *ppAdvDialog = NULL; hr = E_NOTIMPL; // We don't want to add an Advnaced Dialog. } return hr; } HRESULT CScreenSaverPg::OnApply(IN PROPPAGEONAPPLY oaAction) { HRESULT hr = S_OK; if (PPOAACTION_CANCEL != oaAction) { if (m_hDlg) { // Make sure the time we have is the last one entered... SendMessage(m_hDlg, WM_COMMAND, MAKELONG(IDC_SCREENSAVEDELAY, EN_KILLFOCUS), (LPARAM)GetDlgItem(m_hDlg, IDC_SCREENSAVEDELAY)); } // Try to save the current settings... _SaveIni(m_hDlg); } if (PPOAACTION_OK == oaAction) { } return hr; } //=========================== // *** IShellPropSheetExt Interface *** //=========================== HRESULT CScreenSaverPg::AddPages(IN LPFNSVADDPROPSHEETPAGE pfnAddPage, IN LPARAM lParam) { HRESULT hr = E_INVALIDARG; PROPSHEETPAGE psp = {0}; psp.dwSize = sizeof(psp); psp.hInstance = HINST_THISDLL; psp.dwFlags = PSP_DEFAULT; psp.lParam = (LPARAM) this; psp.pszTemplate = MAKEINTRESOURCE(DLG_SCREENSAVER); psp.pfnDlgProc = ScreenSaverDlgProc; HPROPSHEETPAGE hpsp = CreatePropertySheetPage(&psp); if (hpsp) { if (pfnAddPage(hpsp, lParam)) { hr = S_OK; } else { DestroyPropertySheetPage(hpsp); hr = E_FAIL; } } return hr; } //=========================== // *** IPropertyBag Interface *** //=========================== HRESULT CScreenSaverPg::Read(IN LPCOLESTR pszPropName, IN VARIANT * pVar, IN IErrorLog *pErrorLog) { HRESULT hr = E_INVALIDARG; if (pszPropName && pVar) { if (!StrCmpW(pszPropName, SZ_PBPROP_SCREENSAVER_PATH)) { // The caller is asking for the ScreenSaver path. WCHAR szLongPath[MAX_PATH]; DWORD cchSize = GetLongPathName(g_szSaverName, szLongPath, ARRAYSIZE(szLongPath)); if ((0 == cchSize) || (ARRAYSIZE(szLongPath) < cchSize)) { // It failed StrCpyNW(szLongPath, g_szSaverName, ARRAYSIZE(szLongPath)); } hr = HrStrToVariant(szLongPath, pVar); } } return hr; } HRESULT CScreenSaverPg::Write(IN LPCOLESTR pszPropName, IN VARIANT *pVar) { HRESULT hr = E_INVALIDARG; if (pszPropName && pVar && (VT_BSTR == pVar->vt)) { if (!StrCmpW(pszPropName, SZ_PBPROP_SCREENSAVER_PATH)) { if (m_fScreenSavePolicy && !m_fScreenSaveActive) { hr = HRESULT_FROM_WIN32(ERROR_ACCESS_DENIED); } else { _SetByPath(pVar->bstrVal); hr = S_OK; } } } return hr; } HRESULT CScreenSaverPg::_SetByPath(LPCWSTR pszPath) { HRESULT hr = S_OK; // COMPATIBILITY: always use short name // otherwise some apps fault when peeking at SYSTEM.INI DWORD cchSize = GetShortPathNameW(pszPath, g_szSaverName, ARRAYSIZE(g_szSaverName)); if ((0 == cchSize) || (ARRAYSIZE(g_szSaverName) < cchSize)) { // It failed StrCpyNW(g_szSaverName, pszPath, ARRAYSIZE(g_szSaverName)); } if (m_hDlg) { ComboBox_SetCurSel(m_hDlg, 0); SelectSSFromList(m_hDlg); } return hr; } //=========================== // *** IUnknown Interface *** //=========================== ULONG CScreenSaverPg::AddRef() { m_cRef++; return m_cRef; } ULONG CScreenSaverPg::Release() { ASSERT(m_cRef > 0); m_cRef--; if (m_cRef > 0) return m_cRef; delete this; return 0; } HRESULT CScreenSaverPg::QueryInterface(REFIID riid, void **ppvObj) { static const QITAB qit[] = { QITABENT(CScreenSaverPg, IObjectWithSite), QITABENT(CScreenSaverPg, IPropertyBag), QITABENT(CScreenSaverPg, IPersist), QITABENT(CScreenSaverPg, IBasePropPage), QITABENTMULTI(CScreenSaverPg, IShellPropSheetExt, IBasePropPage), { 0 }, }; return QISearch(this, qit, riid, ppvObj); } //=========================== // *** Class Methods *** //=========================== CScreenSaverPg::CScreenSaverPg() : CObjectCLSID(&PPID_ScreenSaver), m_cRef(1) { // This needs to be allocated in Zero Inited Memory. // Assert that all Member Variables are inited to Zero. // This is a global that we want to initialize. g_szSaverName[0] = TEXT('\0'); m_fScreenSavePolicy = FALSE; m_fScreenSaveActive = TRUE; m_lWaitTime = 0; m_hDlg = NULL; m_fUIInitialized = FALSE; _InitState(); } CScreenSaverPg::~CScreenSaverPg() { } HRESULT CScreenSaverPage_CreateInstance(IN IUnknown * punkOuter, IN REFIID riid, OUT LPVOID * ppvObj) { HRESULT hr = E_INVALIDARG; if (!punkOuter && ppvObj) { CScreenSaverPg * pThis = new CScreenSaverPg(); *ppvObj = NULL; if (pThis) { hr = pThis->QueryInterface(riid, ppvObj); pThis->Release(); } else { hr = E_OUTOFMEMORY; } } return hr; }