//--------------------------------------------------------------------------- // // File: plustab.cpp // // Main Implementation of the Effects page // //--------------------------------------------------------------------------- #include "priv.h" #pragma hdrstop #include "shlwapip.h" #include "shlguidp.h" #include "EffectsAdvPg.h" #include "store.h" #include "regutil.h" // OLE-Registry magic number GUID CLSID_EffectsPage = { 0x41e300e0, 0x78b6, 0x11ce,{0x84, 0x9b, 0x44, 0x45, 0x53, 0x54, 0x00, 0x00}}; #define SPI_GETKEYBOARDINDICATORS SPI_GETMENUUNDERLINES//0x100A #define SPI_SETKEYBOARDINDICATORS SPI_SETMENUUNDERLINES//0x100B #define SPI_GETFONTCLEARTYPE 116 #define SPI_SETFONTCLEARTYPE 117 // Handle to the DLL extern HINSTANCE g_hInst; // vars needed for new shell api #define SZ_SHELL32 TEXT("shell32.dll") #define SZ_SHUPDATERECYCLEBINICON "SHUpdateRecycleBinIcon" // Parameter for GetProcAddr()... DO NOT TEXT("") IT! typedef void (* PFNSHUPDATERECYCLEBINICON)( void ); // Function prototype BOOL CALLBACK PlusPackDlgProc( HWND hDlg, UINT uMessage, WPARAM wParam, LPARAM lParam ); // Icon Stuff int GetIconState (void); BOOL ChangeIconSizes(int iOldState, int iNewState); // animation stuff WPARAM GetAnimations(DWORD *pdwEffect); void SetAnimations(WPARAM wVal, DWORD dwEffect, DWORD dwBroadCast); BOOL DisplayFontSmoothingDetails(DWORD *pdwSetting) { return FALSE; } int GetBitsPerPixel(void) { int iBitsPerPixel = 8; HDC hDC = GetDC(NULL); if (hDC) { iBitsPerPixel = GetDeviceCaps(hDC, BITSPIXEL); ReleaseDC(NULL, hDC); } return iBitsPerPixel; } int GetIconState(void) { BOOL bRet; int iSize; bRet = GetRegValueInt(HKEY_CURRENT_USER, SZ_REGKEY_USERMETRICS, SZ_REGVALUE_ICONSIZE, &iSize); if (bRet == FALSE) return ICON_DEFAULT; if (iSize == ICON_DEFAULT_NORMAL) return ICON_DEFAULT; else if (iSize == ICON_DEFAULT_LARGE) return ICON_LARGE; return ICON_INDETERMINATE; } BOOL ChangeIconSizes(int iOldState, int iNewState) { BOOL bRet; int iOldSize, iNewSize; int iHorz; int iVert; // Don't bother if nothing changed if (iOldState == iNewState) return FALSE; // Get New Size switch (iNewState) { case ICON_DEFAULT: iNewSize = ICON_DEFAULT_NORMAL; break; case ICON_LARGE: iNewSize = ICON_DEFAULT_LARGE; break; case ICON_INDETERMINATE: // Don't bother to change anything return FALSE; default: return FALSE; } // Get Original Size bRet = GetRegValueInt(HKEY_CURRENT_USER, SZ_REGKEY_USERMETRICS, SZ_REGVALUE_ICONSIZE, &iOldSize); if (!bRet) { // Try geting system default instead iOldSize = ClassicGetSystemMetrics(SM_CXICON); } // Don't need to change size if nothing has really changed if (iNewSize == iOldSize) return FALSE; // Get new horizontal spacing iHorz = ClassicGetSystemMetrics(SM_CXICONSPACING); iHorz -= iOldSize; if (iHorz < 0) { iHorz = 0; } iHorz += iNewSize; // Get new vertical spacing iVert = ClassicGetSystemMetrics(SM_CYICONSPACING); iVert -= iOldSize; if (iVert < 0) { iVert = 0; } iVert += iNewSize; // Set New sizes and spacing bRet = SetRegValueInt(HKEY_CURRENT_USER, SZ_REGKEY_USERMETRICS, SZ_REGVALUE_ICONSIZE, iNewSize); if (!bRet) return FALSE; // We don't need to call the Async version because this function is called on a background thread. ClassicSystemParametersInfo(SPI_ICONHORIZONTALSPACING, iHorz, NULL, (SPIF_UPDATEINIFILE | SPIF_SENDWININICHANGE)); ClassicSystemParametersInfo(SPI_ICONVERTICALSPACING, iVert, NULL, (SPIF_UPDATEINIFILE | SPIF_SENDWININICHANGE)); // We need to do this in order to force DefView to update. // BUG:194437 ICONMETRICS iconMetrics; iconMetrics.cbSize = sizeof(iconMetrics); ClassicSystemParametersInfo(SPI_GETICONMETRICS, sizeof(iconMetrics), &iconMetrics, 0); ClassicSystemParametersInfo(SPI_SETICONMETRICS, sizeof(iconMetrics), &iconMetrics, SPIF_UPDATEINIFILE | SPIF_SENDWININICHANGE); // We did change the sizes return TRUE; } // // GetAnimations // // Get current state of animations (windows / menus / etc.). // WPARAM GetAnimations(DWORD *pdwEffect) { BOOL fMenu = FALSE, fWindow = FALSE, fCombo = FALSE, fSmooth = FALSE, fList = FALSE, fFade = FALSE; ANIMATIONINFO ai; ai.cbSize = sizeof(ai); if (ClassicSystemParametersInfo(SPI_GETANIMATION, sizeof(ai), (PVOID)&ai, 0 )) { fWindow = (ai.iMinAnimate) ? TRUE : FALSE; } ClassicSystemParametersInfo(SPI_GETCOMBOBOXANIMATION, 0, (PVOID)&fCombo, 0 ); ClassicSystemParametersInfo(SPI_GETLISTBOXSMOOTHSCROLLING, 0, (PVOID)&fList, 0 ); ClassicSystemParametersInfo(SPI_GETMENUANIMATION, 0, (PVOID)&fMenu, 0 ); fSmooth = GetRegValueDword(HKEY_CURRENT_USER, SZ_REGKEY_CPDESKTOP, SZ_REGVALUE_SMOOTHSCROLL); if (fSmooth == REG_BAD_DWORD) { fSmooth = 1; } ClassicSystemParametersInfo(SPI_GETMENUFADE, 0, (PVOID)&fFade, 0 ); *pdwEffect = (fFade ? MENU_EFFECT_FADE : MENU_EFFECT_SCROLL); if (fMenu && fWindow && fCombo && fSmooth && fList) return BST_CHECKED; if ((!fMenu) && (!fWindow) && (!fCombo) && (!fSmooth) && (!fList)) return BST_UNCHECKED; return BST_INDETERMINATE; } // // SetAnimations // // Set animations according (windows / menus / etc.) according to flag. // void SetAnimations(WPARAM wVal, DWORD dwEffect, DWORD dwBroadcast) { if (!IsTSPerfFlagEnabled(TSPerFlag_NoAnimation)) { ANIMATIONINFO ai; // Note, if the checkbox is indeterminate, we treat it like it was checked. // We should never get this far if the user didn't change something so this should be okay. BOOL bVal = (wVal == BST_UNCHECKED) ? 0 : 1; BOOL bEfx = (dwEffect == MENU_EFFECT_FADE) ? 1 : 0; ai.cbSize = sizeof(ai); ai.iMinAnimate = bVal; ClassicSystemParametersInfo(SPI_SETANIMATION, sizeof(ai), (PVOID)&ai, dwBroadcast); ClassicSystemParametersInfo(SPI_SETCOMBOBOXANIMATION, 0, IntToPtr(bVal), dwBroadcast); ClassicSystemParametersInfo(SPI_SETLISTBOXSMOOTHSCROLLING, 0, IntToPtr(bVal), dwBroadcast); ClassicSystemParametersInfo(SPI_SETMENUANIMATION, 0, IntToPtr(bVal), dwBroadcast); ClassicSystemParametersInfo(SPI_SETTOOLTIPANIMATION, 0, IntToPtr(bVal), dwBroadcast); SetRegValueDword(HKEY_CURRENT_USER, SZ_REGKEY_CPDESKTOP, SZ_REGVALUE_SMOOTHSCROLL, bVal); ClassicSystemParametersInfo(SPI_SETMENUFADE, 0, IntToPtr(bEfx), dwBroadcast); ClassicSystemParametersInfo(SPI_SETTOOLTIPFADE, 0, IntToPtr(bEfx), dwBroadcast); ClassicSystemParametersInfo(SPI_SETSELECTIONFADE, 0, bVal ? IntToPtr(bEfx) : 0, dwBroadcast); } } CEffectState::CEffectState() : m_cRef(1) { } CEffectState::~CEffectState() { } HRESULT CEffectState::Load(void) { HRESULT hr = S_OK; // Get the values for the settings from the registry and set the checkboxes // Large Icons _nLargeIcon = GetIconState(); // Full Color Icons if(FALSE == GetRegValueInt(HKEY_CURRENT_USER, SZ_REGKEY_USERMETRICS, SZ_REGVALUE_ICONCOLORDEPTH, &_nHighIconColor)) // Key not in registry yet { _nHighIconColor = 4; } // Use animations _wpMenuAnimation = GetAnimations(&_dwAnimationEffect); // Smooth edges of screen fonts _fFontSmoothing = FALSE; ClassicSystemParametersInfo(SPI_GETFONTSMOOTHING, 0, (PVOID)&_fFontSmoothing, 0); _dwFontSmoothingType = FONT_SMOOTHING_AA; if (ClassicSystemParametersInfo(SPI_GETFONTSMOOTHINGTYPE, 0, (PVOID)&_dwFontSmoothingType, 0)) { } if (FONT_SMOOTHING_MONO == _dwFontSmoothingType) { _dwFontSmoothingType = FONT_SMOOTHING_AA; } // Show contents while dragging _fDragWindow = FALSE; ClassicSystemParametersInfo(SPI_GETDRAGFULLWINDOWS, 0, (PVOID)&_fDragWindow, 0); _fKeyboardIndicators = FALSE; ClassicSystemParametersInfo(SPI_GETKEYBOARDINDICATORS, 0, (PVOID)&_fKeyboardIndicators, 0); _fMenuShadows = TRUE; ClassicSystemParametersInfo(SPI_GETDROPSHADOW, 0, (PVOID)&_fMenuShadows, 0); // Set the old values so we know when they changed. _nOldLargeIcon = _nLargeIcon; _nOldHighIconColor = _nHighIconColor; _wpOldMenuAnimation = _wpMenuAnimation; _fOldFontSmoothing = _fFontSmoothing; _dwOldFontSmoothingType = _dwFontSmoothingType; _fOldDragWindow = _fDragWindow; _fOldKeyboardIndicators = _fKeyboardIndicators; _dwOldAnimationEffect = _dwAnimationEffect; _fOldMenuShadows = _fMenuShadows; return hr; } HRESULT CEffectState::Save(void) { // ClassicSystemParametersInfo() will hang if a top level window is hung (#162570) and USER will not fix that bug. // Therefore, we need to make that API call on a background thread because we need to // be more rebust than to hang. AddRef(); SPICreateThread(Save_WorkerProc, (void *)this); return S_OK; } DWORD CEffectState::Save_WorkerProc(void * pvThis) { CEffectState * pThis = (CEffectState *) pvThis; if (pThis) { pThis->_SaveWorkerProc(); } return 0; } HRESULT CEffectState::_SaveWorkerProc(void) { HRESULT hr = S_OK; // First pass to persist the settings. hr = _SaveSettings(FALSE); if (SUCCEEDED(hr)) { // Second pass to broadcast the change. This may hang if apps are hung. // This pass may only make it half way thru before it aborts. In some cases // it's only given 30 seconds to do it's work. If no apps are hung, that should be // fine. This is cancelled after a period of time because we need this process to go // away, or the Display CPL will not open again if the user launches it again. hr = _SaveSettings(TRUE); } Release(); return hr; } // POSSIBLE FUTURE PERF REFINEMENT: // We could optimize this by checking if we have more than 5 or so // broadcasts to make. Then don't send the broadcasts on SystemParametersInfo() // but instead with WM_WININICHANGE with 0,0. This may reduce flicker. HRESULT CEffectState::_SaveSettings(BOOL fBroadcast) { HRESULT hr = S_OK; BOOL bDorked = FALSE; DWORD dwUpdateFlags = (fBroadcast ? (SPIF_UPDATEINIFILE | SPIF_SENDWININICHANGE) : SPIF_UPDATEINIFILE); BOOL bSendSettingsChange = FALSE; // Full Color Icons if(_nOldHighIconColor != _nHighIconColor) { SetRegValueInt(HKEY_CURRENT_USER, SZ_REGKEY_USERMETRICS, SZ_REGVALUE_ICONCOLORDEPTH, _nHighIconColor); if ((GetBitsPerPixel() < 16) && (_nHighIconColor == 16)) // Display mode won't support icon high colors { } else { _nOldHighIconColor = _nHighIconColor; bSendSettingsChange = TRUE; } } // Full window drag if (_fOldDragWindow != _fDragWindow) { if (fBroadcast) { _fOldDragWindow = _fDragWindow; } if (!IsTSPerfFlagEnabled(TSPerFlag_NoWindowDrag)) { ClassicSystemParametersInfo(SPI_SETDRAGFULLWINDOWS, _fDragWindow, 0, dwUpdateFlags); } // we need to send this because the tray's autohide switches off this bSendSettingsChange = TRUE; } // Show Menu Shadows if (_fOldMenuShadows != _fMenuShadows) { if (fBroadcast) { _fOldMenuShadows = _fMenuShadows; } ClassicSystemParametersInfo(SPI_SETDROPSHADOW, 0, IntToPtr(_fMenuShadows), dwUpdateFlags); // we need to send this because the tray's autohide switches off this PostMessageBroadAsync(WM_SETTINGCHANGE, 0, 0); bSendSettingsChange = TRUE; } // Font smoothing if ((_fOldFontSmoothing != _fFontSmoothing) || (_dwOldFontSmoothingType != _dwFontSmoothingType)) { if (!_fFontSmoothing) { // #168059: If font smoothing is off, we need to set SPI_SETFONTSMOOTHINGTYPE to xxx // Otherwise, it will still use ClearType. _dwFontSmoothingType = FONT_SMOOTHING_MONO; } ClassicSystemParametersInfo(SPI_SETFONTSMOOTHINGTYPE, 0, (PVOID)UlongToPtr(_dwFontSmoothingType), dwUpdateFlags); if (fBroadcast) { _dwOldFontSmoothingType = _dwFontSmoothingType; _fOldFontSmoothing = _fFontSmoothing; } ClassicSystemParametersInfo(SPI_SETFONTSMOOTHING, _fFontSmoothing, 0, dwUpdateFlags); if (fBroadcast) { // Now have the windows repaint with the change. Whistler #179531 RedrawWindow(NULL, NULL, NULL, RDW_ERASE | RDW_INVALIDATE | RDW_ERASENOW | RDW_UPDATENOW | RDW_ALLCHILDREN); } } // Menu animations if ((_wpOldMenuAnimation != _wpMenuAnimation) || (_dwOldAnimationEffect != _dwAnimationEffect)) { if (fBroadcast) { _wpOldMenuAnimation = _wpMenuAnimation; } SetAnimations(_wpMenuAnimation, _dwAnimationEffect, dwUpdateFlags); if (fBroadcast) { _dwOldAnimationEffect = _dwAnimationEffect; } } // Keyboard indicators if (_fOldKeyboardIndicators != _fKeyboardIndicators) { if (fBroadcast) { _fOldKeyboardIndicators = _fKeyboardIndicators; } // Are we turning this on? (!_fKeyboardIndicators means "don't show" -> hide) if (!_fKeyboardIndicators) { // Yes, on: hide the key cues, turn on the mechanism ClassicSystemParametersInfo(SPI_SETKEYBOARDINDICATORS, 0, IntToPtr(_fKeyboardIndicators), dwUpdateFlags); PostMessageBroadAsync(WM_CHANGEUISTATE, MAKEWPARAM(UIS_SET, UISF_HIDEFOCUS | UISF_HIDEACCEL), 0); } else { // No, off: means show the keycues, turn off the mechanism PostMessageBroadAsync(WM_CHANGEUISTATE, MAKEWPARAM(UIS_CLEAR, UISF_HIDEFOCUS | UISF_HIDEACCEL), 0); ClassicSystemParametersInfo(SPI_SETKEYBOARDINDICATORS, 0, IntToPtr(_fKeyboardIndicators), dwUpdateFlags); } } // Large Icons bSendSettingsChange = ChangeIconSizes(_nOldLargeIcon, _nLargeIcon); if (bSendSettingsChange) { if (fBroadcast) { _nOldLargeIcon = _nLargeIcon; } bDorked = TRUE; } // Make the system notice we changed the system icons if (bDorked) { PFNSHUPDATERECYCLEBINICON pfnSHUpdateRecycleBinIcon = NULL; SHChangeNotify(SHCNE_ASSOCCHANGED, 0, NULL, NULL); // should do the trick! // Load SHUpdateRecycleBinIcon() if it exists HINSTANCE hmodShell32 = LoadLibrary(SZ_SHELL32); if (hmodShell32) { pfnSHUpdateRecycleBinIcon = (PFNSHUPDATERECYCLEBINICON)GetProcAddress(hmodShell32, SZ_SHUPDATERECYCLEBINICON); if (pfnSHUpdateRecycleBinIcon != NULL) { pfnSHUpdateRecycleBinIcon(); } FreeLibrary(hmodShell32); } } if (bSendSettingsChange) { // We post this message because if an app is hung or slow, we don't want to hang. PostMessageBroadAsync(WM_SETTINGCHANGE, 0, 0); } return hr; } HRESULT CEffectState::Clone(OUT CEffectState ** ppEffectClone) { HRESULT hr = E_OUTOFMEMORY; *ppEffectClone = new CEffectState(); if (*ppEffectClone) { hr = S_OK; (*ppEffectClone)->_nLargeIcon = _nLargeIcon; (*ppEffectClone)->_nHighIconColor = _nHighIconColor; (*ppEffectClone)->_wpMenuAnimation = _wpMenuAnimation; (*ppEffectClone)->_fFontSmoothing = _fFontSmoothing; (*ppEffectClone)->_dwFontSmoothingType = _dwFontSmoothingType; (*ppEffectClone)->_fDragWindow = _fDragWindow; (*ppEffectClone)->_fKeyboardIndicators = _fKeyboardIndicators; (*ppEffectClone)->_dwAnimationEffect = _dwAnimationEffect; (*ppEffectClone)->_fMenuShadows = _fMenuShadows; (*ppEffectClone)->_nOldLargeIcon = _nOldLargeIcon; (*ppEffectClone)->_nOldHighIconColor = _nOldHighIconColor; (*ppEffectClone)->_wpOldMenuAnimation = _wpOldMenuAnimation; (*ppEffectClone)->_fOldFontSmoothing = _fOldFontSmoothing; (*ppEffectClone)->_dwOldFontSmoothingType = _dwOldFontSmoothingType; (*ppEffectClone)->_fOldDragWindow = _fOldDragWindow; (*ppEffectClone)->_fOldKeyboardIndicators = _fOldKeyboardIndicators; (*ppEffectClone)->_dwOldAnimationEffect = _dwOldAnimationEffect; (*ppEffectClone)->_fOldMenuShadows = _fOldMenuShadows; } return hr; } BOOL CEffectState::IsDirty(void) { BOOL fDirty = FALSE; if ((_nLargeIcon != _nOldLargeIcon) || (_nHighIconColor != _nOldHighIconColor) || (_wpMenuAnimation != _wpOldMenuAnimation) || (_fFontSmoothing != _fOldFontSmoothing) || (_dwFontSmoothingType != _dwOldFontSmoothingType) || (_fDragWindow != _fOldDragWindow) || (_fMenuShadows != _fOldMenuShadows) || (_fKeyboardIndicators != _fOldKeyboardIndicators) || (_dwAnimationEffect != _dwOldAnimationEffect)) { fDirty = TRUE; } return fDirty; } ULONG CEffectState::AddRef() { return InterlockedIncrement(&m_cRef); } ULONG CEffectState::Release() { if (InterlockedDecrement(&m_cRef)) return m_cRef; delete this; return 0; }