windows-nt/Source/XPSP1/NT/shell/ext/pstore/enumid.cpp

517 lines
10 KiB
C++
Raw Normal View History

2020-09-26 03:20:57 -05:00
/*++
Implements IEnumIDList.
--*/
#include <windows.h>
#include <shlobj.h>
#include "pstore.h"
#include "utility.h"
#include "enumid.h"
#include "shfolder.h"
extern LONG g_DllRefCount;
CEnumIDList::CEnumIDList(
LPITEMIDLIST pidl,
BOOL bEnumItems
)
{
m_pIEnumProviders = NULL;
m_pIPStoreProvider = NULL;
m_pIEnumTypes = NULL;
m_pIEnumTypesGlobal = NULL;
m_pIEnumSubtypes = NULL;
m_pIEnumItems = NULL;
m_bEnumItems = bEnumItems;
//
// get the shell's IMalloc pointer
// we'll keep this until we get destroyed
//
if(FAILED(SHGetMalloc(&m_pMalloc)))
delete this;
m_KeyType = PST_KEY_CURRENT_USER;
if(pidl == NULL) {
if( PStoreEnumProviders(0, &m_pIEnumProviders) != S_OK )
m_pIEnumProviders = NULL;
m_dwType = PIDL_TYPE_PROVIDER; // top-level
} else {
m_dwType = GetLastPidlType(pidl) + 1; // parent + 1
}
//
// get provider interface
//
if(m_dwType > PIDL_TYPE_PROVIDER) {
PST_PROVIDERID *ProviderId = GetPidlGuid(pidl);
if(PStoreCreateInstance(&m_pIPStoreProvider, ProviderId, NULL, 0) != S_OK)
m_pIPStoreProvider = NULL;
}
//
// prepare two type enumerators, if appropriate:
// PST_KEY_CURRENT_USER and PST_KEY_LOCAL_MACHINE
//
if(m_dwType == PIDL_TYPE_TYPE && m_pIPStoreProvider) {
m_pIPStoreProvider->EnumTypes(PST_KEY_CURRENT_USER, 0, &m_pIEnumTypes);
m_pIPStoreProvider->EnumTypes(PST_KEY_LOCAL_MACHINE, 0, &m_pIEnumTypesGlobal);
}
//
// prepare subtype enumerator
//
if(m_dwType == PIDL_TYPE_SUBTYPE && m_pIPStoreProvider) {
GUID *pguidType;
m_KeyType = GetLastPidlKeyType(pidl);
pguidType = GetLastPidlGuid(pidl);
CopyMemory(&m_guidType, pguidType, sizeof(GUID));
m_pIPStoreProvider->EnumSubtypes(
m_KeyType,
pguidType,
0,
&m_pIEnumSubtypes
);
}
//
// prepare item enumerator if appropriate.
//
if(m_dwType == PIDL_TYPE_ITEM && m_bEnumItems && m_pIPStoreProvider) {
GUID *pguidType;
GUID *pguidSubtype;
m_KeyType = GetLastPidlKeyType(pidl);
pguidSubtype = GetLastPidlGuid(pidl);
CopyMemory(&m_guidSubtype, pguidSubtype, sizeof(GUID));
pguidType = GetPidlGuid(SearchPidlByType(pidl, PIDL_TYPE_TYPE));
CopyMemory(&m_guidType, pguidType, sizeof(GUID));
m_pIPStoreProvider->EnumItems(
m_KeyType,
pguidType,
pguidSubtype,
0,
&m_pIEnumItems
);
}
m_ulCurrent = 0;
m_ObjRefCount = 1;
InterlockedIncrement(&g_DllRefCount);
}
CEnumIDList::~CEnumIDList()
{
//
// free any interfaces we established.
//
if(m_pIEnumProviders) {
m_pIEnumProviders->Release();
m_pIEnumProviders = NULL;
}
if(m_pIPStoreProvider) {
m_pIPStoreProvider->Release();
m_pIPStoreProvider = NULL;
}
if(m_pIEnumTypes) {
m_pIEnumTypes->Release();
m_pIEnumTypes = NULL;
}
if(m_pIEnumTypesGlobal) {
m_pIEnumTypesGlobal->Release();
m_pIEnumTypesGlobal = NULL;
}
if(m_pIEnumSubtypes) {
m_pIEnumSubtypes->Release();
m_pIEnumSubtypes = NULL;
}
if(m_pIEnumItems) {
m_pIEnumItems->Release();
m_pIEnumItems = NULL;
}
if(m_pMalloc) {
m_pMalloc->Release();
m_pMalloc = NULL;
}
InterlockedDecrement(&g_DllRefCount);
}
STDMETHODIMP
CEnumIDList::QueryInterface(
REFIID riid,
LPVOID *ppReturn
)
{
*ppReturn = NULL;
if(IsEqualIID(riid, IID_IUnknown))
*ppReturn = (IUnknown*)(CEnumIDList*)this;
else if(IsEqualIID(riid, IID_IEnumIDList))
*ppReturn = (CEnumIDList*)this;
if(*ppReturn == NULL)
return E_NOINTERFACE;
(*(LPUNKNOWN*)ppReturn)->AddRef();
return S_OK;
}
STDMETHODIMP_(DWORD)
CEnumIDList::AddRef()
{
return InterlockedIncrement(&m_ObjRefCount);
}
STDMETHODIMP_(DWORD)
CEnumIDList::Release()
{
LONG lDecremented = InterlockedDecrement(&m_ObjRefCount);
if(lDecremented == 0)
delete this;
return lDecremented;
}
STDMETHODIMP
CEnumIDList::Next(
ULONG ulElements,
LPITEMIDLIST *pPidl,
ULONG *pulFetched
)
/*++
Retrieves the specified number of item identifiers in the enumeration
sequence and advances the current position.
Returns the NOERROR value if successful,
Returns S_FALSE value if there are no more items in the enumeration
or an OLE-defined error value if an error occurs.
--*/
{
HRESULT hr;
*pPidl = NULL;
*pulFetched = 0;
if(m_bEnumItems) {
if(m_dwType > PIDL_TYPE_ITEM)
return S_FALSE;
} else {
if(m_dwType > PIDL_TYPE_SUBTYPE)
return S_FALSE; // nothing left to enumerate
}
if(m_dwType == PIDL_TYPE_PROVIDER && m_pIEnumProviders)
{
PPST_PROVIDERINFO pProvInfo;
if( m_pIEnumProviders->Next(1, &pProvInfo, &m_ulCurrent) != S_OK ) {
//
// enumeration of providers complete
//
return S_FALSE;
}
hr = CreateIDList(m_dwType, m_KeyType, &(pProvInfo->ID), pProvInfo->szProviderName, pPidl);
CoTaskMemFree(pProvInfo);
if(hr != S_OK)
return S_FALSE;
*pulFetched = 1;
return NOERROR;
}
//
// must have a valid provider interface at this point
//
if(m_pIPStoreProvider == NULL)
return S_FALSE;
if(m_dwType == PIDL_TYPE_TYPE) {
IEnumPStoreTypes *pIEnumTypes;
PST_KEY KeyType = PST_KEY_CURRENT_USER;
GUID guidType;
type_enum:
if(KeyType == PST_KEY_LOCAL_MACHINE)
pIEnumTypes = m_pIEnumTypesGlobal;
else
pIEnumTypes = m_pIEnumTypes;
if(pIEnumTypes == NULL)
return S_FALSE;
if(pIEnumTypes->Next(1, &guidType, &m_ulCurrent) != S_OK) {
//
// if enumeration at PST_KEY_CURRENT_USER level complete,
// continue at the PST_KEY_LOCAL_MACHINE level.
//
if(KeyType == PST_KEY_CURRENT_USER) {
KeyType = PST_KEY_LOCAL_MACHINE;
goto type_enum;
}
//
// enumeration of types complete
//
return S_FALSE;
}
PST_TYPEINFO *pTypeInfo = NULL;
if(S_OK != m_pIPStoreProvider->GetTypeInfo(
KeyType,
&guidType,
&pTypeInfo,
0
)) return S_FALSE;
hr = CreateIDList(m_dwType, KeyType, &guidType, pTypeInfo->szDisplayName, pPidl);
//
// free pTypeInfo data
//
CoTaskMemFree(pTypeInfo);
if(hr != S_OK)
return S_FALSE;
*pulFetched = 1;
return NOERROR;
}
if (m_dwType == PIDL_TYPE_SUBTYPE && m_pIEnumSubtypes) {
GUID guidSubtype;
GUID *pguidType = &m_guidType;
if(m_pIEnumSubtypes->Next(1, &guidSubtype, &m_ulCurrent) != S_OK) {
//
// enumeration of types complete
//
return S_FALSE;
}
PST_TYPEINFO *pTypeInfo = NULL;
if(m_pIPStoreProvider->GetSubtypeInfo(m_KeyType, pguidType, &guidSubtype, &pTypeInfo, 0) != S_OK)
return S_FALSE;
hr = CreateIDList(m_dwType, m_KeyType, &guidSubtype, pTypeInfo->szDisplayName, pPidl);
//
// free pTypeInfo data
//
CoTaskMemFree(pTypeInfo);
if(hr != S_OK)
return S_FALSE;
*pulFetched = 1;
return NOERROR;
}
if(m_dwType == PIDL_TYPE_ITEM && m_pIEnumItems) {
LPWSTR pszItem;
//
// enumerate and add items associated with specified subtype
//
if(m_pIEnumItems->Next(1, &pszItem, &m_ulCurrent) != S_OK) {
//
// enumeration of items complete
//
return S_FALSE;
}
hr = CreateIDList(
m_dwType,
m_KeyType,
NULL, // no item guid
pszItem,
pPidl
);
//
// free pszItem data
//
CoTaskMemFree(pszItem);
if(hr != S_OK)
return S_FALSE;
*pulFetched = 1;
return NOERROR;
}
return S_FALSE;
}
STDMETHODIMP
CEnumIDList::CreateIDList(
DWORD dwType,
PST_KEY KeyType,
GUID *guid,
LPCWSTR szString,
LPITEMIDLIST *pPidlOut
)
{
DWORD cbString = 0;
DWORD cbPidlContent;
if(szString) {
cbString = lstrlenW(szString);
}
cbString = (cbString + 1) * sizeof(WCHAR);
cbPidlContent = sizeof(PIDL_CONTENT) + cbString;
//
// allocate the memory
//
*pPidlOut = (LPITEMIDLIST)m_pMalloc->Alloc(
sizeof(ITEMIDLIST) + // this item's ITEMIDLIST
cbPidlContent + // this item's data
sizeof(ITEMIDLIST) // terminal ITEMIDLIST
);
if(*pPidlOut == NULL)
return E_OUTOFMEMORY;
LPITEMIDLIST pidlTemp = *pPidlOut;
LPPIDL_CONTENT pidlContent = (LPPIDL_CONTENT)&(pidlTemp->mkid.abID);
//
// set the size of this item
//
pidlTemp->mkid.cb = (unsigned short)(sizeof(ITEMIDLIST) + cbPidlContent);
//
// set the data for this item
//
pidlContent->dwType = dwType;
pidlContent->KeyType = KeyType;
if( guid ) {
CopyMemory(&(pidlContent->guid), guid, sizeof(GUID));
} else {
ZeroMemory(&(pidlContent->guid), sizeof(GUID));
}
if(szString) {
CopyMemory((LPBYTE)(pidlContent+1), szString, cbString);
} else {
((LPWSTR)(pidlContent+1))[0] = L'\0';
}
//
// advance and terminate item ID list
//
pidlTemp = (LPITEMIDLIST)GetPidlNextItem(*pPidlOut);
pidlTemp->mkid.cb = 0;
pidlTemp->mkid.abID[0] = 0;
return NOERROR;
}
STDMETHODIMP
CEnumIDList::Skip(
ULONG ulSkip
)
{
m_ulCurrent += ulSkip;
return NOERROR;
}
STDMETHODIMP
CEnumIDList::Reset(
void
)
{
m_ulCurrent = 0;
return NOERROR;
}
STDMETHODIMP
CEnumIDList::Clone(
LPENUMIDLIST *ppEnum
)
{
return E_NOTIMPL;
}