enumidl.cpp

Drive.dll is a dll that creates a drive to system directoryor drive similar to existing drives such

//
// EnumIDL.cpp
//

#include <Windows.h>
#include <WinINet.h>

#include "EnumIDL.h"
#include "ShellFolder.h"

extern HINSTANCE	g_hInstance;
extern UINT			g_uiRefThisDll;

CEnumIDList::CEnumIDList(CShellFolder *pSF, 
	LPCITEMIDLIST pidl, DWORD dwFlags)
{
	m_pPidlMgr		= new CPidlMgr();
	m_pSF			= pSF;
	m_dwFlags		= dwFlags;
	m_pCurrentList	= NULL;
	m_pFirstList	= NULL;
	m_pLastList		= NULL;

	if(FAILED(SHGetMalloc(&m_pMalloc)))
	{
		// raise an exception
		delete this;
		return;
	}
	m_pMalloc->AddRef();

	m_dwRefCount = 1;

	g_uiRefThisDll++;
	
	// TODO : Create the ID List
	createIDList(pidl);
}

CEnumIDList::~CEnumIDList()
{
	if (m_pMalloc)
	{
		m_pMalloc->Release();
	}
	if (m_pPidlMgr)
	{
		delete m_pPidlMgr;
	}
	g_uiRefThisDll--;
}

///////////////////////////////////////////////////////////
// IUnknown implementation
//
STDMETHODIMP CEnumIDList::QueryInterface(REFIID riid, LPVOID *ppReturn)
{
	*ppReturn = NULL;

	//IUnknown
	if(IsEqualIID(riid, IID_IUnknown))
	{
		*ppReturn = this;
	}
	//IEnumIDList
	else if(IsEqualIID(riid, IID_IEnumIDList))
	{
		*ppReturn = (IEnumIDList*)this;
	}   
	if(*ppReturn)
	{
		(*(LPUNKNOWN*)ppReturn)->AddRef();
		return S_OK;
	}
	return E_NOINTERFACE;
}                                             

STDMETHODIMP_(DWORD) CEnumIDList::AddRef()
{
	return ++m_dwRefCount;
}

STDMETHODIMP_(DWORD) CEnumIDList::Release()
{
	if(--m_dwRefCount == 0)
	{
		delete this;
		return 0;
	}
	return m_dwRefCount;
}

///////////////////////////////////////////////////////////
// IEnumIDList implemenation
//
STDMETHODIMP CEnumIDList::Next(DWORD dwElements, 
	LPITEMIDLIST apidl[], LPDWORD pdwFetched)
{
	DWORD    dwIndex;
	HRESULT  hr = S_OK;

	if(dwElements > 1 && !pdwFetched)
	{
		return E_INVALIDARG;
	}

	for(dwIndex = 0; dwIndex < dwElements; dwIndex++)
	{
		if(!m_pCurrentList)
		{
			hr =  S_FALSE;
			break;
		}
		apidl[dwIndex] = m_pPidlMgr->Copy(m_pCurrentList->pidl);
		m_pCurrentList = m_pCurrentList->pNext;
	}
	if (pdwFetched)
	{
		*pdwFetched = dwIndex;
	}
	return hr;
}

STDMETHODIMP CEnumIDList::Skip(DWORD dwSkip)
{
	DWORD    dwIndex;
	HRESULT  hr = S_OK;

	for(dwIndex = 0; dwIndex < dwSkip; dwIndex++)
	{
		if(!m_pCurrentList)
		{
			hr = S_FALSE;
			break;
		}
		m_pCurrentList = m_pCurrentList->pNext;
	}
	return hr;
}

STDMETHODIMP CEnumIDList::Reset(void)
{
	m_pCurrentList = m_pFirstList;
	return S_OK;
}

STDMETHODIMP CEnumIDList::Clone(LPENUMIDLIST *ppEnum)
{
	return E_NOTIMPL;
}

////////////////////////////////////////////////////////////////////
// Private methods for enumerating...
// TODO : Modify the code to suit your needs
//
void CEnumIDList::createIDList(LPCITEMIDLIST pidl)
{
	// TODO : Add code to create the IDList
}


BOOL CEnumIDList::addToEnumList(LPITEMIDLIST pidl)
{
	LPMYENUMLIST  pNew;

	pNew = (LPMYENUMLIST) m_pMalloc->Alloc(sizeof(MYENUMLIST));

	if(pNew)
	{
		pNew->pNext = NULL;
		pNew->pidl = pidl;

		if(!m_pFirstList)
		{
			m_pFirstList	= pNew;
			m_pCurrentList	= m_pFirstList;
		}

		if (m_pLastList)
		{
			m_pLastList->pNext = pNew;
		}

		m_pLastList = pNew;

		return TRUE;
	}
	return FALSE;
}

////////////////////////////////////////////////////////////////
// CPidlMgr : Class to manage pidls
CPidlMgr::CPidlMgr()
{
	SHGetMalloc(&m_pMalloc);
	m_pMalloc->AddRef();
}

CPidlMgr::~CPidlMgr()
{
	if (m_pMalloc)
	{
		m_pMalloc->Release();
	}
}

void CPidlMgr::Delete(LPITEMIDLIST pidl)
{
	m_pMalloc->Free(pidl);
}

LPITEMIDLIST CPidlMgr::GetNextItem(LPCITEMIDLIST pidl)
{
	if (pidl)
	{
		return (LPITEMIDLIST)(LPBYTE) ( ((LPBYTE)pidl) + pidl->mkid.cb);
	}
	return (NULL);
}

LPITEMIDLIST CPidlMgr::Copy(LPCITEMIDLIST pidlSrc)
{
	LPITEMIDLIST pidlTarget = NULL;
	UINT cbSrc = 0;

	if (NULL == pidlSrc)
	{
		return (NULL);
	}
	cbSrc = GetSize(pidlSrc);
	pidlTarget = (LPITEMIDLIST)m_pMalloc->Alloc(cbSrc);
	if (!pidlTarget)
	{
		return (NULL);
	}
	CopyMemory(pidlTarget, pidlSrc, cbSrc);
	return pidlTarget;
}

UINT CPidlMgr::GetSize(LPCITEMIDLIST pidl)
{
	UINT cbTotal = 0;
	LPITEMIDLIST pidlTemp = (LPITEMIDLIST) pidl;

	if(pidlTemp)
	{
		while(pidlTemp->mkid.cb)
		{
			cbTotal += pidlTemp->mkid.cb;
			pidlTemp = GetNextItem(pidlTemp);
		}  
		cbTotal += sizeof(ITEMIDLIST);
	}
	return (cbTotal);
}

LPMYPIDLDATA CPidlMgr::GetDataPointer(LPCITEMIDLIST pidl)
{
	if (!pidl)
	{
		return NULL;
	}
	return (LPMYPIDLDATA)(pidl->mkid.abID);
}

LPITEMIDLIST CPidlMgr::GetLastItem(LPCITEMIDLIST pidl)
{
	LPITEMIDLIST   pidlLast = NULL;

	if(pidl)
	{
		while(pidl->mkid.cb)
		{
			pidlLast = (LPITEMIDLIST)pidl;
			pidl = GetNextItem(pidl);
		}  
	}
	return pidlLast;
}

LPITEMIDLIST CPidlMgr::Concatenate(LPCITEMIDLIST pidl1, 
	LPCITEMIDLIST pidl2)
{
	LPITEMIDLIST   pidlNew;
	UINT           cb1 = 0, 
	cb2 = 0;

	if(!pidl1 && !pidl2)
	{
		return NULL;
	}

	if(!pidl1)
	{
		pidlNew = Copy(pidl2);
		return pidlNew;
	}

	if(!pidl2)
	{
		pidlNew = Copy(pidl1);
		return pidlNew;
	}

	cb1 = GetSize(pidl1) - sizeof(ITEMIDLIST);

	cb2 = GetSize(pidl2);

	pidlNew = (LPITEMIDLIST)m_pMalloc->Alloc(cb1 + cb2);

	if(pidlNew)
	{
		CopyMemory(pidlNew, pidl1, cb1);
		CopyMemory(((LPBYTE)pidlNew) + cb1, pidl2, cb2);
	}
	return pidlNew;
}


//EOF