bool CXTPShellListCtrlEx::BrowseToFolder(LPCTSTR lpszPath)
{
	XTP_TVITEMDATA lpTVID;

	LPITEMIDLIST  pidl;
	LPSHELLFOLDER pDesktopFolder;
	OLECHAR       szOleChar[MAX_PATH];
	ULONG         chEaten;
	ULONG         dwAttributes;
	HRESULT       hr;

	// Get a pointer to the Desktop's IShellFolder interface.
	if (SUCCEEDED(::SHGetDesktopFolder(&pDesktopFolder)))
	{
		// IShellFolder::ParseDisplayName requires the file name be in
		// Unicode.

#if !defined(_UNICODE)
		::MultiByteToWideChar(CP_ACP, MB_PRECOMPOSED, lpszPath, -1,
			szOleChar, MAX_PATH);
#else
		STRCPY_S(szOleChar, MAX_PATH, lpszPath);
#endif

		// Convert the path to an ITEMIDLIST.
		hr = pDesktopFolder->ParseDisplayName(NULL, NULL, szOleChar,
			&chEaten, &pidl, &dwAttributes);

		if (SUCCEEDED(hr))
		{
			IShellFolder *psfMyFolder;

			lpTVID.lpi = lpTVID.lpifq = pidl;

			pDesktopFolder->BindToObject(lpTVID.lpifq, NULL,
				IID_IShellFolder, (LPVOID*)&psfMyFolder);

			lpTVID.lpsfParent = psfMyFolder;
			PopulateListView(&lpTVID, lpTVID.lpsfParent);

			m_strItemPath = lpszPath;
			pDesktopFolder->Release();

			return true;
		}

		pDesktopFolder->Release();
	}

	return false;
}
Example #2
0
LPITEMIDLIST GetFullyQualPidl(LPSHELLFOLDER lpsf, LPITEMIDLIST lpi)
{
   char szBuff[MAX_PATH];
   OLECHAR szOleChar[MAX_PATH];
   LPSHELLFOLDER lpsfDeskTop;
   LPITEMIDLIST  lpifq;
   ULONG ulEaten, ulAttribs;
   HRESULT hr;

   if( !GetName(lpsf, lpi, SHGDN_FORPARSING, szBuff))
      return NULL;

   hr=SHGetDesktopFolder(&lpsfDeskTop) ;

   if( FAILED(hr))
      return NULL;

   MultiByteToWideChar(CP_ACP,
					   MB_PRECOMPOSED,
					   szBuff,
					   -1,
					   szOleChar,
					   sizeof(szOleChar)) ;

   hr=lpsfDeskTop->ParseDisplayName(NULL,NULL,szOleChar,&ulEaten,&lpifq,&ulAttribs) ;

   lpsfDeskTop->Release() ;

   if( FAILED(hr))
      return NULL;

   return lpifq;
}
Example #3
0
//***************************************************************************************
HRESULT CBCGPShellList::DisplayFolder (LPCTSTR lpszPath)
{
	if (g_pShellManager == NULL)
	{
		ASSERT (FALSE);
		return E_FAIL;
	}

	ASSERT (lpszPath != NULL);
	ASSERT_VALID (g_pShellManager);

	BCGCBITEMINFO info;
	HRESULT hr = g_pShellManager->ItemFromPath (lpszPath, info.pidlRel);

	if (FAILED (hr))
	{
		return hr;
	}

	LPSHELLFOLDER pDesktopFolder;
	hr = SHGetDesktopFolder(&pDesktopFolder);

	if (SUCCEEDED (hr))
	{
		info.pParentFolder = pDesktopFolder;
		info.pidlFQ = info.pidlRel;

		hr = DisplayFolder (&info);
		pDesktopFolder->Release();
	}

	g_pShellManager->FreeItem (info.pidlFQ);
	return hr;
}
Example #4
0
//Pabs inserted
//Parts copied from compiler docs - search for ITEMIDLIST in title in msdn
//Adapted from Q132750:"HOWTO: Convert a File Path to an ITEMIDLIST" in the Knowledge Base
STDAPI PathsEqual(LPCTSTR p0, LPCTSTR p1)
{
	LPSHELLFOLDER pFolder;
	HRESULT hr;
	if (SUCCEEDED(hr = SHGetDesktopFolder(&pFolder)))
	{
		LPITEMIDLIST pidl[2] = { NULL, NULL };
		ULONG chEaten;//only needed by parse dispname
		// Convert the paths to ITEMIDLISTs.
		if (SUCCEEDED(hr = pFolder->ParseDisplayName(NULL, NULL,
				const_cast<LPOLESTR>(&*static_cast<T2W>(p0)), &chEaten, &pidl[0], NULL)) &&
			SUCCEEDED(hr = pFolder->ParseDisplayName(NULL, NULL,
				const_cast<LPOLESTR>(&*static_cast<T2W>(p1)), &chEaten, &pidl[1], NULL)))
		{
			hr = pFolder->CompareIDs(0, pidl[0], pidl[1]);
		}

		//free ITEMIDLISTs
		IMalloc* pm;
		SHGetMalloc(&pm);
		pm->Free(pidl[0]);
		pm->Free(pidl[1]);
		pm->Release();

		pFolder->Release();
	}
	return hr;
}
Example #5
0
/*
 * Get a fully qualified PIDL for a ShellFolder.
 *
 * This is a rather roundabout way of doing things (converting to a full
 * display name and then converting that to a PIDL).  However, there doesn't
 * seem to be a way to just ask a ShellFolder for its fully qualified PIDL.
 * TODO: see if there's a better way now.
 *
 * Pass in the parent ShellFolder and the item's partial PIDL.
 */
LPITEMIDLIST
Pidl::GetFullyQualPidl(LPSHELLFOLDER lpsf, LPITEMIDLIST lpi)
{
    //char szBuff[MAX_PATH];
    //OLECHAR szOleChar[MAX_PATH];
    CString name;
    WCHAR pathBuf[MAX_PATH];
    LPSHELLFOLDER lpsfDeskTop;
    LPITEMIDLIST lpifq;
    ULONG ulAttribs = 0;
    HRESULT hr;
    
    if (!GetName(lpsf, lpi, SHGDN_FORPARSING, &name))
        return NULL;
    
    hr = SHGetDesktopFolder(&lpsfDeskTop);
    
    if (FAILED(hr))
        return NULL;
    
    //MultiByteToWideChar(CP_ACP, MB_PRECOMPOSED, szBuff, -1,
    //                   (USHORT *)szOleChar, sizeof(szOleChar));
    wcscpy_s(pathBuf, name);
    
    hr = lpsfDeskTop->ParseDisplayName(NULL, NULL, pathBuf,
            NULL, &lpifq, &ulAttribs);
    
    lpsfDeskTop->Release();
    
    if (FAILED(hr))
        return NULL;
    
    return lpifq;
}
Example #6
0
BOOL CRecBinViewer::GetFolder2 ()
{
	BOOL			bReturn			= FALSE;
	STRRET			strRet;
	LPSHELLFOLDER	pDesktop		= NULL;
	LPITEMIDLIST	pidlRecycleBin	= NULL;
	CString			dspName;

	
	if (NULL != m_pFolder2)
	{
		m_pFolder2->Release ();
		m_pFolder2 = NULL;
	}
	
	if ((SUCCEEDED (SHGetDesktopFolder(&pDesktop))) &&
		(SUCCEEDED (SHGetSpecialFolderLocation (m_hWnd, CSIDL_BITBUCKET, &pidlRecycleBin))))
	{
		if (SUCCEEDED (pDesktop->BindToObject(pidlRecycleBin, NULL, IID_IShellFolder2, (LPVOID *)&m_pFolder2)))
		{
			if (S_OK == pDesktop->GetDisplayNameOf (pidlRecycleBin, SHGDN_NORMAL, &strRet))			
				GetName (strRet, dspName);			
			bReturn = TRUE;
		}
	}
		
	CoTaskMemFree (pidlRecycleBin);
	
	if (NULL != pDesktop) pDesktop->Release();
	
	return bReturn;
}
Example #7
0
ITEMIDLIST* CUtil::IDListFromPath(LPCTSTR pathName)
{
  LPSHELLFOLDER   pDesktopFolder;
  HRESULT         hr = SHGetDesktopFolder(&pDesktopFolder);
  ITEMIDLIST*     pidl=NULL;

  if (FAILED(hr)) {
    assert(0); 
    return NULL;
  }

  OLECHAR olePath [MAX_PATH];

#ifdef _UNICODE
  lstrcpy(olePath, pathName);
#else
  MultiByteToWideChar(CP_ACP, MB_PRECOMPOSED, lpszPath, -1, pathName, MAX_PATH);
#endif

  ULONG chEaten;
  ULONG dwAttributes;
  hr = pDesktopFolder->ParseDisplayName(NULL, NULL, olePath, &chEaten, &pidl, &dwAttributes);

  pDesktopFolder->Release();
  return pidl;
}
Example #8
0
BOOL sh_get_displayname(LPSHELLFOLDER piFolder, LPCITEMIDLIST pidl,
						 DWORD dwFlags, LPTSTR pszName)
{
	STRRET str;
	BOOL fDesktop = FALSE;
	BOOL fSuccess = TRUE;
	//
	// Check to see if a parent folder was specified.  If not, get a pointer
	// to the desktop folder.
	//
	if (NULL == piFolder)   
	{
		HRESULT hr = SHGetDesktopFolder(&piFolder);

		if (FAILED(hr))
			return (FALSE);

		fDesktop = TRUE;
	}
	//
	// Get the display name from the folder.  Then do any conversions necessary
	// depending on the type of string returned.
	//
	if (NOERROR == piFolder->GetDisplayNameOf(pidl, dwFlags, &str))
	{
		//StrRetToBufA(&str, pidl, pszName, MAX_PATH);
		switch (str.uType)
		{
			case STRRET_WSTR:
				WideCharToMultiByte(CP_ACP, 0, str.pOleStr, -1, pszName, MAX_PATH, NULL, NULL);
				SHMalloc_Free(str.pOleStr);
				//dbg_printf("WSTR: %s", pszName);
				break;

			case STRRET_OFFSET:
				strcpy(pszName, (LPSTR)pidl + str.uOffset);
				//dbg_printf("OFFS: %s", pszName);
				break;

			case STRRET_CSTR:
				strcpy(pszName, str.cStr);
				//dbg_printf("CSTR: %s", pszName);
				break;

			default:
				fSuccess = FALSE;
				break;
		}
	}
	else
	{
		fSuccess = FALSE;
	}

	if (fDesktop)
		piFolder->Release();

	return (fSuccess);
}
BOOL COXShellNamespaceNavigator::
GetShellFolderFullIDL(CString sFolderFullPath,
					  LPITEMIDLIST* ppidlFull) const
{
	ASSERT(ppidlFull!=NULL);

	// If lpcsFolderFullPath is NULL then just return the Desktop's IDL which is NULL
	if(sFolderFullPath.IsEmpty())
	{
		*ppidlFull=NULL;
		return TRUE;
	}

	// First of all get the Desktop's IShellFolder interface. 
	LPSHELLFOLDER lpDesktopFolder;
    if(FAILED(SHGetDesktopFolder(&lpDesktopFolder)))
        return FALSE;


	OLECHAR unicodeFolderPath[MAX_PATH];

#ifndef _UNICODE
	UTBStr::mbstowcs(unicodeFolderPath,MAX_PATH,sFolderFullPath,MAX_PATH);
#else
	UTBStr::tcscpy(unicodeFolderPath, MAX_PATH, sFolderFullPath);
#endif

	LPITEMIDLIST lpidl;
    ULONG chEaten;
    ULONG dwAttributes;
    HRESULT hResult=lpDesktopFolder->
		ParseDisplayName(m_pOwnerWnd!=NULL ? m_pOwnerWnd->GetSafeHwnd() : NULL,
		NULL,unicodeFolderPath,&chEaten,&lpidl,&dwAttributes);
	if(FAILED(hResult))
	{
		lpDesktopFolder->Release();
		m_pMalloc->Free(lpidl);
        return FALSE;
	}

	*ppidlFull=CopyPIDL(lpidl);
	lpDesktopFolder->Release();
	m_pMalloc->Free(lpidl);

	return TRUE;
}
Example #10
0
/**
 * 简单的枚举文件夹内容,返回内容数量
 */
int SimpleEnumFolder(LPCTSTR lpszPath		// 文件夹路径
	, CShellManager* pShellManager			// Shell管理器
	, function<void(LPITEMIDLIST)> filter)	// 过滤器函数
{
	ENSURE(lpszPath != nullptr);
	ASSERT_VALID(pShellManager);

	AFX_SHELLITEMINFO info;
	HRESULT hr = pShellManager->ItemFromPath(lpszPath, info.pidlRel);
	if (FAILED(hr))	{
		return 0;
	}

	int nFolderCount = 0;

	LPSHELLFOLDER pDesktopFolder;
	hr = SHGetDesktopFolder(&pDesktopFolder);

	if (SUCCEEDED(hr)) {

		IShellFolder* psfCurFolder = nullptr;
		hr = pDesktopFolder->BindToObject(info.pidlRel, nullptr, IID_IShellFolder, (LPVOID*)&psfCurFolder);

		LPENUMIDLIST pEnum = nullptr;
		HRESULT hRes = psfCurFolder->EnumObjects(nullptr, (SHCONTF)(SHCONTF_FOLDERS), &pEnum);
		if (SUCCEEDED(hRes) && pEnum != nullptr) {

			DWORD dwFetched = 1;
			LPITEMIDLIST pidlTemp;
			while (pEnum->Next(1, &pidlTemp, &dwFetched) == S_OK && dwFetched) {

				if (!filter._Empty()) {
					LPITEMIDLIST itemID = pShellManager->ConcatenateItem(info.pidlRel, pidlTemp);
					filter(itemID);
					pShellManager->FreeItem(itemID);
				}

				pShellManager->FreeItem(pidlTemp);

				nFolderCount++;
				dwFetched = 0;
			}

			pEnum->Release();
		}

		psfCurFolder->Release();
		pDesktopFolder->Release();
	}

	pShellManager->FreeItem(info.pidlRel);
	return nFolderCount;
}
Example #11
0
//This gets a fully qualified long absolute filename from any other type of file name ON ANY Win32 PLATFORM damn stupid Micro$uck$ & bloody GetLongPathName
//It was copied and enhanced from an article by Jeffrey Richter available in the MSDN under "Periodicals\Periodicals 1997\Microsoft Systems Journal\May\Win32 Q & A" (search for GetLongPathName & choose the last entry)
STDAPI GetLongPathNameWin32(LPCTSTR lpszShortPath, LPTSTR lpszLongPath)
{
	/*Alternative methods to consider adding here
	GetLongPathName on Win98/NT5
	Recursive FindFirstFile ... FindClose calls
	Interrupt 21h Function 7160h Minor Code 2h
	- does exactly what we want
		- to the damn letter
		- even resolves SUBST's (or not if you only want the drive letter)
			- remember those from DOS?
	- but the MSDN doesn't say anything about whether or not it is supported
	  by WinNT4 (It is only listed in Win95 docs)*/

	// Do not attempt to operate in-place
	if (lpszLongPath == lpszShortPath)
		return S_FALSE;
	// Make sure it is an absolute path
	LPTSTR lpszFilePart = 0;
	if (GetFullPathName(lpszShortPath, MAX_PATH, lpszLongPath, &lpszFilePart) <= MAX_PATH)
	{
		// Get the Desktop's shell folder interface
		LPSHELLFOLDER psfDesktop = 0;
		HRESULT hr = SHGetDesktopFolder(&psfDesktop);
		if (SUCCEEDED(hr))
		{
			// Request an ID list (relative to the desktop) for the short pathname
			ULONG chEaten = 0;
			LPITEMIDLIST pidlShellItem = 0;
			hr = psfDesktop->ParseDisplayName(0, 0, const_cast<LPWSTR>(&*static_cast<T2W>(lpszLongPath)), &chEaten, &pidlShellItem, 0);
			if (SUCCEEDED(hr))
			{
				// We did get an ID list, convert it to a long pathname
				SHGetPathFromIDList(pidlShellItem, lpszLongPath);
				// Free the ID list allocated by ParseDisplayName
				LPMALLOC pMalloc = NULL;
				SHGetMalloc(&pMalloc);
				pMalloc->Free(pidlShellItem);
				pMalloc->Release();
			}
			psfDesktop->Release(); // Release the desktop's IShellFolder
		}
	}
	else
	{
		lstrcpy(lpszLongPath, lpszShortPath);
	}
	return S_OK;
}
Example #12
0
        Ztring OpenFolder_Show(void* Handle, const Ztring &Title, const Ztring &Caption)
        {
            //Caption
            Directory_Select_Caption=Caption;

            if (IsWin9X())
            {
                return Ztring(); //Not supported in Win9X
            }
            else
            {
                //Values
                LPMALLOC        Malloc;
                LPSHELLFOLDER   ShellFolder;
                BROWSEINFO      BrowseInfo;
                LPITEMIDLIST    ItemIdList;

                //Initializing the SHBrowseForFolder function
                if (SHGetMalloc(&Malloc)!=NOERROR)
                    return Ztring();
                if (SHGetDesktopFolder(&ShellFolder)!=NOERROR)
                    return Ztring();
                ZeroMemory(&BrowseInfo, sizeof(BROWSEINFOW));
                BrowseInfo.ulFlags+=BIF_RETURNONLYFSDIRS;
                BrowseInfo.hwndOwner=(HWND)Handle;
                BrowseInfo.pszDisplayName=InitDir;
                BrowseInfo.lpszTitle=Title.c_str();
                BrowseInfo.lpfn=ShowOpenFolder_CallbackProc;

                //Displaying
                ItemIdList=SHBrowseForFolder(&BrowseInfo);

                //Releasing
                ShellFolder->Release();
                if (ItemIdList!=NULL)
                {
                    SHGetPathFromIDList(ItemIdList, InitDir);
                    Malloc->Free(ItemIdList);
                    Malloc->Release();

                    //The value
                    return InitDir;
                }
                else
                    return Ztring();
            }
        }
void CSelectDrivesDlg::OnBnClickedBrowsefolder()
{
	// Buffer, because SHBrowseForFolder() wants a buffer
	CString sDisplayName, sSelectedFolder = m_folderName;
	BROWSEINFO bi;
	ZeroMemory(&bi, sizeof(bi));

	// Load a meaningful title for the browse dialog
	CString title= LoadString(IDS_SELECTFOLDER);
	bi.hwndOwner= m_hWnd;
	// Use the CString as buffer (minimum is MAX_PATH as length)
	bi.pszDisplayName= sDisplayName.GetBuffer(_MAX_PATH);
	bi.lpszTitle= title;
	// Set a callback function to pre-select a folder
	bi.lpfn = BFFCALLBACK(BrowseCallbackProc);
	bi.lParam = LPARAM(sSelectedFolder.GetBuffer());
	// Set the required flags
	bi.ulFlags= BIF_RETURNONLYFSDIRS | BIF_EDITBOX | BIF_NEWDIALOGSTYLE | BIF_NONEWFOLDERBUTTON;
	
	LPITEMIDLIST pidl= SHBrowseForFolder(&bi);
	// Release the actual buffer
	sDisplayName.ReleaseBuffer();
	sSelectedFolder.ReleaseBuffer();

	if (pidl != NULL)
	{
		CString sDir;

		LPSHELLFOLDER pshf;
		HRESULT hr= SHGetDesktopFolder(&pshf); 
		ASSERT(SUCCEEDED(hr));
		
		STRRET strret;
		strret.uType= STRRET_CSTR;
		hr= pshf->GetDisplayNameOf(pidl, SHGDN_FORPARSING, &strret);
		ASSERT(SUCCEEDED(hr));
		sDir= MyStrRetToString(pidl, &strret);

		CoTaskMemFree(pidl);
		pshf->Release();

		m_folderName= sDir;
		m_radio= RADIO_AFOLDER;
		UpdateData(false);
		UpdateButtons();
	}
}
Example #14
0
HRESULT WINAPI _SHILCreateFromPath(LPCWSTR pszPath, LPITEMIDLIST *ppidl, DWORD *rgflnOut)
{
   if (!pszPath || !ppidl) {
      return E_INVALIDARG;
   }

   LPSHELLFOLDER psf;
   HRESULT hr = ::SHGetDesktopFolder(&psf);
   if (hr != NOERROR) {
      return hr;
   }

   ULONG chEaten;
   LPOLESTR lpszDisplayName = ::StrDupW(pszPath);
   hr = psf->ParseDisplayName(NULL, NULL, lpszDisplayName, &chEaten, ppidl, rgflnOut);
   ::LocalFree(lpszDisplayName);
   psf->Release();
   return hr;
}
Example #15
0
LPITEMIDLIST ConvertPathToLpItemIdList(const TCHAR* pszPath)
{
  LPITEMIDLIST  pidl = NULL;
  LPSHELLFOLDER pDesktopFolder;

  if (SUCCEEDED(SHGetDesktopFolder(&pDesktopFolder)))
  {
    OLECHAR       olePath[MAX_PATH];
    ULONG         chEaten;
    ULONG         dwAttributes;
    HRESULT       hr;

    _tcscpy_s(olePath, pszPath);
    hr = pDesktopFolder->ParseDisplayName(NULL, NULL, olePath, 
      &chEaten, &pidl, &dwAttributes);
    pDesktopFolder->Release();
  }

  return pidl;
}
Example #16
0
//***************************************************************************************
HRESULT CBCGPShellList::DisplayParentFolder ()
{
	ASSERT_VALID (g_pShellManager);

	HRESULT hr = E_FAIL;
	if (m_pidlCurFQ == NULL)
	{
		return hr;
	}

	BCGCBITEMINFO info;
	int nLevel = g_pShellManager->GetParentItem (m_pidlCurFQ, info.pidlFQ);

	if (nLevel < 0)
	{
		return hr;
	}

	if (nLevel == 0)	// Desktop
	{
		hr = DisplayFolder (&info);
	}
	else
	{
		LPSHELLFOLDER pDesktopFolder;
		hr = SHGetDesktopFolder(&pDesktopFolder);

		if (SUCCEEDED (hr))
		{
			info.pParentFolder = pDesktopFolder;
			info.pidlRel = info.pidlFQ;

			hr = DisplayFolder (&info);
			pDesktopFolder->Release();
		}
	}

	g_pShellManager->FreeItem (info.pidlFQ);
	return hr;
}
void CBrowseForFolder::GetPidl(CString name, LPITEMIDLIST pidl)
{
	LPSHELLFOLDER pshf;
	ULONG chEaten;
	
#ifdef _UNICODE
	OLECHAR* oleRoot = name.GetBuffer(name.GetLength());
#else
	OLECHAR oleRoot[MAX_PATH];
	// convert path to Unicode string
	MultiByteToWideChar(CP_ACP, MB_PRECOMPOSED, name, -1,
		oleRoot, MAX_PATH);
#endif	
	if (SUCCEEDED(SHGetDesktopFolder(&pshf)))
	{
		// get pidl
		pshf->ParseDisplayName(hWndOwner, NULL, oleRoot, &chEaten, 
			&pidl, NULL);
	}
	else return;
	pshf->Release();
}
Example #18
0
BOOL BrowseForFolder(HWND hWnd, CString& strTitle, CString& strResult, BOOL bIncludeFiles, _tBrowseCallbackProc pCallback)
{
	BOOL bRet = FALSE;
    WCHAR szFolder[MAX_PATH * 2];
	
	ZeroMemory(szFolder, sizeof(szFolder));
	
    BROWSEINFO info;
    LPSHELLFOLDER shell;
    LPITEMIDLIST FolderID;
	
    SHGetDesktopFolder(&shell);
	
    info.hwndOwner = hWnd;
    info.pidlRoot = NULL;
    info.pszDisplayName = szFolder;
    info.lpszTitle = strTitle.GetBuffer(MAX_PATH);
    info.ulFlags = BIF_NEWDIALOGSTYLE;
	if (bIncludeFiles)
		info.ulFlags |= BIF_BROWSEINCLUDEFILES | BIF_NONEWFOLDERBUTTON;
    info.lpfn = pCallback;
	
    FolderID = SHBrowseForFolder(&info);
	
	if(FolderID != NULL)
	{
		if(SHGetPathFromIDList(FolderID, szFolder))
		{
			strResult= szFolder;
			bRet = TRUE;
		}
	}
	
    shell->Release();

	strTitle.ReleaseBuffer();
	
	return bRet;
}
Example #19
0
// first called when the mouse enters our target window space
STDMETHODIMP CDropTarget::DragEnter(LPDATAOBJECT pDataObject, DWORD grfKeyState, POINTL pt, LPDWORD pdwEffect)
{
    // don't set "*pdwEffect = DROPEFFECT_NONE"; that would adversely affect the drop target
    BOOL ok = FALSE;
    AddRef();
    if (m_pidl)
    {
        LPSHELLFOLDER psfFolder;
        LPITEMIDLIST pidlItem;
        LPITEMIDLIST pidlFull;
        if (sh_get_uiobject(m_pidl, &pidlFull, &pidlItem, &psfFolder, IID_IDropTarget, (void**)&m_pDropTarget))
        {
            HRESULT hr = m_pDropTarget->DragEnter(pDataObject, grfKeyState, pt, pdwEffect);
            if(SUCCEEDED(hr)) ok = TRUE;
        }
        if (psfFolder) psfFolder->Release();
        freeIDList(pidlItem);
        freeIDList(pidlFull);
    }
    if(FALSE == ok) *pdwEffect = DROPEFFECT_NONE; // we can't understand this thing
    m_pDataObject = pDataObject;
    return S_OK;
}
Example #20
0
LPITEMIDLIST getAbsolutePidlFromAbsFilePath(LPWSTR path)
{
	LPITEMIDLIST pidl = NULL;
	LPITEMIDLIST pidlAbsolute = NULL;

	// namespace extension root (desktop) for parsing path
	LPSHELLFOLDER psfDesktop = NULL;
	if (FAILED(SHGetDesktopFolder(&psfDesktop)))
		return pidl;

	// parse path for absolute PIDL
	if (FAILED(psfDesktop->ParseDisplayName(NULL, NULL, path, NULL, &pidl, NULL)))
		return pidl;

	// get the absolute pidl, do not need to free pidlTemp
	pidlAbsolute = ILClone(pidl);

	// cleanup
	CoTaskMemFree(pidl);
	psfDesktop->Release();

	return pidlAbsolute;
}
Example #21
0
// Get long path name from short path name.
// assumes that LongPath has enough characters to hold the generated name
static bool ShortPathToLongPath (const char *ShortPath, char *LongPath)
{
// Man, this is a seriously disturbed function.
// Win32 could use a GetLongFileName function (NT 5 has one...)
	LPSHELLFOLDER psfDesktop = NULL;

	WCHAR szShortPathNameW[MAX_PATH];

	// convert path name to wide and copy to local storage
	ULONG chEaten = 0;
	LPITEMIDLIST pidlShellItem = NULL;

	mbstowcs (szShortPathNameW, ShortPath, MAX_PATH);

	// Get desktop's shell folder interface
	HRESULT hr = SHGetDesktopFolder (&psfDesktop);

	// request an ID list (relative to the desktop) for the short pathname
	hr = psfDesktop->ParseDisplayName (NULL, NULL, szShortPathNameW, &chEaten, &pidlShellItem, NULL);
	psfDesktop->Release ();		// release desktop's IShellFolder

	if (FAILED (hr))
	{
		return false;
	}

	// got an ID list.  Convert it to a long pathname
	SHGetPathFromIDListA (pidlShellItem, LongPath);

	// Free the ID list allocated by ParseDisplayName
	LPMALLOC pMalloc = NULL;
	SHGetMalloc (&pMalloc);
	pMalloc->Free (pidlShellItem);
	pMalloc->Release ();

	return true;
}
Example #22
0
//初始化浏览器控件(nID为资源文件中树型控件的id)
BOOL Init_Browser(HWND hWnd,UINT nID)
{
	HIMAGELIST hImageList;
   LPSHELLFOLDER lpsf = 0 ;
   SHFILEINFO    sfi;
	HRESULT hr ;
	BOOL bOK;

	memset(szFoldername,0,MAX_PATH);
   hTreeWnd=GetDlgItem(hWnd,nID);

   hImageList = (HIMAGELIST)SHGetFileInfo((LPCSTR)"C:\\",
                                           0,
                                           &sfi,
                                           sizeof(SHFILEINFO),
                                           SHGFI_SYSICONINDEX | SHGFI_SMALLICON) ;

  	if(hImageList)
   	TreeView_SetImageList(hTreeWnd,hImageList,0);

	hr=SHGetDesktopFolder(&lpsf) ;

	if( SUCCEEDED(hr))
	{
	   TreeView_DeleteAllItems(hTreeWnd);
	   FillTreeView(hTreeWnd,lpsf,NULL,TVI_ROOT) ;
      ExpandTree();
      TreeView_SelectItem(hTreeWnd,TreeView_GetRoot(hTreeWnd));//,TVGN_FIRSTVISIBLE);
      bOK = TRUE;
	}
   else
   	bOK = FALSE;

	if(lpsf)
		lpsf->Release();
	return bOK;
}
/* #FN#
   Populates the tree view control with file list */
void
/* #AS#
   Nothing */
CShellTree::
PopulateTree()
{
	LPSHELLFOLDER lpsf = NULL;
	LPITEMIDLIST  lpi  = NULL;
	HRESULT hr;

	/* Get a pointer to the desktop folder */
	hr = SHGetDesktopFolder( &lpsf );

	if( SUCCEEDED(hr) )
	{
		/* Initialize the tree view to be empty */
		DeleteAllItems();

		/* Fill in the tree view from the root */
		FillTreeView( lpsf, NULL, TVI_ROOT );
		/* Release the folder pointer */
		lpsf->Release();
	}
	TV_SORTCB tvscb;
	tvscb.hParent     = TVI_ROOT;
	tvscb.lParam      = 0;
	tvscb.lpfnCompare = TreeViewCompareProc;

	/* Sort the items in the tree view */
	SortChildrenCB( &tvscb /*, FALSE*/ );

	HTREEITEM hItem = GetRootItem();
	Expand( hItem, TVE_EXPAND );
	Select( GetRootItem(), TVGN_CARET );

} /* #OF# CShellTree::PopulateTree */
int CDirectoryDlg::DoModal()
{
    LPMALLOC        pMalloc;
    BROWSEINFO      bi;
    LPITEMIDLIST    pidl;
    LPSHELLFOLDER   pDesktopFolder;
    TCHAR           szInitialPath[MAX_PATH];
    OLECHAR         oleInitialPath[MAX_PATH];
    ULONG           chEaten;
    ULONG           dwAttributes;
    HRESULT         hr;
    CFileStatus     FileStatus;

    lstrcpy(szInitialPath, m_strInitialDir);

    /*  IMPORTANT NOTE: Do not forget that the path may not be existent,
        SHBrowseForFolder reacts very vexing to this fact. So assure that the
        path is valid and exists.
    */

    
    if(!CFile::GetStatus(m_strInitialDir, FileStatus)) 
    {
        ::GetCurrentDirectory(MAX_PATH, m_strInitialDir.GetBuffer(MAX_PATH+1));
        m_strInitialDir.ReleaseBuffer();
        lstrcpy(szInitialPath, m_strInitialDir);
    }
    

    //
    // Get a pointer to the Desktop's IShellFolder interface.
    //
    hr = SHGetDesktopFolder(&pDesktopFolder);

    if (FAILED(hr))
    {
        UTIL_DisplaySysError(hr, NULL, NULL);
        return IDABORT;
    }

    //
    // IShellFolder::ParseDisplayName requires the file name be in
    // Unicode.
    //
    MultiByteToWideChar(CP_ACP, MB_PRECOMPOSED, szInitialPath, -1,
                        oleInitialPath, MAX_PATH);

    //
    // Convert the path to an ITEMIDLIST.
    //
    hr = pDesktopFolder->ParseDisplayName(NULL,
                                          NULL,
                                          oleInitialPath,
                                          &chEaten,
                                          &pidl,
                                          &dwAttributes);

    //release the desktop folder object
    pDesktopFolder->Release();

    if (FAILED(hr))
    {
        UTIL_DisplaySysError(hr, NULL, NULL);
        return IDABORT;
    }

    //
    // pidl now contains a pointer to an ITEMIDLIST for .\readme.txt.
    // This ITEMIDLIST needs to be freed using the IMalloc allocator
    // returned from SHGetMalloc().
    //
    hr = SHGetMalloc(&pMalloc);

    if(FAILED(hr)) 
    {
        UTIL_DisplaySysError(hr, NULL, NULL);
        return IDABORT;
    }

    HWND    hWndTop;
    HWND    hWndOwner = CWnd::GetSafeOwner_(NULL, &hWndTop);

    ZeroMemory(&bi,sizeof(bi));
    bi.hwndOwner = hWndOwner;
    bi.pidlRoot = NULL;
    bi.pszDisplayName = NULL;
    bi.lpszTitle = "";
    bi.ulFlags = BIF_RETURNONLYFSDIRS | BIF_VALIDATE;
    bi.lpfn = BrowsePathCallbackProc;
    bi.lParam = (LPARAM)szInitialPath;

    pidl = SHBrowseForFolder(&bi);

	if (hWndTop != NULL)
    {
        EnableWindow(hWndTop, TRUE);
    }

    if (pidl)
    {
        SHGetPathFromIDList(pidl, szInitialPath);
        pMalloc->Free(pidl);
        pMalloc->Release();
        m_strDirectory = szInitialPath;
    }
    if(m_strDirectory.IsEmpty())
    {
        return IDCANCEL;
    }
    return IDOK;
}
Example #25
0
LRESULT WINAPI WMCommandProc(HWND hWnd, UINT id, HWND hwndCtl, UINT codeNotify) {
  int nIdx = FindControlIdx(id);
  // Ignore if the dialog is in the process of being created
  if (g_done || nIdx < 0)
    return 0;

  switch (pFields[nIdx].nType)
  {
    case FIELD_BROWSEBUTTON:
      --nIdx;
    case FIELD_LINK:
    case FIELD_BUTTON:
    case FIELD_CHECKBOX:
    case FIELD_RADIOBUTTON:
      if (codeNotify != BN_CLICKED)
        return 0;
      break;
    case FIELD_COMBOBOX:
    case FIELD_LISTBOX:
      if (codeNotify != LBN_SELCHANGE) // LBN_SELCHANGE == CBN_SELCHANGE
        return 0;
      break;
    default:
      return 0;
  }

  FieldType *pField = pFields + nIdx;

  char szBrowsePath[MAX_PATH];

  switch (pField->nType) {
    case FIELD_FILEREQUEST: {
      OPENFILENAME ofn={0,};

      ofn.lStructSize = sizeof(ofn);
      ofn.hwndOwner = hConfigWindow;
      ofn.lpstrFilter = pField->pszFilter;
      ofn.lpstrFile = szBrowsePath;
      ofn.nMaxFile  = sizeof(szBrowsePath);
      ofn.Flags = pField->nFlags & (OFN_OVERWRITEPROMPT | OFN_HIDEREADONLY | OFN_PATHMUSTEXIST | OFN_FILEMUSTEXIST | OFN_CREATEPROMPT | OFN_EXPLORER);

      GetWindowText(pField->hwnd, szBrowsePath, sizeof(szBrowsePath));

    tryagain:
      GetCurrentDirectory(BUFFER_SIZE, szResult); // save working dir
      if ((pField->nFlags & FLAG_SAVEAS) ? GetSaveFileName(&ofn) : GetOpenFileName(&ofn)) {
        mySetWindowText(pField->hwnd, szBrowsePath);
        SetCurrentDirectory(szResult); // restore working dir
                                       // OFN_NOCHANGEDIR doesn't always work (see MSDN)
        break;
      }
      else if (szBrowsePath[0] && CommDlgExtendedError() == FNERR_INVALIDFILENAME) {
        szBrowsePath[0] = '\0';
        goto tryagain;
      }

      break;
    }

    case FIELD_DIRREQUEST: {
      BROWSEINFO bi;

      bi.hwndOwner = hConfigWindow;
      bi.pidlRoot = NULL;
      bi.pszDisplayName = szBrowsePath;
      bi.lpszTitle = pField->pszText;
#ifndef BIF_NEWDIALOGSTYLE
#define BIF_NEWDIALOGSTYLE 0x0040
#endif
      bi.ulFlags = BIF_STATUSTEXT | BIF_RETURNONLYFSDIRS | BIF_NEWDIALOGSTYLE;
      bi.lpfn = BrowseCallbackProc;
      bi.lParam = nIdx;
      bi.iImage = 0;

      if (pField->pszRoot) {
        LPSHELLFOLDER sf;
        ULONG eaten;
        LPITEMIDLIST root;
        int ccRoot = (lstrlen(pField->pszRoot) * 2) + 2;
        LPWSTR pwszRoot = (LPWSTR) MALLOC(ccRoot);
        MultiByteToWideChar(CP_ACP, 0, pField->pszRoot, -1, pwszRoot, ccRoot);
        SHGetDesktopFolder(&sf);
        sf->ParseDisplayName(hConfigWindow, NULL, pwszRoot, &eaten, &root, NULL);
        bi.pidlRoot = root;
        sf->Release();
        FREE(pwszRoot);
      }
      //CoInitializeEx(NULL, COINIT_APARTMENTTHREADED);
      LPITEMIDLIST pResult = SHBrowseForFolder(&bi);
      if (!pResult)
        break;

      if (SHGetPathFromIDList(pResult, szBrowsePath)) {
        mySetWindowText(pField->hwnd, szBrowsePath);
      }

      CoTaskMemFree(pResult);

      break;
    }

    case FIELD_LINK:
    case FIELD_BUTTON:
      // Allow the state to be empty - this might be useful in conjunction
      // with the NOTIFY flag
      if (*pField->pszState)
        ShellExecute(hMainWindow, NULL, pField->pszState, NULL, NULL, SW_SHOWDEFAULT);
      break;
  }

  if (pField->nFlags & LBS_NOTIFY) {
    // Remember which control was activated then pretend the user clicked Next
    g_NotifyField = nIdx + 1;
    mySendMessage(hMainWindow, WM_NOTIFY_OUTER_NEXT, 1, 0);
  }

  return 0;
}
Example #26
0
LPITEMIDLIST GetCurrentFolder()
{
/*
	How To Convert a File Path to an ITEMIDLIST
	http://support.microsoft.com/default.aspx?scid=kb;en-us;132750
*/
	LPITEMIDLIST   pidl;
	LPSHELLFOLDER  pDesktopFolder;
	TCHAR          szPath[ MAX_PATH ];
#ifndef PA_UNICODE
	OLECHAR        olePath[ MAX_PATH ];
#endif
	ULONG          chEaten;
	ULONG          dwAttributes;
	HRESULT        hr;

	//
	// Get the path we need to convert.
	//
	GetCurrentDirectory( MAX_PATH, szPath );

	//
	// Get a pointer to the Desktop's IShellFolder interface.
	//
	if( SUCCEEDED( SHGetDesktopFolder( &pDesktopFolder ) ) )
	{

		//
		// IShellFolder::ParseDisplayName requires the file name be in
		// Unicode.
		//
#ifndef	PA_UNICODE	
		MultiByteToWideChar( CP_ACP, MB_PRECOMPOSED, szPath, -1, olePath, MAX_PATH );
#endif
		//
		// Convert the path to an ITEMIDLIST.
		//
		// hr = pDesktopFolder->lpVtbl->ParseDisplayName(
		hr = pDesktopFolder->ParseDisplayName(
			( HWND__ * )pDesktopFolder,
			NULL,
#ifndef PA_UNICODE			
			olePath,
#else
			szPath,
#endif			
			&chEaten,
			&pidl,
			&dwAttributes
		);
	
		if( FAILED( hr ) )
		{
			// Handle error.
			return NULL;
		}
	
		//
		// pidl now contains a pointer to an ITEMIDLIST for .\readme.txt.
		// This ITEMIDLIST needs to be freed using the IMalloc allocator
		// returned from SHGetMalloc().
		//
	
		// release the desktop folder object
		// pDesktopFolder->lpVtbl->Release();
		pDesktopFolder->Release();

		return pidl;
	}
	else
	{
		return NULL;
	}
}
LPSHELLFOLDER COXShellNamespaceNavigator::GetShellFolder(LPCITEMIDLIST pidlFull) const
{
	// First of all get the Desktop's IShellFolder interface. 
	LPSHELLFOLDER lpDesktopFolder;
    if(FAILED(SHGetDesktopFolder(&lpDesktopFolder)))
		return NULL;

	// If pidlFull is NULL then just return the Desktop's IShellFolder
	if(pidlFull==NULL)
	{
		ASSERT(lpDesktopFolder!=NULL);
		if(lpDesktopFolder!=NULL)
			m_mapIShellFolderToRelease.SetAt((DWORD_PTR)lpDesktopFolder,NULL);
		return lpDesktopFolder;
	}

	// If we have valid IDL we should retrieve its IShellFolder interface. We accomplish it 
	// using IShellFolder::BindToObject
	//
/*
HRESULT BindToObject(
    LPCITEMIDLIST pidl,
    LPBC pbcReserved,
    REFIID riid,
    LPVOID *ppvOut
   );	

Retrieves an IShellFolder object for a subfolder. 

Returns NOERROR if successful, or an OLE-defined error value otherwise. 

pidl		-	Address of an ITEMIDLIST structure that identifies the subfolder 
				relative to its parent folder. 
pbcReserved -	Reserved. Callers should specify NULL for this parameter; those 
				called should ignore it. 
riid		-	Identifier of the interface to return. This parameter must point to 
				the IID_IShellFolder interface identifier. 
ppvOut		-	Address that receives the interface pointer. If an error occurs, 
				a NULL pointer is returned in this address. 
*/
	// 
	// Note that pidl have to be relative to its parent folder but as long as we are
	// going to call this method of desktop folder interface then the fully qualified
	// pidl we got using ParseDisplayName method can be used.
	//

	LPSHELLFOLDER lpFolder;
	HRESULT hResult=lpDesktopFolder->
		BindToObject(pidlFull,0,IID_IShellFolder,(LPVOID*)&lpFolder);

	if(FAILED(hResult))
	{
		ASSERT(lpDesktopFolder!=NULL);
		if(lpDesktopFolder!=NULL)
			m_mapIShellFolderToRelease.SetAt((DWORD_PTR)lpDesktopFolder,NULL);
		return lpDesktopFolder;
	}
	else
	{
		// release desktop folder
		lpDesktopFolder->Release();

		ASSERT(lpFolder!=NULL);
		if(lpFolder!=NULL)
			m_mapIShellFolderToRelease.SetAt((DWORD_PTR)lpFolder,NULL);
		return lpFolder;
	}
}
Example #28
0
/*!	独自拡張プロパティシートのウィンドウプロシージャ
	@author ryoji
	@date 2007.05.25 新規
*/
static LRESULT CALLBACK PropSheetWndProc( HWND hwnd, UINT uMsg, WPARAM wParam, LPARAM lParam )
{
	switch( uMsg ){
	case WM_SHOWWINDOW:
		// 追加ボタンの位置を調整する
		if( wParam ){
			HWND hwndBtn;
			RECT rcOk;
			RECT rcTab;
			POINT pt;

			hwndBtn = ::GetDlgItem( hwnd, 0x02000 );
			::GetWindowRect( ::GetDlgItem( hwnd, IDOK ), &rcOk );
			::GetWindowRect( PropSheet_GetTabControl( hwnd ), &rcTab );
			pt.x = rcTab.left;
			pt.y = rcOk.top;
			::ScreenToClient( hwnd, &pt );
			::MoveWindow( hwndBtn, pt.x, pt.y, DpiScaleX(140), rcOk.bottom - rcOk.top, FALSE );
		}
		break;

	case WM_COMMAND:
		// 追加ボタンが押された時はその処理を行う
		if( HIWORD( wParam ) == BN_CLICKED && LOWORD( wParam ) == 0x02000 ){
			HWND hwndBtn = ::GetDlgItem( hwnd, 0x2000 );
			RECT rc;
			POINT pt;

			// メニューを表示する
			::GetWindowRect( hwndBtn, &rc );
			pt.x = rc.left;
			pt.y = rc.bottom;
			GetMonitorWorkRect( pt, &rc );	// モニタのワークエリア

			HMENU hMenu = ::CreatePopupMenu();
			::InsertMenu( hMenu, 0, MF_BYPOSITION | MF_STRING, 100, LS(STR_SHELL_MENU_OPEN) );
			::InsertMenu( hMenu, 1, MF_BYPOSITION | MF_STRING, 101, LS(STR_SHELL_MENU_IMPEXP) );

			int nId = ::TrackPopupMenu( hMenu, TPM_LEFTALIGN | TPM_TOPALIGN | TPM_LEFTBUTTON | TPM_RETURNCMD,
										( pt.x > rc.left )? pt.x: rc.left,
										( pt.y < rc.bottom )? pt.y: rc.bottom,
										0, hwnd, NULL );
			::DestroyMenu( hMenu );

			// 選択されたメニューの処理
			switch( nId ){
			case 100:	// 設定フォルダを開く
				TCHAR szPath[_MAX_PATH];
				GetInidir( szPath );

				// フォルダの ITEMIDLIST を取得して ShellExecuteEx() で開く
				// Note. MSDN の ShellExecute() の解説にある方法でフォルダを開こうとした場合、
				//       フォルダと同じ場所に <フォルダ名>.exe があるとうまく動かない。
				//       verbが"open"やNULLではexeのほうが実行され"explore"では失敗する
				//       (フォルダ名の末尾に'\\'を付加してもWindows 2000では付加しないのと同じ動作になってしまう)
				LPSHELLFOLDER pDesktopFolder;
				if( SUCCEEDED(::SHGetDesktopFolder(&pDesktopFolder)) ){
					LPMALLOC pMalloc;
					if( SUCCEEDED(::SHGetMalloc(&pMalloc)) ){
						LPITEMIDLIST pIDL;
						WCHAR pwszDisplayName[_MAX_PATH];
						_tcstowcs(pwszDisplayName, szPath, _countof(pwszDisplayName));
//#ifdef _UNICODE
//						pwszDisplayName = szPath;
//#else
//						WCHAR wszPath[_MAX_PATH];
//						::MultiByteToWideChar( CP_ACP, 0, szPath, -1, wszPath, _MAX_PATH );
//						pwszDisplayName = wszPath;
//#endif
						if( SUCCEEDED(pDesktopFolder->ParseDisplayName(NULL, NULL, pwszDisplayName, NULL, &pIDL, NULL)) ){
							SHELLEXECUTEINFO si;
							::ZeroMemory( &si, sizeof(si) );
							si.cbSize   = sizeof(si);
							si.fMask    = SEE_MASK_IDLIST;
							si.lpVerb   = _T("open");
							si.lpIDList = pIDL;
							si.nShow    = SW_SHOWNORMAL;
							::ShellExecuteEx( &si );	// フォルダを開く
							pMalloc->Free( (void*)pIDL );
						}
						pMalloc->Release();
					}
					pDesktopFolder->Release();
				}
				break;
			case 101:	// インポート/エクスポートの起点リセット(起点を設定フォルダにする)
				int nMsgResult = MYMESSAGEBOX(
					hwnd,
					MB_OKCANCEL | MB_ICONINFORMATION,
					GSTR_APPNAME,
					LS(STR_SHELL_IMPEXPDIR)
				);
				if( IDOK == nMsgResult )
				{
					DLLSHAREDATA *pShareData = &GetDllShareData();
					GetInidir( pShareData->m_sHistory.m_szIMPORTFOLDER );
					AddLastChar( pShareData->m_sHistory.m_szIMPORTFOLDER, _countof2(pShareData->m_sHistory.m_szIMPORTFOLDER), _T('\\') );
				}
				break;
			}
		}
		break;

	case WM_DESTROY:
		::SetWindowLongPtr( hwnd, GWLP_WNDPROC, (LONG_PTR)s_pOldPropSheetWndProc );
		break;
	}

	return ::CallWindowProc( s_pOldPropSheetWndProc, hwnd, uMsg, wParam, lParam );
}
Example #29
0
LRESULT WINAPI WMCommandProc(HWND hWnd, UINT id, HWND hwndCtl, UINT codeNotify) {
  switch (codeNotify) {
    case BN_CLICKED:    // The user pressed a button
    case LBN_SELCHANGE: // The user changed the selection in a ListBox control
//  case CBN_SELCHANGE: // The user changed the selection in a DropList control (same value as LBN_SELCHANGE)
    {
      char szBrowsePath[MAX_PATH];
      int nIdx = FindControlIdx(id);
      if (nIdx < 0)
        break;
      if (pFields[nIdx].nType == FIELD_BROWSEBUTTON)
        --nIdx;
      FieldType *pField = pFields + nIdx;
      switch (pField->nType) {
        case FIELD_FILEREQUEST: {
          OPENFILENAME ofn={0,};

          ofn.lStructSize = sizeof(ofn);
          ofn.hwndOwner = hConfigWindow;
          ofn.lpstrFilter = pField->pszFilter;
          ofn.lpstrFile = szBrowsePath;
          ofn.nMaxFile  = sizeof(szBrowsePath);
          ofn.Flags = pField->nFlags & (OFN_OVERWRITEPROMPT | OFN_HIDEREADONLY | OFN_PATHMUSTEXIST | OFN_FILEMUSTEXIST | OFN_CREATEPROMPT | OFN_EXPLORER);

          GetWindowText(pField->hwnd, szBrowsePath, sizeof(szBrowsePath));

        tryagain:
          if ((pField->nFlags & FLAG_SAVEAS) ? GetSaveFileName(&ofn) : GetOpenFileName(&ofn)) {
            mySetWindowText(pField->hwnd, szBrowsePath);
            break;
          }
          else if (szBrowsePath[0] && CommDlgExtendedError() == FNERR_INVALIDFILENAME) {
            szBrowsePath[0] = '\0';
            goto tryagain;
          }

          break;
        }

        case FIELD_DIRREQUEST: {
          BROWSEINFO bi;

          bi.hwndOwner = hConfigWindow;
          bi.pidlRoot = NULL;
          bi.pszDisplayName = szBrowsePath;
          bi.lpszTitle = pField->pszText;
#ifndef BIF_NEWDIALOGSTYLE
#define BIF_NEWDIALOGSTYLE 0x0040
#endif
          bi.ulFlags = BIF_STATUSTEXT | BIF_RETURNONLYFSDIRS | BIF_NEWDIALOGSTYLE;
          bi.lpfn = BrowseCallbackProc;
          bi.lParam = nIdx;
          bi.iImage = 0;

          if (pField->pszRoot) {
            LPSHELLFOLDER sf;
            ULONG eaten;
            LPITEMIDLIST root;
            int ccRoot = (lstrlen(pField->pszRoot) * 2) + 2;
            LPWSTR pwszRoot = (LPWSTR) MALLOC(ccRoot);
            MultiByteToWideChar(CP_ACP, 0, pField->pszRoot, -1, pwszRoot, ccRoot);
            SHGetDesktopFolder(&sf);
            sf->ParseDisplayName(hConfigWindow, NULL, pwszRoot, &eaten, &root, NULL);
            bi.pidlRoot = root;
            sf->Release();
            FREE(pwszRoot);
          }
//          CoInitializeEx(NULL, COINIT_APARTMENTTHREADED);
          LPITEMIDLIST pResult = SHBrowseForFolder(&bi);
          if (!pResult)
            break;

          if (SHGetPathFromIDList(pResult, szBrowsePath)) {
            mySetWindowText(pField->hwnd, szBrowsePath);
          }

          LPMALLOC pMalloc;
          if (!SHGetMalloc(&pMalloc)) {
            pMalloc->Free(pResult);
          }

          break;
        }

        case FIELD_LINK:
        case FIELD_BUTTON:
          // Allow the state to be empty - this might be useful in conjunction
          // with the NOTIFY flag
          if (*pField->pszState)
            ShellExecute(hMainWindow, NULL, pField->pszState, NULL, NULL, SW_SHOWDEFAULT);
          break;
      }

      if (pField->nFlags & LBS_NOTIFY) {
        // Remember which control was activated then pretend the user clicked Next
        g_NotifyField = nIdx + 1;
        // the next button must be enabled or nsis will ignore WM_COMMAND
        BOOL bWasDisabled = EnableWindow(hNextButton, TRUE);
        FORWARD_WM_COMMAND(hMainWindow, IDOK, hNextButton, BN_CLICKED, mySendMessage);
        if (bWasDisabled)
          EnableWindow(hNextButton, FALSE);
      }
    }
    break;
  }
  return 0;
}
Example #30
0
/**
 * Begin a saved search.
 */
JNIEXPORT jlong JNICALL WindowsSavedSearch_METHOD(beginSearch)
    ( JNIEnv *env, jclass, jstring jPath )
{
    jstring_to_c const cPath( env, jPath );

    SavedSearch*    cSavedSearch = NULL;
    bool            error = false;
    LPITEMIDLIST    pidl = NULL;
    LPSHELLFOLDER   pDesktop = NULL;
    HRESULT         result;

    if ( FAILED( ::CoInitialize( NULL ) ) )
        goto error;

    cSavedSearch = new SavedSearch;

    if ( FAILED( ::SHGetMalloc( &cSavedSearch->m_pMalloc ) ) )
        goto error;

    //
    // We have to start at the filesystem root (the "Desktop" in Windows).
    //
    if ( FAILED( ::SHGetDesktopFolder( &pDesktop ) ) )
        goto error;

    //
    // ParseDisplayName() wants UTF-16, so convert the path first.
    //
    WCHAR wPath[ MAX_PATH ];
    if ( !LC_toWCHAR( cPath, wPath, sizeof wPath ) )
        goto error;

    result = pDesktop->ParseDisplayName( NULL, NULL, wPath, NULL, &pidl, NULL );
    if ( FAILED( result ) )
        goto error;

    //
    // Binding the path of what we want relative to the Desktop gets us the
    // PIDL for the path of the saved search file.
    //
    result = pDesktop->BindToObject(
        pidl, NULL, IID_IShellFolder,
        reinterpret_cast<void**>( &cSavedSearch->m_pFolder )
    );
    if ( FAILED( result ) )
        goto error;

    //
    // We can now start the enumeration of the saved search file which runs the
    // search.
    //
    result = cSavedSearch->m_pFolder->EnumObjects(
        NULL, SHCONTF_FOLDERS | SHCONTF_NONFOLDERS, &cSavedSearch->m_pEnumIDList
    );
    if ( result == S_FALSE || FAILED( result ) )
        goto error;

    goto done;

error:
    error = true;
done:
    if ( pDesktop )
        pDesktop->Release();
    if ( cSavedSearch && cSavedSearch->m_pMalloc && pidl )
        cSavedSearch->m_pMalloc->Free( pidl );
    if ( error ) {
        delete cSavedSearch;
        return 0;
    }
    return reinterpret_cast<jlong>( cSavedSearch );
}