Microsoft/Windows2000
Microsoft/Windows2000
1
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity
45f4a58588
Windows2000/private/shell/shell32/rundlg.cpp

1203 lines
33 KiB
C++
Raw Normal View History

First commit
2001-01-01 00:00:00 +01:00
/**\
FILE: rundlg.cpp
DESCRIPTION:
CRunDlg implements the Dialog that can navigate through
the Shell Name Space and ShellExec() commands.
\**/
#include "shellprv.h"
extern "C" {
#include <regstr.h>
#include <shellp.h>
#include "ole2dup.h"
#include "ids.h"
#include "defview.h"
#include "lvutil.h"
#include "idlcomm.h"
#include "filetbl.h"
#include "undo.h"
#include "vdate.h"
} ;
#include "cnctnpt.h"
#ifndef SAFERELEASE
#define SAFERELEASE(x) { if (x) { x->Release(); x = NULL; } }
#endif
#ifdef WINNT
BOOL g_bCheckRunInSep = FALSE;
HANDLE g_hCheckNow = NULL;
HANDLE h_hRunDlgCS = NULL;
#endif // WINNT
const TCHAR c_szRunMRU[] = REGSTR_PATH_EXPLORER TEXT("\\RunMRU");
const TCHAR c_szRunDlgReady[] = TEXT("MSShellRunDlgReady");
const TCHAR c_szWaitingThreadID[] = TEXT("WaitingThreadID");
const TCHAR c_szQuote[] = TEXT("\"");
const TCHAR c_szAutoCompleteReg[] = REGSTR_PATH_EXPLORER TEXT("\\AutoComplete");
const TCHAR c_szACRunDlg[] = TEXT("Use AutoComplete");
BOOL RunDlgNotifyParent(HWND hDlg, HWND hwnd, LPTSTR pszCmd, LPCTSTR pszWorkingDir);
void ExchangeWindowPos(HWND hwnd0, HWND hwnd1);
#define WM_SETUPAUTOCOMPLETE (WM_APP)
/**\
CLASS: CRunDlg
DESCRIPTION:
CRunDlg implements the Dialog that can navigate through
the Shell Name Space and ShellExec() commands.
\**/
class CRunDlg
: public IDropTarget
{
public:
// Public Interfaces
// ** IUnknown **
virtual STDMETHODIMP_(ULONG) AddRef(void);
virtual STDMETHODIMP_(ULONG) Release(void);
virtual STDMETHODIMP QueryInterface(REFIID riid, void ** ppvObj);
// ** IDropTarget methods **
virtual STDMETHODIMP DragEnter(IDataObject *pdtobj, DWORD grfKeyState, POINTL pt, DWORD *pdwEffect);
virtual STDMETHODIMP DragOver(DWORD grfKeyState, POINTL pt, DWORD *pdwEffect);
virtual STDMETHODIMP DragLeave(void);
virtual STDMETHODIMP Drop(IDataObject *pdtobj, DWORD grfKeyState, POINTL pt, DWORD *pdwEffect);
protected:
// Private Member Functions
// Constructor / Destructor
CRunDlg();
~CRunDlg(void); // This is now an OLE Object and cannot be used as a normal Class.
BOOL OKPushed(void);
void ExitRunDlg(BOOL bOK);
void InitRunDlg(HWND hDlg);
void InitRunDlg2(HWND hDlg);
void BrowsePushed(void);
// Friend Functions
friend HRESULT CRunDlg_CreateInstance(IUnknown *punkOuter, REFIID riid, IUnknown **ppunk);
friend DWORD CALLBACK CheckRunInSeparateThreadProc(void *pv);
friend BOOL_PTR CALLBACK RunDlgProc(HWND hDlg, UINT uMsg, WPARAM wParam, LPARAM lParam);
friend WINAPI RunFileDlg(HWND hwndParent, HICON hIcon, LPCTSTR pszWorkingDir, LPCTSTR pszTitle,
LPCTSTR pszPrompt, DWORD dwFlags);
// Private Member Variables
UINT m_cRef;
// local data
HWND m_hDlg;
// parameters
HICON m_hIcon;
LPCTSTR m_pszWorkingDir;
LPCTSTR m_pszTitle;
LPCTSTR m_pszPrompt;
DWORD m_dwFlags;
HANDLE m_hEventReady;
DWORD m_dwThreadId;
BITBOOL m_fDone : 1;
BITBOOL m_fAutoCompInitialized : 1;
};
// optimistic cache for this
HANDLE g_hMRURunDlg = NULL;
HANDLE OpenRunDlgMRU()
{
HANDLE hmru = InterlockedExchangePointer(&g_hMRURunDlg, NULL);
if (hmru == NULL)
{
MRUINFO mi = {
SIZEOF(MRUINFO),
26,
MRU_CACHEWRITE,
HKEY_CURRENT_USER,
c_szRunMRU,
NULL // NOTE: use default string compare
// since this is a GLOBAL MRU
} ;
hmru = CreateMRUList(&mi);
}
return hmru;
}
void CloseRunDlgMRU(HANDLE hmru)
{
hmru = InterlockedExchangePointer(&g_hMRURunDlg, hmru);
if (hmru)
FreeMRUList(hmru); // race, destroy copy
}
STDAPI_(void) FlushRunDlgMRU(void)
{
CloseRunDlgMRU(NULL);
}
// Implementation of CRunDlg
/**\
FUNCTION: CRunDlg_CreateInstance
DESCRIPTION:
This function will create an instance of the
CRunDlg COM object.
\**/
HRESULT CRunDlg_CreateInstance(IUnknown *punkOuter, REFIID riid, IUnknown **ppunk)
{
if (punkOuter)
return E_FAIL;
*ppunk = NULL;
CRunDlg * p = new CRunDlg();
if (p)
{
*ppunk = SAFECAST(p, IDropTarget *);
return NOERROR;
}
return E_OUTOFMEMORY;
}
/**\
Run Dialog Constructor
\**/
CRunDlg::CRunDlg()
{
m_cRef = 1;
// This needs to be allocated in Zero Inited Memory.
// ASSERT that all Member Variables are inited to Zero.
ASSERT(!m_hDlg);
ASSERT(!m_hIcon);
ASSERT(!m_pszWorkingDir);
ASSERT(!m_pszTitle);
ASSERT(!m_pszPrompt);
ASSERT(!m_dwFlags);
ASSERT(!m_hEventReady);
ASSERT(!m_fDone);
ASSERT(!m_dwThreadId);
}
/**\
Run Dialog destructor
\**/
CRunDlg::~CRunDlg()
{
}
// ** IUnknown Interface **
HRESULT CRunDlg::QueryInterface(REFIID riid, void **ppvObj)
{
if (IsEqualIID(riid, IID_IUnknown) || IsEqualIID(riid, IID_IDropTarget))
{
*ppvObj = SAFECAST(this, IDropTarget*);
}
else
{
*ppvObj = NULL;
return E_NOINTERFACE;
}
AddRef();
return S_OK;
}
/**\
FUNCTION: AddRef
\**/
ULONG CRunDlg::AddRef()
{
m_cRef++;
return m_cRef;
}
/**\
FUNCTION: Release
\**/
ULONG CRunDlg::Release()
{
ASSERT(m_cRef > 0);
m_cRef--;
if (m_cRef > 0)
return m_cRef;
delete this;
return 0;
}
// ** IDropTarget Interface **
STDMETHODIMP CRunDlg::DragEnter(IDataObject * pdtobj, DWORD grfKeyState, POINTL ptl, LPDWORD pdwEffect)
{
DebugMsg(DM_TRACE, TEXT("sh - TR CRunDlg::DragEnter called"));
ASSERT(pdtobj);
_DragEnter(m_hDlg, ptl, pdtobj);
*pdwEffect &= DROPEFFECT_LINK | DROPEFFECT_COPY;
return NOERROR;
}
STDMETHODIMP CRunDlg::DragOver(DWORD grfKeyState, POINTL ptl, LPDWORD pdwEffect)
{
_DragMove(m_hDlg, ptl);
*pdwEffect &= DROPEFFECT_LINK | DROPEFFECT_COPY;
return NOERROR;
}
STDMETHODIMP CRunDlg::DragLeave(void)
{
DebugMsg(DM_TRACE, TEXT("sh - TR CRunDlg::DragLeave called"));
DAD_DragLeave();
return NOERROR;
}
typedef struct {
HRESULT (*pfnGetData)(STGMEDIUM *, LPTSTR pszFile);
FORMATETC fmte;
} DATA_HANDLER;
HRESULT _GetHDROPFromData(STGMEDIUM *pmedium, LPTSTR pszPath)
{
return DragQueryFile((HDROP)pmedium->hGlobal, 0, pszPath, MAX_PATH) ? S_OK : E_FAIL;
}
HRESULT _GetText(STGMEDIUM *pmedium, LPTSTR pszPath)
{
LPCSTR psz = (LPCSTR)GlobalLock(pmedium->hGlobal);
if (psz)
{
SHAnsiToTChar(psz, pszPath, MAX_PATH);
GlobalUnlock(pmedium->hGlobal);
return S_OK;
}
return E_FAIL;
}
HRESULT _GetUnicodeText(STGMEDIUM *pmedium, LPTSTR pszPath)
{
LPCWSTR pwsz = (LPCWSTR)GlobalLock(pmedium->hGlobal);
if (pwsz)
{
SHUnicodeToTChar(pwsz, pszPath, MAX_PATH);
GlobalUnlock(pmedium->hGlobal);
return S_OK;
}
return E_FAIL;
}
STDMETHODIMP CRunDlg::Drop(IDataObject * pdtobj, DWORD grfKeyState,
POINTL pt, DWORD *pdwEffect)
{
TCHAR szPath[MAX_PATH];
DAD_DragLeave();
szPath[0] = 0;
DATA_HANDLER rg_data_handlers[] = {
_GetHDROPFromData, {CF_HDROP, NULL, DVASPECT_CONTENT, -1, TYMED_HGLOBAL},
_GetUnicodeText, {CF_UNICODETEXT, NULL, DVASPECT_CONTENT, -1, TYMED_HGLOBAL},
_GetText, {g_cfShellURL, NULL, DVASPECT_CONTENT, -1, TYMED_HGLOBAL},
_GetText, {CF_TEXT, NULL, DVASPECT_CONTENT, -1, TYMED_HGLOBAL},
};
IEnumFORMATETC *penum;
if (SUCCEEDED(pdtobj->EnumFormatEtc(DATADIR_GET, &penum)))
{
FORMATETC fmte;
while (penum->Next(1, &fmte, NULL) == S_OK)
{
for (int i = 0; i < ARRAYSIZE(rg_data_handlers); i++)
{
STGMEDIUM medium;
if ((rg_data_handlers[i].fmte.cfFormat == fmte.cfFormat) &&
SUCCEEDED(pdtobj->GetData(&rg_data_handlers[i].fmte, &medium)))
{
HRESULT hres = rg_data_handlers[i].pfnGetData(&medium, szPath);
ReleaseStgMedium(&medium);
if (SUCCEEDED(hres))
goto Done;
}
}
}
Done:
penum->Release();
}
if (szPath[0])
{
TCHAR szText[MAX_PATH + MAX_PATH];
GetDlgItemText(m_hDlg, IDD_COMMAND, szText, ARRAYSIZE(szText) - ARRAYSIZE(szPath));
if (szText[0])
lstrcat(szText, c_szSpace);
if (StrChr(szPath, TEXT(' ')))
PathQuoteSpaces(szPath); // there's a space in the file... add qutoes
lstrcat(szText, szPath);
SetDlgItemText(m_hDlg, IDD_COMMAND, szText);
EnableOKButtonFromID(m_hDlg, IDD_COMMAND);
#ifdef WINNT
if (g_hCheckNow)
SetEvent(g_hCheckNow);
#endif // WINNT
*pdwEffect &= DROPEFFECT_COPY | DROPEFFECT_LINK;
}
else
*pdwEffect = 0;
return NOERROR;
}
BOOL PromptForMedia(HWND hwnd, LPCTSTR pszPath)
{
BOOL fContinue = TRUE;
TCHAR szPathTemp[MAX_URL_STRING];
StrCpyN(szPathTemp, pszPath, ARRAYSIZE(szPathTemp));
PathRemoveArgs(szPathTemp);
PathUnquoteSpaces(szPathTemp);
// We only want to check for media if it's a drive path
// because the Start->Run dialog can receive all kinds of
// wacky stuff. (Relative paths, URLs, App Path exes,
// any shell exec hooks, etc.)
if (-1 != PathGetDriveNumber(szPathTemp))
{
if (FAILED(SHPathPrepareForWrite(hwnd, NULL, szPathTemp, SHPPFW_IGNOREFILENAME)))
fContinue = FALSE; // User decliened to insert or format media.
}
return fContinue;
}
// ** Private Members **
BOOL CRunDlg::OKPushed(void)
{
HWND hwndOwner;
TCHAR szText[MAX_PATH];
TCHAR szTitle[64];
DWORD dwFlags;
BOOL fSuccess = FALSE;
int iRun;
HWND hDlg = m_hDlg;
TCHAR szNotExp[ MAX_PATH ];
if (m_fDone)
return TRUE;
// Get out of the "synchronized input queues" state
if (m_dwThreadId)
{
AttachThreadInput(GetCurrentThreadId(), m_dwThreadId, FALSE);
}
// Get the command line and dialog title, leave some room for the slash on the end
GetDlgItemText(hDlg, IDD_COMMAND, szNotExp, ARRAYSIZE(szNotExp) - 2);
PathRemoveBlanks(szNotExp);
// This used to happen only on NT, do it everywhere:
SHExpandEnvironmentStrings(szNotExp, szText, ARRAYSIZE(szText) - 2);
// We will go ahead if this isn't a file path. If it is, we
if (PromptForMedia(hDlg, szText))
{
GetWindowText(hDlg, szTitle, ARRAYSIZE(szTitle));
// Hide this dialog (REVIEW, to avoid save bits window flash)
SetWindowPos(hDlg, 0, 0, 0, 0, 0, SWP_HIDEWINDOW|SWP_NOACTIVATE|SWP_NOMOVE|SWP_NOSIZE|SWP_NOZORDER);
// HACK: We need to activate the owner window before we call
// ShellexecCmdLine, so that our folder DDE code can find an
// explorer window as the ForegroundWindow.
hwndOwner = GetWindow(hDlg, GW_OWNER);
if (hwndOwner)
{
SetActiveWindow(hwndOwner);
}
else
{
hwndOwner = hDlg;
}
iRun = RunDlgNotifyParent(hDlg, hwndOwner, szText, m_pszWorkingDir);
switch (iRun)
{
case RFR_NOTHANDLED:
if (m_dwFlags & RFD_USEFULLPATHDIR)
{
dwFlags = SECL_USEFULLPATHDIR;
}
else
{
dwFlags = 0;
}
#ifdef WINNT
if ((!(m_dwFlags & RFD_NOSEPMEMORY_BOX)) && (m_dwFlags & RFD_WOW_APP))
{
if (IsDlgButtonChecked( hDlg, IDD_RUNINSEPARATE ) == 1 )
{
dwFlags |= SECL_SEPARATE_VDM;
}
}
#endif
#ifdef WINNT
ShrinkWorkingSet();
#endif
fSuccess = ShellExecCmdLine( hwndOwner,
szText,
m_pszWorkingDir,
SW_SHOWNORMAL,
szTitle,
dwFlags
);
break;
case RFR_SUCCESS:
fSuccess = TRUE;
break;
case RFR_FAILURE:
fSuccess = FALSE;
break;
}
}
// Get back into "synchronized input queues" state
if (m_dwThreadId)
{
AttachThreadInput(GetCurrentThreadId(), m_dwThreadId, TRUE);
}
if (fSuccess)
{
HANDLE hmru = OpenRunDlgMRU();
if (hmru)
{
// NB the old MRU format has a slash and the show cmd on the end
// we need to maintain that so we don't end up with garbage on
// the end of the line
lstrcat(szNotExp, TEXT("\\1"));
AddMRUString(hmru, szNotExp);
CloseRunDlgMRU(hmru);
}
return TRUE;
}
// Something went wrong. Put the dialog back up.
SetWindowPos(hDlg, 0, 0, 0, 0, 0, SWP_SHOWWINDOW|SWP_NOMOVE|SWP_NOSIZE|SWP_NOZORDER);
SetForegroundWindow(hDlg);
SetFocus(GetDlgItem(hDlg, IDD_COMMAND));
return FALSE;
}
void CRunDlg::ExitRunDlg(BOOL bOK)
{
if (!m_fDone)
{
RevokeDragDrop(m_hDlg);
m_fDone = TRUE;
}
#ifdef WINNT
if (!(m_dwFlags & RFD_NOSEPMEMORY_BOX))
{
g_bCheckRunInSep = FALSE;
SetEvent( g_hCheckNow );
}
#endif // WINNT
EndDialog(m_hDlg, bOK);
}
void CRunDlg::InitRunDlg(HWND hDlg)
{
HWND hCB;
SetWindowLongPtr(hDlg, DWLP_USER, (LONG_PTR)this);
if (m_pszTitle)
SetWindowText(hDlg, m_pszTitle);
if (m_pszPrompt)
SetDlgItemText(hDlg, IDD_PROMPT, m_pszPrompt);
if (m_hIcon)
Static_SetIcon(GetDlgItem(hDlg, IDD_ICON), m_hIcon);
if (m_dwFlags & RFD_NOBROWSE)
{
HWND hBrowse = GetDlgItem(hDlg, IDD_BROWSE);
ExchangeWindowPos(hBrowse, GetDlgItem(hDlg, IDCANCEL));
ExchangeWindowPos(hBrowse, GetDlgItem(hDlg, IDOK));
ShowWindow(hBrowse, SW_HIDE);
}
if (m_dwFlags & RFD_NOSHOWOPEN)
ShowWindow(GetDlgItem(hDlg, IDD_RUNDLGOPENPROMPT), SW_HIDE);
hCB = GetDlgItem(hDlg, IDD_COMMAND);
SendMessage(hCB, CB_LIMITTEXT, MAX_PATH - 1, 0L);
HANDLE hmru = OpenRunDlgMRU();
if (hmru)
{
for (int nMax = EnumMRUList(hmru, -1, NULL, 0), i=0; i<nMax; ++i)
{
TCHAR szCommand[MAX_PATH];
if (EnumMRUList(hmru, i, szCommand, ARRAYSIZE(szCommand)) > 0)
{
// old MRU format has a slash at the end with the show cmd
LPTSTR pszField = StrRChr(szCommand, NULL, TEXT('\\'));
if (pszField)
*pszField = 0;
// The command to run goes in the combobox.
SendMessage(hCB, CB_ADDSTRING, 0, (LPARAM)(LPTSTR)szCommand);
}
}
CloseRunDlgMRU(hmru);
}
if (!(m_dwFlags & RFD_NODEFFILE))
SendMessage(hCB, CB_SETCURSEL, 0, 0L);
SendMessage(hDlg, WM_COMMAND, MAKEWPARAM(IDD_COMMAND, CBN_SELCHANGE), (LPARAM) hCB);
// Make sure the OK button is initialized properly
EnableOKButtonFromID(hDlg, IDD_COMMAND);
#ifdef WINNT
// Create the thread that will take care of the
// "Run in Separate Memory Space" checkbox in the background.
if (m_dwFlags & RFD_NOSEPMEMORY_BOX)
{
ShowWindow(GetDlgItem(hDlg, IDD_RUNINSEPARATE), SW_HIDE);
}
else
{
HANDLE hThread = NULL;
ASSERT( g_hCheckNow == NULL );
g_hCheckNow = CreateEvent( NULL, TRUE, FALSE, NULL );
if (g_hCheckNow)
{
DWORD dwDummy;
g_bCheckRunInSep = TRUE;
hThread = CreateThread(NULL, 0, CheckRunInSeparateThreadProc, hDlg, 0, &dwDummy);
}
if ((g_hCheckNow==NULL) || (!g_bCheckRunInSep) || (hThread==NULL))
{
// We've encountered a problem setting up, so make the user
// choose.
CheckDlgButton( hDlg, IDD_RUNINSEPARATE, 1 );
EnableWindow( GetDlgItem( hDlg, IDD_RUNINSEPARATE ), TRUE );
g_bCheckRunInSep = FALSE;
}
// These calls will just do nothing if either handle is NULL.
if (hThread)
CloseHandle( hThread );
if (g_hCheckNow)
SetEvent( g_hCheckNow );
}
#endif // WINNT
}
// InitRunDlg 2nd phase. It must be called after freeing parent thread.
void CRunDlg::InitRunDlg2(HWND hDlg)
{
// Register ourselves as a drop target. Allow people to drop on
// both the dlg box and edit control.
RegisterDragDrop(hDlg, SAFECAST(this, IDropTarget*));
}
void CRunDlg::BrowsePushed(void)
{
HWND hDlg = m_hDlg;
TCHAR szText[MAX_PATH];
// Get out of the "synchronized input queues" state
if (m_dwThreadId)
{
AttachThreadInput(GetCurrentThreadId(), m_dwThreadId, FALSE);
m_dwThreadId = 0;
}
GetDlgItemText(hDlg, IDD_COMMAND, szText, ARRAYSIZE(szText));
PathUnquoteSpaces(szText);
if (GetFileNameFromBrowse(hDlg, szText, ARRAYSIZE(szText), m_pszWorkingDir,
MAKEINTRESOURCE(IDS_EXE), MAKEINTRESOURCE(IDS_PROGRAMSFILTER),
MAKEINTRESOURCE(IDS_BROWSE)))
{
PathQuoteSpaces(szText);
SetDlgItemText(hDlg, IDD_COMMAND, szText);
EnableOKButtonFromID(hDlg, IDD_COMMAND);
SendMessage(hDlg, WM_NEXTDLGCTL, (WPARAM)GetDlgItem(hDlg, IDOK), TRUE);
}
}
// ** Other Functions **
// Use the common browse dialog to get a filename.
// The working directory of the common dialog will be set to the directory
// part of the file path if it is more than just a filename.
// If the filepath consists of just a filename then the working directory
// will be used.
// The full path to the selected file will be returned in szFilePath.
// HWND hDlg, // Owner for browse dialog.
// LPSTR szFilePath, // Path to file
// UINT cchFilePath, // Max length of file path buffer.
// LPSTR szWorkingDir, // Working directory
// LPSTR szDefExt, // Default extension to use if the user doesn't
// // specify enter one.
// LPSTR szFilters, // Filter string.
// LPSTR szTitle // Title for dialog.
STDAPI_(BOOL) _GetFileNameFromBrowse(HWND hwnd, LPTSTR szFilePath, UINT cbFilePath,
LPCTSTR szWorkingDir, LPCTSTR szDefExt, LPCTSTR szFilters, LPCTSTR szTitle,
DWORD dwFlags)
{
OPENFILENAME ofn; // Structure used to init dialog.
TCHAR szBrowserDir[MAX_PATH]; // Directory to start browsing from.
TCHAR szFilterBuf[MAX_PATH]; // if szFilters is MAKEINTRESOURCE
TCHAR szDefExtBuf[10]; // if szDefExt is MAKEINTRESOURCE
TCHAR szTitleBuf[64]; // if szTitleBuf is MAKEINTRESOURCE
szBrowserDir[0] = TEXT('0'); // By default use CWD.
// Set up info for browser.
lstrcpy(szBrowserDir, szFilePath);
PathRemoveArgs(szBrowserDir);
PathRemoveFileSpec(szBrowserDir);
if (*szBrowserDir == TEXT('\0') && szWorkingDir)
{
lstrcpyn(szBrowserDir, szWorkingDir, ARRAYSIZE(szBrowserDir));
}
// Stomp on the file path so that the dialog doesn't
// try to use it to initialise the dialog. The result is put
// in here.
szFilePath[0] = TEXT('\0');
// Set up szDefExt
if (IS_INTRESOURCE(szDefExt))
{
LoadString(HINST_THISDLL, (UINT)LOWORD((DWORD_PTR)szDefExt), szDefExtBuf, ARRAYSIZE(szDefExtBuf));
szDefExt = szDefExtBuf;
}
// Set up szFilters
if (IS_INTRESOURCE(szFilters))
{
LPTSTR psz;
LoadString(HINST_THISDLL, (UINT)LOWORD((DWORD_PTR)szFilters), szFilterBuf, ARRAYSIZE(szFilterBuf));
psz = szFilterBuf;
while (*psz)
{
if (*psz == TEXT('#'))
#if (defined(DBCS) || (defined(FE_SB) && !defined(UNICODE)))
*psz++ = TEXT('\0');
else
psz = CharNext(psz);
#else
*psz = TEXT('\0');
psz = CharNext(psz);
#endif
}
szFilters = szFilterBuf;
}
// Set up szTitle
if (IS_INTRESOURCE(szTitle))
{
LoadString(HINST_THISDLL, (UINT)LOWORD((DWORD_PTR)szTitle), szTitleBuf, ARRAYSIZE(szTitleBuf));
szTitle = szTitleBuf;
}
// Setup info for comm dialog.
ofn.lStructSize = SIZEOF(ofn);
ofn.hwndOwner = hwnd;
ofn.hInstance = NULL;
ofn.lpstrFilter = szFilters;
ofn.lpstrCustomFilter = NULL;
ofn.nFilterIndex = 1;
ofn.nMaxCustFilter = 0;
ofn.lpstrFile = szFilePath;
ofn.nMaxFile = cbFilePath;
ofn.lpstrInitialDir = szBrowserDir;
ofn.lpstrTitle = szTitle;
ofn.Flags = dwFlags;
ofn.lpfnHook = NULL;
ofn.lpstrDefExt = szDefExt;
ofn.lpstrFileTitle = NULL;
// Call it.
return GetOpenFileName(&ofn);
}
BOOL WINAPI GetFileNameFromBrowse(HWND hwnd, LPTSTR szFilePath, UINT cchFilePath,
LPCTSTR szWorkingDir, LPCTSTR szDefExt, LPCTSTR szFilters, LPCTSTR szTitle)
{
return _GetFileNameFromBrowse(hwnd, szFilePath, cchFilePath,
szWorkingDir, szDefExt, szFilters, szTitle,
OFN_HIDEREADONLY | OFN_FILEMUSTEXIST | OFN_NOCHANGEDIR | OFN_NODEREFERENCELINKS);
}
#ifdef WINNT
// Do checking of the .exe type in the background so the UI doesn't
// get hung up while we scan. This is particularly important with
// the .exe is over the network or on a floppy.
DWORD CALLBACK CheckRunInSeparateThreadProc(void *pv)
{
DWORD dwBinaryType;
DWORD cch;
LPTSTR pszFilePart;
TCHAR szFile[MAX_PATH+1];
TCHAR szFullFile[MAX_PATH+1];
TCHAR szExp[MAX_PATH+1];
HWND hDlg = (HWND)pv;
BOOL fCheck = TRUE, fEnable = FALSE;
HRESULT hr = CoInitialize(0);
if (EVAL(SUCCEEDED(hr)))
{
// BUGBUG: Re-write to use PIDL from CShellUrl because it will prevent from having
// to do the Search for the file name a second time.
DebugMsg( DM_TRACE, TEXT("CheckRunInSeparateThreadProc created and running") );
while( g_bCheckRunInSep )
{
WaitForSingleObject( g_hCheckNow, INFINITE );
ResetEvent( g_hCheckNow );
if (g_bCheckRunInSep)
{
CRunDlg * prd;
LPTSTR pszT;
BOOL f16bit = FALSE;
szFile[0] = 0;
szFullFile[0] = 0;
cch = 0;
GetWindowText( GetDlgItem( hDlg, IDD_COMMAND ), szFile, ARRAYSIZE(szFile) );
// Remove & throw away arguments
PathRemoveBlanks(szFile);
if (PathIsNetworkPath(szFile))
{
f16bit = TRUE;
fCheck = FALSE;
fEnable = TRUE;
goto ChangeTheBox;
}
// if the unquoted string exists as a file, just use it
if (!PathFileExistsAndAttributes(szFile, NULL))
{
pszT = PathGetArgs(szFile);
if (*pszT)
*(pszT - 1) = TEXT('\0');
PathUnquoteSpaces(szFile);
}
if (szFile[0])
{
SHExpandEnvironmentStrings(szFile, szExp, ARRAYSIZE(szExp));
if (PathIsUNC(szExp) || IsRemoteDrive(DRIVEID(szExp)))
{
f16bit = TRUE;
fCheck = FALSE;
fEnable = TRUE;
goto ChangeTheBox;
}
cch = SearchPath(NULL, szExp, TEXT(".EXE"),
ARRAYSIZE(szExp), szFullFile, &pszFilePart);
}
if ((cch != 0) && (cch <= (ARRAYSIZE(szFullFile) - 1)))
{
if ( (GetBinaryType(szFullFile, &dwBinaryType) &&
(dwBinaryType == SCS_WOW_BINARY)) )
{
f16bit = TRUE;
fCheck = FALSE;
fEnable = TRUE;
}
else
{
f16bit = FALSE;
fCheck = TRUE;
fEnable = FALSE;
}
}
else
{
f16bit = FALSE;
fCheck = TRUE;
fEnable = FALSE;
}
ChangeTheBox:
CheckDlgButton( hDlg, IDD_RUNINSEPARATE, fCheck ? 1 : 0 );
EnableWindow( GetDlgItem( hDlg, IDD_RUNINSEPARATE ), fEnable );
prd = (CRunDlg *)GetWindowLongPtr(hDlg, DWLP_USER);
if (prd)
{
if (f16bit)
prd->m_dwFlags |= RFD_WOW_APP;
else
prd->m_dwFlags &= (~RFD_WOW_APP);
}
}
}
}
CloseHandle( g_hCheckNow );
g_hCheckNow = NULL;
CoUninitialize();
return 0;
}
#endif // WINNT
void ExchangeWindowPos(HWND hwnd0, HWND hwnd1)
{
HWND hParent;
RECT rc[2];
hParent = GetParent(hwnd0);
ASSERT(hParent == GetParent(hwnd1));
GetWindowRect(hwnd0, &rc[0]);
GetWindowRect(hwnd1, &rc[1]);
MapWindowPoints(HWND_DESKTOP, hParent, (LPPOINT)rc, 4);
SetWindowPos(hwnd0, NULL, rc[1].left, rc[1].top, 0, 0,
SWP_NOZORDER|SWP_NOSIZE);
SetWindowPos(hwnd1, NULL, rc[0].left, rc[0].top, 0, 0,
SWP_NOZORDER|SWP_NOSIZE);
}
BOOL RunDlgNotifyParent(HWND hDlg, HWND hwnd, LPTSTR pszCmd, LPCTSTR pszWorkingDir)
{
NMRUNFILE rfn;
rfn.hdr.hwndFrom = hDlg;
rfn.hdr.idFrom = 0;
rfn.hdr.code = RFN_EXECUTE;
rfn.lpszCmd = pszCmd;
rfn.lpszWorkingDir = pszWorkingDir;
rfn.nShowCmd = SW_SHOWNORMAL;
return (BOOL) SendMessage(hwnd, WM_NOTIFY, 0, (LPARAM)&rfn);
}
void MRUSelChange(HWND hDlg)
{
TCHAR szCmd[MAX_PATH];
HWND hCB = GetDlgItem(hDlg, IDD_COMMAND);
int nItem = (int)SendMessage(hCB, CB_GETCURSEL, 0, 0L);
if (nItem < 0)
return;
// BUGBUG REVIEW: Buffer overrun potential here?
SendMessage(hCB, CB_GETLBTEXT, nItem, (LPARAM)szCmd);
// We can't use EnableOKButtonFromID here because when we get this message,
// the window does not have the text yet, so it will fail.
EnableOKButtonFromString(hDlg, szCmd);
}
/* REVIEW UNDONE - Environment substitution, CL history, WD field, run as styles.
//--------*/
const DWORD aRunHelpIds[] = {
IDD_ICON, NO_HELP,
IDD_PROMPT, NO_HELP,
IDD_RUNDLGOPENPROMPT, IDH_TRAY_RUN_COMMAND,
IDD_COMMAND, IDH_TRAY_RUN_COMMAND,
#ifdef WINNT
IDD_RUNINSEPARATE, IDH_TRAY_RUN_SEPMEM,
#endif
IDD_BROWSE, IDH_BROWSE,
IDOK, IDH_TRAY_RUN_OK,
IDCANCEL, IDH_TRAY_RUN_CANCEL,
0, 0
};
BOOL_PTR CALLBACK RunDlgProc(HWND hDlg, UINT uMsg, WPARAM wParam, LPARAM lParam)
{
CRunDlg * prd = (CRunDlg *)GetWindowLongPtr(hDlg, DWLP_USER);
switch (uMsg)
{
case WM_INITDIALOG:
/* The title will be in the lParam. */
prd = (CRunDlg *)lParam;
prd->m_hDlg = hDlg;
prd->m_fDone = FALSE;
prd->InitRunDlg(hDlg);
// Let the parent thread run on if it was waiting for us to
// grab type-ahead.
if (prd->m_hEventReady)
{
// We need to grab the activation so we can process input.
// DebugMsg(DM_TRACE, "s.rdp: Getting activation.");
SetForegroundWindow(hDlg);
SetFocus(GetDlgItem(hDlg, IDD_COMMAND));
// Now it's safe to wake the guy up properly.
// DebugMsg(DM_TRACE, "s.rdp: Waking sleeping parent.");
SetEvent(prd->m_hEventReady);
CloseHandle(prd->m_hEventReady);
}
else
{
SetForegroundWindow(hDlg);
SetFocus(GetDlgItem(hDlg, IDD_COMMAND));
}
// InitRunDlg 2nd phase (must be called after SetEvent)
prd->InitRunDlg2(hDlg);
// We're handling focus changes.
return FALSE;
case WM_PAINT:
if (!prd->m_fAutoCompInitialized)
{
prd->m_fAutoCompInitialized = TRUE;
PostMessage(hDlg, WM_SETUPAUTOCOMPLETE, 0, 0);
}
return FALSE;
case WM_SETUPAUTOCOMPLETE:
SHAutoComplete(GetWindow(GetDlgItem(hDlg, IDD_COMMAND), GW_CHILD), (SHACF_FILESYSTEM | SHACF_URLALL | SHACF_FILESYS_ONLY));
break;
case WM_HELP:
WinHelp((HWND) ((LPHELPINFO) lParam)->hItemHandle, NULL, HELP_WM_HELP,
(ULONG_PTR) (LPTSTR) aRunHelpIds);
break;
case WM_CONTEXTMENU: // right mouse click
WinHelp((HWND) wParam, NULL, HELP_CONTEXTMENU,
(ULONG_PTR) (LPTSTR) aRunHelpIds);
break;
case WM_DESTROY:
break;
case WM_COMMAND:
switch (GET_WM_COMMAND_ID(wParam, lParam))
{
case IDHELP:
break;
case IDD_COMMAND:
switch (GET_WM_COMMAND_CMD(wParam, lParam))
{
case CBN_SELCHANGE:
MRUSelChange(hDlg);
#ifdef WINNT
if ( g_hCheckNow )
SetEvent( g_hCheckNow );
#endif // WINNT
break;
case CBN_EDITCHANGE:
case CBN_SELENDOK:
EnableOKButtonFromID(hDlg, IDD_COMMAND);
#ifdef WINNT
if ( g_hCheckNow )
SetEvent( g_hCheckNow );
#endif // WINNT
break;
}
break;
case IDOK:
// fake an ENTER key press so AutoComplete can do it's thing
if ( SendMessage( GetDlgItem( hDlg, IDD_COMMAND), WM_KEYDOWN, VK_RETURN, 0x1c0001 ) )
{
if (!prd->OKPushed()) {
#ifdef WINNT
if (!(prd->m_dwFlags & RFD_NOSEPMEMORY_BOX))
{
g_bCheckRunInSep = FALSE;
SetEvent( g_hCheckNow );
}
#endif // WINNT
break;
}
}
else
{
break; // AutoComplete wants more user input
}
// fall through
case IDCANCEL:
prd->ExitRunDlg(FALSE);
break;
case IDD_BROWSE:
prd->BrowsePushed();
#ifdef WINNT
SetEvent( g_hCheckNow );
#endif // WINNT
break;
default:
return FALSE;
}
break;
default:
return FALSE;
}
return TRUE;
}
// Puts up the standard file.run dialog.
// REVIEW UNDONE This should use a RUNDLG structure for all the various
// options instead of just passing them as parameters, a ptr to the struct
// would be passed to the dialog via the lParam.
STDAPI_(int) RunFileDlg(HWND hwndParent, HICON hIcon, LPCTSTR pszWorkingDir, LPCTSTR pszTitle, LPCTSTR pszPrompt, DWORD dwFlags)
{
int rc = 0;
IDropTarget *pdt;
CoInitialize(0);
CRunDlg_CreateInstance(NULL, IID_IDropTarget, (IUnknown **)&pdt);
if (pdt)
{
CRunDlg * prd = (CRunDlg *) pdt;
prd->m_hIcon = hIcon;
prd->m_pszWorkingDir = pszWorkingDir;
prd->m_pszTitle = pszTitle;
prd->m_pszPrompt = pszPrompt;
prd->m_dwFlags = dwFlags;
if (SHRestricted(REST_RUNDLGMEMCHECKBOX))
ClearFlag(prd->m_dwFlags, RFD_NOSEPMEMORY_BOX);
else
SetFlag(prd->m_dwFlags, RFD_NOSEPMEMORY_BOX);
// prd->m_hEventReady = 0;
// prd->m_dwThreadId = 0;
// We do this so we can get type-ahead when we're running on a
// separate thread. The parent thread needs to block to give us time
// to do the attach and then get some messages out of the queue hence
// the event.
if (hwndParent)
{
// HACK The parent signals it's waiting for the dialog to grab type-ahead
// by sticking it's threadId in a property on the parent.
prd->m_dwThreadId = PtrToUlong(GetProp(hwndParent, c_szWaitingThreadID));
if (prd->m_dwThreadId)
{
// DebugMsg(DM_TRACE, "s.rfd: Attaching input to %x.", idThread);
AttachThreadInput(GetCurrentThreadId(), prd->m_dwThreadId, TRUE);
// NB Hack.
prd->m_hEventReady = OpenEvent(EVENT_ALL_ACCESS, TRUE, c_szRunDlgReady);
}
}
rc = (int)DialogBoxParam(HINST_THISDLL, MAKEINTRESOURCE(DLG_RUN), hwndParent,
RunDlgProc, (LPARAM)prd);
pdt->Release();
}
CoUninitialize();
return rc;
}
Reference in New Issue Copy Permalink