dirtree.cpp

在VC编程环境下

						case SHELL_DRIVE:
							_splitpath(szCompare,drive,dir,fname,ext);
							szCompare = drive;
							break;
						case SHELL_FOLDER:
							GetItemText(treeNode,szCompare);
							break;
						}
						strupr(szCompare);
						if(strcmp(szCompare,szSearchName) == 0)
						{
							TreeView_EnsureVisible(m_hWnd,treeNode);
							SelectItem(treeNode);
							bRet=true;
						}
					}
				}
				lpsf2->Release();
			}
		}
		treeNode = TreeView_GetNextSibling(m_hWnd,treeNode);
	}
	return bRet;
}
/****************************************************************************
*
*    FUNCTION: ConcatPidls(LPCITEMIDLIST pidl1, LPCITEMIDLIST pidl2)
*
*    PURPOSE:  Concatenates two PIDLs 
*
****************************************************************************/
LPITEMIDLIST CDirTree::ConcatPidls(LPCITEMIDLIST pidl1, LPCITEMIDLIST pidl2)
{
    LPITEMIDLIST pidlNew;
    UINT cb1;
    UINT cb2;

    if (pidl1)  //May be NULL
       cb1 = GetSize(pidl1) - sizeof(pidl1->mkid.cb);
    else
       cb1 = 0;

    cb2 = GetSize(pidl2);

    pidlNew = CreatePidl(cb1 + cb2);
    if (pidlNew)
    {
        if (pidl1)
           memcpy(pidlNew, pidl1, cb1);
        memcpy(((LPTSTR)pidlNew) + cb1, pidl2, cb2);
    }
    return pidlNew;
}
/****************************************************************************
*
*    FUNCTION: GetSize(LPCITEMIDLIST pidl)
*
*    PURPOSE:  Gets the size of the PIDL 
*
****************************************************************************/
UINT CDirTree::GetSize(LPCITEMIDLIST pidl)
{
    UINT cbTotal = 0;
    if (pidl)
    {
        cbTotal += sizeof(pidl->mkid.cb);
        while (pidl->mkid.cb)
        {
            cbTotal += pidl->mkid.cb;
			LPTSTR lpMem=(LPTSTR)pidl;
			lpMem+=pidl->mkid.cb;
			pidl = (LPITEMIDLIST)lpMem;
        }
    }

    return cbTotal;
}

/****************************************************************************
*
*    FUNCTION: CreatePidl(UINT cbSize)
*
*    PURPOSE:  Allocates a PIDL 
*
****************************************************************************/
LPITEMIDLIST CDirTree::CreatePidl(UINT cbSize)
{
    LPMALLOC lpMalloc;
    HRESULT  hr;
    LPITEMIDLIST pidl=NULL;

    hr=SHGetMalloc(&lpMalloc);

    if (FAILED(hr))
       return 0;

    pidl=(LPITEMIDLIST)lpMalloc->Alloc(cbSize);

    if (pidl)
        memset(pidl, 0, cbSize);      // zero-init for external task   alloc

    if (lpMalloc) lpMalloc->Release();

    return pidl;
}
/****************************************************************************
*
*    FUNCTION: GetName(LPSHELLFOLDER lpsf,LPITEMIDLIST  lpi,DWORD dwFlags,
*             LPTSTR         lpFriendlyName)
*
*    PURPOSE:  Gets the friendly name for the folder 
*
****************************************************************************/
BOOL CDirTree::GetName(LPSHELLFOLDER lpsf,
					   LPITEMIDLIST  lpi,
					   DWORD         dwFlags,
					   LPTSTR        lpFriendlyName)
{
	BOOL   bSuccess=TRUE;
	STRRET str;

	if (NOERROR==lpsf->GetDisplayNameOf(lpi,dwFlags, &str))
	{
		switch (str.uType)
		{
		case STRRET_WSTR:
			WideCharToMultiByte(CP_ACP, 
                                0,
                                str.pOleStr,
                                -1,
                                lpFriendlyName,
								_MAX_PATH,
                                NULL,
                                NULL);

			break;
		case STRRET_OFFSET:
			lstrcpy(lpFriendlyName, (LPTSTR)lpi+str.uOffset);
			break;
		case STRRET_CSTR:
			lstrcpy(lpFriendlyName, (LPTSTR)str.cStr);
			break;
		default:
			bSuccess = FALSE;
			break;
		}
	}
	else
		bSuccess = FALSE;

	return bSuccess;
}
/****************************************************************************
*
*    FUNCTION: CopyITEMID(LPMALLOC lpMalloc, LPITEMIDLIST lpi)
*
*    PURPOSE:  Copies the ITEMID 
*
****************************************************************************/
LPITEMIDLIST CDirTree::CopyITEMID(LPMALLOC lpMalloc, LPITEMIDLIST lpi)
{
   LPITEMIDLIST lpiTemp;

   lpiTemp=(LPITEMIDLIST)lpMalloc->Alloc(lpi->mkid.cb+sizeof(lpi->mkid.cb));
   CopyMemory((PVOID)lpiTemp, (CONST VOID *)lpi, lpi->mkid.cb+sizeof(lpi->mkid.cb));

   return lpiTemp;
}
/****************************************************************************
*
*    FUNCTION: GetIcon(LPITEMIDLIST lpi, UINT uFlags)
*
*    PURPOSE:  Gets the index for the current icon.  Index is index into system
*              image list.
*
*  PARAMETERS:
*    lpi    - Fully qualified item id list for current item.
*    uFlags - Flags for SHGetFileInfo()
*
*  RETURN VALUE:
*    Icon index for current item.
****************************************************************************/
int CDirTree::GetItemIcon(LPITEMIDLIST lpi, UINT uFlags)
{
   SHFILEINFO    sfi;

   SHGetFileInfo((LPCSTR)lpi, 
                 0,
                 &sfi, 
                 sizeof(SHFILEINFO), 
                 uFlags);

   return sfi.iIcon;
}
//=============================================================================
BOOL CDirTree::OnFolderSelected(NMHDR* pNMHDR,LPTSTR szFolderPath) 
{
	LPTVITEMDATA	lptvid;  //Long pointer to TreeView item data
	LPSHELLFOLDER	lpsf2=NULL;
	static char		szBuff[MAX_PATH];
	HRESULT			hr;
	BOOL			bRet = FALSE;      
	TV_SORTCB		tvscb;
	HTREEITEM		hItem=NULL;

	if((hItem = GetSelection()))
	{
		TVITEM item;
		item.hItem = hItem;
		item.mask = TVIF_PARAM;
		::SendMessage(m_hWnd, TVM_GETITEM, 0, (LPARAM)&item);
		lptvid=(LPTVITEMDATA)item.lParam;

		if (lptvid && lptvid->lpsfParent && lptvid->lpi)
		{
			hr=lptvid->lpsfParent->BindToObject(lptvid->lpi,
					 0,IID_IShellFolder,(LPVOID *)&lpsf2);

			if (SUCCEEDED(hr))
				{
					ULONG ulAttrs = SFGAO_FILESYSTEM;

					// Determine what type of object we have.
					lptvid->lpsfParent->GetAttributesOf(1, (const struct _ITEMIDLIST **)&lptvid->lpi, &ulAttrs);

					if (ulAttrs & (SFGAO_FILESYSTEM))
					{
						if(SHGetPathFromIDList(lptvid->lpifq,szBuff)){
							lstrcpy(szFolderPath,szBuff);
							bRet = TRUE;
						}
					}
					//non standard from here(NEW CODE)
					NM_TREEVIEW* pnmtv = (NM_TREEVIEW*)pNMHDR;
					if ((pnmtv->itemNew.cChildren == 1) && !(pnmtv->itemNew.state & TVIS_EXPANDEDONCE)){
						FillDirTree(lpsf2,lptvid->lpifq,pnmtv->itemNew.hItem);

						tvscb.hParent     = pnmtv->itemNew.hItem;
						tvscb.lParam      = 0;
						tvscb.lpfnCompare = SortCBProc;
						SortChildrenCB(&tvscb);
						
						pnmtv->itemNew.state |= TVIS_EXPANDEDONCE;
						pnmtv->itemNew.stateMask |= TVIS_EXPANDEDONCE;
						pnmtv->itemNew.mask |= TVIF_STATE;
						SetItem(&pnmtv->itemNew);
					}
				}

		}
		if(lpsf2)
			lpsf2->Release();
		
	}	
	return bRet;
}
//===============================================================================
//=================================================================
void CDirTree::OnSelchanged(LPNMHDR pNMHDR) 
{
	char szPath[_MAX_PATH];
	szPath[0] = '\0';
	OnFolderSelected(pNMHDR, szPath);
	if(m_pOwner)
		SendMessage(m_pOwner->m_hWnd,FBWM_NOTIFY,MAKEWPARAM(GetWndID(),FB_TCN_SELCHANGED),(LPARAM)szPath);
}
/////////////////////////////////////////////////////////////////////
void CDirTree::OnItemexpanding(LPNMHDR pNMHDR) 
{
	LPTVITEMDATA   lptvid;
	HRESULT        hr;
	LPSHELLFOLDER  lpsf2=NULL;
	static char    szBuff[MAX_PATH];
	TV_SORTCB      tvscb;

	NM_TREEVIEW* pnmtv = (NM_TREEVIEW*)pNMHDR;

    if ((pnmtv->itemNew.state & TVIS_EXPANDEDONCE))
         return;
		
    lptvid=(LPTVITEMDATA)pnmtv->itemNew.lParam;
    if (lptvid)
       {
            hr=lptvid->lpsfParent->BindToObject(lptvid->lpi,
                0, IID_IShellFolder,(LPVOID *)&lpsf2);

            if (SUCCEEDED(hr))
            {
                FillDirTree(lpsf2,
                       lptvid->lpifq,
                       pnmtv->itemNew.hItem);
            }

            tvscb.hParent     = pnmtv->itemNew.hItem;
            tvscb.lParam      = 0;
            tvscb.lpfnCompare = SortCBProc;

            SortChildrenCB(&tvscb);
    }	
}
//////////////////////////////////////////////////////////////////////////////////////////
void CDirTree::OnNotify(LPNMHDR pNMHDR,LRESULT &lResult)
{
	switch(pNMHDR->code)
	{
		case TVN_SELCHANGED:
			OnSelchanged(pNMHDR);
			break;
		case TVN_ITEMEXPANDING:
			OnItemexpanding(pNMHDR);
			if(m_nBkMode == 2)
				Invalidate();
			break;
		default:
			CFBTreeView::OnNotify(pNMHDR,lResult);
			break;
	}

	lResult = 0;
}