HRESULT SHPathToPIDL(LPCTSTR szPath, LPITEMIDLIST* ppidl)
{
LPSHELLFOLDER pShellFolder = NULL;
OLECHAR wszPath[MAX_PATH] = {0};
ULONG nCharsParsed = 0;
// Get an IShellFolder interface pointer
HRESULT hr = SHGetDesktopFolder(&pShellFolder);
if(FAILED(hr))
return hr;
// Convert the path name to Unicode
MultiByteToWideChar(CP_ACP, MB_PRECOMPOSED, szPath, -1, wszPath, MAX_PATH);
// Call ParseDisplayName() to do the job
hr = pShellFolder->lpVtbl->ParseDisplayName(pShellFolder,NULL, NULL, wszPath, &nCharsParsed, ppidl, NULL);
// Clean up
pShellFolder->lpVtbl->Release(pShellFolder);
return hr;
}
//获取指定目录的IShellFolder接口
IShellFolder *CFileSearch::GetIShellFolderByPath(LPTSTR path)
{
IShellFolder *m_ShellFolderTopMost=NULL;
HRESULT hr=SHGetDesktopFolder(&m_ShellFolderTopMost);
if(FAILED(hr))
{
return NULL;
}
IShellFolder *m_pFolder;
LPITEMIDLIST pidlWorkDir=NULL;
OLECHAR strOleFilePath[MAX_PATH];
MultiByteToWideChar( CP_ACP, MB_PRECOMPOSED, path, -1, strOleFilePath, MAX_PATH );
hr = m_ShellFolderTopMost->ParseDisplayName(NULL,NULL,strOleFilePath,NULL,&pidlWorkDir,NULL);
if(FAILED(hr))
{
return NULL;
}
hr=m_ShellFolderTopMost->BindToObject(pidlWorkDir,NULL,IID_IShellFolder,(LPVOID*)&m_pFolder);
if(m_ShellFolderTopMost)m_ShellFolderTopMost->Release();
return m_pFolder;
}
static void test_IOleWindow(void)
{
IShellFolder *desktop;
IShellView *view;
HRESULT hr;
hr = SHGetDesktopFolder(&desktop);
ok(hr == S_OK, "got (0x%08x)\n", hr);
hr = IShellFolder_CreateViewObject(desktop, NULL, &IID_IShellView, (void**)&view);
ok(hr == S_OK, "got (0x%08x)\n", hr);
/* IShellView::ContextSensitiveHelp */
hr = IShellView_ContextSensitiveHelp(view, TRUE);
ok(hr == E_NOTIMPL, "got (0x%08x)\n", hr);
hr = IShellView_ContextSensitiveHelp(view, FALSE);
ok(hr == E_NOTIMPL, "got (0x%08x)\n", hr);
IShellView_Release(view);
IShellFolder_Release(desktop);
}
Ztring OpenFolder_Show(void* Handle, const Ztring &Title, const Ztring &Caption)
{
//Caption
Directory_Select_Caption=Caption;
//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(BROWSEINFO));
BrowseInfo.ulFlags+=BIF_RETURNONLYFSDIRS;
BrowseInfo.hwndOwner=(HWND)Handle;
BrowseInfo.pszDisplayName=InitDirA;
BrowseInfo.lpszTitle=Title.c_str();
BrowseInfo.lpfn=ShowOpenFolder_CallbackProc;
//Displaying
ItemIdList=SHBrowseForFolder(&BrowseInfo);
//Releasing
ShellFolder->Release();
if (ItemIdList!=NULL)
{
SHGetPathFromIDList(ItemIdList, InitDirA);
Malloc->Free(ItemIdList);
Malloc->Release();
//The value
return InitDirA;
}
else
return Ztring();
}
//***************************************************************************************
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();
}
/* adapted from http://blogs.msdn.com/oldnewthing/archive/2004/09/20/231739.aspx */
IDataObject* GetDataObjectForFile(WCHAR* filePath, HWND hwnd)
{
ScopedComPtr<IShellFolder> pDesktopFolder;
HRESULT hr = SHGetDesktopFolder(&pDesktopFolder);
if (FAILED(hr))
return NULL;
IDataObject* pDataObject = NULL;
ScopedMem<WCHAR> lpWPath(str::Dup(filePath));
LPITEMIDLIST pidl;
hr = pDesktopFolder->ParseDisplayName(NULL, NULL, lpWPath, NULL, &pidl, NULL);
if (SUCCEEDED(hr)) {
ScopedComPtr<IShellFolder> pShellFolder;
LPCITEMIDLIST pidlChild;
hr = SHBindToParent(pidl, IID_IShellFolder, (void**)&pShellFolder, &pidlChild);
if (SUCCEEDED(hr))
pShellFolder->GetUIObjectOf(hwnd, 1, &pidlChild, IID_IDataObject, NULL, (void **)&pDataObject);
CoTaskMemFree(pidl);
}
return pDataObject;
}
LPITEMIDLIST ShellFunctions::GetIDListForParent(LPCWSTR lpszFileName)
{
int temp=LastCharIndex(lpszFileName,L'\\');
LPCWSTR szFolder;
if (temp==-1)
szFolder=alloccopy(lpszFileName);
else
szFolder=alloccopy(lpszFileName,temp+1);
LPITEMIDLIST pidl=NULL;
IShellFolder *pDesktop;
if (FAILED(SHGetDesktopFolder(&pDesktop)))
{
delete[] szFolder;
return NULL;
}
HRESULT hRes=pDesktop->ParseDisplayName(NULL,NULL,(LPOLESTR)szFolder,NULL,&pidl,NULL);
pDesktop->Release();
return FAILED(hRes)?NULL:pidl;
}
static void COMDLG32_UpdateCurrentDir(const FileOpenDlgInfos *fodInfos)
{
LPSHELLFOLDER psfDesktop;
STRRET strret;
HRESULT res;
res = SHGetDesktopFolder(&psfDesktop);
if (FAILED(res))
return;
res = IShellFolder_GetDisplayNameOf(psfDesktop, fodInfos->ShellInfos.pidlAbsCurrent,
SHGDN_FORPARSING, &strret);
if (SUCCEEDED(res)) {
WCHAR wszCurrentDir[MAX_PATH];
res = StrRetToBufW(&strret, fodInfos->ShellInfos.pidlAbsCurrent, wszCurrentDir, MAX_PATH);
if (SUCCEEDED(res))
SetCurrentDirectoryW(wszCurrentDir);
}
IShellFolder_Release(psfDesktop);
}
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;
}
/****************************************************************************
*
* FUNCTION: GetFullyQualPidl(LPSHELLFOLDER lpsf, LPITEMIDLIST lpi)
*
* PURPOSE: Gets the Fully qualified Pidls for the folder
*
****************************************************************************/
LPITEMIDLIST CShellPidl::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,
(USHORT *)szOleChar,
sizeof(szOleChar));
hr=lpsfDeskTop->ParseDisplayName(NULL,
NULL,
szOleChar,
&ulEaten,
&lpifq,
&ulAttribs);
lpsfDeskTop->Release();
if (FAILED(hr))
return NULL;
return lpifq;
}
/// <summary>
///
/// </summary>
void TileGroup::SetFolder(LPWSTR folder) {
PIDLIST_ABSOLUTE idList;
// Just in case we are switching folders, deregister for old notifications
if (mChangeNotifyUID != 0) {
SHChangeNotifyDeregister(mChangeNotifyUID);
mChangeNotifyUID = 0;
}
// Get the folder we are interested in
if (_wcsicmp(folder, L"desktop") == 0) {
SHGetKnownFolderIDList(FOLDERID_Desktop, 0, nullptr, &idList);
SHGetDesktopFolder(reinterpret_cast<IShellFolder**>(&mWorkingFolder));
} else {
mRootFolder->ParseDisplayName(nullptr, nullptr, folder, nullptr, &idList, nullptr);
mRootFolder->BindToObject(idList, nullptr, IID_IShellFolder, reinterpret_cast<LPVOID*>(&mWorkingFolder));
}
// Enumerate the contents of this folder
LoadFolderRequest request;
request.blackList = mHiddenItems;
request.folder = mWorkingFolder;
request.targetIconWidth = mTileSettings.mIconSize;
nCore::LoadFolder(request, this);
// Register for change notifications
SHChangeNotifyEntry watchEntries[] = { idList, FALSE };
mChangeNotifyUID = SHChangeNotifyRegister(
mWindow->GetWindowHandle(),
CHANGE_SOURCES,
CHANGE_EVENTS,
mChangeNotifyMsg,
1,
watchEntries);
// Let go fo the PIDLists
CoTaskMemFree(idList);
}
/*++
* @name FinalConstruct
*
* Creates an instance of CISFBand, and initializes its Shell Folder Band for enumeration.
*
* @return The error code.
*
*--*/
HRESULT CQuickLaunchBand::FinalConstruct()
{
HRESULT hr = RSHELL_CISFBand_CreateInstance(IID_PPV_ARG(IUnknown, &m_punkISFB));
if (FAILED_UNEXPECTEDLY(hr))
return hr;
CComPtr<IShellFolderBand> pISFB;
hr = m_punkISFB->QueryInterface(IID_PPV_ARG(IShellFolderBand, &pISFB));
if (FAILED_UNEXPECTEDLY(hr))
return hr;
CComPtr<IShellFolder> pISF;
hr = SHGetDesktopFolder(&pISF);
if (FAILED_UNEXPECTEDLY(hr))
return hr;
CComHeapPtr<ITEMIDLIST> pidl(PidlBrowse(m_hWndBro, CSIDL_DESKTOP));
if (pidl == NULL)
return E_FAIL;
pISFB->InitializeSFB(pISF, pidl);
return hr;
}
CString GetSpeacialFolderLocation(int csidl)
{
IShellFolder *desktop;
LPITEMIDLIST pidl;
STRRET strRet;
if(FAILED(SHGetDesktopFolder(&desktop)))
{
return L"";
}
if(FAILED(SHGetSpecialFolderLocation(NULL, csidl, &pidl)))
{
return L"";
}
if(FAILED(desktop->GetDisplayNameOf(pidl, SHGDN_FORPARSING, &strRet)))
{
return L"";
}
if(pidl)
{
ILFree(pidl);
}
return strRet.pOleStr;
}
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;
}
static HRESULT ShellItem_get_shellfolder(ShellItem *This, IBindCtx *pbc, IShellFolder **ppsf)
{
IShellFolder *desktop;
HRESULT ret;
ret = SHGetDesktopFolder(&desktop);
if (SUCCEEDED(ret))
{
if (_ILIsDesktop(This->pidl))
{
*ppsf = desktop;
IShellFolder_AddRef(*ppsf);
}
else
{
ret = IShellFolder_BindToObject(desktop, This->pidl, pbc, &IID_IShellFolder, (void**)ppsf);
}
IShellFolder_Release(desktop);
}
return ret;
}
IShellFolder* sh_get_folder_interface(LPCITEMIDLIST pIDFolder)
{
IShellFolder* pShellFolder = NULL;
IShellFolder* pThisFolder = NULL;
HRESULT hr;
hr = SHGetDesktopFolder(&pShellFolder);
if (NOERROR != hr)
return NULL;
if (NextID(pIDFolder) == pIDFolder)
return pShellFolder;
hr = pShellFolder->BindToObject(
pIDFolder, NULL, IID_IShellFolder, (LPVOID*)&pThisFolder);
pShellFolder->Release();
if (NOERROR != hr)
return NULL;
return pThisFolder;
}
BOOL GetThumbNail(HDC hDC, LPCTSTR lpszFilePath,LPCTSTR lpszSavepath)
{
bool bFileExit = PathFileExists(lpszSavepath);
if(bFileExit)
return TRUE;
IShellFolder * pShellFolder = NULL;
if( SHGetDesktopFolder( &pShellFolder) == S_OK )
{
LPITEMIDLIST pidl = NULL;
HRESULT hRes = pShellFolder->ParseDisplayName( NULL, NULL, (LPTSTR)(LPCTSTR)lpszFilePath, NULL, &pidl, NULL);
if( hRes == S_OK )
{
LPCITEMIDLIST pidlLast = NULL;
IShellFolder * pParentFolder = NULL;
HRESULT hRes = SHBindToParent( pidl, IID_IShellFolder, (void**)&pParentFolder, &pidlLast );
if( hRes == S_OK )
{
HBITMAP hBmpImage = ExtractThumb(pParentFolder, pidlLast );
if( hBmpImage )
{
SaveImage(hDC,hBmpImage,lpszSavepath);
//HBITMAP hbmpOld = hBmpImage;
//if( hbmpOld )
// DeleteObject(hbmpOld);
}
else
return false;
pParentFolder->Release();
}
}
pShellFolder->Release();
return true;
}
return false;
}
//初始化浏览器控件（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;
}
// 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;
}
static void test_GetItemObject(void)
{
IShellFolder *desktop;
IShellView *view;
IUnknown *unk;
HRESULT hr;
hr = SHGetDesktopFolder(&desktop);
ok(hr == S_OK, "got (0x%08x)\n", hr);
hr = IShellFolder_CreateViewObject(desktop, NULL, &IID_IShellView, (void**)&view);
ok(hr == S_OK, "got (0x%08x)\n", hr);
/* from documentation three interfaces are supported for SVGIO_BACKGROUND:
IContextMenu, IDispatch, IPersistHistory */
hr = IShellView_GetItemObject(view, SVGIO_BACKGROUND, &IID_IContextMenu, (void**)&unk);
ok(hr == S_OK, "got (0x%08x)\n", hr);
IUnknown_Release(unk);
unk = NULL;
hr = IShellView_GetItemObject(view, SVGIO_BACKGROUND, &IID_IDispatch, (void**)&unk);
todo_wine ok(hr == S_OK || broken(hr == E_NOTIMPL) /* NT4 */, "got (0x%08x)\n", hr);
if (unk) IUnknown_Release(unk);
unk = NULL;
hr = IShellView_GetItemObject(view, SVGIO_BACKGROUND, &IID_IPersistHistory, (void**)&unk);
todo_wine ok(hr == S_OK || broken(hr == E_NOTIMPL) /* W9x, NT4 */, "got (0x%08x)\n", hr);
if (unk) IUnknown_Release(unk);
/* example of unsupported interface, base for IPersistHistory */
hr = IShellView_GetItemObject(view, SVGIO_BACKGROUND, &IID_IPersist, (void**)&unk);
ok(hr == E_NOINTERFACE || broken(hr == E_NOTIMPL) /* W2K */, "got (0x%08x)\n", hr);
IShellView_Release(view);
IShellFolder_Release(desktop);
}
/* #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 */
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;
}
BOOL CDirDialog::DoBrowse(CWnd *pwndParent/*=NULL*/)
{
if( ! m_strSelDir.IsEmpty() )
{
m_strSelDir.TrimRight();
if( m_strSelDir.Right(1) == "\\" || m_strSelDir.Right(1) == "//" )
m_strSelDir = m_strSelDir.Left(m_strSelDir.GetLength() - 1);
}
LPMALLOC pMalloc;
if (SHGetMalloc (&pMalloc)!= NOERROR)
return FALSE;
BROWSEINFO bInfo;
LPITEMIDLIST pidl;
ZeroMemory ( (PVOID) &bInfo,sizeof (BROWSEINFO));
if (!m_strInitDir.IsEmpty ())
{
OLECHAR olePath[MAX_PATH];
ULONG chEaten;
ULONG dwAttributes;
HRESULT hr;
LPSHELLFOLDER pDesktopFolder;
//
// Get a pointer to the Desktop's IShellFolder interface.
//
if (SUCCEEDED(SHGetDesktopFolder(&pDesktopFolder)))
{
//
// IShellFolder::ParseDisplayName requires the file name be in Unicode.
//
MultiByteToWideChar(CP_ACP, MB_PRECOMPOSED, m_strInitDir.GetBuffer(MAX_PATH), -1,
olePath, MAX_PATH);
m_strInitDir.ReleaseBuffer (-1);
//
// Convert the path to an ITEMIDLIST.
//
hr = pDesktopFolder->ParseDisplayName(NULL,
NULL,
olePath,
&chEaten,
&pidl,
&dwAttributes);
if (FAILED(hr))
{
pMalloc ->Free (pidl);
pMalloc ->Release ();
return FALSE;
}
bInfo.pidlRoot = pidl;
}
}
bInfo.hwndOwner = pwndParent == NULL ? NULL : pwndParent->GetSafeHwnd();
bInfo.pszDisplayName = m_strPath.GetBuffer (MAX_PATH);
bInfo.lpszTitle = m_strWindowTitle;
bInfo.ulFlags = BIF_RETURNFSANCESTORS
| BIF_RETURNONLYFSDIRS
| (FALSE/*m_bStatus*/ ? BIF_STATUSTEXT : 0);
bInfo.lpfn = BrowseCtrlCallback; // address of callback function
bInfo.lParam = (LPARAM)this; // pass address of object to callback function
if ((pidl = ::SHBrowseForFolder(&bInfo)) == NULL)
{
return FALSE;
}
m_strPath.ReleaseBuffer();
m_iImageIndex = bInfo.iImage;
if (::SHGetPathFromIDList(pidl, m_strPath.GetBuffer(MAX_PATH)) == FALSE)
{
pMalloc ->Free(pidl);
pMalloc ->Release();
return FALSE;
}
m_strPath.ReleaseBuffer();
pMalloc ->Free(pidl);
pMalloc ->Release();
return TRUE;
}
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;
}
CShareOverlay::CShareOverlay( void )
{
SHGetDesktopFolder(&m_pDesktop);
}
/**************************************************************************
* IExtractIconW::GetIconLocation
*
* mapping filetype to icon
*/
static HRESULT WINAPI IExtractIconW_fnGetIconLocation(IExtractIconW * iface, UINT uFlags,
LPWSTR szIconFile, UINT cchMax, int * piIndex, UINT * pwFlags)
{
IExtractIconWImpl *This = impl_from_IExtractIconW(iface);
char sTemp[MAX_PATH];
int icon_idx;
GUID const * riid;
LPITEMIDLIST pSimplePidl = ILFindLastID(This->pidl);
TRACE("(%p) (flags=%u %p %u %p %p)\n", This, uFlags, szIconFile, cchMax, piIndex, pwFlags);
if (pwFlags)
*pwFlags = 0;
if (_ILIsDesktop(pSimplePidl))
{
lstrcpynW(szIconFile, swShell32Name, cchMax);
*piIndex = -IDI_SHELL_DESKTOP;
}
/* my computer and other shell extensions */
else if ((riid = _ILGetGUIDPointer(pSimplePidl)))
{
static const WCHAR fmt[] = { 'C','L','S','I','D','\\',
'{','%','0','8','l','x','-','%','0','4','x','-','%','0','4','x','-',
'%','0','2','x','%','0','2','x','-','%','0','2','x', '%','0','2','x',
'%','0','2','x','%','0','2','x','%','0','2','x','%','0','2','x','}',0 };
WCHAR xriid[50];
sprintfW(xriid, fmt,
riid->Data1, riid->Data2, riid->Data3,
riid->Data4[0], riid->Data4[1], riid->Data4[2], riid->Data4[3],
riid->Data4[4], riid->Data4[5], riid->Data4[6], riid->Data4[7]);
if (HCR_GetDefaultIconW(xriid, szIconFile, cchMax, &icon_idx))
{
*piIndex = icon_idx;
}
else
{
lstrcpynW(szIconFile, swShell32Name, cchMax);
if(IsEqualGUID(riid, &CLSID_MyComputer))
*piIndex = -IDI_SHELL_MY_COMPUTER;
else if(IsEqualGUID(riid, &CLSID_MyDocuments))
*piIndex = -IDI_SHELL_MY_DOCUMENTS;
else if(IsEqualGUID(riid, &CLSID_NetworkPlaces))
*piIndex = -IDI_SHELL_MY_NETWORK_PLACES;
else if(IsEqualGUID(riid, &CLSID_UnixFolder) ||
IsEqualGUID(riid, &CLSID_UnixDosFolder))
*piIndex = -IDI_SHELL_DRIVE;
else
*piIndex = -IDI_SHELL_FOLDER;
}
}
else if (_ILIsDrive (pSimplePidl))
{
static const WCHAR drive[] = { 'D','r','i','v','e',0 };
int icon_idx = -1;
if (_ILGetDrive(pSimplePidl, sTemp, MAX_PATH))
{
switch(GetDriveTypeA(sTemp))
{
case DRIVE_REMOVABLE: icon_idx = IDI_SHELL_FLOPPY; break;
case DRIVE_CDROM: icon_idx = IDI_SHELL_CDROM; break;
case DRIVE_REMOTE: icon_idx = IDI_SHELL_NETDRIVE; break;
case DRIVE_RAMDISK: icon_idx = IDI_SHELL_RAMDISK; break;
}
}
if (icon_idx != -1)
{
lstrcpynW(szIconFile, swShell32Name, cchMax);
*piIndex = -icon_idx;
}
else
{
if (HCR_GetDefaultIconW(drive, szIconFile, cchMax, &icon_idx))
{
*piIndex = icon_idx;
}
else
{
lstrcpynW(szIconFile, swShell32Name, cchMax);
*piIndex = -IDI_SHELL_DRIVE;
}
}
}
else if (_ILIsFolder (pSimplePidl))
{
getIconLocationForFolder(This, uFlags, szIconFile, cchMax, piIndex, pwFlags);
}
else
{
BOOL found = FALSE;
if (_ILIsCPanelStruct(pSimplePidl))
{
if (SUCCEEDED(CPanel_GetIconLocationW(pSimplePidl, szIconFile, cchMax, piIndex)))
found = TRUE;
}
else if (_ILGetExtension(pSimplePidl, sTemp, MAX_PATH))
{
if (HCR_MapTypeToValueA(sTemp, sTemp, MAX_PATH, TRUE)
&& HCR_GetDefaultIconA(sTemp, sTemp, MAX_PATH, &icon_idx))
{
if (!lstrcmpA("%1", sTemp)) /* icon is in the file */
{
SHGetPathFromIDListW(This->pidl, szIconFile);
*piIndex = 0;
}
else
{
MultiByteToWideChar(CP_ACP, 0, sTemp, -1, szIconFile, cchMax);
*piIndex = icon_idx;
}
found = TRUE;
}
else if (!lstrcmpiA(sTemp, "lnkfile"))
{
/* extract icon from shell shortcut */
IShellFolder* dsf;
IShellLinkW* psl;
if (SUCCEEDED(SHGetDesktopFolder(&dsf)))
{
HRESULT hr = IShellFolder_GetUIObjectOf(dsf, NULL, 1, (LPCITEMIDLIST*)&This->pidl, &IID_IShellLinkW, NULL, (LPVOID*)&psl);
if (SUCCEEDED(hr))
{
hr = IShellLinkW_GetIconLocation(psl, szIconFile, MAX_PATH, piIndex);
if (SUCCEEDED(hr) && *szIconFile)
found = TRUE;
IShellLinkW_Release(psl);
}
IShellFolder_Release(dsf);
}
}
}
if (!found) /* default icon */
{
lstrcpynW(szIconFile, swShell32Name, cchMax);
*piIndex = 0;
}
}
TRACE("-- %s %x\n", debugstr_w(szIconFile), *piIndex);
return S_OK;
}
/* Process items in the StartUp group of the user's Programs under the Start Menu. Some installers put
* shell links here to restart themselves after boot. */
static BOOL ProcessStartupItems(void)
{
BOOL ret = FALSE;
HRESULT hr;
IMalloc *ppM = NULL;
IShellFolder *psfDesktop = NULL, *psfStartup = NULL;
LPITEMIDLIST pidlStartup = NULL, pidlItem;
ULONG NumPIDLs;
IEnumIDList *iEnumList = NULL;
STRRET strret;
WCHAR wszCommand[MAX_PATH];
WINE_TRACE("Processing items in the StartUp folder.\n");
hr = SHGetMalloc(&ppM);
if (FAILED(hr))
{
WINE_ERR("Couldn't get IMalloc object.\n");
goto done;
}
hr = SHGetDesktopFolder(&psfDesktop);
if (FAILED(hr))
{
WINE_ERR("Couldn't get desktop folder.\n");
goto done;
}
hr = SHGetSpecialFolderLocation(NULL, CSIDL_STARTUP, &pidlStartup);
if (FAILED(hr))
{
WINE_TRACE("Couldn't get StartUp folder location.\n");
goto done;
}
hr = IShellFolder_BindToObject(psfDesktop, pidlStartup, NULL, &IID_IShellFolder, (LPVOID*)&psfStartup);
if (FAILED(hr))
{
WINE_TRACE("Couldn't bind IShellFolder to StartUp folder.\n");
goto done;
}
hr = IShellFolder_EnumObjects(psfStartup, NULL, SHCONTF_NONFOLDERS | SHCONTF_INCLUDEHIDDEN, &iEnumList);
if (FAILED(hr))
{
WINE_TRACE("Unable to enumerate StartUp objects.\n");
goto done;
}
while (IEnumIDList_Next(iEnumList, 1, &pidlItem, &NumPIDLs) == S_OK &&
(NumPIDLs) == 1)
{
hr = IShellFolder_GetDisplayNameOf(psfStartup, pidlItem, SHGDN_FORPARSING, &strret);
if (FAILED(hr))
WINE_TRACE("Unable to get display name of enumeration item.\n");
else
{
hr = StrRetToBufW(&strret, pidlItem, wszCommand, MAX_PATH);
if (FAILED(hr))
WINE_TRACE("Unable to parse display name.\n");
else
{
HINSTANCE hinst;
hinst = ShellExecuteW(NULL, NULL, wszCommand, NULL, NULL, SW_SHOWNORMAL);
if (PtrToUlong(hinst) <= 32)
WINE_WARN("Error %p executing command %s.\n", hinst, wine_dbgstr_w(wszCommand));
}
}
IMalloc_Free(ppM, pidlItem);
}
/* Return success */
ret = TRUE;
done:
if (iEnumList) IEnumIDList_Release(iEnumList);
if (psfStartup) IShellFolder_Release(psfStartup);
if (pidlStartup) IMalloc_Free(ppM, pidlStartup);
return ret;
}
/******************************************************************************
* HCR_GetFolderAttributes [Internal]
*
* Query the registry for a shell folders' attributes
*
* PARAMS
* pidlFolder [I] A simple pidl of type PT_GUID.
* pdwAttributes [IO] In: Attributes to be queried, OUT: Resulting attributes.
*
* RETURNS
* TRUE: Found information for the attributes in the registry
* FALSE: No attribute information found
*
* NOTES
* If queried for an attribute, which is set in the CallForAttributes registry
* value, the function binds to the shellfolder objects and queries it.
*/
BOOL HCR_GetFolderAttributes(LPCITEMIDLIST pidlFolder, LPDWORD pdwAttributes)
{
HKEY hSFKey;
LPOLESTR pwszCLSID;
LONG lResult;
DWORD dwTemp, dwLen;
static const WCHAR wszAttributes[] = { 'A','t','t','r','i','b','u','t','e','s',0 };
static const WCHAR wszCallForAttributes[] = {
'C','a','l','l','F','o','r','A','t','t','r','i','b','u','t','e','s',0 };
WCHAR wszShellFolderKey[] = { 'C','L','S','I','D','\\','{','0','0','0','2','1','4','0','0','-',
'0','0','0','0','-','0','0','0','0','-','C','0','0','0','-','0','0','0','0','0','0','0',
'0','0','0','4','6','}','\\','S','h','e','l','l','F','o','l','d','e','r',0 };
TRACE("(pidlFolder=%p, pdwAttributes=%p)\n", pidlFolder, pdwAttributes);
if (!_ILIsPidlSimple(pidlFolder)) {
static BOOL firstHit = TRUE;
if (firstHit) {
ERR("should be called for simple PIDL's only!\n");
firstHit = FALSE;
}
return FALSE;
}
if (!_ILIsDesktop(pidlFolder)) {
if (FAILED(StringFromCLSID(_ILGetGUIDPointer(pidlFolder), &pwszCLSID))) return FALSE;
memcpy(&wszShellFolderKey[6], pwszCLSID, 38 * sizeof(WCHAR));
CoTaskMemFree(pwszCLSID);
}
lResult = RegOpenKeyExW(HKEY_CLASSES_ROOT, wszShellFolderKey, 0, KEY_READ, &hSFKey);
#ifdef __REACTOS__
if (lResult != ERROR_SUCCESS)
{
ERR("Cannot open key: %ls\n", wszShellFolderKey);
return FALSE;
}
#else
if (lResult != ERROR_SUCCESS) return FALSE;
#endif
dwLen = sizeof(DWORD);
lResult = RegQueryValueExW(hSFKey, wszCallForAttributes, 0, NULL, (LPBYTE)&dwTemp, &dwLen);
if ((lResult == ERROR_SUCCESS) && (dwTemp & *pdwAttributes)) {
LPSHELLFOLDER psfDesktop, psfFolder;
HRESULT hr;
RegCloseKey(hSFKey);
hr = SHGetDesktopFolder(&psfDesktop);
if (SUCCEEDED(hr)) {
hr = IShellFolder_BindToObject(psfDesktop, pidlFolder, NULL, &IID_IShellFolder,
(LPVOID*)&psfFolder);
if (SUCCEEDED(hr)) {
hr = IShellFolder_GetAttributesOf(psfFolder, 0, NULL, pdwAttributes);
IShellFolder_Release(psfFolder);
}
IShellFolder_Release(psfDesktop);
}
if (FAILED(hr)) return FALSE;
} else {
lResult = RegQueryValueExW(hSFKey, wszAttributes, 0, NULL, (LPBYTE)&dwTemp, &dwLen);
RegCloseKey(hSFKey);
if (lResult == ERROR_SUCCESS) {
*pdwAttributes &= dwTemp;
} else {
return FALSE;
}
}
TRACE("-- *pdwAttributes == 0x%08x\n", *pdwAttributes);
return TRUE;
}
BOOL showContextMenu (HWND hDlg, TCHAR* FName, WNDPROC menuProc)
{
TCHAR* FileName = PathFindFileName (FName);
TCHAR FilePath [MAX_PATH];
lstrcpy (FilePath, FName);
*PathFindFileName (FilePath) = L'\0';
LPSHELLFOLDER DesktopFolder;
if (NOERROR != SHGetDesktopFolder (&DesktopFolder))
{
return FALSE;
}
LPITEMIDLIST ParentPidl;
ULONG Eaten;
if (S_OK != DesktopFolder->ParseDisplayName (hDlg, 0, FilePath, &Eaten, &ParentPidl, 0))
{
return FALSE;
}
LPSHELLFOLDER ParentFolder;
if (S_OK != DesktopFolder->BindToObject (ParentPidl, 0, IID_IShellFolder, (void**)&ParentFolder))
{
return FALSE;
}
LPITEMIDLIST Pidl;
if (S_OK != ParentFolder->ParseDisplayName (hDlg, 0, FileName, &Eaten, &Pidl, 0))
{
return FALSE;
}
LPCONTEXTMENU CM;
if (S_OK != ParentFolder->GetUIObjectOf (hDlg, 1, (LPCITEMIDLIST*)&Pidl, IID_IContextMenu, 0, (void**)&CM))
{
return FALSE;
}
HMENU hMenu = CreatePopupMenu ();
if (hMenu == NULL)
{
return FALSE;
}
CM->QueryContextMenu (hMenu, 0, 1, 0x7FFF, CMF_EXTENDEDVERBS | CMF_EXPLORE);
WNDPROC defWndProc = (WNDPROC) SetWindowLong (hDlg, GWL_WNDPROC, (LONG)menuProc);
SetProp (hDlg, L"defWndProc", (HANDLE) defWndProc);
POINT pt;
GetCursorPos (&pt);
int Cmd = TrackPopupMenu (hMenu,
TPM_LEFTALIGN | TPM_LEFTBUTTON | TPM_RIGHTBUTTON | TPM_RETURNCMD,
pt.x, pt.y, 0, hDlg, 0);
SetWindowLong (hDlg, GWL_WNDPROC, (LONG) RemoveProp (hDlg, L"defWndProc"));
if (Cmd)
{
// Set up a CMINVOKECOMMANDINFO structure.
CMINVOKECOMMANDINFO CI;
ZeroMemory (&CI, sizeof(CMINVOKECOMMANDINFO));
CI.cbSize = sizeof (CMINVOKECOMMANDINFO);
CI.hwnd = hDlg;
CI.lpVerb = (LPCSTR) MAKEINTRESOURCE(Cmd - 1);
CI.lpParameters = "";
CI.lpDirectory = "";
CI.nShow = SW_SHOWNORMAL;
CM->InvokeCommand (&CI);
}
return DestroyMenu (hMenu);
}
