shellpidl.cpp

vc座的资源管理器源代码

   return hr;
}

void CShellPidl::GetTypeName(LPITEMIDLIST lpi,CString &sTypeName)
{
   SHFILEINFO    sfi;
   ZeroMemory(&sfi,sizeof(sfi));
   UINT uFlags = SHGFI_PIDL | SHGFI_TYPENAME;
   SHGetFileInfo((LPCTSTR)lpi, 0, &sfi, sizeof(SHFILEINFO), uFlags);
   sTypeName = sfi.szTypeName;
}

void CShellPidl::GetDisplayName(LPITEMIDLIST lpifq,CString &sDisplayName)
{
   SHFILEINFO    sfi;
   ZeroMemory(&sfi,sizeof(sfi));
   UINT uFlags = SHGFI_PIDL | SHGFI_DISPLAYNAME;
   SHGetFileInfo((LPCTSTR)lpifq, 0, &sfi, sizeof(SHFILEINFO), uFlags);
   sDisplayName = sfi.szDisplayName;
}

void CShellPidl::GetNormalAndSelectedIcons (
   LPITEMIDLIST lpifq, int &iImage, int &iSelectedImage)
{
   // Don't check the return value here. 
   // If IGetIcon() fails, you're in big trouble.
   iImage = GetIcon (lpifq, 
      SHGFI_PIDL | SHGFI_SYSICONINDEX | SHGFI_SMALLICON);
   
   iSelectedImage = GetIcon (lpifq, 
      SHGFI_PIDL | SHGFI_SYSICONINDEX | SHGFI_SMALLICON | SHGFI_OPENICON);
   
   return;
}

BOOL CShellPidl::HandleMenuMsg(HWND hwnd, LPSHELLFOLDER lpsfParent,
     LPITEMIDLIST  lpi, UINT uMsg, WPARAM wParam, LPARAM lParam)
{
    LPCONTEXTMENU lpcm=NULL;
    HRESULT hr=lpsfParent->GetUIObjectOf(hwnd,
        1,  // get attributes for this many objects
        (const struct _ITEMIDLIST **)&lpi,
        IID_IContextMenu,
        0,
        (LPVOID *)&lpcm);
    if (SUCCEEDED(hr))  
    {
	    LPCONTEXTMENU2 lpcm2=NULL;
		hr = lpcm->QueryInterface(IID_IContextMenu2,(LPVOID*)&lpcm2);
		lpcm->Release();
		if (SUCCEEDED(hr))  
	    {
			lpcm2->HandleMenuMsg(uMsg,wParam,lParam);
			lpcm2->Release();
		}
		return TRUE;
	}
	return FALSE;
}

BOOL CShellPidl::PopupTheMenu(HWND hwnd, LPSHELLFOLDER lpsfParent,
     LPITEMIDLIST  *plpi, UINT cidl, LPPOINT lppt)
{
 	CMenu menu;
    menu.CreatePopupMenu();
	g_CoolMenuManager.Install(CWnd::FromHandle(hwnd));
	CString sPath;
	if (lpsfParent == NULL)
		lpsfParent = GetDesktopFolder();
	SHPidlToPathEx(*plpi,sPath,lpsfParent);
	CShellContextMenu shell_menu(hwnd,sPath,plpi,cidl,lpsfParent);
	shell_menu.SetMenu(&menu);
    int idCmd = menu.TrackPopupMenu(TPM_FLAGS, lppt->x, lppt->y, CWnd::FromHandle(hwnd));
	shell_menu.InvokeCommand(idCmd);
	g_CoolMenuManager.Uninstall();
	return TRUE;
}

/****************************************************************************
*
*    FUNCTION: GetName(LPSHELLFOLDER lpsf,LPITEMIDLIST  lpi,DWORD dwFlags,
*             LPSTR         lpFriendlyName)
*
*    PURPOSE:  Gets the friendly name for the folder 
*
****************************************************************************/
BOOL CShellPidl::GetName (LPSHELLFOLDER lpsf, LPITEMIDLIST lpi, 
   DWORD dwFlags, CString &sFriendlyName)
{
   BOOL   bSuccess=TRUE;
   STRRET str;

   if (NOERROR==lpsf->GetDisplayNameOf(lpi,dwFlags, &str))
   {
      switch (str.uType)
      {
         case STRRET_WSTR:
#ifdef UNICODE
			 _tcscpy(sFriendlyName.GetBuffer(MAX_PATH),str.pOleStr);
			 sFriendlyName.ReleaseBuffer();
#else
            WideCharToMultiByte(
               CP_ACP,                 // code page
               0,		               // dwFlags
               str.pOleStr,            // lpWideCharStr
               -1,                     // cchWideCharStr
               sFriendlyName.GetBuffer(_MAX_PATH),         // lpMultiByteStr
               _MAX_PATH, // cchMultiByte
               NULL,                   // lpDefaultChar
               NULL);                  // lpUsedDefaultChar
#endif
			sFriendlyName.ReleaseBuffer();	
             break;

         case STRRET_OFFSET:
             sFriendlyName = (LPTSTR)lpi+str.uOffset;
             break;

         case STRRET_CSTR:             
             sFriendlyName = (LPTSTR)str.cStr;
             break;

         default:
             bSuccess = FALSE;
             break;
      }
   }
   else
      bSuccess = FALSE;

   return bSuccess;
}

//
// ResolveChannel: Resolves a Channel Shortcut to its URL
//
STDMETHODIMP CShellPidl::ResolveChannel(IShellFolder* pFolder, LPCITEMIDLIST pidl, LPTSTR* lpszURL)
{
   IShellLink* pShellLink;

   *lpszURL = NULL;  // Assume failure

   // Get a pointer to the IShellLink interface from the given folder
   HRESULT hr = pFolder->GetUIObjectOf(NULL, 1, &pidl, IID_IShellLink, NULL, (LPVOID*)&pShellLink);
   if (SUCCEEDED(hr))
   {
      LPITEMIDLIST pidlChannel;

      // Convert the IShellLink pointer to a PIDL.
      hr = pShellLink->GetIDList(&pidlChannel);
      if (SUCCEEDED(hr))
      {
         IShellFolder* psfDesktop;

         hr = SHGetDesktopFolder(&psfDesktop);
         if (SUCCEEDED(hr))
         {
            STRRET strret;

            hr = psfDesktop->GetDisplayNameOf(pidlChannel, 0, &strret);
            if (SUCCEEDED(hr))
				StrRetToStr(strret, lpszURL, pidlChannel);

            psfDesktop->Release();
         }
      }

      pShellLink->Release();
   }

   return hr;
}

STDMETHODIMP CShellPidl::ResolveHistoryShortcut(LPSHELLFOLDER pFolder,LPCITEMIDLIST *ppidl,CString &sURL)
{
	HRESULT hr=E_FAIL;
	IDataObject *pObj=NULL;
	hr = pFolder->GetUIObjectOf(NULL, 1, ppidl, IID_IDataObject, NULL, (LPVOID*)&pObj);
	if (SUCCEEDED(hr))
	{
		hr = GetURL(pObj,sURL);
		pObj->Release();
	}
	return hr;
}

STDMETHODIMP CShellPidl::GetURL(IDataObject *pDataObj,CString &sURL)
{
	sURL.Empty();
	STGMEDIUM stgm;
	ZeroMemory(&stgm, sizeof(stgm));

    FORMATETC fetc;
    fetc.cfFormat = CF_SHELLURL;
    fetc.ptd = NULL;
    fetc.dwAspect = DVASPECT_CONTENT;
    fetc.lindex = -1;
    fetc.tymed = TYMED_HGLOBAL;

    HRESULT hr = pDataObj->QueryGetData(&fetc);
	if (FAILED(hr))
		return hr;
    hr = pDataObj->GetData(&fetc, &stgm);
	if (FAILED(hr))
		return hr;
    LPCTSTR pData = (LPCTSTR)GlobalLock(stgm.hGlobal);
	sURL = pData;
	GlobalUnlock(stgm.hGlobal);
    ReleaseStgMedium(&stgm);
	return S_OK;
}

//
// ResolveInternetShortcut: Resolves an Internet Shortcut to its URL
//
STDMETHODIMP CShellPidl::ResolveInternetShortcut(LPCTSTR lpszLinkFile, LPTSTR* lpszURL)
{
	IUniformResourceLocator* pUrlLink = NULL;

	*lpszURL=NULL;

	HRESULT hr = CoCreateInstance(CLSID_InternetShortcut, NULL, CLSCTX_INPROC_SERVER,
							 IID_IUniformResourceLocator, (LPVOID*)&pUrlLink);
	if (FAILED(hr))
		return hr;

	IPersistFile* pPersistFile = NULL;
	hr = pUrlLink->QueryInterface(IID_IPersistFile, (LPVOID*)&pPersistFile);
	if (SUCCEEDED(hr))
	{
		 // Ensure that the string is Unicode. 
		 WORD wsz[MAX_PATH];  
		#ifdef UNICODE
		 _tcscpy(wsz,lpszLinkFile);
		#else
		 MultiByteToWideChar(CP_ACP, 0, lpszLinkFile, -1, wsz, MAX_PATH);
		#endif
		 // Load the Internet Shortcut from persistent storage.
		 hr = pPersistFile->Load(wsz, STGM_READ);
		 if (SUCCEEDED(hr))
		 {
			hr = pUrlLink->GetURL(lpszURL);
		 }
		 pPersistFile->Release();
	}
	pUrlLink->Release();

	return hr;
}  

//
// ResolveLink: Resolves a Shell Link to its actual folder location
//
STDMETHODIMP CShellPidl::ResolveLink(HWND hWnd,LPCTSTR lpszLinkFile, LPTSTR* lpszURL)
{
   IShellLink* pShellLink = NULL;

   *lpszURL = NULL;   // Assume failure

   HRESULT hr = CoCreateInstance(CLSID_ShellLink, NULL, CLSCTX_INPROC_SERVER,
                                 IID_IShellLink, (LPVOID*)&pShellLink); 
   if (SUCCEEDED(hr))
   {
      IPersistFile* pPersistFile = NULL;

      hr = pShellLink->QueryInterface(IID_IPersistFile, (LPVOID*)&pPersistFile);
      if (SUCCEEDED(hr))
      {
         // Ensure that the string is Unicode. 
         WORD wsz[MAX_PATH];  
#ifdef UNICODE
		 _tcscpy(wsz,lpszLinkFile);
#else
         MultiByteToWideChar(CP_ACP, 0, lpszLinkFile, -1, wsz, MAX_PATH);
#endif

         // Load the shortcut.from persistent storage
         hr = pPersistFile->Load(wsz, STGM_READ);
         if (SUCCEEDED(hr))
         {
            WIN32_FIND_DATA wfd;      

            hr = pShellLink->Resolve(hWnd, SLR_NO_UI); 
            if (NOERROR == hr)
            {
               // Get the path to the link target. 
	   		   *lpszURL = (LPTSTR)m_pMalloc->Alloc(MAX_PATH);  // Must remember to Free later

               hr = pShellLink->GetPath(*lpszURL, MAX_PATH - 1, (WIN32_FIND_DATA*)&wfd, SLGP_UNCPRIORITY);
            }
         }

         pPersistFile->Release();
      }

      pShellLink->Release();
   }

   return hr;
}

//
// This method converts a STRRET structure to a LPTSTR
//
#ifdef UNICODE
STDMETHODIMP CShellPidl::StrRetToStr(STRRET StrRet, LPTSTR* str, LPITEMIDLIST pidl)
{
	HRESULT hr = S_OK;
	int cch;
	LPSTR strOffset;

	*str = NULL;  // Assume failure

	switch (StrRet.uType)
   {
		case STRRET_WSTR: 
			cch = wcslen(StrRet.pOleStr) + 1; // NULL terminator
			*str = (LPTSTR)m_pMalloc->Alloc(cch * sizeof(TCHAR));

			if (*str != NULL)
				lstrcpyn(*str, StrRet.pOleStr, cch);
			else
				hr = E_FAIL;
			break;

		case STRRET_OFFSET: 
			strOffset = (((char *) pidl) + StrRet.uOffset);

			cch = MultiByteToWideChar(CP_OEMCP, 0, strOffset, -1, NULL, 0); 
			*str = (LPTSTR)m_pMalloc->Alloc(cch * sizeof(TCHAR));

			if (*str != NULL)
				MultiByteToWideChar(CP_OEMCP, 0, strOffset, -1, *str, cch); 
			else
				hr = E_FAIL;
			break;

		case STRRET_CSTR: 
			cch = MultiByteToWideChar(CP_OEMCP, 0, StrRet.cStr, -1, NULL, 0); 
			*str = (LPTSTR)m_pMalloc->Alloc(cch * sizeof(TCHAR)); 

			if (*str != NULL)
				MultiByteToWideChar(CP_OEMCP, 0, StrRet.cStr, -1, *str, cch); 
			else
				hr = E_FAIL;

			break;
	} 
 
	return hr;
}
#else // UNICODE not defined
STDMETHODIMP CShellPidl::StrRetToStr(STRRET StrRet, LPTSTR* str, LPITEMIDLIST pidl)
{

	HRESULT hr = S_OK;
	int cch;
	LPSTR strOffset;

	*str = NULL;  // Assume failure

	switch (StrRet.uType)
   {
		case STRRET_WSTR: 
			cch = WideCharToMultiByte(CP_ACP, 0, StrRet.pOleStr, -1, NULL, 0, NULL, NULL); 
			*str = (LPTSTR)m_pMalloc->Alloc(cch * sizeof(TCHAR)); 

			if (*str != NULL)
				WideCharToMultiByte(CP_ACP, 0, StrRet.pOleStr, -1, *str, cch, NULL, NULL); 
			else
				hr = E_FAIL;
			break;

		case STRRET_OFFSET: 
			strOffset = (((char *) pidl) + StrRet.uOffset);

			cch = strlen(strOffset) + 1; // NULL terminator
			*str = (LPTSTR)m_pMalloc->Alloc(cch * sizeof(TCHAR));

			if (*str != NULL)
				strcpy(*str, strOffset);
			else
				hr = E_FAIL;
			break;

		case STRRET_CSTR: 
			cch = strlen(StrRet.cStr) + 1; // NULL terminator
			*str = (LPTSTR)m_pMalloc->Alloc(cch * sizeof(TCHAR));

			if (*str != NULL)
				strcpy(*str, StrRet.cStr);
			else
				hr = E_FAIL;

			break;
	} 

	return hr;
}
#endif