1527 lines
37 KiB
C++
1527 lines
37 KiB
C++
#include "priv.h"
|
|
#include "sccls.h"
|
|
#include "iface.h"
|
|
#include "augisf.h"
|
|
#include "menuisf.h"
|
|
|
|
//=================================================================
|
|
// Implementation of an IShellFolder that wraps a collection of
|
|
// other IShellFolders. We call this an augmented IShellFolder
|
|
// object.
|
|
//
|
|
//=================================================================
|
|
|
|
// The CAugmentedISF wraps all the pidls so it can identify which pidl
|
|
// belongs to which IShellFolder object.
|
|
|
|
typedef struct tagIDWRAP
|
|
{
|
|
// Real pidl goes on the end
|
|
|
|
UINT nID; // Refers to a specific IShellFolder object
|
|
UINT cbOriginal; // the original size of the pidl. we need this because we dword align the pidl before wrapping it
|
|
} IDWRAP, * PIDWRAP;
|
|
|
|
#define IDWrap_GetWrap(pidl) ((PIDWRAP)(((LPBYTE)pidl) + (pidl)->mkid.cb - SIZEOF(IDWRAP)))
|
|
#define IDWrap_GetID(pidl) (IDWrap_GetWrap(pidl)->nID)
|
|
#define IDWrap_GetOriginalSize(pidl) (IDWrap_GetWrap(pidl)->cbOriginal)
|
|
|
|
/*----------------------------------------------------------
|
|
The CAugmentedISF object holds an array of CISFElems, each of which
|
|
refers to an IShellFolder which will be enumerated.
|
|
*/
|
|
class CISFElem
|
|
{
|
|
public:
|
|
CISFElem * Clone(void);
|
|
HRESULT AcquireEnumerator(DWORD dwFlags);
|
|
IShellFolder * GetPSF() { return _psf; };
|
|
IEnumIDList * GetEnumerator() { return _pei; };
|
|
void GetNameSpaceID(GUID * rguid);
|
|
HRESULT SetPidl(LPCITEMIDLIST pidl);
|
|
LPCITEMIDLIST GetPidl() { return _pidl; };
|
|
DWORD GetFlags() { return _dwFlags; };
|
|
void SetRegister(UINT uReg) { _uRegister = uReg; };
|
|
UINT GetRegister() { return _uRegister; };
|
|
|
|
CISFElem(const GUID * pguid, IShellFolder * psf, DWORD dwFlags);
|
|
~CISFElem();
|
|
|
|
protected:
|
|
|
|
GUID _guid; // Unique ID
|
|
IShellFolder * _psf;
|
|
IEnumIDList * _pei; // Used by CAugSIFEnum only
|
|
LPITEMIDLIST _pidl;
|
|
DWORD _dwFlags;
|
|
UINT _uRegister;
|
|
|
|
friend BOOL IsValidPCISFElem(CISFElem * pel);
|
|
};
|
|
|
|
//
|
|
// CAugmentedISF enumerator
|
|
//
|
|
class CAugISFEnum : public IEnumIDList
|
|
{
|
|
public:
|
|
// *** IUnknown methods ***
|
|
STDMETHOD(QueryInterface) (REFIID riid, LPVOID * ppvObj);
|
|
STDMETHOD_(ULONG,AddRef) () ;
|
|
STDMETHOD_(ULONG,Release) ();
|
|
|
|
// *** IEnumIDList methods ***
|
|
STDMETHOD(Next) (ULONG celt,
|
|
LPITEMIDLIST *rgelt,
|
|
ULONG *pceltFetched);
|
|
STDMETHOD(Skip) (ULONG celt);
|
|
STDMETHOD(Reset) ();
|
|
STDMETHOD(Clone) (IEnumIDList **ppenum);
|
|
|
|
// Other methods
|
|
HRESULT Init(HDPA hdpaISF, DWORD dwEnumFlags);
|
|
|
|
CAugISFEnum();
|
|
~CAugISFEnum();
|
|
|
|
protected:
|
|
IEnumIDList * _GetObjectEnumerator(int nID);
|
|
|
|
UINT _cRef;
|
|
int _iCurISF; // current item in _hdpaISF
|
|
HDPA _hdpaISF;
|
|
};
|
|
|
|
/*----------------------------------------------------------
|
|
Pidl wrapping routine
|
|
*/
|
|
LPITEMIDLIST AugISF_WrapPidl( LPCITEMIDLIST pidl, int nID )
|
|
{
|
|
LPITEMIDLIST pidlRet = NULL;
|
|
|
|
// get the size of the pidl
|
|
// round up to dword align.
|
|
UINT cbPidlSize = (pidl->mkid.cb + 3) & ~3;
|
|
|
|
ASSERT(cbPidlSize >= pidl->mkid.cb);
|
|
UINT cbSize = SIZEOF(IDWRAP) + cbPidlSize + SIZEOF(DWORD); // pidl plus terminator
|
|
LPBYTE p = (LPBYTE)SHAlloc(cbSize);
|
|
if (p)
|
|
{
|
|
ZeroMemory(p, cbSize);
|
|
memcpy(p, pidl, pidl->mkid.cb);
|
|
|
|
IDWRAP* pidw = (IDWRAP*) (p + cbPidlSize);
|
|
pidw->nID = nID;
|
|
pidw->cbOriginal = pidl->mkid.cb;
|
|
|
|
// now make the cb be the whole pidl (not including the final null)
|
|
pidlRet = (LPITEMIDLIST)p;
|
|
pidlRet->mkid.cb = (USHORT) (cbPidlSize + SIZEOF(IDWRAP));
|
|
}
|
|
return pidlRet;
|
|
}
|
|
|
|
// GetIDListWrapCount and GetNameSpaceCount are not used anywhere
|
|
#if 0
|
|
/*----------------------------------------------------------
|
|
Purpose: IAugmentedShellFolder2::GetIDListWrapCount
|
|
*/
|
|
STDMETHODIMP CAugmentedISF::GetNameSpaceCount( OUT LONG* pcNamespaces )
|
|
{
|
|
if( NULL == pcNamespaces )
|
|
return E_INVALIDARG ;
|
|
|
|
*pcNamespaces = (NULL != _hdpa) ? DPA_GetPtrCount( _hdpa ) : 0 ;
|
|
return S_OK ;
|
|
}
|
|
|
|
/*----------------------------------------------------------
|
|
Purpose: IAugmentedShellFolder2::GetIDListWrapCount
|
|
*/
|
|
STDMETHODIMP CAugmentedISF::GetIDListWrapCount(
|
|
LPCITEMIDLIST pidlWrap,
|
|
OUT LONG * pcPidls )
|
|
{
|
|
if( NULL == pidlWrap || NULL == pcPidls )
|
|
return E_INVALIDARG ;
|
|
|
|
PIDWRAP pWrap = IDWrap_GetWrap(pidlWrap) ;
|
|
*pcPidls = 0 ;
|
|
|
|
if( NULL != _hdpa &&
|
|
DPA_GetPtrCount( _hdpa ) > (int)pWrap->nID &&
|
|
pWrap->cbOriginal < pidlWrap->mkid.cb + sizeof(IDWRAP) )
|
|
*pcPidls = 1 ;
|
|
|
|
return S_OK ;
|
|
}
|
|
#endif
|
|
/*----------------------------------------------------------
|
|
Purpose: IAugmentedShellFolder2::UnWrapIDList
|
|
*/
|
|
STDMETHODIMP CAugmentedISF::UnWrapIDList(
|
|
LPCITEMIDLIST pidl,
|
|
LONG cPidls,
|
|
IShellFolder ** ppsf,
|
|
LPITEMIDLIST * ppidlFolder,
|
|
LPITEMIDLIST * ppidl,
|
|
LONG * pcFetched )
|
|
{
|
|
HRESULT hres = E_INVALIDARG;
|
|
|
|
ASSERT(IS_VALID_PIDL(pidl));
|
|
|
|
if( pcFetched )
|
|
*pcFetched = 0 ;
|
|
|
|
if (pidl)
|
|
{
|
|
UINT nId = IDWrap_GetID(pidl);
|
|
CISFElem * pel = (CISFElem *)DPA_GetPtr(_hdpa, nId);
|
|
|
|
if (pel)
|
|
{
|
|
LPITEMIDLIST pidlNew = ILClone(GetNativePidl(pidl, nId));
|
|
LPITEMIDLIST pidlFolderNew = ILClone(pel->GetPidl());
|
|
|
|
if (pidlNew && pidlFolderNew)
|
|
{
|
|
if ( ppsf )
|
|
{
|
|
*ppsf = pel->GetPSF();
|
|
(*ppsf)->AddRef();
|
|
}
|
|
|
|
*ppidl = pidlNew;
|
|
*ppidlFolder = pidlFolderNew;
|
|
|
|
if( pcFetched )
|
|
*pcFetched = 1 ;
|
|
|
|
hres = (cPidls == 1) ? S_OK : S_FALSE ;
|
|
}
|
|
else
|
|
{
|
|
ILFree(pidlNew);
|
|
ILFree(pidlFolderNew);
|
|
hres = E_OUTOFMEMORY;
|
|
}
|
|
}
|
|
else
|
|
hres = E_FAIL;
|
|
}
|
|
|
|
return hres;
|
|
}
|
|
|
|
/*----------------------------------------------------------
|
|
Purpose: CAugmentedISF::TranslatePidl
|
|
*/
|
|
LPITEMIDLIST CAugmentedISF::TranslatePidl( LPCITEMIDLIST pidlNS, LPCITEMIDLIST pidl, LPARAM nID )
|
|
{
|
|
LPITEMIDLIST pidlRet = NULL;
|
|
|
|
// Is this not empty and an immediate child?
|
|
if (ILIsParent(pidlNS, pidl, TRUE))
|
|
{
|
|
LPCITEMIDLIST pidlChild;
|
|
LPITEMIDLIST pidlNew;
|
|
TCHAR szFullName[MAX_PATH];
|
|
LPITEMIDLIST pidlFull = NULL;
|
|
|
|
// HACKHACK (lamadio): You cannot use SHGetRealIDL for augisf encapsulated
|
|
// IShellFolders. This routine QIs for INeedRealShellFolder, which IAugISF
|
|
// doesnot forward. The fstree code does not handle aggregation, so this
|
|
// cannot be forwarded anyway. This code can be cleaned up when we rewrite
|
|
// the fstree stuff... Sep.4.1997
|
|
|
|
if (SUCCEEDED(SHGetNameAndFlags(pidl, SHGDN_FORPARSING, szFullName, SIZECHARS(szFullName), NULL))
|
|
&& (pidlFull = ILCreateFromPath(szFullName)) != NULL)
|
|
{
|
|
pidlChild = ILFindLastID(pidlFull);
|
|
pidlNew = ILClone(pidlFull);
|
|
}
|
|
else
|
|
{
|
|
pidlChild = ILFindLastID(pidl);
|
|
pidlNew = ILClone(pidl);
|
|
}
|
|
|
|
// Yes; create a new full pidl where the last element is wrapped
|
|
|
|
if (pidlNew)
|
|
{
|
|
ILRemoveLastID(pidlNew);
|
|
|
|
LPITEMIDLIST pidlWrap = AugISF_WrapPidl( pidlChild, (int)nID );
|
|
if (pidlWrap)
|
|
{
|
|
pidlRet = ILCombine(pidlNew, pidlWrap);
|
|
ILFree(pidlWrap);
|
|
}
|
|
ILFree(pidlNew);
|
|
}
|
|
|
|
ILFree(pidlFull); //Checks for a NULL pidl
|
|
}
|
|
else
|
|
pidlRet = (LPITEMIDLIST)pidl;
|
|
|
|
return pidlRet;
|
|
}
|
|
|
|
/*----------------------------------------------------------
|
|
Purpose: CAugmentedISF::GetNativePidl
|
|
Clones and returns a copy of the native ('source') pidl
|
|
contained in the specified wrap.
|
|
*/
|
|
LPITEMIDLIST CAugmentedISF::GetNativePidl(LPCITEMIDLIST pidl, LPARAM lParam /*int nID*/ )
|
|
{
|
|
ASSERT(IS_VALID_PIDL(pidl));
|
|
UNREFERENCED_PARAMETER( lParam ) ; // only one source ID in the wrap!
|
|
|
|
LPITEMIDLIST pidlNew = ILClone(pidl);
|
|
|
|
if (pidlNew)
|
|
{
|
|
// Take off our trailing wrap signature
|
|
pidlNew->mkid.cb = IDWrap_GetOriginalSize(pidl);
|
|
|
|
ASSERT(sizeof(IDWRAP) >= sizeof(USHORT));
|
|
|
|
USHORT * pu = (USHORT *)_ILNext(pidlNew);
|
|
*pu = 0;
|
|
}
|
|
return pidlNew;
|
|
}
|
|
|
|
|
|
|
|
|
|
CISFElem::CISFElem(const GUID * pguid, IShellFolder * psf, DWORD dwFlags) : _dwFlags(dwFlags)
|
|
{
|
|
ASSERT(IS_VALID_CODE_PTR(psf, IShellFolder));
|
|
ASSERT(NULL == pguid || IS_VALID_READ_PTR(pguid, GUID));
|
|
|
|
if (pguid)
|
|
CopyMemory(&_guid, pguid, sizeof(_guid));
|
|
|
|
_psf = psf;
|
|
_psf->AddRef();
|
|
}
|
|
|
|
CISFElem::~CISFElem()
|
|
{
|
|
ASSERT(IS_VALID_CODE_PTR(_psf, IShellFolder));
|
|
|
|
_psf->Release();
|
|
|
|
if (_pei)
|
|
_pei->Release();
|
|
|
|
Pidl_Set(&_pidl, NULL);
|
|
}
|
|
|
|
CISFElem * CISFElem::Clone(void)
|
|
{
|
|
CISFElem * pelem = new CISFElem(&_guid, _psf, _dwFlags);
|
|
|
|
if (pelem)
|
|
{
|
|
// If this fails, we're punting and going ahead anyway
|
|
pelem->SetPidl(_pidl);
|
|
}
|
|
|
|
return pelem;
|
|
}
|
|
|
|
|
|
void CISFElem::GetNameSpaceID(GUID * pguid)
|
|
{
|
|
ASSERT(IS_VALID_WRITE_PTR(pguid, GUID));
|
|
CopyMemory(pguid, &_guid, sizeof(_guid));
|
|
}
|
|
|
|
|
|
HRESULT CISFElem::SetPidl(LPCITEMIDLIST pidl)
|
|
{
|
|
HRESULT hres = S_OK;
|
|
|
|
Pidl_Set(&_pidl, pidl);
|
|
|
|
if (pidl && NULL == _pidl)
|
|
hres = E_OUTOFMEMORY;
|
|
|
|
return hres;
|
|
}
|
|
|
|
/*----------------------------------------------------------
|
|
Purpose: Gets an enumerator for the IShellFolder and caches it.
|
|
|
|
*/
|
|
HRESULT CISFElem::AcquireEnumerator(DWORD dwFlags)
|
|
{
|
|
return IShellFolder_EnumObjects(_psf, NULL, dwFlags, &_pei);
|
|
}
|
|
|
|
|
|
//
|
|
// CAugmentedISF object
|
|
//
|
|
|
|
|
|
#undef SUPERCLASS
|
|
|
|
|
|
#ifdef DEBUG
|
|
|
|
BOOL IsValidPCISFElem(CISFElem * pel)
|
|
{
|
|
return (IS_VALID_WRITE_PTR(pel, CISFElem) &&
|
|
IS_VALID_CODE_PTR(pel->_psf, IShellFolder) &&
|
|
(NULL == pel->_pidl || IS_VALID_PIDL(pel->_pidl)));
|
|
}
|
|
|
|
#endif
|
|
|
|
// Constructor
|
|
CAugmentedISF::CAugmentedISF() :
|
|
_cRef(1)
|
|
{
|
|
DllAddRef();
|
|
}
|
|
|
|
|
|
/*----------------------------------------------------------
|
|
Purpose: Callback to destroy each element
|
|
|
|
*/
|
|
int CISFElem_DestroyCB(LPVOID pv, LPVOID pvData)
|
|
{
|
|
CISFElem * pel = (CISFElem *)pv;
|
|
|
|
ASSERT(NULL == pel || IS_VALID_STRUCT_PTR(pel, CISFElem));
|
|
|
|
if (pel)
|
|
delete pel;
|
|
|
|
return TRUE;
|
|
}
|
|
|
|
|
|
/*----------------------------------------------------------
|
|
Purpose: Callback to set the owner of each element
|
|
|
|
*/
|
|
int CISFElem_SetOwnerCB(LPVOID pv, LPVOID pvData)
|
|
{
|
|
CISFElem * pel = (CISFElem *)pv;
|
|
|
|
ASSERT(IS_VALID_STRUCT_PTR(pel, CISFElem));
|
|
|
|
IShellFolder * psf = pel->GetPSF();
|
|
if (psf)
|
|
{
|
|
IUnknown_SetOwner(psf, (IUnknown *)pvData);
|
|
// don't need to release psf
|
|
}
|
|
|
|
return TRUE;
|
|
}
|
|
|
|
|
|
typedef struct {
|
|
HRESULT hres;
|
|
HWND hwnd;
|
|
const IID * piid;
|
|
void ** ppvObj;
|
|
} CVODATA;
|
|
|
|
|
|
/*----------------------------------------------------------
|
|
Purpose: Callback to call CreateViewObject
|
|
|
|
*/
|
|
int CISFElem_CreateViewObjectCB(LPVOID pv, LPVOID pvData)
|
|
{
|
|
CISFElem * pel = (CISFElem *)pv;
|
|
CVODATA * pdata = (CVODATA *)pvData;
|
|
|
|
ASSERT(IS_VALID_STRUCT_PTR(pel, CISFElem));
|
|
ASSERT(IS_VALID_WRITE_PTR(pdata, CVODATA));
|
|
|
|
IShellFolder * psf = pel->GetPSF();
|
|
if (psf)
|
|
{
|
|
pdata->hres = psf->CreateViewObject(pdata->hwnd, *(pdata->piid), pdata->ppvObj);
|
|
if (SUCCEEDED(pdata->hres))
|
|
return FALSE; // stop on first success
|
|
|
|
// don't need to release psf
|
|
}
|
|
|
|
return TRUE;
|
|
}
|
|
|
|
|
|
|
|
// Destructor
|
|
CAugmentedISF::~CAugmentedISF()
|
|
{
|
|
SetOwner(NULL);
|
|
|
|
DPA_DestroyCallback(_hdpa, CISFElem_DestroyCB, NULL);
|
|
_hdpa = NULL;
|
|
|
|
DllRelease();
|
|
}
|
|
|
|
|
|
STDMETHODIMP_(ULONG) CAugmentedISF::AddRef()
|
|
{
|
|
_cRef++;
|
|
return _cRef;
|
|
}
|
|
|
|
|
|
STDMETHODIMP_(ULONG) CAugmentedISF::Release()
|
|
{
|
|
ASSERT(_cRef > 0);
|
|
_cRef--;
|
|
|
|
if (_cRef > 0)
|
|
return _cRef;
|
|
|
|
delete this;
|
|
return 0;
|
|
}
|
|
|
|
|
|
STDMETHODIMP CAugmentedISF::QueryInterface(REFIID riid, void **ppvObj)
|
|
{
|
|
static const QITAB qit[] = {
|
|
QITABENT(CAugmentedISF, IShellFolder),
|
|
QITABENT(CAugmentedISF, IAugmentedShellFolder),
|
|
QITABENT(CAugmentedISF, IAugmentedShellFolder2),
|
|
QITABENT(CAugmentedISF, IShellService),
|
|
QITABENT(CAugmentedISF, ITranslateShellChangeNotify),
|
|
{ 0 },
|
|
};
|
|
return QISearch(this, qit, riid, ppvObj);
|
|
}
|
|
|
|
|
|
/*----------------------------------------------------------
|
|
Purpose: IShellService::SetOwner method
|
|
|
|
*/
|
|
STDMETHODIMP CAugmentedISF::SetOwner(IUnknown* punk)
|
|
{
|
|
HRESULT hres = S_OK;
|
|
|
|
ASSERT(NULL == punk || IS_VALID_CODE_PTR(punk, IUnknown));
|
|
|
|
if (_hdpa && _punkOwner)
|
|
DPA_EnumCallback(_hdpa, CISFElem_SetOwnerCB, NULL);
|
|
|
|
ATOMICRELEASE(_punkOwner);
|
|
|
|
if (punk)
|
|
{
|
|
hres = punk->QueryInterface(IID_IUnknown, (LPVOID *)&_punkOwner);
|
|
|
|
if (_hdpa)
|
|
DPA_EnumCallback(_hdpa, CISFElem_SetOwnerCB, (void *)_punkOwner);
|
|
}
|
|
|
|
return hres;
|
|
}
|
|
|
|
|
|
/*----------------------------------------------------------
|
|
Purpose: IShellFolder::EnumObjects method
|
|
|
|
*/
|
|
STDMETHODIMP CAugmentedISF::EnumObjects(HWND hwndOwner, DWORD grfFlags, LPENUMIDLIST * ppenumIDList)
|
|
{
|
|
HRESULT hres = E_FAIL;
|
|
|
|
if (_hdpa)
|
|
{
|
|
*ppenumIDList = new CAugISFEnum();
|
|
|
|
if (*ppenumIDList)
|
|
{
|
|
hres = ((CAugISFEnum *)(*ppenumIDList))->Init(_hdpa, grfFlags);
|
|
|
|
if (FAILED(hres))
|
|
{
|
|
delete *ppenumIDList;
|
|
*ppenumIDList = NULL;
|
|
}
|
|
}
|
|
else
|
|
hres = E_OUTOFMEMORY;
|
|
}
|
|
return hres;
|
|
}
|
|
|
|
|
|
/*----------------------------------------------------------
|
|
Purpose: IShellFolder::BindToObject method
|
|
|
|
*/
|
|
STDMETHODIMP CAugmentedISF::BindToObject(LPCITEMIDLIST pidl, LPBC pbcReserved,
|
|
REFIID riid, LPVOID * ppvOut)
|
|
{
|
|
HRESULT hres = E_FAIL;
|
|
|
|
ASSERT(IS_VALID_PIDL(pidl));
|
|
ASSERT(IS_VALID_WRITE_PTR(ppvOut, LPVOID));
|
|
|
|
*ppvOut = NULL;
|
|
|
|
UINT id = IDWrap_GetID(pidl);
|
|
IShellFolder * psf = _GetObjectPSF(id);
|
|
|
|
if (psf)
|
|
{
|
|
LPITEMIDLIST pidlReal = GetNativePidl(pidl, id);
|
|
|
|
if (pidlReal)
|
|
{
|
|
hres = psf->BindToObject(pidlReal, pbcReserved, riid, ppvOut);
|
|
ILFree(pidlReal);
|
|
}
|
|
else
|
|
hres = E_OUTOFMEMORY;
|
|
|
|
psf->Release();
|
|
}
|
|
|
|
return hres;
|
|
}
|
|
|
|
|
|
/*----------------------------------------------------------
|
|
Purpose: IShellFolder::BindToStorage method
|
|
|
|
*/
|
|
STDMETHODIMP CAugmentedISF::BindToStorage(LPCITEMIDLIST pidl, LPBC pbcReserved,
|
|
REFIID riid, LPVOID * ppvObj)
|
|
{
|
|
TraceMsg(TF_WARNING, "Called unimplemented CAugmentedISF::BindToStorage");
|
|
return E_NOTIMPL;
|
|
}
|
|
|
|
|
|
/*----------------------------------------------------------
|
|
Purpose: IShellFolder::CompareIDs method
|
|
|
|
*/
|
|
STDMETHODIMP CAugmentedISF::CompareIDs(LPARAM lParam, LPCITEMIDLIST pidl1, LPCITEMIDLIST pidl2)
|
|
{
|
|
HRESULT hres = 0;
|
|
int nID1 = IDWrap_GetID(pidl1);
|
|
int nID2 = IDWrap_GetID(pidl2);
|
|
|
|
if (nID1 == nID2)
|
|
{
|
|
IShellFolder * psf = _GetObjectPSF(nID1);
|
|
if (psf)
|
|
{
|
|
LPITEMIDLIST pidlReal1 = GetNativePidl(pidl1, nID1);
|
|
|
|
if (pidlReal1)
|
|
{
|
|
LPITEMIDLIST pidlReal2 = GetNativePidl(pidl2, nID2);
|
|
if (pidlReal2)
|
|
{
|
|
hres = psf->CompareIDs(lParam, pidlReal1, pidlReal2);
|
|
ILFree(pidlReal2);
|
|
}
|
|
ILFree(pidlReal1);
|
|
}
|
|
psf->Release();
|
|
}
|
|
}
|
|
else
|
|
{
|
|
//In this situation, we want to see if one of these items wants to be sorted
|
|
// below the other.
|
|
CISFElem * pel1 = (CISFElem *)DPA_GetPtr(_hdpa, nID1);
|
|
CISFElem * pel2 = (CISFElem *)DPA_GetPtr(_hdpa, nID2);
|
|
DWORD dwel1 = 0;
|
|
DWORD dwel2 = 0;
|
|
|
|
if (pel1)
|
|
dwel1 = pel1->GetFlags();
|
|
|
|
if (pel2)
|
|
dwel2 = pel2->GetFlags();
|
|
|
|
// if both want their items sorted below the other, punt and do neither.
|
|
if ((dwel1 & ASFF_SORTDOWN) ^ (dwel2 & ASFF_SORTDOWN))
|
|
hres = ResultFromShort((dwel1 & ASFF_SORTDOWN)? 1 : -1);
|
|
else
|
|
hres = (nID1 - nID2);
|
|
}
|
|
|
|
return hres;
|
|
}
|
|
|
|
|
|
/*----------------------------------------------------------
|
|
Purpose: IShellFolder::CreateViewObject method
|
|
|
|
*/
|
|
STDMETHODIMP CAugmentedISF::CreateViewObject (HWND hwndOwner, REFIID riid, LPVOID * ppvOut)
|
|
{
|
|
HRESULT hres = E_FAIL;
|
|
|
|
if (_hdpa)
|
|
{
|
|
CVODATA cvodata;
|
|
|
|
cvodata.hres = E_FAIL;
|
|
cvodata.hwnd = hwndOwner;
|
|
cvodata.piid = &riid;
|
|
cvodata.ppvObj = ppvOut;
|
|
|
|
// Whoever responds first wins
|
|
DPA_EnumCallback(_hdpa, CISFElem_CreateViewObjectCB, (void *)&cvodata);
|
|
|
|
hres = cvodata.hres;
|
|
}
|
|
|
|
return hres;
|
|
}
|
|
|
|
|
|
/*----------------------------------------------------------
|
|
Purpose: IShellFolder::GetAttributesOf method
|
|
|
|
*/
|
|
STDMETHODIMP CAugmentedISF::GetAttributesOf(UINT cidl, LPCITEMIDLIST * apidl,
|
|
ULONG * pfInOut)
|
|
{
|
|
HRESULT hres = E_FAIL;
|
|
|
|
ASSERT(IS_VALID_READ_PTR(apidl, LPCITEMIDLIST));
|
|
ASSERT(IS_VALID_WRITE_PTR(pfInOut, ULONG));
|
|
|
|
ULONG fInOut = *pfInOut;
|
|
*pfInOut &= 0;
|
|
|
|
// We only handle one pidl
|
|
if (1 == cidl && apidl)
|
|
{
|
|
UINT id = IDWrap_GetID(*apidl);
|
|
IShellFolder * psf = _GetObjectPSF(id);
|
|
|
|
if (psf)
|
|
{
|
|
LPITEMIDLIST pidlReal = GetNativePidl(*apidl, id);
|
|
|
|
if (pidlReal)
|
|
{
|
|
hres = psf->GetAttributesOf(1, (LPCITEMIDLIST *)&pidlReal, &fInOut);
|
|
*pfInOut = fInOut;
|
|
ILFree(pidlReal);
|
|
}
|
|
else
|
|
hres = E_OUTOFMEMORY;
|
|
|
|
psf->Release();
|
|
}
|
|
}
|
|
|
|
return hres;
|
|
}
|
|
|
|
|
|
/*----------------------------------------------------------
|
|
Purpose: IShellFolder::GetUIObjectOf method
|
|
|
|
*/
|
|
STDMETHODIMP CAugmentedISF::GetUIObjectOf(HWND hwndOwner, UINT cidl, LPCITEMIDLIST * apidl,
|
|
REFIID riid, UINT * prgfInOut, LPVOID * ppvOut)
|
|
{
|
|
HRESULT hres = E_FAIL;
|
|
|
|
ASSERT(IS_VALID_READ_PTR(apidl, LPCITEMIDLIST));
|
|
|
|
*ppvOut = NULL;
|
|
|
|
// We only handle one pidl
|
|
if (1 == cidl && apidl)
|
|
{
|
|
UINT id = IDWrap_GetID(*apidl);
|
|
IShellFolder * psf = _GetObjectPSF(id);
|
|
|
|
if (psf)
|
|
{
|
|
LPITEMIDLIST pidlReal = GetNativePidl(*apidl, id);
|
|
|
|
if (pidlReal)
|
|
{
|
|
hres = psf->GetUIObjectOf(hwndOwner, 1, (LPCITEMIDLIST *)&pidlReal, riid, prgfInOut, ppvOut);
|
|
ILFree(pidlReal);
|
|
}
|
|
else
|
|
hres = E_OUTOFMEMORY;
|
|
|
|
psf->Release();
|
|
}
|
|
}
|
|
|
|
return hres;
|
|
}
|
|
|
|
|
|
/*----------------------------------------------------------
|
|
Purpose: IShellFolder::GetDisplayNameOf method
|
|
|
|
*/
|
|
STDMETHODIMP CAugmentedISF::GetDisplayNameOf(LPCITEMIDLIST pidl, DWORD uFlags,
|
|
LPSTRRET pstrret)
|
|
{
|
|
HRESULT hres = E_FAIL;
|
|
|
|
ASSERT(NULL == pidl || IS_VALID_PIDL(pidl));
|
|
ASSERT(IS_VALID_WRITE_PTR(pstrret, STRRET));
|
|
|
|
if (pidl)
|
|
{
|
|
UINT id = IDWrap_GetID(pidl);
|
|
IShellFolder * psf = _GetObjectPSF(id);
|
|
|
|
if (psf)
|
|
{
|
|
LPITEMIDLIST pidlReal = GetNativePidl(pidl, id);
|
|
|
|
if (pidlReal)
|
|
{
|
|
hres = psf->GetDisplayNameOf(pidlReal, uFlags, pstrret);
|
|
ILFree(pidlReal);
|
|
}
|
|
else
|
|
hres = E_OUTOFMEMORY;
|
|
|
|
psf->Release();
|
|
}
|
|
else
|
|
hres = E_FAIL;
|
|
}
|
|
|
|
return hres;
|
|
}
|
|
|
|
|
|
/*----------------------------------------------------------
|
|
Purpose: IShellFolder::SetNameOf method
|
|
|
|
*/
|
|
STDMETHODIMP CAugmentedISF::SetNameOf(HWND hwndOwner, LPCITEMIDLIST pidl,
|
|
LPCOLESTR lpszName, DWORD uFlags,
|
|
LPITEMIDLIST * ppidlOut)
|
|
{
|
|
HRESULT hres = E_FAIL;
|
|
|
|
ASSERT(NULL == pidl || IS_VALID_PIDL(pidl));
|
|
if (pidl)
|
|
{
|
|
UINT id = IDWrap_GetID(pidl);
|
|
IShellFolder * psf = _GetObjectPSF(id);
|
|
|
|
if (psf)
|
|
{
|
|
LPITEMIDLIST pidlReal = GetNativePidl(pidl, id);
|
|
|
|
if (pidlReal)
|
|
{
|
|
LPITEMIDLIST pidlOut = NULL;
|
|
hres = psf->SetNameOf(hwndOwner, pidlReal,
|
|
lpszName, uFlags,
|
|
&pidlOut);
|
|
|
|
// Do they want a pidl back?
|
|
if (SUCCEEDED(hres) && ppidlOut)
|
|
{
|
|
*ppidlOut = AugISF_WrapPidl( pidlOut, id );
|
|
|
|
if (!*ppidlOut)
|
|
hres = E_OUTOFMEMORY;
|
|
}
|
|
|
|
ILFree(pidlOut);
|
|
ILFree(pidlReal);
|
|
}
|
|
else
|
|
hres = E_OUTOFMEMORY;
|
|
|
|
psf->Release();
|
|
}
|
|
else
|
|
hres = E_FAIL;
|
|
}
|
|
|
|
return hres;
|
|
}
|
|
|
|
|
|
/*----------------------------------------------------------
|
|
Purpose: IShellFolder::ParseDisplayName method
|
|
|
|
*/
|
|
STDMETHODIMP CAugmentedISF::ParseDisplayName(HWND hwndOwner,
|
|
LPBC pbcReserved, LPOLESTR lpszDisplayName,
|
|
ULONG * pchEaten, LPITEMIDLIST * ppidl, ULONG *pdwAttributes)
|
|
{
|
|
TraceMsg(TF_WARNING, "Called unimplemented CAugmentedISF::ParseDisplayNameOf");
|
|
return E_NOTIMPL;
|
|
}
|
|
|
|
|
|
/*----------------------------------------------------------
|
|
Purpose: IAugmentedShellFolder::AddNameSpace
|
|
|
|
*/
|
|
STDMETHODIMP CAugmentedISF::AddNameSpace(const GUID * pguid,
|
|
IShellFolder * psf, LPCITEMIDLIST pidl, DWORD dwFlags)
|
|
{
|
|
HRESULT hres = E_INVALIDARG;
|
|
|
|
ASSERT(IS_VALID_CODE_PTR(psf, IShellFolder));
|
|
ASSERT(NULL == pguid || IS_VALID_READ_PTR(pguid, GUID));
|
|
ASSERT(NULL == pidl || IS_VALID_PIDL(pidl));
|
|
|
|
if (NULL == _hdpa)
|
|
{
|
|
_hdpa = DPA_Create(4);
|
|
}
|
|
|
|
if (psf && _hdpa)
|
|
{
|
|
hres = S_OK; // Assume success
|
|
|
|
CISFElem * pel = new CISFElem(pguid, psf, dwFlags);
|
|
if (pel)
|
|
{
|
|
hres = pel->SetPidl(pidl);
|
|
if (SUCCEEDED(hres))
|
|
{
|
|
if (DPA_ERR == DPA_AppendPtr(_hdpa, pel))
|
|
hres = E_OUTOFMEMORY;
|
|
}
|
|
|
|
if (FAILED(hres))
|
|
delete pel;
|
|
}
|
|
else
|
|
hres = E_OUTOFMEMORY;
|
|
}
|
|
return hres;
|
|
}
|
|
|
|
|
|
/*----------------------------------------------------------
|
|
Purpose: IAugmentedShellFolder::GetNameSpaceID
|
|
|
|
*/
|
|
STDMETHODIMP CAugmentedISF::GetNameSpaceID(LPCITEMIDLIST pidl, GUID * pguidOut)
|
|
{
|
|
HRESULT hres = E_INVALIDARG;
|
|
|
|
ASSERT(IS_VALID_PIDL(pidl));
|
|
ASSERT(IS_VALID_WRITE_PTR(pguidOut, GUID));
|
|
|
|
if (pidl && pguidOut)
|
|
{
|
|
UINT id = IDWrap_GetID(pidl);
|
|
|
|
hres = E_FAIL;
|
|
|
|
if (_hdpa)
|
|
{
|
|
CISFElem * pel = (CISFElem *)DPA_GetPtr(_hdpa, id);
|
|
if (pel)
|
|
{
|
|
pel->GetNameSpaceID(pguidOut);
|
|
hres = S_OK;
|
|
}
|
|
}
|
|
}
|
|
|
|
return hres;
|
|
}
|
|
|
|
|
|
/*----------------------------------------------------------
|
|
Purpose: IAugmentedShellFolder::QueryNameSpace
|
|
|
|
*/
|
|
STDMETHODIMP CAugmentedISF::QueryNameSpace(DWORD dwID, GUID * pguidOut,
|
|
IShellFolder ** ppsf)
|
|
{
|
|
HRESULT hres = E_FAIL;
|
|
|
|
ASSERT(NULL == pguidOut || IS_VALID_WRITE_PTR(pguidOut, GUID));
|
|
ASSERT(NULL == ppsf || IS_VALID_WRITE_PTR(ppsf, IShellFolder));
|
|
|
|
if (_hdpa)
|
|
{
|
|
CISFElem * pel = (CISFElem *)DPA_GetPtr(_hdpa, dwID);
|
|
if (pel)
|
|
{
|
|
if (ppsf)
|
|
{
|
|
IShellFolder * psf = pel->GetPSF();
|
|
psf->AddRef();
|
|
*ppsf = psf;
|
|
}
|
|
|
|
if (pguidOut)
|
|
pel->GetNameSpaceID(pguidOut);
|
|
|
|
hres = S_OK;
|
|
}
|
|
}
|
|
|
|
return hres;
|
|
}
|
|
|
|
|
|
/*----------------------------------------------------------
|
|
Purpose: IAugmentedShellFolder::EnumNameSpace
|
|
|
|
*/
|
|
STDMETHODIMP CAugmentedISF::EnumNameSpace(DWORD uNameSpace, DWORD * pdwID)
|
|
{
|
|
HRESULT hres = E_FAIL;
|
|
|
|
if (_hdpa)
|
|
{
|
|
DWORD celem = DPA_GetPtrCount(_hdpa);
|
|
|
|
if (-1 == uNameSpace)
|
|
hres = celem;
|
|
else
|
|
{
|
|
if (uNameSpace >= celem)
|
|
hres = E_FAIL;
|
|
else
|
|
{
|
|
// For now, simply use the index given
|
|
*pdwID = uNameSpace;
|
|
hres = S_OK;
|
|
}
|
|
}
|
|
}
|
|
|
|
return hres;
|
|
}
|
|
|
|
|
|
|
|
/*----------------------------------------------------------
|
|
Purpose: ITranslateShellChangeNotify::TranslateIDs
|
|
*/
|
|
STDMETHODIMP CAugmentedISF::TranslateIDs(LONG *plEvent,
|
|
LPCITEMIDLIST pidl1, LPCITEMIDLIST pidl2,
|
|
LPITEMIDLIST * ppidlOut1, LPITEMIDLIST * ppidlOut2,
|
|
LONG *plEvent2, LPITEMIDLIST *ppidlOut1Event2,
|
|
LPITEMIDLIST *ppidlOut2Event2)
|
|
{
|
|
HRESULT hres = S_OK;
|
|
|
|
*plEvent2 = (LONG)-1;
|
|
|
|
*ppidlOut1Event2 = NULL;
|
|
*ppidlOut2Event2 = NULL;
|
|
|
|
|
|
*ppidlOut1 = (LPITEMIDLIST)pidl1;
|
|
*ppidlOut2 = (LPITEMIDLIST)pidl2;
|
|
|
|
if (_hdpa)
|
|
{
|
|
int cElem = DPA_GetPtrCount(_hdpa);
|
|
int i;
|
|
|
|
// Go thru all the namespaces and find which one should
|
|
// translate this notification
|
|
for (i = 0; i < cElem; i++)
|
|
{
|
|
CISFElem * pel = (CISFElem *)DPA_FastGetPtr(_hdpa, i);
|
|
if (pel)
|
|
{
|
|
LPCITEMIDLIST pidlNS = pel->GetPidl();
|
|
|
|
if (pidlNS)
|
|
{
|
|
if (pidl1)
|
|
{
|
|
*ppidlOut1 = TranslatePidl(pidlNS, pidl1, i);
|
|
if (NULL == *ppidlOut1)
|
|
hres = E_OUTOFMEMORY;
|
|
}
|
|
|
|
if (SUCCEEDED(hres) && pidl2)
|
|
{
|
|
*ppidlOut2 = TranslatePidl(pidlNS, pidl2, i);
|
|
if (NULL == *ppidlOut2)
|
|
hres = E_OUTOFMEMORY;
|
|
}
|
|
|
|
if (FAILED(hres))
|
|
{
|
|
if (*ppidlOut1 != pidl1)
|
|
Pidl_Set(ppidlOut1, NULL);
|
|
|
|
if (*ppidlOut2 != pidl2)
|
|
Pidl_Set(ppidlOut2, NULL);
|
|
break;
|
|
}
|
|
else
|
|
{
|
|
if (*ppidlOut1 != pidl1 || *ppidlOut2 != pidl2)
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
return hres;
|
|
}
|
|
|
|
|
|
/*----------------------------------------------------------
|
|
Purpose: ITranslateShellChangeNotify::IsChildID
|
|
*/
|
|
STDMETHODIMP CAugmentedISF::IsChildID(LPCITEMIDLIST pidlKid, BOOL fImmediate)
|
|
{
|
|
HRESULT hres = S_FALSE;
|
|
//At this point we should have a translated pidl
|
|
if (pidlKid)
|
|
{
|
|
// Weirdness: If fImmediate is TRUE, then this is a Wrapped pidl. If it's
|
|
// false, then it's not, and we need to check to see if it's a Real FS Child.
|
|
if (fImmediate)
|
|
{
|
|
LPCITEMIDLIST pidlRelKid = ILFindLastID(pidlKid);
|
|
if (pidlRelKid)
|
|
{
|
|
int nID = IDWrap_GetID(pidlRelKid);
|
|
CISFElem * pel = (CISFElem *)DPA_GetPtr(_hdpa, nID);
|
|
if (pel && pel->GetPidl())
|
|
{
|
|
|
|
if (ILIsParent(pel->GetPidl(), pidlKid, TRUE))
|
|
hres = S_OK;
|
|
}
|
|
}
|
|
}
|
|
else
|
|
{
|
|
int cElem = DPA_GetPtrCount(_hdpa);
|
|
int i;
|
|
|
|
for (i = 0; i < cElem; i++)
|
|
{
|
|
CISFElem * pel = (CISFElem *)DPA_GetPtr(_hdpa, i);
|
|
if (pel && pel->GetPidl())
|
|
{
|
|
if (ILIsParent(pel->GetPidl(), pidlKid, FALSE))
|
|
{
|
|
hres = S_OK;
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
return hres;
|
|
}
|
|
|
|
|
|
/*----------------------------------------------------------
|
|
Purpose: ITranslateShellChangeNotify::IsEqualID
|
|
|
|
*/
|
|
STDMETHODIMP CAugmentedISF::IsEqualID(LPCITEMIDLIST pidl1, LPCITEMIDLIST pidl2)
|
|
{
|
|
int cElem = DPA_GetPtrCount(_hdpa);
|
|
int i;
|
|
|
|
for (i = 0; i < cElem; i++)
|
|
{
|
|
CISFElem * pel = (CISFElem *)DPA_FastGetPtr(_hdpa, i);
|
|
|
|
if (pel)
|
|
{
|
|
if (pidl1)
|
|
{
|
|
if (ILIsEqual(pel->GetPidl(),pidl1))
|
|
return S_OK;
|
|
}
|
|
else if (pidl2)
|
|
{
|
|
if (ILIsParent(pidl2, pel->GetPidl(), FALSE))
|
|
return S_OK;
|
|
}
|
|
}
|
|
}
|
|
|
|
return S_FALSE;
|
|
}
|
|
|
|
/*----------------------------------------------------------
|
|
Purpose: ITranslateShellChangeNotify::Register
|
|
Registers all pidls contained to the passed in window
|
|
|
|
*/
|
|
STDMETHODIMP CAugmentedISF::Register(HWND hwnd, UINT uMsg, long lEvents)
|
|
{
|
|
HRESULT hres = NOERROR;
|
|
if (_hdpa)
|
|
{
|
|
int cElem = DPA_GetPtrCount(_hdpa);
|
|
int i;
|
|
|
|
for (i = 0; i < cElem; i++)
|
|
{
|
|
CISFElem * pel = (CISFElem *)DPA_FastGetPtr(_hdpa, i);
|
|
|
|
// Has this namespace been registered yet?
|
|
if (pel && 0 == pel->GetRegister())
|
|
{
|
|
// No; register it
|
|
LPCITEMIDLIST pidlNS = pel->GetPidl();
|
|
|
|
if (pidlNS)
|
|
{
|
|
pel->SetRegister(RegisterNotify(hwnd, uMsg, pidlNS, lEvents,
|
|
SHCNRF_ShellLevel | SHCNRF_InterruptLevel, TRUE));
|
|
}
|
|
}
|
|
}
|
|
}
|
|
else
|
|
hres = E_FAIL;
|
|
|
|
return hres;
|
|
|
|
}
|
|
|
|
/*----------------------------------------------------------
|
|
Purpose: ITranslateShellChangeNotify::Unregister
|
|
|
|
*/
|
|
STDMETHODIMP CAugmentedISF::Unregister()
|
|
{
|
|
HRESULT hres = NOERROR;
|
|
if (_hdpa)
|
|
{
|
|
int cElem = DPA_GetPtrCount(_hdpa);
|
|
int i;
|
|
|
|
for (i = 0; i < cElem; i++)
|
|
{
|
|
CISFElem * pel = (CISFElem *)DPA_FastGetPtr(_hdpa, i);
|
|
UINT uReg;
|
|
if (pel && (uReg = pel->GetRegister()) != 0)
|
|
{
|
|
// SHChangeNotifyDeregister will flush messages
|
|
// which will send a notify which will come back here...
|
|
pel->SetRegister(0);
|
|
SHChangeNotifyDeregister(uReg);
|
|
}
|
|
}
|
|
}
|
|
else
|
|
hres = E_FAIL;
|
|
|
|
return hres;
|
|
|
|
}
|
|
|
|
/*----------------------------------------------------------
|
|
Purpose: Returns the psf associated with the ID.
|
|
|
|
*/
|
|
IShellFolder * CAugmentedISF::_GetObjectPSF(int nID)
|
|
{
|
|
IShellFolder * psf = NULL;
|
|
|
|
if (_hdpa)
|
|
{
|
|
CISFElem * pel = (CISFElem *)DPA_GetPtr(_hdpa, nID);
|
|
if (pel)
|
|
{
|
|
psf = pel->GetPSF();
|
|
ASSERT(IS_VALID_CODE_PTR(psf, IShellFolder));
|
|
|
|
psf->AddRef();
|
|
}
|
|
}
|
|
return psf;
|
|
}
|
|
|
|
|
|
|
|
//
|
|
// CAugISF Enumerator object
|
|
//
|
|
|
|
#undef SUPERCLASS
|
|
|
|
|
|
// Constructor
|
|
CAugISFEnum::CAugISFEnum() :
|
|
_cRef(1)
|
|
{
|
|
}
|
|
|
|
|
|
// Destructor
|
|
CAugISFEnum::~CAugISFEnum()
|
|
{
|
|
if (_hdpaISF)
|
|
{
|
|
DPA_DestroyCallback(_hdpaISF, CISFElem_DestroyCB, NULL);
|
|
_hdpaISF = NULL;
|
|
}
|
|
}
|
|
|
|
|
|
HRESULT CAugISFEnum::Init(HDPA hdpaISF, DWORD dwEnumFlags)
|
|
{
|
|
HRESULT hres = S_OK;
|
|
|
|
ASSERT(IS_VALID_HANDLE(hdpaISF, DPA));
|
|
|
|
// Clone the DPA
|
|
_hdpaISF = DPA_Clone(hdpaISF, NULL);
|
|
if (_hdpaISF)
|
|
{
|
|
// Clone the elements too
|
|
int cElem = DPA_GetPtrCount(_hdpaISF);
|
|
int i;
|
|
|
|
// If something fails in the loop, at least try to enumerate
|
|
// other namespaces.
|
|
for (i = 0; i < cElem; i++)
|
|
{
|
|
CISFElem * pel = (CISFElem *)DPA_FastGetPtr(_hdpaISF, i);
|
|
if (pel)
|
|
{
|
|
CISFElem * pelNew = pel->Clone();
|
|
if (pelNew)
|
|
{
|
|
// Get the enumerator
|
|
if (SUCCEEDED(pelNew->AcquireEnumerator(dwEnumFlags)))
|
|
DPA_SetPtr(_hdpaISF, i, pelNew);
|
|
else
|
|
{
|
|
TraceMsg(TF_WARNING, "CAugISFEnum::Init. Namespace %d has no enumerator.", i);
|
|
|
|
// Remove it from the list to enumerate, and continue
|
|
DPA_DeletePtr(_hdpaISF, i);
|
|
cElem--;
|
|
i--;
|
|
delete pelNew;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
else
|
|
hres = E_OUTOFMEMORY;
|
|
|
|
return hres;
|
|
}
|
|
|
|
|
|
STDMETHODIMP CAugISFEnum::QueryInterface(REFIID riid, LPVOID * ppvObj)
|
|
{
|
|
static const QITAB qit[] = {
|
|
QITABENT(CAugISFEnum, IEnumIDList),
|
|
{ 0 },
|
|
};
|
|
return QISearch(this, qit, riid, ppvObj);
|
|
}
|
|
|
|
|
|
STDMETHODIMP_(ULONG) CAugISFEnum::AddRef()
|
|
{
|
|
return ++_cRef;
|
|
}
|
|
|
|
|
|
STDMETHODIMP_(ULONG) CAugISFEnum::Release()
|
|
{
|
|
if (--_cRef > 0) {
|
|
return _cRef;
|
|
}
|
|
|
|
delete this;
|
|
return 0;
|
|
}
|
|
|
|
|
|
/*----------------------------------------------------------
|
|
Purpose: IEnumIDList::Next method
|
|
|
|
This will call the current enumerator for the next
|
|
object. The object's pidl is wrapped in an IDWRAP
|
|
(which is stamped with the identifier of the specific
|
|
IShellFolder the object belongs to) and handed back.
|
|
|
|
If the current enumerator has no more items to return,
|
|
this function will call the next enumerator for its
|
|
first item, and returns that. The subsequent call
|
|
will pick up from there.
|
|
|
|
*/
|
|
STDMETHODIMP CAugISFEnum::Next(ULONG celt, LPITEMIDLIST *rgelt, ULONG *pceltFetched)
|
|
{
|
|
ULONG celtFetched = 0;
|
|
HRESULT hres = S_FALSE;
|
|
|
|
if (celt > 0)
|
|
{
|
|
IEnumIDList * pei = _GetObjectEnumerator(_iCurISF);
|
|
if (pei)
|
|
{
|
|
LPITEMIDLIST pidl;
|
|
|
|
hres = pei->Next(1, &pidl, &celtFetched);
|
|
|
|
if (SUCCEEDED(hres))
|
|
{
|
|
// End of enumeration for this object?
|
|
if (S_FALSE == hres)
|
|
{
|
|
// Yes; go to next ISF object
|
|
_iCurISF++;
|
|
hres = Next(celt, rgelt, &celtFetched);
|
|
}
|
|
else
|
|
{
|
|
// No; now wrap the pidl.
|
|
rgelt[0] = AugISF_WrapPidl( pidl, _iCurISF );
|
|
if (rgelt[0])
|
|
{
|
|
celtFetched = 1;
|
|
hres = S_OK;
|
|
}
|
|
else
|
|
hres = E_OUTOFMEMORY;
|
|
|
|
ILFree(pidl);
|
|
}
|
|
}
|
|
|
|
pei->Release();
|
|
}
|
|
}
|
|
|
|
if (pceltFetched)
|
|
*pceltFetched = celtFetched;
|
|
|
|
return hres;
|
|
}
|
|
|
|
|
|
STDMETHODIMP CAugISFEnum::Skip(ULONG celt)
|
|
{
|
|
return E_NOTIMPL;
|
|
}
|
|
|
|
|
|
STDMETHODIMP CAugISFEnum::Reset()
|
|
{
|
|
if (_hdpaISF)
|
|
{
|
|
// Reset all the enumerators
|
|
int cel = DPA_GetPtrCount(_hdpaISF);
|
|
int i;
|
|
|
|
for (i = 0; i < cel; i++)
|
|
{
|
|
CISFElem * pel = (CISFElem *)DPA_FastGetPtr(_hdpaISF, i);
|
|
if (pel)
|
|
{
|
|
IEnumIDList * pei = pel->GetEnumerator();
|
|
if (pei)
|
|
{
|
|
pei->Reset();
|
|
// Don't Release b/c GetEnumerator doesn't AddRef
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
_iCurISF = 0;
|
|
|
|
return S_OK;
|
|
}
|
|
|
|
|
|
STDMETHODIMP CAugISFEnum::Clone(IEnumIDList **ppenum)
|
|
{
|
|
*ppenum = NULL;
|
|
return E_NOTIMPL;
|
|
}
|
|
|
|
|
|
/*----------------------------------------------------------
|
|
Purpose: Returns the enumerator associated with the ID.
|
|
|
|
*/
|
|
IEnumIDList * CAugISFEnum::_GetObjectEnumerator(int nID)
|
|
{
|
|
IEnumIDList * pei = NULL;
|
|
|
|
if (_hdpaISF)
|
|
{
|
|
CISFElem * pel = (CISFElem *)DPA_GetPtr(_hdpaISF, nID);
|
|
if (pel)
|
|
{
|
|
pei = pel->GetEnumerator();
|
|
ASSERT(IS_VALID_CODE_PTR(pei, IEnumIDList));
|
|
|
|
pei->AddRef();
|
|
}
|
|
}
|
|
return pei;
|
|
}
|
|
|
|
|
|
/*----------------------------------------------------------
|
|
Purpose: Create-instance function for class factory
|
|
|
|
*/
|
|
STDAPI CAugmentedISF_CreateInstance(IUnknown* pUnkOuter, IUnknown** ppunk, LPCOBJECTINFO poi)
|
|
{
|
|
// aggregation checking is handled in class factory
|
|
|
|
HRESULT hres;
|
|
CAugmentedISF* pObj;
|
|
|
|
hres = E_OUTOFMEMORY;
|
|
|
|
pObj = new CAugmentedISF();
|
|
if (pObj)
|
|
{
|
|
*ppunk = SAFECAST(pObj, IShellFolder *);
|
|
hres = S_OK;
|
|
}
|
|
|
|
return hres;
|
|
}
|