able/windows-nt
1
0
Fork 0
Code Issues Pull requests Projects Releases Wiki Activity
windows-nt/Source/XPSP1/NT/shell/themes/themeui/screensaverpg.cpp

2292 lines
68 KiB
C++
Raw Normal View History

Add source files
2020-09-26 03:20:57 -05:00
/*****************************************************************************\
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 <scrnsave.h>
#include "exe.h"
#include "ScreenSaverPg.h"
#include <MSGinaExports.h> // 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;
}
Reference in a new issue Copy permalink