2681 lines
71 KiB
C++
2681 lines
71 KiB
C++
#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 <section name>.<prop name> 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<BYTE*>(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<BYTE*>(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<SHORT>(ptL.x);
|
|
ppt->y = static_cast<SHORT>(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;
|
|
}
|