列举shell namespace的树控件

逍遥万里 — Tue, 02 Nov 2004 16:47:00 GMT

#if !defined(AFX_EXPLORERTREE_H__F22991C2_DB9C_11D6_B7DB_0080C82BE86B__INCLUDED_)
#define AFX_EXPLORERTREE_H__F22991C2_DB9C_11D6_B7DB_0080C82BE86B__INCLUDED_

#if _MSC_VER > 1000
#pragma once
#endif // _MSC_VER > 1000
// ExplorerTree.h : header file
//

/////////////////////////////////////////////////////////////////////////////
// CExplorerTree window
class CExplorerTree : public CTreeCtrl
{
public:
	HTREEITEM GetItemFromPath(CString&path);
	class FILEITEM{
	public:
		LPITEMIDLIST pidl;
		BOOL bListed;
		FILEITEM(){
			pidl=NULL;
			bListed=FALSE;
		}
	};
	typedef FILEITEM* LPFILEITEM;
	
	CExplorerTree(DWORD flag=SHCONTF_FOLDERS);//SHCONTF_NONFOLDER,SHCONTF_INCLUDEHIDDEN
	virtual ~CExplorerTree();
	void BuildTree();
	void RefreshTree(HTREEITEM item=NULL);
	void DeleteTree(HTREEITEM item=NULL);
	void ListFolder(HTREEITEM item);
	BOOL GetItemPath(HTREEITEM item,CString&path);
	void ExpandTree(HTREEITEM item);
	BOOL GetItemFolder(HTREEITEM&item,LPSHELLFOLDER&lpFolder);
	protected:
	LPMALLOC lpMalloc;
	LPSHELLFOLDER lpDesktop;
	DWORD dwListFlag;
//methods
	static int CALLBACK CompareItem(LPARAM lParam1,LPARAM lParam2,LPARAM lParam);
	LPITEMIDLIST Append(LPCITEMIDLIST pidlBase,LPCITEMIDLIST pidlAdd);
	LPITEMIDLIST MakeCopy(LPCITEMIDLIST pidl);
	UINT GetSize(LPCITEMIDLIST pidl);
	LPITEMIDLIST GetNextItemID(LPCITEMIDLIST pidl);
	int GetIcon(LPITEMIDLIST pidl,UINT flag=SHGFI_OPENICON);
	BOOL GetItemName(LPITEMIDLIST  pidl,CString&name);
	BOOL ItemIsFileSystem(LPITEMIDLIST pidl);
	// Overrides
	// ClassWizard generated virtual function overrides
	//{{AFX_VIRTUAL(CExplorerTree)
	public:
	//}}AFX_VIRTUAL

	// Generated message map functions
protected:
	BOOL EqualPIDL(LPITEMIDLIST&pidl1,LPITEMIDLIST&pidl2);
	HTREEITEM FindPath(HTREEITEM item,LPITEMIDLIST&pidl);
	//{{AFX_MSG(CExplorerTree)
	afx_msg void OnItemExpanded(NMHDR* pNMHDR, LRESULT* pResult);
	afx_msg int OnCreate(LPCREATESTRUCT lpCreateStruct);
	afx_msg void OnDestroy();
	//}}AFX_MSG

	DECLARE_MESSAGE_MAP()
};

/////////////////////////////////////////////////////////////////////////////

//{{AFX_INSERT_LOCATION}}
// Microsoft Visual C++ will insert additional declarations immediately before the previous line.

#endif // !defined(AFX_EXPLORERTREE_H__F22991C2_DB9C_11D6_B7DB_0080C82BE86B__INCLUDED_)

// ExplorerTree.cpp : implementation file
//

#include "stdafx.h"
#include "ExplorerTree.h"
#include <atlconv.h>
#ifdef _DEBUG
#define new DEBUG_NEW
#undef THIS_FILE
static char THIS_FILE[] = __FILE__;
#endif

/////////////////////////////////////////////////////////////////////////////
// CExplorerTree

CExplorerTree::CExplorerTree(DWORD flag)
{
	dwListFlag=flag;
	lpMalloc=NULL;
	lpDesktop=NULL;
}

CExplorerTree::~CExplorerTree()
{
}


BEGIN_MESSAGE_MAP(CExplorerTree, CTreeCtrl)
	//{{AFX_MSG_MAP(CExplorerTree)
	ON_NOTIFY_REFLECT(TVN_ITEMEXPANDED, OnItemExpanded)
	ON_WM_CREATE()
	ON_WM_DESTROY()
	//}}AFX_MSG_MAP
END_MESSAGE_MAP()

/////////////////////////////////////////////////////////////////////////////
// CExplorerTree message handlers
int CExplorerTree::OnCreate(LPCREATESTRUCT lpCreateStruct) 
{
	if (CTreeCtrl::OnCreate(lpCreateStruct) == -1)
		return -1;
	BuildTree();
	return 0;
}

void CExplorerTree::RefreshTree(HTREEITEM item)
{
	if(ItemHasChildren(item)){
		DeleteTree(item);
	}
	ListFolder(item);
}

int CExplorerTree::GetIcon(LPITEMIDLIST pidl, UINT flag)
{
	SHFILEINFO sfi;
	flag|=(SHGFI_SYSICONINDEX|SHGFI_SMALLICON|SHGFI_PIDL);
	SHGetFileInfo((LPCTSTR)pidl,0,&sfi,sizeof(SHFILEINFO),flag);
	return sfi.iIcon;
}

BOOL CExplorerTree::GetItemName(LPITEMIDLIST pidl, CString &name)
{
	SHFILEINFO sfi;
	SHGetFileInfo((LPCTSTR)pidl,0,&sfi,sizeof(SHFILEINFO),SHGFI_DISPLAYNAME|SHGFI_PIDL);
	name=sfi.szDisplayName;

	return TRUE;
}

void CExplorerTree::OnItemExpanded(NMHDR* pNMHDR, LRESULT* pResult) 
{
	NM_TREEVIEW* pNMTreeView = (NM_TREEVIEW*)pNMHDR;
	*pResult = 0;
	HTREEITEM item=pNMTreeView->itemNew.hItem;
	if (ItemHasChildren(item)&&pNMTreeView->action==TVE_EXPAND){
		ExpandTree(pNMTreeView->itemNew.hItem);
	}
}

void CExplorerTree::DeleteTree(HTREEITEM item)
{
	LPSHELLFOLDER lpFolder=NULL;
	HTREEITEM root=item;
	if(root==NULL)
		root=GetRootItem();
	if(root==NULL)
		return;
	if (ItemHasChildren(root)){
		HTREEITEM hChildItem = GetChildItem(root);
		while (hChildItem != NULL)
		{
			DeleteTree(hChildItem);
			LPFILEITEM pItem=(LPFILEITEM)GetItemData(hChildItem);
			LPITEMIDLIST pidl=pItem->pidl;
			lpMalloc->Free(pidl);
			delete pItem;
			DeleteItem(hChildItem);
			hChildItem = GetChildItem(root);
		}
	}
}

void CExplorerTree::ListFolder(HTREEITEM item)
{
	HTREEITEM hRoot=item;
	if(item==NULL)
		hRoot=GetRootItem();
	LPFILEITEM pItem=(LPFILEITEM)GetItemData(hRoot);
	if(ItemHasChildren(hRoot))
		return;
	LPITEMIDLIST pidl,temp;
	int open;
	int nm;
	LPSHELLFOLDER lpFolder=NULL;
	if(!GetItemFolder(hRoot,lpFolder)||lpFolder==NULL)
		return;
	BeginWaitCursor();
	CString name;
	LPENUMIDLIST lpEnum=NULL;
	ULONG cnt;
	LPITEMIDLIST root=pItem->pidl;
	pItem->bListed=TRUE;
	if(SUCCEEDED(lpFolder->EnumObjects(0,dwListFlag,&lpEnum))){
		while(S_OK==lpEnum->Next(1,&temp,&cnt)){
			pidl=Append(root,temp);
			if(ItemIsFileSystem(pidl)){
				open=GetIcon(pidl);
				nm=GetIcon(pidl,0);
				GetItemName(pidl,name);

				pItem=new FILEITEM;
				pItem->pidl=pidl;
				HTREEITEM child=InsertItem(name,nm,open,hRoot);
				SetItemData(child,(DWORD)pItem);
			}
			else
				lpMalloc->Free(pidl);
			lpMalloc->Free(temp);
		}
		lpEnum->Release();
	}
	lpFolder->Release();
	TVSORTCB tvs;
	tvs.hParent = hRoot;
	tvs.lpfnCompare = CompareItem;
	tvs.lParam =(long)this;
	SortChildrenCB(&tvs);
	EndWaitCursor();
}

LPITEMIDLIST CExplorerTree::GetNextItemID(LPCITEMIDLIST pidl) 
{ 
	// Check for valid pidl.
	if(pidl == NULL)
		return NULL;
	
	// Get the size of the specified item identifier. 
	int cb = pidl->mkid.cb; 
	
	// If the size is zero, it is the end of the list. 
	if (cb == 0) 
		return NULL; 
	
	// Add cb to pidl (casting to increment by bytes). 
	pidl = (LPITEMIDLIST) (((LPBYTE) pidl) + cb); 
	
	// Return NULL if it is null-terminating, or a pidl otherwise. 
	return (pidl->mkid.cb == 0) ? NULL : (LPITEMIDLIST) pidl; 
} 

UINT CExplorerTree::GetSize(LPCITEMIDLIST pidl)
{
    UINT cbTotal = 0;
    if (pidl)
    {
        cbTotal += sizeof(pidl->mkid.cb);    // Null terminator
        while (pidl)
        {
            cbTotal += pidl->mkid.cb;
            pidl = GetNextItemID(pidl);
        }
    }
    return cbTotal;
}

LPITEMIDLIST CExplorerTree::MakeCopy(LPCITEMIDLIST pidl)
{
    UINT cb = 0;
	LPITEMIDLIST pidlTemp = (LPITEMIDLIST) pidl;
	
	// Calculate size of list.
    cb = GetSize(pidl);
	
    LPITEMIDLIST pidlRet = (LPITEMIDLIST)lpMalloc->Alloc(cb);
    if (pidlRet)
        CopyMemory(pidlRet, pidl, cb);
    return pidlRet;
}

LPITEMIDLIST CExplorerTree::Append(LPCITEMIDLIST pidlBase, LPCITEMIDLIST pidlAdd)
{
    if(pidlBase == NULL)
        return NULL;
    if(pidlAdd == NULL)
        return MakeCopy(pidlBase);
    
    LPITEMIDLIST pidlNew;
	
    UINT cb1 = GetSize(pidlBase) - sizeof(pidlBase->mkid.cb);
    UINT cb2 = GetSize(pidlAdd);
	
    pidlNew = (LPITEMIDLIST)lpMalloc->Alloc(cb1 + cb2);
    if (pidlNew)
    {
        CopyMemory(pidlNew, pidlBase, cb1);
        CopyMemory(((LPSTR)pidlNew) + cb1, pidlAdd, cb2);
    }
    return pidlNew;
}

BOOL CExplorerTree::GetItemFolder(HTREEITEM &item, LPSHELLFOLDER &lpFolder)
{
	HTREEITEM parent=item;
	LPITEMIDLIST pidl=NULL;
	if(item==GetRootItem())
		return SUCCEEDED(lpDesktop->QueryInterface(IID_IShellFolder,(void**)&lpFolder));
	LPFILEITEM pItem=(LPFILEITEM)GetItemData(item);
	pidl=pItem->pidl;
	HRESULT hres=lpDesktop->BindToObject(pidl,0,IID_IShellFolder,(void**)&lpFolder);
	return SUCCEEDED(hres);
}

void CExplorerTree::OnDestroy() 
{
	DeleteTree();
	HTREEITEM root=GetRootItem();
	if(root==NULL)
		return;
	LPFILEITEM pItem=(LPFILEITEM)GetItemData(root);
	LPITEMIDLIST pidl=pItem->pidl;
	lpMalloc->Free(pidl);
	delete pItem;
	DeleteAllItems();
	if(lpMalloc)
		lpMalloc->Release();
	if(lpDesktop)
		lpDesktop->Release();
	CTreeCtrl::OnDestroy();
}

void CExplorerTree::BuildTree()
{
	if(lpMalloc||lpDesktop||GetRootItem())
		return;
	SHFILEINFO sfi;
	ZeroMemory(&sfi,sizeof(SHFILEINFO));
	HIMAGELIST hil=(HIMAGELIST)SHGetFileInfo("*.txt",FILE_ATTRIBUTE_NORMAL,&sfi,sizeof(SHFILEINFO),
		SHGFI_USEFILEATTRIBUTES|SHGFI_SYSICONINDEX|SHGFI_SMALLICON);
	if(hil){
		CImageList *pim=CImageList::FromHandle(hil);
		SetImageList(pim,LVSIL_NORMAL);
		pim->Detach();
	}
	SHGetMalloc(&lpMalloc);
	SHGetDesktopFolder(&lpDesktop);
	LPITEMIDLIST pidl=(LPITEMIDLIST)lpMalloc->Alloc(sizeof(USHORT));
	*((USHORT*)pidl)=0;
	int open=GetIcon(pidl);
	int nm=GetIcon(pidl,0);
	CString name;
	GetItemName(lpDesktop,pidl,name);
	HTREEITEM hRoot=InsertItem(name,nm,open);
	LPFILEITEM pItem=new FILEITEM;
	pItem->pidl=pidl;
	SetItemData(hRoot,(DWORD)pItem);
	RefreshTree(hRoot);
	Expand(hRoot,TVE_EXPAND);
}

BOOL CExplorerTree::GetItemPath(HTREEITEM item, CString &path)
{
	LPFILEITEM pItem=(LPFILEITEM)GetItemData(item);
	LPITEMIDLIST pidl=pItem->pidl;
	BOOL ret=SHGetPathFromIDList(pidl,path.GetBuffer(MAX_PATH));
	path.ReleaseBuffer();
	return ret;
}

int CExplorerTree::CompareItem(LPARAM lParam1, LPARAM lParam2, LPARAM lParam)
{
	LPITEMIDLIST p1=((LPFILEITEM)lParam1)->pidl;
	LPITEMIDLIST p2=((LPFILEITEM)lParam2)->pidl;
	CString name1,name2;
	CExplorerTree*pTree=(CExplorerTree*)lParam;
	SHGetPathFromIDList(p1,name1.GetBuffer(MAX_PATH));
	name1.ReleaseBuffer();
	SHGetPathFromIDList(p2,name2.GetBuffer(MAX_PATH));
	name2.ReleaseBuffer();
	if(name1.IsEmpty()&&name2.IsEmpty()){
		pTree->GetItemName(pTree->lpDesktop,p1,name1);
		pTree->GetItemName(pTree->lpDesktop,p2,name2);
	}
	if(name1.IsEmpty()&&!name2.IsEmpty())
		return 1;
	if(name2.IsEmpty()&&!name1.IsEmpty())
		return -1;
	return strcmpi(name1,name2);
}

void CExplorerTree::ExpandTree(HTREEITEM item)
{
	LPFILEITEM pItem=(LPFILEITEM)GetItemData(item);
	if(ItemHasChildren(item)){
		HTREEITEM hChildItem = GetChildItem(item);
		while (hChildItem != NULL)
		{
			LPFILEITEM pItem=(LPFILEITEM)GetItemData(hChildItem);
			if(!pItem->bListed)
				ListFolder(hChildItem);
			hChildItem = GetNextItem(hChildItem, TVGN_NEXT);
		}
	}
//	RedrawWindow();
}

BOOL CExplorerTree::ItemIsFileSystem(LPITEMIDLIST pidl)
{
	SHFILEINFO sfi;
	UINT flag=(SHGFI_ATTRIBUTES|SHGFI_PIDL);
	SHGetFileInfo((LPCTSTR)pidl,0,&sfi,sizeof(SHFILEINFO),flag);
	return TRUE;//(sfi.dwAttributes&(SFGAO_FILESYSTEM|SFGAO_FILESYSANCESTOR));
}

HTREEITEM CExplorerTree::GetItemFromPath(CString &path)
{
	USES_CONVERSION;
	LPITEMIDLIST pidl;
/*	if(pidl!=NULL){
		HTREEITEM item=FindPath(GetRootItem(),pidl);
		lpMalloc->Free(pidl);
		return item;
	}
	else
		return NULL;
*/
	CString xx;
	HTREEITEM item=GetRootItem();
	int index=0;
	do{
		index=path.Find("\\",index+1);
		if(index!=-1)
			xx=path.Left(index+1);
		else
			xx=path;
		if(NOERROR!=lpDesktop->ParseDisplayName(0,0,A2W(xx),0,&pidl,0))
			return NULL;
		item=FindPath(item,pidl);
		if(item)
			ExpandTree(GetParentItem(item));
		lpMalloc->Free(pidl);
	}while(xx!=path);
	return item;
}

HTREEITEM CExplorerTree::FindPath(HTREEITEM item, LPITEMIDLIST &pidl)
{
	LPFILEITEM pItem=(LPFILEITEM)GetItemData(item);
	CString text=GetItemText(item);
	if(EqualPIDL(pItem->pidl,pidl))
		return item;
	if(!ItemHasChildren(item))
		return NULL;
	HTREEITEM hFound=NULL;
	HTREEITEM hChildItem = GetChildItem(item);
	while (hChildItem != NULL)
	{
		text=GetItemText(hChildItem);
		hFound=FindPath(hChildItem,pidl);
		if(hFound!=NULL)
			break;
		hChildItem = GetNextItem(hChildItem, TVGN_NEXT);
	}
	return hFound;
}

BOOL CExplorerTree::EqualPIDL(LPITEMIDLIST &pidl1, LPITEMIDLIST &pidl2)
{
	UINT sz=GetSize(pidl1);
	if(sz!=GetSize(pidl2))
		return FALSE;
	BYTE* p1=(BYTE*)pidl1;
	BYTE* p2=(BYTE*)pidl2;
	for(UINT i=0;i<sz;i++){
		if(*p1++!=*p2++)
			return FALSE;
	}
	return TRUE;
}