#include "priv.h" #include "varutil.h" #define COMPILE_MULTIMON_STUBS #include "multimon.h" #define MAX_PROPERTY_SIZE 2048 // simple inline base class. class CBasePropertyBag : public IPropertyBag, IPropertyBag2 { public: // IUnknown STDMETHODIMP QueryInterface(REFIID riid, void **ppv) { static const QITAB qit[] = { QITABENT(CBasePropertyBag, IPropertyBag), QITABENT(CBasePropertyBag, IPropertyBag2), { 0 }, }; return QISearch(this, qit, riid, ppv); } STDMETHODIMP_(ULONG) AddRef() { return InterlockedIncrement(&_cRef); } STDMETHODIMP_(ULONG) Release() { if (InterlockedDecrement(&_cRef)) return _cRef; delete this; return 0; } // IPropertyBag STDMETHODIMP Read(LPCOLESTR pszPropName, VARIANT *pVar, IErrorLog *pErrorLog) PURE; STDMETHODIMP Write(LPCOLESTR pszPropName, VARIANT *pVar) PURE; // IPropertyBag2 (note, does not derive from IPropertyBag) STDMETHODIMP Read(ULONG cProperties, PROPBAG2 *pPropBag, IErrorLog *pErrLog, VARIANT *pvarValue, HRESULT *phrError); STDMETHODIMP Write(ULONG cProperties, PROPBAG2 *pPropBag, VARIANT *pvarValue); STDMETHODIMP CountProperties(ULONG *pcProperties); STDMETHODIMP GetPropertyInfo(ULONG iProperty, ULONG cProperties, PROPBAG2 *pPropBag, ULONG *pcProperties); STDMETHODIMP LoadObject(LPCOLESTR pstrName, DWORD dwHint, IUnknown *pUnkObject, IErrorLog *pErrLog); protected: // methods CBasePropertyBag() {} // DONT DELETE ME CBasePropertyBag(DWORD grfMode) : _cRef(1), _grfMode(grfMode) {} virtual ~CBasePropertyBag() {} // DONT DELETE ME HRESULT _CanRead(void) { return STGM_WRITE != (_grfMode & (STGM_WRITE | STGM_READWRITE)) ? S_OK : E_ACCESSDENIED;} HRESULT _CanWrite(void) { return (_grfMode & (STGM_WRITE | STGM_READWRITE)) ? S_OK : E_ACCESSDENIED;} protected: // members LONG _cRef; DWORD _grfMode; }; STDMETHODIMP CBasePropertyBag::Read(ULONG cProperties, PROPBAG2 *pPropBag, IErrorLog *pErrLog, VARIANT *pvarValue, HRESULT *phrError) { return E_NOTIMPL; } STDMETHODIMP CBasePropertyBag::Write(ULONG cProperties, PROPBAG2 *pPropBag, VARIANT *pvarValue) { return E_NOTIMPL; } STDMETHODIMP CBasePropertyBag::CountProperties(ULONG *pcProperties) { return E_NOTIMPL; } STDMETHODIMP CBasePropertyBag::GetPropertyInfo(ULONG iProperty, ULONG cProperties, PROPBAG2 *pPropBag, ULONG *pcProperties) { return E_NOTIMPL; } STDMETHODIMP CBasePropertyBag::LoadObject(LPCOLESTR pstrName, DWORD dwHint, IUnknown *pUnkObject, IErrorLog *pErrLog) { return E_NOTIMPL; } // // Ini file property bag implementation // class CIniPropertyBag : public CBasePropertyBag { public: // IPropertyBag STDMETHODIMP Read(LPCOLESTR pszPropName, VARIANT *pVar, IErrorLog *pErrorLog); STDMETHODIMP Write(LPCOLESTR pszPropName, VARIANT *pVar); protected: // methods CIniPropertyBag(DWORD grfMode) : CBasePropertyBag(grfMode) {} virtual ~CIniPropertyBag(); HRESULT _Init(LPCWSTR pszFile, LPCWSTR pszSection); HRESULT _GetSectionAndName(LPCWSTR pszProp, LPWSTR pszSection, UINT cchSec, LPWSTR pszName, UINT cchName); protected: // members LPWSTR _pszFile; LPWSTR _pszSection; friend HRESULT SHCreatePropertyBagOnProfileSection(LPCWSTR pszFile, LPCWSTR pszSection, DWORD grfMode, REFIID riid, void **ppv); }; CIniPropertyBag::~CIniPropertyBag() { LocalFree(_pszFile); // accepts NULL LocalFree(_pszSection); // accepts NULL } HRESULT CIniPropertyBag::_Init(LPCWSTR pszFile, LPCWSTR pszSection) { HRESULT hr = E_OUTOFMEMORY; _pszFile = StrDupW(pszFile); if (_pszFile) { if (pszSection) { _pszSection = StrDupW(pszSection); if (_pszSection) hr = S_OK; } else { hr = S_OK; } } return hr; } // support the
. scheme HRESULT CIniPropertyBag::_GetSectionAndName(LPCWSTR pszProp, LPWSTR pszSection, UINT cchSec, LPWSTR pszName, UINT cchName) { HRESULT hr; LPCWSTR pszSlash = StrChrW(pszProp, L'\\'); if (pszSlash) { StrCpyNW(pszSection, pszProp, min((UINT)(pszSlash - pszProp) + 1, cchSec)); StrCpyNW(pszName, pszSlash + 1, cchName); hr = S_OK; } else if (_pszSection) { StrCpyNW(pszSection, _pszSection, cchSec); StrCpyNW(pszName, pszProp, cchName); hr = S_OK; } else { hr = E_INVALIDARG; } return hr; } // only supports strings. use VariantChangeType() to suppor others HRESULT CIniPropertyBag::Read(LPCOLESTR pszPropName, VARIANT *pvar, IErrorLog *pErrorLog) { VARTYPE vtDesired = pvar->vt; VariantInit(pvar); HRESULT hr = _CanRead(); if (SUCCEEDED(hr)) { WCHAR szSec[64], szName[64]; hr = _GetSectionAndName(pszPropName, szSec, ARRAYSIZE(szSec), szName, ARRAYSIZE(szName)); if (SUCCEEDED(hr)) { WCHAR sz[MAX_PROPERTY_SIZE]; if (SHGetIniStringUTF7W(szSec, szName, sz, ARRAYSIZE(sz), _pszFile)) { pvar->bstrVal = SysAllocString(sz); if (pvar->bstrVal) { pvar->vt = VT_BSTR; hr = VariantChangeTypeForRead(pvar, vtDesired); } else { hr = E_OUTOFMEMORY; } } else { hr = E_FAIL; } } } return hr; } // only writes as strings to the INI file, we use VariantChangeType() to morp the types. HRESULT CIniPropertyBag::Write(LPCOLESTR pszPropName, VARIANT *pvar) { HRESULT hr = _CanWrite(); if (SUCCEEDED(hr)) { LPCWSTR psz = pvar->vt == VT_EMPTY ? NULL : pvar->bstrVal; VARIANT var = { 0 }; if ((pvar->vt != VT_EMPTY) && (pvar->vt != VT_BSTR)) { hr = VariantChangeType(&var, pvar, 0, VT_BSTR); if (SUCCEEDED(hr)) psz = var.bstrVal; } if (SUCCEEDED(hr)) { WCHAR szSec[64], szName[64]; hr = _GetSectionAndName(pszPropName, szSec, ARRAYSIZE(szSec), szName, ARRAYSIZE(szName)); if (SUCCEEDED(hr)) { if (!SHSetIniStringUTF7W(szSec, szName, psz, _pszFile)) { hr = E_FAIL; } else { SHChangeNotifyWrap(SHCNE_UPDATEITEM, SHCNF_PATHW, _pszFile, NULL); } } } VariantClear(&var); } return hr; } HRESULT SHCreatePropertyBagOnProfileSection(LPCWSTR pszFile, LPCWSTR pszSection, DWORD grfMode, REFIID riid, void **ppv) { if (grfMode & STGM_CREATE) { // we need to touch this file first HANDLE h = CreateFileW(pszFile, 0, FILE_SHARE_DELETE, NULL, CREATE_NEW, FILE_ATTRIBUTE_HIDDEN | FILE_ATTRIBUTE_SYSTEM, NULL); if (INVALID_HANDLE_VALUE != h) { WCHAR szFolder[MAX_PATH]; StrCpyNW(szFolder, pszFile, ARRAYSIZE(szFolder)); if (PathRemoveFileSpecW(szFolder)) { PathMakeSystemFolderW(szFolder); } CloseHandle(h); } } if (PathFileExistsAndAttributesW(pszFile, NULL)) { CIniPropertyBag *pbag = new CIniPropertyBag(grfMode); if (pbag) { HRESULT hr = pbag->_Init(pszFile, pszSection); if (SUCCEEDED(hr)) hr = pbag->QueryInterface(riid, ppv); pbag->Release(); return hr; } } *ppv = NULL; return E_OUTOFMEMORY; } // // Registry property bag implementation // class CRegPropertyBag : public CBasePropertyBag { public: // IPropertyBag STDMETHODIMP Read(LPCOLESTR pszPropName, VARIANT *pVar, IErrorLog *pErrorLog); STDMETHODIMP Write(LPCOLESTR pszPropName, VARIANT *pVar); protected: // methods CRegPropertyBag(DWORD grfMode); virtual ~CRegPropertyBag(); HRESULT _Init(HKEY hk, LPCWSTR pszSubKey); friend HRESULT SHCreatePropertyBagOnRegKey(HKEY hk, LPCWSTR pszSubKey, DWORD grfMode, REFIID riid, void **ppv); private: HRESULT _ReadDword(LPCOLESTR pszPropName, VARIANT *pvar); HRESULT _ReadString(LPCOLESTR pszPropName, VARIANT *pvar, DWORD cb); HRESULT _ReadStream(VARIANT* pvar, BYTE* pBuff, DWORD cb); HRESULT _ReadBinary(LPCOLESTR pszPropName, VARIANT* pvar, VARTYPE vt, DWORD cb); HRESULT _GetStreamSize(IStream* pstm, DWORD* pcb); HRESULT _CopyStreamIntoBuff(IStream* pstm, BYTE* pBuff, DWORD cb); HRESULT _WriteStream(LPCOLESTR pszPropName, IStream* pstm); protected: // members HKEY _hk; friend HRESULT SHCreatePropertyBagOnRegKey(HKEY hk, LPCWSTR pszSubKey, DWORD grfMode, REFIID riid, void **ppv); }; CRegPropertyBag::CRegPropertyBag(DWORD grfMode) : CBasePropertyBag(grfMode) { ASSERT(NULL == _hk); } CRegPropertyBag::~CRegPropertyBag() { if (_hk) RegCloseKey(_hk); } HRESULT CRegPropertyBag::_Init(HKEY hk, LPCWSTR pszSubKey) { DWORD err; REGSAM sam = 0; if (SUCCEEDED(_CanRead())) sam |= KEY_READ; if (SUCCEEDED(_CanWrite())) sam |= KEY_WRITE; if (_grfMode & STGM_CREATE) err = RegCreateKeyExWrapW(hk, pszSubKey, 0, NULL, 0, sam, NULL, &_hk, NULL); else err = RegOpenKeyExWrapW(hk, pszSubKey, 0, sam, &_hk); return HRESULT_FROM_WIN32(err); } HRESULT CRegPropertyBag::_ReadDword(LPCOLESTR pszPropName, VARIANT *pvar) { HRESULT hr; DWORD dwType; DWORD cb = sizeof(pvar->lVal); if (NOERROR == SHGetValueW(_hk, NULL, pszPropName, &dwType, &pvar->lVal, &cb)) { ASSERT(REG_DWORD == dwType); pvar->vt = VT_UI4; hr = S_OK; } else { hr = E_FAIL; } return hr; } HRESULT CRegPropertyBag::_ReadString(LPCOLESTR pszPropName, VARIANT *pvar, DWORD cb) { HRESULT hr; DWORD dwType; pvar->bstrVal = SysAllocStringByteLen(NULL, cb); if (pvar->bstrVal) { pvar->vt = VT_BSTR; if (NOERROR == SHGetValueW(_hk, NULL, pszPropName, &dwType, pvar->bstrVal, &cb)) { hr = S_OK; } else { VariantClear(pvar); hr = E_FAIL; } } else { hr = E_OUTOFMEMORY; } return hr; } HRESULT CRegPropertyBag::_ReadStream(VARIANT* pvar, BYTE* pBuff, DWORD cb) { HRESULT hr; pvar->punkVal = SHCreateMemStream(pBuff, cb); if (pvar->punkVal) { pvar->vt = VT_UNKNOWN; hr = S_OK; } else { hr = E_OUTOFMEMORY; } return hr; } HRESULT CRegPropertyBag::_ReadBinary(LPCOLESTR pszPropName, VARIANT* pvar, VARTYPE vt, DWORD cb) { HRESULT hr; switch(vt) { case VT_UNKNOWN: hr = E_FAIL; if (EVAL(cb >= sizeof(GUID))) { BYTE* pBuff = static_cast(LocalAlloc(LPTR, cb)); if (pBuff) { DWORD dwType; if (NOERROR == SHGetValueW(_hk, NULL, pszPropName, &dwType, pBuff, &cb)) { GUID* pguid = (GUID*)pBuff; if (IsEqualGUID(GUID_NULL, *pguid)) { // it's our non-cocreatable IStream implementation hr = _ReadStream(pvar, pBuff + sizeof(GUID), cb - sizeof(GUID)); } else { ASSERTMSG(FALSE, "We don't support writing other types of objects yet."); } } LocalFree(pBuff); } } break; default: hr = E_FAIL; break; } return hr; } HRESULT CRegPropertyBag::Read(LPCOLESTR pszPropName, VARIANT *pvar, IErrorLog *pErrorLog) { HRESULT hr = _CanRead(); if (SUCCEEDED(hr)) { VARTYPE vtDesired = pvar->vt; VariantInit(pvar); DWORD dwType; DWORD cb; if (NOERROR == SHGetValueW(_hk, NULL, pszPropName, &dwType, NULL, &cb)) { switch(dwType) { case REG_DWORD: hr = _ReadDword(pszPropName, pvar); break; case REG_SZ: hr = _ReadString(pszPropName, pvar, cb); break; case REG_BINARY: hr = _ReadBinary(pszPropName, pvar, vtDesired, cb); break; default: hr = E_FAIL; break; } if (SUCCEEDED(hr)) { hr = VariantChangeTypeForRead(pvar, vtDesired); } } else { hr = E_FAIL; } } if (FAILED(hr)) VariantInit(pvar); return hr; } HRESULT CRegPropertyBag::_GetStreamSize(IStream* pstm, DWORD* pcb) { HRESULT hr; *pcb = 0; ULARGE_INTEGER uli; hr = IStream_Size(pstm, &uli); if (SUCCEEDED(hr)) { if (0 == uli.HighPart) { *pcb = uli.LowPart; } else { hr = E_FAIL; } } return hr; } HRESULT CRegPropertyBag::_CopyStreamIntoBuff(IStream* pstm, BYTE* pBuff, DWORD cb) { HRESULT hr; hr = IStream_Reset(pstm); if (SUCCEEDED(hr)) { hr = IStream_Read(pstm, pBuff, cb); } return hr; } HRESULT CRegPropertyBag::_WriteStream(LPCOLESTR pszPropName, IStream* pstm) { HRESULT hr; DWORD cb; hr = _GetStreamSize(pstm, &cb); if (SUCCEEDED(hr) && cb) { BYTE* pBuff = static_cast(LocalAlloc(LPTR, cb + sizeof(GUID))); if (pBuff) { // we're using a NULL GUID to mean our own IStream implementation hr = _CopyStreamIntoBuff(pstm, pBuff + sizeof(GUID), cb); if (SUCCEEDED(hr)) { if (NOERROR != SHSetValueW(_hk, NULL, pszPropName, REG_BINARY, pBuff, cb + sizeof(GUID))) { hr = E_FAIL; } } LocalFree(pBuff); } else { hr = E_OUTOFMEMORY; } } return hr; } HRESULT CRegPropertyBag::Write(LPCOLESTR pszPropName, VARIANT *pvar) { HRESULT hr = _CanWrite(); if (SUCCEEDED(hr)) { VARIANT var = { 0 }; switch(pvar->vt) { case VT_EMPTY: SHDeleteValueW(_hk, NULL, pszPropName); break; case VT_I1: case VT_I2: case VT_I4: case VT_INT: case VT_UI1: case VT_UI2: case VT_UI4: case VT_UINT: case VT_BOOL: hr = VariantChangeType(&var, pvar, 0, VT_UI4); if (SUCCEEDED(hr)) { if (NOERROR != SHSetValueW(_hk, NULL, pszPropName, REG_DWORD, &var.lVal, sizeof(var.lVal))) { hr = E_FAIL; } } break; case VT_UNKNOWN: IStream* pstm; hr = pvar->punkVal->QueryInterface(IID_PPV_ARG(IStream, &pstm)); if (SUCCEEDED(hr)) { hr = _WriteStream(pszPropName, pstm); pstm->Release(); } else { TraceMsg(TF_WARNING, "CRegPropertyBag::Write: Someone is trying to write an object we don't know how to save"); } break; default: hr = VariantChangeType(&var, pvar, 0, VT_BSTR); if (SUCCEEDED(hr)) { if (NOERROR != SHSetValueW(_hk, NULL, pszPropName, REG_SZ, var.bstrVal, CbFromCchW(lstrlenW(var.bstrVal) + 1))) { hr = E_FAIL; } VariantClear(&var); } break; } } return hr; } HRESULT SHCreatePropertyBagOnRegKey(HKEY hk, LPCWSTR pszSubKey, DWORD grfMode, REFIID riid, void **ppv) { HRESULT hr; CRegPropertyBag *pbag = new CRegPropertyBag(grfMode); if (pbag) { hr = pbag->_Init(hk, pszSubKey); if (SUCCEEDED(hr)) hr = pbag->QueryInterface(riid, ppv); pbag->Release(); } else { *ppv = NULL; hr = E_OUTOFMEMORY; } return hr; } // // Memory property bag implementation // typedef struct { LPWSTR pszPropName; VARIANT variant; } PBAGENTRY, * LPPBAGENTRY; class CMemPropertyBag : public CBasePropertyBag { public: // IPropertyBag STDMETHOD(Read)(LPCOLESTR pszPropName, VARIANT *pVar, IErrorLog *pErrorLog); STDMETHOD(Write)(LPCOLESTR pszPropName, VARIANT *pVar); protected: // methods CMemPropertyBag(DWORD grfMode) : CBasePropertyBag(grfMode) {} ~CMemPropertyBag(); HRESULT _Find(LPCOLESTR pszPropName, PBAGENTRY **pppbe, BOOL fCreate); friend HRESULT SHCreatePropertyBagOnMemory(DWORD grfMode, REFIID riid, void **ppv); protected: // members HDSA _hdsaProperties; }; INT _FreePropBagCB(LPVOID pData, LPVOID lParam) { LPPBAGENTRY ppbe = (LPPBAGENTRY)pData; Str_SetPtrW(&ppbe->pszPropName, NULL); VariantClear(&ppbe->variant); return 1; } CMemPropertyBag::~CMemPropertyBag() { if (_hdsaProperties) DSA_DestroyCallback(_hdsaProperties, _FreePropBagCB, NULL); } // // manange the list of propeties in the property bag // HRESULT CMemPropertyBag::_Find(LPCOLESTR pszPropName, PBAGENTRY **pppbe, BOOL fCreate) { int i; PBAGENTRY pbe = { 0 }; *pppbe = NULL; // look up the property in the DSA // PERF: change to a DPA and sort accordingly for better perf (daviddv 110798) for ( i = 0 ; _hdsaProperties && (i < DSA_GetItemCount(_hdsaProperties)) ; i++ ) { LPPBAGENTRY ppbe = (LPPBAGENTRY)DSA_GetItemPtr(_hdsaProperties, i); if ( !StrCmpIW(pszPropName, ppbe->pszPropName) ) { *pppbe = ppbe; return S_OK; } } // no entry found, should we create one? if ( !fCreate ) return E_FAIL; // yes, so lets check to see if we have a DSA yet. if ( !_hdsaProperties ) _hdsaProperties = DSA_Create(SIZEOF(PBAGENTRY), 4); if ( !_hdsaProperties ) return E_OUTOFMEMORY; // we have the DSA so lets fill the record we want to put into it if ( !Str_SetPtrW(&pbe.pszPropName, pszPropName) ) return E_OUTOFMEMORY; VariantInit(&pbe.variant); // append it to the DSA we are using i = DSA_AppendItem(_hdsaProperties, &pbe); if ( -1 == i ) { Str_SetPtrW(&pbe.pszPropName, NULL); return E_OUTOFMEMORY; } *pppbe = (LPPBAGENTRY)DSA_GetItemPtr(_hdsaProperties, i); return S_OK; } // // IPropertyBag methods // STDMETHODIMP CMemPropertyBag::Read(LPCOLESTR pszPropName, VARIANT *pv, IErrorLog *pErrorLog) { VARTYPE vtDesired = pv->vt; VariantInit(pv); HRESULT hr = _CanRead(); if (SUCCEEDED(hr)) { hr = (pszPropName && pv) ? S_OK : E_INVALIDARG; if (SUCCEEDED(hr)) { LPPBAGENTRY ppbe; hr = _Find(pszPropName, &ppbe, FALSE); if (SUCCEEDED(hr)) { hr = VariantCopy(pv, &ppbe->variant); if (SUCCEEDED(hr)) hr = VariantChangeTypeForRead(pv, vtDesired); } } } return hr; } STDMETHODIMP CMemPropertyBag::Write(LPCOLESTR pszPropName, VARIANT *pv) { HRESULT hr = _CanWrite(); if (SUCCEEDED(hr)) { hr = (pszPropName && pv) ? S_OK : E_INVALIDARG; if (SUCCEEDED(hr)) { LPPBAGENTRY ppbe; hr = _Find(pszPropName, &ppbe, TRUE); if (SUCCEEDED(hr)) { hr = VariantCopy(&ppbe->variant, pv); } } } return hr; } // // Exported function for creating a IPropertyBag (or variant of) object. // STDAPI SHCreatePropertyBagOnMemory(DWORD grfMode, REFIID riid, void **ppv) { CMemPropertyBag *ppb = new CMemPropertyBag(grfMode); if (ppb) { HRESULT hres = ppb->QueryInterface(riid, ppv); ppb->Release(); return hres; } *ppv = NULL; return E_OUTOFMEMORY; } // // Property bag helper functions // STDAPI SHPropertyBag_ReadType(IPropertyBag *ppb, LPCWSTR pszPropName, VARIANT *pv, VARTYPE vt) { VariantInit(pv); pv->vt = vt; HRESULT hr = ppb->Read(pszPropName, pv, NULL); if (SUCCEEDED(hr)) { if (vt != pv->vt && vt != VT_EMPTY) { TraceMsg(TF_WARNING, "SHPropertyBag_ReadType found an IPropertyBag that did not return the correct data!"); } // Our IPropertyBag implementations have been buggy in the past, cover up for them hr = VariantChangeTypeForRead(pv, vt); } else { // don't break the caller by returning a bogus VARIANT struct VariantInit(pv); } return hr; } STDAPI SHPropertyBag_ReadBSTR(IPropertyBag *ppb, LPCWSTR pszPropName, BSTR* pbstr) { RIPMSG(NULL != ppb, "SHPropertyBag_ReadBSTR caller passed bad ppb"); RIPMSG(IS_VALID_STRING_PTRW(pszPropName, -1), "SHPropertyBag_ReadBSTR caller passed bad pszPropName"); RIPMSG(IS_VALID_WRITE_PTR(pbstr, *pbstr), "SHPropertyBag_ReadBSTR caller passed bad pbstr"); HRESULT hr; if (ppb && pszPropName && pbstr) { VARIANT va; hr = SHPropertyBag_ReadType(ppb, pszPropName, &va, VT_BSTR); if (SUCCEEDED(hr)) *pbstr = va.bstrVal; else *pbstr = NULL; } else { hr = E_INVALIDARG; } return hr; } STDAPI SHPropertyBag_ReadStr(IPropertyBag* ppb, LPCWSTR pszPropName, LPWSTR psz, int cch) { RIPMSG(NULL != ppb, "SHPropertyBag_ReadStr caller passed bad ppb"); RIPMSG(IS_VALID_STRING_PTRW(pszPropName, -1), "SHPropertyBag_ReadStr caller passed bad pszPropName"); RIPMSG(IS_VALID_WRITE_BUFFER(psz, *psz, cch), "SHPropertyBag_ReadStr caller passed bad psz and cch"); HRESULT hr; if (ppb && pszPropName && psz) { VARIANT va; hr = SHPropertyBag_ReadType(ppb, pszPropName, &va, VT_BSTR); if (SUCCEEDED(hr)) { StrCpyNW(psz, va.bstrVal, cch); VariantClear(&va); hr = S_OK; } else { hr = E_FAIL; } } else { hr = E_INVALIDARG; } return hr; } STDAPI SHPropertyBag_WriteStr(IPropertyBag* ppb, LPCWSTR pszPropName, LPCWSTR psz) { RIPMSG(NULL != ppb, "SHPropertyBag_WriteStr caller passed bad ppb"); RIPMSG(IS_VALID_STRING_PTRW(pszPropName, -1), "SHPropertyBag_WriteStr caller passed bad pszPropName"); RIPMSG(NULL == psz || IS_VALID_STRING_PTRW(psz, -1), "SHPropertyBag_WriteStr caller passed bad psz"); HRESULT hr; if (ppb && pszPropName) { VARIANT va; va.bstrVal = SysAllocString(psz); if (va.bstrVal) { va.vt = VT_BSTR; hr = ppb->Write(pszPropName, &va); SysFreeString(va.bstrVal); } else { hr = E_OUTOFMEMORY; } } else { hr = E_INVALIDARG; } return hr; } STDAPI SHPropertyBag_ReadInt(IPropertyBag* ppb, LPCWSTR pszPropName, int* piResult) { RIPMSG(NULL != ppb, "SHPropertyBag_ReadInt caller passed bad ppb"); RIPMSG(IS_VALID_STRING_PTRW(pszPropName, -1), "SHPropertyBag_ReadInt caller passed bad pszPropName"); RIPMSG(IS_VALID_WRITE_PTR(piResult, *piResult), "SHPropertyBag_ReadInt caller passed bad piResult"); HRESULT hr; if (ppb && pszPropName && piResult) { VARIANT va; hr = SHPropertyBag_ReadType(ppb, pszPropName, &va, VT_I4); if (SUCCEEDED(hr)) { *piResult = va.ulVal; // VT_I4 has nothing to VariantClear } } else { hr = E_INVALIDARG; } return hr; } STDAPI SHPropertyBag_WriteInt(IPropertyBag* ppb, LPCWSTR pszPropName, int i) { RIPMSG(NULL != ppb, "SHPropertyBag_WriteInt caller passed bad ppb"); RIPMSG(IS_VALID_STRING_PTRW(pszPropName, -1), "SHPropertyBag_WriteInt caller passed bad pszPropName"); HRESULT hr; if (ppb && pszPropName) { VARIANT va; va.vt = VT_I4; va.lVal = i; hr = ppb->Write(pszPropName, &va); } else { hr = E_INVALIDARG; } return hr; } STDAPI SHPropertyBag_ReadSHORT(IPropertyBag* ppb, LPCWSTR pszPropName, SHORT* psh) { RIPMSG(NULL != ppb, "SHPropertyBag_ReadSHORT caller passed bad ppb"); RIPMSG(IS_VALID_STRING_PTRW(pszPropName, -1), "SHPropertyBag_ReadSHORT caller passed bad pszPropName"); RIPMSG(IS_VALID_WRITE_PTR(psh, *psh), "SHPropertyBag_ReadSHORT caller passed bad psh"); HRESULT hr; if (ppb && pszPropName && psh) { VARIANT va; hr = SHPropertyBag_ReadType(ppb, pszPropName, &va, VT_UI2); if (SUCCEEDED(hr)) { *psh = va.iVal; } } else { hr = E_INVALIDARG; } return hr; } STDAPI SHPropertyBag_WriteSHORT(IPropertyBag* ppb, LPCWSTR pszPropName, SHORT sh) { RIPMSG(NULL != ppb, "SHPropertyBag_WriteSHORT caller passed bad ppb"); RIPMSG(IS_VALID_STRING_PTRW(pszPropName, -1), "SHPropertyBag_WriteSHORT caller passed bad pszPropName"); HRESULT hr; if (ppb && pszPropName) { VARIANT va; va.vt = VT_UI2; va.iVal = sh; hr = ppb->Write(pszPropName, &va); } else { hr = E_INVALIDARG; } return hr; } STDAPI SHPropertyBag_ReadLONG(IPropertyBag* ppb, LPCWSTR pszPropName, LONG* pl) { RIPMSG(NULL != ppb, "SHPropertyBag_ReadLONG caller passed bad ppb"); RIPMSG(IS_VALID_STRING_PTRW(pszPropName, -1), "SHPropertyBag_ReadLONG caller passed bad pszPropName"); RIPMSG(IS_VALID_WRITE_PTR(pl, *pl), "SHPropertyBag_ReadLONG caller passed bad pl"); HRESULT hr; if (ppb && pszPropName && pl) { VARIANT va; hr = SHPropertyBag_ReadType(ppb, pszPropName, &va, VT_I4); if (SUCCEEDED(hr)) { *pl = va.ulVal; } } else { hr = E_INVALIDARG; } return hr; } STDAPI SHPropertyBag_WriteLONG(IPropertyBag* ppb, LPCWSTR pszPropName, LONG l) { RIPMSG(NULL != ppb, "SHPropertyBag_WriteLONG caller passed bad ppb"); RIPMSG(IS_VALID_STRING_PTRW(pszPropName, -1), "SHPropertyBag_WriteLONG caller passed bad pszPropName"); HRESULT hr; if (ppb && pszPropName) { VARIANT va; va.vt = VT_I4; va.lVal = l; hr = ppb->Write(pszPropName, &va); } else { hr = E_INVALIDARG; } return hr; } STDAPI SHPropertyBag_ReadDWORD(IPropertyBag* ppb, LPCWSTR pszPropName, DWORD* pdw) { RIPMSG(NULL != ppb, "SHPropertyBag_ReadDWORD caller passed bad ppb"); RIPMSG(IS_VALID_STRING_PTRW(pszPropName, -1), "SHPropertyBag_ReadDWORD caller passed bad pszPropName"); RIPMSG(IS_VALID_WRITE_PTR(pdw, *pdw), "SHPropertyBag_ReadInt caller passed bad pdw"); HRESULT hr; if (ppb && pszPropName && pdw) { VARIANT va; hr = SHPropertyBag_ReadType(ppb, pszPropName, &va, VT_UI4); if (SUCCEEDED(hr)) { *pdw = va.ulVal; // VT_UI4 has nothing to VariantClear } } else { hr = E_INVALIDARG; } return hr; } STDAPI SHPropertyBag_WriteDWORD(IPropertyBag* ppb, LPCWSTR pszPropName, DWORD dw) { RIPMSG(NULL != ppb, "SHPropertyBag_WriteDWORD caller passed bad ppb"); RIPMSG(IS_VALID_STRING_PTRW(pszPropName, -1), "SHPropertyBag_WriteDWORD caller passed bad pszPropName"); HRESULT hr; if (ppb && pszPropName) { VARIANT va; va.vt = VT_UI4; va.ulVal = dw; hr = ppb->Write(pszPropName, &va); } else { hr = E_INVALIDARG; } return hr; } // This shipped on Whistler Beta 1. It's exported by ordinal. STDAPI_(BOOL) SHPropertyBag_ReadBOOLOld(IPropertyBag *ppb, LPCWSTR pwzPropName, BOOL fResult) { VARIANT va; HRESULT hr = SHPropertyBag_ReadType(ppb, pwzPropName, &va, VT_BOOL); if (SUCCEEDED(hr)) { fResult = (va.boolVal == VARIANT_TRUE); // VT_BOOL has nothing to VariantClear } return fResult; } STDAPI SHPropertyBag_ReadBOOL(IPropertyBag* ppb, LPCWSTR pszPropName, BOOL* pfResult) { RIPMSG(NULL != ppb, "SHPropertyBag_ReadBOOL caller passed bad ppb"); RIPMSG(IS_VALID_STRING_PTRW(pszPropName, -1), "SHPropertyBag_ReadBOOL caller passed bad pszPropName"); RIPMSG(IS_VALID_WRITE_PTR(pfResult, *pfResult), "SHPropertyBag_ReadBOOL caller passed bad pfResult"); HRESULT hr; if (ppb && pszPropName && pfResult) { VARIANT va; hr = SHPropertyBag_ReadType(ppb, pszPropName, &va, VT_BOOL); if (SUCCEEDED(hr)) { *pfResult = (va.boolVal == VARIANT_TRUE); } } else { hr = E_INVALIDARG; } return hr; } STDAPI SHPropertyBag_WriteBOOL(IPropertyBag* ppb, LPCWSTR pszPropName, BOOL fValue) { RIPMSG(NULL != ppb, "SHPropertyBag_WriteBOOL caller passed bad ppb"); RIPMSG(IS_VALID_STRING_PTRW(pszPropName, -1), "SHPropertyBag_WriteBOOL caller passed bad pszPropName"); HRESULT hr; if (ppb && pszPropName) { VARIANT va; va.vt = VT_BOOL; va.boolVal = fValue ? VARIANT_TRUE : VARIANT_FALSE; hr = ppb->Write(pszPropName, &va); } else { hr = E_INVALIDARG; } return hr; } STDAPI SHPropertyBag_ReadGUID(IPropertyBag* ppb, LPCWSTR pszPropName, GUID* pguid) { RIPMSG(NULL != ppb, "SHPropertyBag_ReadGUID caller passed bad ppb"); RIPMSG(IS_VALID_STRING_PTRW(pszPropName, -1), "SHPropertyBag_ReadGUID caller passed bad pszPropName"); RIPMSG(IS_VALID_WRITE_PTR(pguid, *pguid), "SHPropertyBag_ReadGUID caller passed bad pguid"); HRESULT hr; if (ppb && pszPropName && pguid) { VARIANT var; hr = SHPropertyBag_ReadType(ppb, pszPropName, &var, VT_EMPTY); if (SUCCEEDED(hr)) { if (var.vt == (VT_ARRAY | VT_UI1)) // some code has been writing GUIDs as array's of bytes { hr = VariantToGUID(&var, pguid) ? S_OK : E_FAIL; } else if (var.vt == VT_BSTR) { hr = GUIDFromStringW(var.bstrVal, pguid) ? S_OK : E_FAIL; } VariantClear(&var); } } else { hr = E_INVALIDARG; } return hr; } STDAPI SHPropertyBag_WriteGUID(IPropertyBag *ppb, LPCWSTR pszPropName, const GUID *pguid) { RIPMSG(NULL != ppb, "SHPropertyBag_WriteGUID caller passed bad ppb"); RIPMSG(IS_VALID_STRING_PTRW(pszPropName, -1), "SHPropertyBag_WriteGUID caller passed bad pszPropName"); RIPMSG(IS_VALID_READ_PTR(pguid, *pguid), "SHPropertyBag_WriteGUID caller passed bad pguid"); HRESULT hr; if (ppb && pszPropName && pguid) { WCHAR sz[64]; SHStringFromGUIDW(*pguid, sz, ARRAYSIZE(sz)); hr = SHPropertyBag_WriteStr(ppb, pszPropName, sz); // assumes null terminator } else { hr = E_INVALIDARG; } return hr; } STDAPI SHPropertyBag_ReadPOINTL(IPropertyBag* ppb, LPCWSTR pszPropName, POINTL* ppt) { RIPMSG(NULL != ppb, "SHPropertyBag_ReadPOINTL caller passed bad ppb"); RIPMSG(IS_VALID_STRING_PTRW(pszPropName, -1), "SHPropertyBag_ReadPOINTL caller passed bad pszPropName"); RIPMSG(IS_VALID_WRITE_PTR(ppt, *ppt), "SHPropertyBag_ReadPOINTL caller passed bad ppt"); HRESULT hr; if (ppb && pszPropName && ppt) { WCHAR szProp[MAX_PATH]; RIP(lstrlenW(pszPropName) < ARRAYSIZE(szProp) - 2); StrCpyNW(szProp, pszPropName, ARRAYSIZE(szProp)); UINT cch = lstrlenW(szProp); if (ARRAYSIZE(szProp) - cch >= 3) { StrCpyNW(szProp + cch, L".x", ARRAYSIZE(szProp) - cch); hr = SHPropertyBag_ReadLONG(ppb, szProp, &ppt->x); if (SUCCEEDED(hr)) { StrCpyNW(szProp + cch, L".y", ARRAYSIZE(szProp) - cch); hr = SHPropertyBag_ReadLONG(ppb, szProp, &ppt->y); } } else { hr = E_FAIL; } } else { hr = E_INVALIDARG; } return hr; } STDAPI SHPropertyBag_WritePOINTL(IPropertyBag* ppb, LPCWSTR pszPropName, const POINTL* ppt) { RIPMSG(NULL != ppb, "SHPropertyBag_WritePOINTL caller passed bad ppb"); RIPMSG(IS_VALID_STRING_PTRW(pszPropName, -1), "SHPropertyBag_WritePOINTL caller passed bad pszPropName"); RIPMSG(IS_VALID_READ_PTR(ppt, *ppt), "SHPropertyBag_WritePOINTL caller passed bad ppt"); HRESULT hr; if (ppb && pszPropName && ppt) { WCHAR szProp[MAX_PATH]; RIP(lstrlenW(pszPropName) < ARRAYSIZE(szProp) - 2); StrCpyNW(szProp, pszPropName, ARRAYSIZE(szProp)); UINT cch = lstrlenW(szProp); if (ARRAYSIZE(szProp) - cch >= 3) { StrCpyNW(szProp + cch, L".x", ARRAYSIZE(szProp) - cch); hr = SHPropertyBag_WriteLONG(ppb, szProp, ppt->x); if (SUCCEEDED(hr)) { StrCpyNW(szProp + cch, L".y", ARRAYSIZE(szProp) - cch); hr = SHPropertyBag_WriteLONG(ppb, szProp, ppt->y); if (FAILED(hr)) { StrCpyNW(szProp + cch, L".x", ARRAYSIZE(szProp) - cch); hr = SHPropertyBag_Delete(ppb, szProp); } } } else { hr = E_FAIL; } } else { hr = E_INVALIDARG; } return hr; } STDAPI SHPropertyBag_ReadPOINTS(IPropertyBag* ppb, LPCWSTR pszPropName, POINTS* ppt) { RIPMSG(NULL != ppb, "SHPropertyBag_ReadPOINTS caller passed bad ppb"); RIPMSG(IS_VALID_STRING_PTRW(pszPropName, -1), "SHPropertyBag_ReadPOINTS caller passed bad pszPropName"); RIPMSG(IS_VALID_WRITE_PTR(ppt, *ppt), "SHPropertyBag_ReadPOINTS caller passed bad ppt"); HRESULT hr; if (ppb && pszPropName && ppt) { POINTL ptL; hr = SHPropertyBag_ReadPOINTL(ppb, pszPropName, &ptL); if (SUCCEEDED(hr)) { ppt->x = static_cast(ptL.x); ppt->y = static_cast(ptL.y); } } else { hr = E_INVALIDARG; } return hr; } STDAPI SHPropertyBag_WritePOINTS(IPropertyBag* ppb, LPCWSTR pszPropName, const POINTS* ppt) { RIPMSG(NULL != ppb, "SHPropertyBag_WritePOINTS caller passed bad ppb"); RIPMSG(IS_VALID_STRING_PTRW(pszPropName, -1), "SHPropertyBag_WritePOINTS caller passed bad pszPropName"); RIPMSG(IS_VALID_READ_PTR(ppt, *ppt), "SHPropertyBag_WritePOINTS caller passed bad ppt"); HRESULT hr; if (ppb && pszPropName && ppt) { POINTL ptL; ptL.x = ppt->x; ptL.y = ppt->y; hr = SHPropertyBag_WritePOINTL(ppb, pszPropName, &ptL); } else { hr = E_INVALIDARG; } return hr; } STDAPI SHPropertyBag_ReadRECTL(IPropertyBag* ppb, LPCWSTR pszPropName, RECTL* prc) { RIPMSG(NULL != ppb, "SHPropertyBag_ReadRECTL caller passed bad ppb"); RIPMSG(IS_VALID_STRING_PTRW(pszPropName, -1), "SHPropertyBag_ReadRECTL caller passed bad pszPropName"); RIPMSG(IS_VALID_WRITE_PTR(prc, *prc), "SHPropertyBag_ReadRECTL caller passed bad prc"); HRESULT hr; if (ppb && pszPropName && prc) { WCHAR szProp[MAX_PATH]; RIP(lstrlenW(pszPropName) < ARRAYSIZE(szProp) - 7); StrCpyNW(szProp, pszPropName, ARRAYSIZE(szProp)); UINT cch = lstrlenW(szProp); if (ARRAYSIZE(szProp) - cch >= 8) { StrCpyNW(szProp + cch, L".left", ARRAYSIZE(szProp) - cch); hr = SHPropertyBag_ReadLONG(ppb, szProp, &prc->left); if (SUCCEEDED(hr)) { StrCpyNW(szProp + cch, L".top", ARRAYSIZE(szProp) - cch); hr = SHPropertyBag_ReadLONG(ppb, szProp, &prc->top); if (SUCCEEDED(hr)) { StrCpyNW(szProp + cch, L".right", ARRAYSIZE(szProp) - cch); hr = SHPropertyBag_ReadLONG(ppb, szProp, &prc->right); if (SUCCEEDED(hr)) { StrCpyNW(szProp + cch, L".bottom", ARRAYSIZE(szProp) - cch); hr = SHPropertyBag_ReadLONG(ppb, szProp, &prc->bottom); } } } } else { hr = E_FAIL; } } else { hr = E_INVALIDARG; } return hr; } STDAPI SHPropertyBag_WriteRECTL(IPropertyBag* ppb, LPCWSTR pszPropName, const RECTL* prc) { RIPMSG(NULL != ppb, "SHPropertyBag_WriteRECTL caller passed bad ppb"); RIPMSG(IS_VALID_STRING_PTRW(pszPropName, -1), "SHPropertyBag_WriteRECTL caller passed bad pszPropName"); RIPMSG(IS_VALID_READ_PTR(prc, *prc), "SHPropertyBag_WriteRECTL caller passed bad prc"); HRESULT hr; if (ppb && pszPropName && prc) { WCHAR szProp[MAX_PATH]; RIP(lstrlenW(pszPropName) < ARRAYSIZE(szProp) - 7); StrCpyNW(szProp, pszPropName, ARRAYSIZE(szProp)); UINT cch = lstrlenW(szProp); if (ARRAYSIZE(szProp) - cch >= 8) { StrCpyNW(szProp + cch, L".left", ARRAYSIZE(szProp) - cch); hr = SHPropertyBag_WriteLONG(ppb, szProp, prc->left); if (SUCCEEDED(hr)) { StrCpyNW(szProp + cch, L".top", ARRAYSIZE(szProp) - cch); hr = SHPropertyBag_WriteLONG(ppb, szProp, prc->top); if (SUCCEEDED(hr)) { StrCpyNW(szProp + cch, L".right", ARRAYSIZE(szProp) - cch); hr = SHPropertyBag_WriteLONG(ppb, szProp, prc->right); if (SUCCEEDED(hr)) { StrCpyNW(szProp + cch, L".bottom", ARRAYSIZE(szProp) - cch); hr = SHPropertyBag_WriteLONG(ppb, szProp, prc->bottom); if (FAILED(hr)) { StrCpyNW(szProp + cch, L".right", ARRAYSIZE(szProp) - cch); hr = SHPropertyBag_Delete(ppb, szProp); } } if (FAILED(hr)) { StrCpyNW(szProp + cch, L".top", ARRAYSIZE(szProp) - cch); hr = SHPropertyBag_Delete(ppb, szProp); } } if (FAILED(hr)) { StrCpyNW(szProp + cch, L".left", ARRAYSIZE(szProp) - cch); hr = SHPropertyBag_Delete(ppb, szProp); } } } else { hr = E_FAIL; } } else { hr = E_INVALIDARG; } return hr; } STDAPI SHPropertyBag_ReadStream(IPropertyBag* ppb, LPCWSTR pszPropName, IStream** ppstm) { RIPMSG(NULL != ppb, "SHPropertyBag_GetSTREAM caller passed bad ppb"); RIPMSG(IS_VALID_STRING_PTRW(pszPropName, -1), "SHPropertyBag_GetSTREAM caller passed bad pszPropName"); RIPMSG(IS_VALID_WRITE_PTR(ppstm, *ppstm), "SHPropertyBag_GetSTREAM caller passed bad ppstm"); HRESULT hr; if (ppb && pszPropName && ppstm) { VARIANT va; hr = SHPropertyBag_ReadType(ppb, pszPropName, &va, VT_UNKNOWN); if (SUCCEEDED(hr)) { hr = va.punkVal->QueryInterface(IID_PPV_ARG(IStream, ppstm)); va.punkVal->Release(); } } else { hr = E_INVALIDARG; } return hr; } STDAPI SHPropertyBag_WriteStream(IPropertyBag* ppb, LPCWSTR pszPropName, IStream* pstm) { RIPMSG(NULL != ppb, "SHPropertyBag_GetSTREAM caller passed bad ppb"); RIPMSG(IS_VALID_STRING_PTRW(pszPropName, -1), "SHPropertyBag_GetSTREAM caller passed bad pszPropName"); RIPMSG(NULL != pstm, "SHPropertyBag_GetSTREAM caller passed bad pstm"); HRESULT hr; if (ppb && pszPropName && pstm) { VARIANT va; va.vt = VT_UNKNOWN; va.punkVal = pstm; hr = ppb->Write(pszPropName, &va); } else { hr = E_INVALIDARG; } return hr; } STDAPI SHPropertyBag_Delete(IPropertyBag* ppb, LPCWSTR pszPropName) { RIPMSG(NULL != ppb, "SHPropertyBag_GetSTREAM caller passed bad ppb"); RIPMSG(IS_VALID_STRING_PTRW(pszPropName, -1), "SHPropertyBag_GetSTREAM caller passed bad pszPropName"); HRESULT hr; if (ppb && pszPropName) { VARIANT va; va.vt = VT_EMPTY; hr = ppb->Write(pszPropName, &va); } else { hr = E_INVALIDARG; } return hr; } class CDesktopUpgradePropertyBag : public CBasePropertyBag { public: // IPropertyBag STDMETHODIMP Read(LPCOLESTR pszPropName, VARIANT *pVar, IErrorLog *pErrorLog); STDMETHODIMP Write(LPCOLESTR pszPropName, VARIANT *pVar); protected: CDesktopUpgradePropertyBag() : CBasePropertyBag(STGM_READ) {} ~CDesktopUpgradePropertyBag() {} friend HRESULT SHGetDesktopUpgradePropertyBag(REFIID riid, void** ppv); private: HRESULT _ReadFlags(VARIANT* pVar); HRESULT _ReadItemPositions(VARIANT* pVar); IStream* _GetOldDesktopViewStream(void); IStream* _NewStreamFromOld(IStream* pstmOld); BOOL _AlreadyUpgraded(HKEY hk); void _MarkAsUpgraded(HKEY hk); }; HRESULT CDesktopUpgradePropertyBag::_ReadFlags(VARIANT* pVar) { HRESULT hr; FOLDERSETTINGS fs; DWORD cb = sizeof(fs); if (NOERROR == SHGetValue(HKEY_CURRENT_USER, REGSTR_PATH_EXPLORER TEXT("\\DeskView"), TEXT("Settings"), NULL, (BYTE *)&fs, &cb) && cb >= sizeof(fs)) { pVar->uintVal = fs.fFlags | FWF_DESKTOP | FWF_NOCLIENTEDGE; pVar->vt = VT_UINT; hr = S_OK; } else { hr = E_FAIL; } return hr; } typedef struct { WORD wSig; BYTE bDontCare[12]; WORD cbPosOffset; }OLDVS_STREAMHEADER; #define OLDVS_STREAMHEADERSIG 28 // sizeof(WIN95HEADER) IStream* CDesktopUpgradePropertyBag::_NewStreamFromOld(IStream* pstmOld) { IStream* pstmNew = NULL; OLDVS_STREAMHEADER ovssh; if (SUCCEEDED(IStream_Read(pstmOld, &ovssh, sizeof(ovssh))) && OLDVS_STREAMHEADERSIG == ovssh.wSig) { LARGE_INTEGER liPos; liPos.QuadPart = ovssh.cbPosOffset - sizeof(ovssh); if (SUCCEEDED(pstmOld->Seek(liPos, STREAM_SEEK_CUR, NULL))) { ULARGE_INTEGER uliSize; if (SUCCEEDED(IStream_Size(pstmOld, &uliSize))) { pstmNew = SHCreateMemStream(NULL, 0); if (pstmNew) { uliSize.QuadPart -= ovssh.cbPosOffset; if (SUCCEEDED(pstmOld->CopyTo(pstmNew, uliSize, NULL, NULL))) { IStream_Reset(pstmNew); } else { pstmNew->Release(); pstmNew = NULL; } } } } } return pstmNew; } BOOL CDesktopUpgradePropertyBag::_AlreadyUpgraded(HKEY hk) { DWORD dwUpgrade; DWORD cbUpgrade = sizeof(dwUpgrade); DWORD dwType; return (ERROR_SUCCESS == SHGetValueW(hk, NULL, L"Upgrade", &dwType, &dwUpgrade, &cbUpgrade)); } void CDesktopUpgradePropertyBag::_MarkAsUpgraded(HKEY hk) { DWORD dwVal = 1; SHSetValueW(hk, NULL, L"Upgrade", REG_DWORD, &dwVal, sizeof(dwVal)); } IStream* CDesktopUpgradePropertyBag::_GetOldDesktopViewStream() { IStream* pstmRet = NULL; HKEY hk = SHGetShellKey(SHELLKEY_HKCU_EXPLORER, L"Streams\\Desktop", FALSE); if (hk) { if (!_AlreadyUpgraded(hk)) { pstmRet = SHOpenRegStream2W(hk, NULL, L"ViewView2", STGM_READ); if (NULL != pstmRet) { ULARGE_INTEGER uliSize; if (SUCCEEDED(IStream_Size(pstmRet, &uliSize)) && 0 == uliSize.QuadPart) { pstmRet->Release(); pstmRet = NULL; } } if (NULL == pstmRet) pstmRet = SHOpenRegStream2W(hk, NULL, L"ViewView", STGM_READ); _MarkAsUpgraded(hk); } RegCloseKey(hk); } return pstmRet; } HRESULT CDesktopUpgradePropertyBag::_ReadItemPositions(VARIANT* pVar) { HRESULT hr = E_FAIL; IStream* pstmOld = _GetOldDesktopViewStream(); if (pstmOld) { IStream* pstmNew = _NewStreamFromOld(pstmOld); if (pstmNew) { pVar->punkVal = pstmNew; pVar->vt = VT_UNKNOWN; hr = S_OK; } pstmOld->Release(); } return hr; } HRESULT CDesktopUpgradePropertyBag::Read(LPCOLESTR pszPropName, VARIANT* pVar, IErrorLog *pErrorLog) { HRESULT hr; VARTYPE vtDesired = pVar->vt; if (0 == StrCmpW(VS_PROPSTR_FFLAGS, pszPropName)) { hr = _ReadFlags(pVar); } else if (0 == StrCmpNW(VS_PROPSTR_ITEMPOS, pszPropName, ARRAYSIZE(VS_PROPSTR_ITEMPOS) - 1)) { hr = _ReadItemPositions(pVar); } else { hr = E_FAIL; } if (SUCCEEDED(hr)) { hr = VariantChangeTypeForRead(pVar, vtDesired); } else { VariantInit(pVar); } return hr; } HRESULT CDesktopUpgradePropertyBag::Write(LPCOLESTR pszPropName, VARIANT *pVar) { return E_NOTIMPL; } HRESULT SHGetDesktopUpgradePropertyBag(REFIID riid, void** ppv) { HRESULT hr; *ppv = NULL; CDesktopUpgradePropertyBag* pbag = new CDesktopUpgradePropertyBag(); if (pbag) { hr = pbag->QueryInterface(riid, ppv); pbag->Release(); } else { hr = E_OUTOFMEMORY; } return hr; } class CViewStatePropertyBag : public CBasePropertyBag { public: // IPropertyBag STDMETHODIMP Read(LPCOLESTR pszPropName, VARIANT *pVar, IErrorLog *pErrorLog); STDMETHODIMP Write(LPCOLESTR pszPropName, VARIANT *pVar); protected: CViewStatePropertyBag(void); virtual ~CViewStatePropertyBag(); HRESULT _Init(LPCITEMIDLIST pidl, LPCWSTR pszBagName, DWORD dwFlags); BOOL _IsSameBag(LPCITEMIDLIST pidl, LPCWSTR pszBagName, DWORD dwFlags); friend HRESULT SHGetViewStatePropertyBag(LPCITEMIDLIST pidl, LPCWSTR pszBagName, DWORD dwFlags, REFIID riid, void** ppv); friend HRESULT GetCachedViewStatePropertyBag(LPCITEMIDLIST pidl, LPCWSTR pszBagName, DWORD dwFlags, REFIID riid, void** ppv); private: HRESULT _CreateBag(LPCITEMIDLIST pidl, LPCWSTR pszBagName, DWORD dwFlags, DWORD grfMode, REFIID riid, void** ppv); HRESULT _CreateUpgradeBag(REFIID riid, void** ppv); BOOL _CanAccessPidlBag(void); BOOL _EnsurePidlBag(DWORD grfMode, REFIID riid); HRESULT _ReadPidlBag(LPCOLESTR pszPropName, VARIANT *pVar, IErrorLog *pErrorLog); BOOL _CanAccessUpgradeBag(void); BOOL _EnsureUpgradeBag(DWORD grfMode, REFIID riid); HRESULT _ReadUpgradeBag(LPCOLESTR pszPropName, VARIANT *pVar, IErrorLog *pErrorLog); BOOL _CanAccessInheritBag(void); BOOL _EnsureInheritBag(DWORD grfMode, REFIID riid); HRESULT _ReadInheritBag(LPCOLESTR pszPropName, VARIANT *pVar, IErrorLog *pErrorLog); BOOL _CanAccessUserDefaultsBag(void); BOOL _EnsureUserDefaultsBag(DWORD grfMode, REFIID riid); HRESULT _ReadUserDefaultsBag(LPCOLESTR pszPropName, VARIANT *pVar, IErrorLog *pErrorLog); BOOL _CanAccessFolderDefaultsBag(void); BOOL _EnsureFolderDefaultsBag(DWORD grfMode, REFIID riid); HRESULT _ReadFolderDefaultsBag(LPCOLESTR pszPropName, VARIANT *pVar, IErrorLog *pErrorLog); BOOL _CanAccessGlobalDefaultsBag(void); BOOL _EnsureGlobalDefaultsBag(DWORD grfMode, REFIID riid); HRESULT _ReadGlobalDefaultsBag(LPCOLESTR pszPropName, VARIANT *pVar, IErrorLog *pErrorLog); BOOL _EnsureReadBag(DWORD grfMode, REFIID riid); BOOL _EnsureWriteBag(DWORD grfMode, REFIID riid); HRESULT _GetRegKey(LPCITEMIDLIST pidl, LPCWSTR pszBagName, DWORD dwFlags, DWORD grfMode, HKEY hk, LPWSTR pszKey, UINT cch); DWORD _GetMRUSize(HKEY hk); HRESULT _GetMRUSlots(LPCITEMIDLIST pidl, DWORD grfMode, HKEY hk, DWORD adwSlot[], DWORD dwcSlots, DWORD* pdwFetched); HRESULT _GetMRUSlot(LPCITEMIDLIST pidl, DWORD grfMode, HKEY hk, DWORD* pdwSlot); HKEY _GetHKey(DWORD dwFlags); void _ResetTryAgainFlag(); HRESULT _FindNearestInheritBag(REFIID riid, void** ppv); void _PruneMRUTree(void); BOOL _IsSamePidl(LPCITEMIDLIST pidl); BOOL _IsSystemFolder(void); private: LPITEMIDLIST _pidl; LPWSTR _pszBagName; DWORD _dwFlags; IPropertyBag* _ppbPidl; IPropertyBag* _ppbUpgrade; IPropertyBag* _ppbInherit; IPropertyBag* _ppbUserDefaults; IPropertyBag* _ppbFolderDefaults; IPropertyBag* _ppbGlobalDefaults; IPropertyBag* _ppbRead; IPropertyBag* _ppbWrite; BOOL _fTriedPidlBag; BOOL _fTriedUpgradeBag; BOOL _fTriedInheritBag; BOOL _fTriedUserDefaultsBag; BOOL _fTriedFolderDefaultsBag; BOOL _fTriedGlobalDefaultsBag; BOOL _fTriedReadBag; BOOL _fTriedWriteBag; }; CViewStatePropertyBag::CViewStatePropertyBag() : CBasePropertyBag(STGM_READ) { ASSERT(NULL == _pidl); ASSERT(NULL == _pszBagName); ASSERT( 0 == _dwFlags); ASSERT(NULL == _ppbPidl); ASSERT(NULL == _ppbUpgrade); ASSERT(NULL == _ppbInherit); ASSERT(NULL == _ppbUserDefaults); ASSERT(NULL == _ppbFolderDefaults); ASSERT(NULL == _ppbGlobalDefaults); ASSERT(NULL == _ppbRead); ASSERT(NULL == _ppbWrite); } CViewStatePropertyBag::~CViewStatePropertyBag() { if (_pidl) ILFree(_pidl); if (_pszBagName) LocalFree(_pszBagName); if (_ppbPidl) _ppbPidl->Release(); if (_ppbUpgrade) _ppbUpgrade->Release(); if (_ppbInherit) _ppbInherit->Release(); if (_ppbUserDefaults) _ppbUserDefaults->Release(); if (_ppbFolderDefaults) _ppbFolderDefaults->Release(); if (_ppbGlobalDefaults) _ppbGlobalDefaults->Release(); if (_ppbRead) _ppbRead->Release(); if (_ppbWrite) _ppbWrite->Release(); } HKEY CViewStatePropertyBag::_GetHKey(DWORD dwFlags) { HKEY hkRet; if ((dwFlags & SHGVSPB_PERUSER) || (dwFlags & SHGVSPB_INHERIT)) { if (!(_dwFlags & SHGVSPB_ROAM) || !(dwFlags & SHGVSPB_PERFOLDER)) { hkRet = SHGetShellKey(SHELLKEY_HKCU_SHELLNOROAM, NULL, TRUE); } else { hkRet = SHGetShellKey(SHELLKEY_HKCU_SHELL, NULL, TRUE); } } else { hkRet = SHGetShellKey(SHELLKEY_HKLM_SHELL, NULL, TRUE); } return hkRet; } DWORD CViewStatePropertyBag::_GetMRUSize(HKEY hk) { DWORD dwMRUSize; DWORD dwSize = sizeof(dwMRUSize); if (NOERROR != SHGetValueW(hk, NULL, L"BagMRU Size", NULL, &dwMRUSize, &dwSize)) { dwMRUSize = 400; // default size. } return dwMRUSize; } HRESULT CViewStatePropertyBag::_GetMRUSlots(LPCITEMIDLIST pidl, DWORD grfMode, HKEY hk, DWORD adwSlots[], DWORD cSlots, DWORD* pdwFetched) { HRESULT hr; IMruPidlList *pmru; hr = CoCreateInstance(CLSID_MruPidlList, NULL, CLSCTX_INPROC_SERVER, IID_PPV_ARG(IMruPidlList, &pmru)); if (SUCCEEDED(hr)) { hr = pmru->InitList(_GetMRUSize(hk), hk, L"BagMRU"); if (SUCCEEDED(hr)) { hr = pmru->QueryPidl(pidl, cSlots, adwSlots, pdwFetched); if (S_OK == hr || (grfMode & (STGM_WRITE | STGM_READWRITE))) { hr = pmru->UsePidl(pidl, &adwSlots[0]); } else if (1 == cSlots) // return S_FALSE for cSlots > 1 if parent slots exist. { hr = E_FAIL; } } pmru->Release(); } return hr; } HRESULT CViewStatePropertyBag::_GetMRUSlot(LPCITEMIDLIST pidl, DWORD grfMode, HKEY hk, DWORD* pdwSlot) { DWORD dwFetched; return _GetMRUSlots(pidl, grfMode, hk, pdwSlot, 1, &dwFetched); } HRESULT CViewStatePropertyBag::_GetRegKey(LPCITEMIDLIST pidl, LPCWSTR pszBagName, DWORD dwFlags, DWORD grfMode, HKEY hk, LPWSTR pszKey, UINT cch) { HRESULT hr = S_OK; if ((dwFlags & SHGVSPB_PERFOLDER) || (dwFlags & SHGVSPB_INHERIT)) { DWORD dwSlot; hr = _GetMRUSlot(pidl, grfMode, hk, &dwSlot); if (SUCCEEDED(hr)) { if (!(dwFlags & SHGVSPB_INHERIT)) { wnsprintfW(pszKey, cch, L"Bags\\%d\\%s", dwSlot, pszBagName); } else { wnsprintfW(pszKey, cch, L"Bags\\%d\\%s\\Inherit", dwSlot, pszBagName); } } } else { wnsprintfW(pszKey, cch, L"Bags\\AllFolders\\%s", pszBagName); } return hr; } HRESULT CViewStatePropertyBag::_Init(LPCITEMIDLIST pidl, LPCWSTR pszBagName, DWORD dwFlags) { HRESULT hr = E_OUTOFMEMORY; if (pidl) { _pidl = ILClone(pidl); } _pszBagName = StrDupW(pszBagName); if (_pszBagName) { _dwFlags = dwFlags; hr = S_OK; } return hr; } BOOL CViewStatePropertyBag::_IsSamePidl(LPCITEMIDLIST pidl) { return (((pidl == NULL) && (_pidl == NULL)) || ((pidl != NULL) && (_pidl != NULL) && ILIsEqual(pidl, _pidl))); } BOOL CViewStatePropertyBag::_IsSameBag(LPCITEMIDLIST pidl, LPCWSTR pszBagName, DWORD dwFlags) { return dwFlags == _dwFlags && 0 == StrCmpW(pszBagName, _pszBagName) && _IsSamePidl(pidl); } HRESULT CViewStatePropertyBag::_CreateBag(LPCITEMIDLIST pidl, LPCWSTR pszBagName, DWORD dwFlags, DWORD grfMode, REFIID riid, void** ppv) { HRESULT hr; DWORD grfMode2 = grfMode | ((grfMode & (STGM_WRITE | STGM_READWRITE)) ? STGM_CREATE : 0); if (!(dwFlags & SHGVSPB_ALLUSERS) || !(dwFlags & SHGVSPB_PERFOLDER)) { HKEY hk = _GetHKey(dwFlags); if (hk) { WCHAR szRegSubKey[64]; hr = _GetRegKey(pidl, pszBagName, dwFlags, grfMode2, hk, szRegSubKey, ARRAYSIZE(szRegSubKey)); if (SUCCEEDED(hr)) { hr = SHCreatePropertyBagOnRegKey(hk, szRegSubKey, grfMode2, riid, ppv); } RegCloseKey(hk); } else { hr = E_FAIL; } } else { IBindCtx* pbctx; hr = BindCtx_CreateWithMode(grfMode2, &pbctx); if (SUCCEEDED(hr)) { // can't use - causes link problems. // hr = SHBindToObjectEx(NULL, _pidl, pbctx, riid, ppv); IShellFolder* psf; hr = SHGetDesktopFolder(&psf); if (SUCCEEDED(hr)) { hr = psf->BindToObject(_pidl, pbctx, riid, ppv); if (SUCCEEDED(hr) && NULL == *ppv) hr = E_FAIL; psf->Release(); } pbctx->Release(); } } return hr; } HRESULT CViewStatePropertyBag::_CreateUpgradeBag(REFIID riid, void** ppv) { return SHGetDesktopUpgradePropertyBag(riid, ppv); } BOOL CViewStatePropertyBag::_CanAccessPidlBag() { return (_dwFlags & SHGVSPB_PERUSER) && (_dwFlags & SHGVSPB_PERFOLDER); } BOOL CViewStatePropertyBag::_EnsurePidlBag(DWORD grfMode, REFIID riid) { if (!_ppbPidl && !_fTriedPidlBag && _CanAccessPidlBag()) { _fTriedPidlBag = TRUE; _CreateBag(_pidl, _pszBagName, (SHGVSPB_PERUSER | SHGVSPB_PERFOLDER), grfMode, riid, (void**)&_ppbPidl); } return NULL != _ppbPidl; } HRESULT CViewStatePropertyBag::_ReadPidlBag(LPCOLESTR pszPropName, VARIANT *pVar, IErrorLog *pErrorLog) { HRESULT hr; if (_EnsurePidlBag(STGM_READ, IID_IPropertyBag)) { hr = _ppbPidl->Read(pszPropName, pVar, pErrorLog); } else { hr = E_FAIL; } return hr; } BOOL CViewStatePropertyBag::_CanAccessUpgradeBag() { // only upgrade desktop for now. return 0 == StrCmpW(_pszBagName, VS_BAGSTR_DESKTOP); } BOOL CViewStatePropertyBag::_EnsureUpgradeBag(DWORD grfMode, REFIID riid) { if (!_ppbUpgrade && !_fTriedUpgradeBag && _CanAccessUpgradeBag()) { _fTriedUpgradeBag = TRUE; _CreateUpgradeBag(riid, (void**)&_ppbUpgrade); } return NULL != _ppbUpgrade; } HRESULT CViewStatePropertyBag::_ReadUpgradeBag(LPCOLESTR pszPropName, VARIANT *pVar, IErrorLog *pErrorLog) { HRESULT hr; if (_EnsureUpgradeBag(STGM_READ, IID_IPropertyBag)) { hr = _ppbUpgrade->Read(pszPropName, pVar, pErrorLog); } else { hr = E_FAIL; } return hr; } HRESULT CViewStatePropertyBag::_FindNearestInheritBag(REFIID riid, void** ppv) { HRESULT hr = E_FAIL; *ppv = NULL; HKEY hk = _GetHKey(SHGVSPB_INHERIT); if (hk) { DWORD aParentSlots[64]; DWORD dwFetched; if (SUCCEEDED(_GetMRUSlots(_pidl, STGM_READ, hk, aParentSlots, ARRAYSIZE(aParentSlots), &dwFetched))) { for (DWORD i = 0; i < dwFetched && FAILED(hr); i++) { WCHAR szRegSubKey[64]; wnsprintfW(szRegSubKey, ARRAYSIZE(szRegSubKey), L"Bags\\%d\\%s\\Inherit", aParentSlots[i], _pszBagName); hr = SHCreatePropertyBagOnRegKey(hk, szRegSubKey, STGM_READ, riid, ppv); } } RegCloseKey(hk); } return hr; } BOOL CViewStatePropertyBag::_CanAccessInheritBag() { return _CanAccessPidlBag() || (_dwFlags & SHGVSPB_INHERIT); } BOOL CViewStatePropertyBag::_EnsureInheritBag(DWORD grfMode, REFIID riid) { if (!_ppbInherit && !_fTriedInheritBag && _CanAccessInheritBag()) { _fTriedInheritBag = TRUE; _FindNearestInheritBag(riid, (void**)&_ppbInherit); } return NULL != _ppbInherit; } HRESULT CViewStatePropertyBag::_ReadInheritBag(LPCOLESTR pszPropName, VARIANT *pVar, IErrorLog *pErrorLog) { HRESULT hr; if (_EnsureInheritBag(STGM_READ, IID_IPropertyBag)) { hr = _ppbInherit->Read(pszPropName, pVar, pErrorLog); } else { hr = E_FAIL; } return hr; } BOOL CViewStatePropertyBag::_CanAccessUserDefaultsBag() { return _CanAccessPidlBag() || ((_dwFlags & SHGVSPB_PERUSER) && (_dwFlags & SHGVSPB_ALLFOLDERS)); } BOOL CViewStatePropertyBag::_EnsureUserDefaultsBag(DWORD grfMode, REFIID riid) { if (!_ppbUserDefaults && !_fTriedUserDefaultsBag && _CanAccessUserDefaultsBag()) { _fTriedUserDefaultsBag = TRUE; _CreateBag(NULL, _pszBagName, SHGVSPB_PERUSER | SHGVSPB_ALLFOLDERS, grfMode, riid, (void**)&_ppbUserDefaults); } return NULL != _ppbUserDefaults; } HRESULT CViewStatePropertyBag::_ReadUserDefaultsBag(LPCOLESTR pszPropName, VARIANT *pVar, IErrorLog *pErrorLog) { HRESULT hr; if (_EnsureUserDefaultsBag(STGM_READ, IID_IPropertyBag)) { hr = _ppbUserDefaults->Read(pszPropName, pVar, pErrorLog); } else { hr = E_FAIL; } return hr; } BOOL CViewStatePropertyBag::_CanAccessFolderDefaultsBag() { return _CanAccessUserDefaultsBag() || ((_dwFlags & SHGVSPB_ALLUSERS) && (_dwFlags & SHGVSPB_PERFOLDER)); } BOOL CViewStatePropertyBag::_IsSystemFolder() { BOOL fRet = FALSE; LPCITEMIDLIST pidlLast; IShellFolder* psf; if (SUCCEEDED(SHBindToParent(_pidl, IID_PPV_ARG(IShellFolder, &psf), &pidlLast))) { WIN32_FIND_DATAW fd; if (SUCCEEDED(SHGetDataFromIDListW(psf, pidlLast, SHGDFIL_FINDDATA, &fd, sizeof(fd)))) { fRet = PathIsSystemFolder(NULL, fd.dwFileAttributes); } psf->Release(); } return fRet; } BOOL CViewStatePropertyBag::_EnsureFolderDefaultsBag(DWORD grfMode, REFIID riid) { if (!_ppbFolderDefaults && !_fTriedFolderDefaultsBag && _CanAccessFolderDefaultsBag()) { _fTriedFolderDefaultsBag = TRUE; // PERF: Use the desktop.ini only if the folder is a system folder. if (_IsSystemFolder()) { _CreateBag(_pidl, _pszBagName, SHGVSPB_ALLUSERS | SHGVSPB_PERFOLDER, grfMode, riid, (void**)&_ppbFolderDefaults); } } return NULL != _ppbFolderDefaults; } HRESULT CViewStatePropertyBag::_ReadFolderDefaultsBag(LPCOLESTR pszPropName, VARIANT *pVar, IErrorLog *pErrorLog) { HRESULT hr; if (_EnsureFolderDefaultsBag(STGM_READ, IID_IPropertyBag)) { hr = _ppbFolderDefaults->Read(pszPropName, pVar, pErrorLog); } else { hr = E_FAIL; } return hr; } BOOL CViewStatePropertyBag::_CanAccessGlobalDefaultsBag() { return _CanAccessFolderDefaultsBag() || ((_dwFlags & SHGVSPB_ALLUSERS) && (_dwFlags & SHGVSPB_ALLFOLDERS)); } BOOL CViewStatePropertyBag::_EnsureGlobalDefaultsBag(DWORD grfMode, REFIID riid) { if (!_ppbGlobalDefaults && !_fTriedGlobalDefaultsBag && _CanAccessGlobalDefaultsBag()) { _fTriedGlobalDefaultsBag = TRUE; _CreateBag(NULL, _pszBagName, SHGVSPB_ALLUSERS | SHGVSPB_ALLFOLDERS, grfMode, riid, (void**)&_ppbGlobalDefaults); } return NULL != _ppbGlobalDefaults; } HRESULT CViewStatePropertyBag::_ReadGlobalDefaultsBag(LPCOLESTR pszPropName, VARIANT *pVar, IErrorLog *pErrorLog) { HRESULT hr; if (_EnsureGlobalDefaultsBag(STGM_READ, IID_IPropertyBag)) { hr = _ppbGlobalDefaults->Read(pszPropName, pVar, pErrorLog); } else { hr = E_FAIL; } return hr; } BOOL CViewStatePropertyBag::_EnsureReadBag(DWORD grfMode, REFIID riid) { if (!_ppbRead && !_fTriedReadBag) { _fTriedReadBag = TRUE; _CreateBag(_pidl, _pszBagName, _dwFlags, grfMode, riid, (void**)&_ppbRead); } return NULL != _ppbRead; } HRESULT CViewStatePropertyBag::Read(LPCOLESTR pszPropName, VARIANT *pVar, IErrorLog *pErrorLog) { HRESULT hr; if ((_dwFlags & SHGVSPB_NOAUTODEFAULTS) || (_dwFlags & SHGVSPB_INHERIT)) { if (_EnsureReadBag(STGM_READ, IID_IPropertyBag)) { hr = _ppbRead->Read(pszPropName, pVar, pErrorLog); } else { hr = E_FAIL; } } else { hr = _ReadPidlBag(pszPropName, pVar, pErrorLog); // per user per folder if (FAILED(hr)) { hr = _ReadInheritBag(pszPropName, pVar, pErrorLog); if (FAILED(hr)) { hr = _ReadUpgradeBag(pszPropName, pVar, pErrorLog); // (legacy per user per folder) if (FAILED(hr)) { hr = _ReadUserDefaultsBag(pszPropName, pVar, pErrorLog); // per user all folders if (FAILED(hr)) { hr = _ReadFolderDefaultsBag(pszPropName, pVar, pErrorLog); // per folder all users if (FAILED(hr)) { hr = _ReadGlobalDefaultsBag(pszPropName, pVar, pErrorLog); // all folders all users } } } } } } return hr; } void CViewStatePropertyBag::_PruneMRUTree() { HKEY hk = _GetHKey(SHGVSPB_INHERIT); if (hk) { IMruPidlList *pmru; HRESULT hr = CoCreateInstance(CLSID_MruPidlList, NULL, CLSCTX_INPROC_SERVER, IID_PPV_ARG(IMruPidlList, &pmru)); if (SUCCEEDED(hr)) { hr = pmru->InitList(200, hk, L"BagMRU"); if (SUCCEEDED(hr)) { pmru->PruneKids(_pidl); } pmru->Release(); } RegCloseKey(hk); } } void CViewStatePropertyBag::_ResetTryAgainFlag() { if (_dwFlags & SHGVSPB_NOAUTODEFAULTS) { _fTriedReadBag = FALSE; } else { if ((_dwFlags & SHGVSPB_PERUSER) && (_dwFlags & SHGVSPB_PERFOLDER)) { _fTriedPidlBag = FALSE; } else if (_dwFlags & SHGVSPB_INHERIT) { _fTriedInheritBag = FALSE; } else if ((_dwFlags & SHGVSPB_PERUSER) && (_dwFlags & SHGVSPB_ALLFOLDERS)) { _fTriedUserDefaultsBag = FALSE; } else if ((_dwFlags & SHGVSPB_ALLUSERS) && (_dwFlags & SHGVSPB_PERFOLDER)) { _fTriedFolderDefaultsBag = FALSE; } else if ((_dwFlags & SHGVSPB_ALLUSERS) && (_dwFlags & SHGVSPB_ALLFOLDERS)) { _fTriedGlobalDefaultsBag = FALSE; } } } BOOL CViewStatePropertyBag::_EnsureWriteBag(DWORD grfMode, REFIID riid) { if (!_ppbWrite && !_fTriedWriteBag) { _fTriedWriteBag = TRUE; _CreateBag(_pidl, _pszBagName, _dwFlags, grfMode, riid, (void**)&_ppbWrite); if (_ppbWrite) { _ResetTryAgainFlag(); if (SHGVSPB_INHERIT & _dwFlags) { _PruneMRUTree(); } } } return NULL != _ppbWrite; } HRESULT CViewStatePropertyBag::Write(LPCOLESTR pszPropName, VARIANT *pVar) { HRESULT hr; if (_EnsureWriteBag(STGM_WRITE, IID_IPropertyBag)) { hr = _ppbWrite->Write(pszPropName, pVar); } else { hr = E_FAIL; } return hr; } #ifdef DEBUG void IS_VALID_SHGVSPB_PARAMS(LPCITEMIDLIST pidl, LPCWSTR pszBagName, DWORD dwFlags, REFIID riid, void** ppv) { RIP((NULL == pidl && (dwFlags & SHGVSPB_ALLFOLDERS)) || (IsValidPIDL(pidl) && ((SHGVSPB_PERFOLDER & dwFlags) || (SHGVSPB_INHERIT & dwFlags)))); RIP(pszBagName); RIP(SHGVSPB_PERUSER == (dwFlags & (SHGVSPB_PERUSER | SHGVSPB_ALLUSERS | SHGVSPB_INHERIT)) || SHGVSPB_ALLUSERS == (dwFlags & (SHGVSPB_PERUSER | SHGVSPB_ALLUSERS | SHGVSPB_INHERIT)) || SHGVSPB_INHERIT == (dwFlags & (SHGVSPB_PERUSER | SHGVSPB_ALLUSERS | SHGVSPB_INHERIT))); RIP(SHGVSPB_PERFOLDER == (dwFlags & (SHGVSPB_PERFOLDER | SHGVSPB_ALLFOLDERS | SHGVSPB_INHERIT)) || SHGVSPB_ALLFOLDERS == (dwFlags & (SHGVSPB_PERFOLDER | SHGVSPB_ALLFOLDERS | SHGVSPB_INHERIT)) || SHGVSPB_INHERIT == (dwFlags & (SHGVSPB_PERFOLDER | SHGVSPB_ALLFOLDERS | SHGVSPB_INHERIT))); RIP(riid == IID_IPropertyBag || riid == IID_IUnknown); RIP(NULL != ppv); } #else #define IS_VALID_SHGVSPB_PARAMS(a, b, c, d, e) #endif // Cache the last bag accessed. CViewStatePropertyBag* g_pCachedBag = NULL; EXTERN_C void FreeViewStatePropertyBagCache() { ENTERCRITICAL; { if (g_pCachedBag) { g_pCachedBag->Release(); g_pCachedBag = NULL; } } LEAVECRITICAL; } BOOL SHIsRemovableDrive(LPCITEMIDLIST pidl) { BOOL fRet = FALSE; LPCITEMIDLIST pidlLast; IShellFolder* psf; if (SUCCEEDED(SHBindToParent(pidl, IID_PPV_ARG(IShellFolder, &psf), &pidlLast))) { STRRET str; if (SUCCEEDED(psf->GetDisplayNameOf(pidlLast, SHGDN_FORPARSING, &str))) { WCHAR szPath[MAX_PATH]; if (SUCCEEDED(StrRetToBufW(&str, pidlLast, szPath, ARRAYSIZE(szPath)))) { int iDrive = PathGetDriveNumberW(szPath); if (iDrive != -1) { int iDriveType = RealDriveType(iDrive, FALSE); fRet = (DRIVE_REMOVABLE == iDriveType || DRIVE_CDROM == iDriveType); } } } psf->Release(); } return fRet; } STDAPI SHGetViewStatePropertyBag(LPCITEMIDLIST pidl, LPCWSTR pszBagName, DWORD dwFlags, REFIID riid, void** ppv) { IS_VALID_SHGVSPB_PARAMS(pidl, pszBagName, dwFlags, riid, ppv); HRESULT hr; *ppv = NULL; ENTERCRITICAL; { if (g_pCachedBag && g_pCachedBag->_IsSameBag(pidl, pszBagName, dwFlags)) { hr = S_OK; } else { if (!SHIsRemovableDrive(pidl)) { CViewStatePropertyBag* pBag = new CViewStatePropertyBag(); if (pBag) { hr = pBag->_Init(pidl, pszBagName, dwFlags); if (SUCCEEDED(hr)) { if (g_pCachedBag) g_pCachedBag->Release(); g_pCachedBag = pBag; } else { pBag->Release(); } } else { hr = E_OUTOFMEMORY; } } else { hr = E_FAIL; // don't save property bags for removable drives. } } if (SUCCEEDED(hr)) { hr = g_pCachedBag->QueryInterface(riid, ppv); } } LEAVECRITICAL; return hr; } ULONG SHGetPerScreenResName(WCHAR* pszRes, ULONG cch, DWORD dwVersion) { RIPMSG(IS_VALID_WRITE_BUFFER(pszRes, *pszRes, cch), "SHGetPerScreenResName caller passed bad pszRes or cch"); ULONG uRet; if (0 == dwVersion) { HDC hdc = GetDC(NULL); int x = GetDeviceCaps(hdc, HORZRES); int y = GetDeviceCaps(hdc, VERTRES); ReleaseDC(NULL, hdc); int n = GetSystemMetrics(SM_CMONITORS); int cchLen = wnsprintfW(pszRes, cch, L"%dx%d(%d)", x, y, n); uRet = (cchLen > 0) ? cchLen : 0; } else { uRet = 0; } return uRet; }