Microsoft/WindowsXP-SP1
Microsoft
/
WindowsXP-SP1
1
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity
WindowsXP-SP1/shell/comdlg32/filenew.cpp

12164 lines
338 KiB
C++
Raw Permalink Blame History

/*++
Copyright (c) 1990-1998, Microsoft Corporation All rights reserved.
Module Name:
filenew.cpp
Abstract:
This module implements the Win32 explorer fileopen dialogs.
--*/
//
// Include Files.
//
// precompiled headers
#include "precomp.h"
#pragma hdrstop
#include "cdids.h"
#include "fileopen.h"
#include "d32tlog.h"
#include "filenew.h"
#include "filemru.h"
#include "util.h"
#include "uxtheme.h"
#ifndef ASSERT
#define ASSERT Assert
#endif
//
// Constant Declarations.
//
#define IDOI_SHARE 1
#define CDM_SETSAVEBUTTON (CDM_LAST + 100)
#define CDM_FSNOTIFY (CDM_LAST + 101)
#define CDM_SELCHANGE (CDM_LAST + 102)
#define TIMER_FSCHANGE 100
#define NODE_DESKTOP 0
#define NODE_DRIVES 1
#define DEREFMACRO(x) x
#define FILE_PADDING 10
#define MAX_URL_STRING INTERNET_MAX_URL_LENGTH
#define MAXDOSFILENAMELEN (12 + 1) // 8.3 filename + 1 for NULL
//
// IShellView::MenuHelp flags.
//
#define MH_DONE 0x0001
// MH_LONGHELP
#define MH_MERGEITEM 0x0004
#define MH_SYSITEM 0x0008
#define MH_POPUP 0x0010
#define MH_TOOLBAR 0x0020
#define MH_TOOLTIP 0x0040
//
// IShellView::MenuHelp return values.
//
#define MH_NOTHANDLED 0
#define MH_STRINGFILLED 1
#define MH_ALLHANDLED 2
#define MYCBN_DRAW 0x8000
#define MIN_DEFEXT_LEN 4
#define MAX_DRIVELIST_STRING_LEN (64 + 4)
#define REGSTR_PATH_PLACESBAR TEXT("Software\\Microsoft\\Windows\\CurrentVersion\\Policies\\comdlg32\\Placesbar")
#define MAXPLACESBARITEMS 5
//
// Macro Definitions.
//
#define IsServer(psz) (IsUNC(psz) && !StrChr((psz) + 2, CHAR_BSLASH))
#define LPIDL_GetIDList(_pida,n) \
(LPCITEMIDLIST)(((LPBYTE)(_pida)) + (_pida)->aoffset[n])
#define RECTWIDTH(_rc) ((_rc).right - (_rc).left)
#define RECTHEIGHT(_rc) ((_rc).bottom - (_rc).top)
#define IsVisible(_hwnd) (GetWindowLong(_hwnd, GWL_STYLE) & WS_VISIBLE)
#define HwndToBrowser(_hwnd) (CFileOpenBrowser *)GetWindowLongPtr(_hwnd, DWLP_USER)
#define StoreBrowser(_hwnd, _pbrs) \
SetWindowLongPtr(_hwnd, DWLP_USER, (LONG_PTR)_pbrs);
//
// Typedef Declarations.
//
typedef struct _OFNINITINFO
{
LPOPENFILEINFO lpOFI;
BOOL bSave;
BOOL bEnableSizing;
HRESULT hrOleInit;
} OFNINITINFO, *LPOFNINITINFO;
#define VC_NEWFOLDER 0
#define VC_VIEWLIST 1
#define VC_VIEWDETAILS 2
//
// Global Variables.
//
HWND gp_hwndActiveOpen = NULL;
HACCEL gp_haccOpen = NULL;
HACCEL gp_haccOpenView = NULL;
HHOOK gp_hHook = NULL;
int gp_nHookRef = -1;
UINT gp_uQueryCancelAutoPlay = 0;
static int g_cxSmIcon = 0 ;
static int g_cySmIcon = 0 ;
static int g_cxGrip;
static int g_cyGrip;
const LPCSTR c_szCommandsA[] =
{
CMDSTR_NEWFOLDERA,
CMDSTR_VIEWLISTA,
CMDSTR_VIEWDETAILSA,
};
const LPCWSTR c_szCommandsW[] =
{
CMDSTR_NEWFOLDERW,
CMDSTR_VIEWLISTW,
CMDSTR_VIEWDETAILSW,
};
extern "C"
{
extern RECT g_rcDlg;
}
//
// Function Prototypes.
//
LRESULT CALLBACK
OKSubclass(
HWND hOK,
UINT msg,
WPARAM wParam,
LPARAM lParam);
void
GetControlsArea(
HWND hDlg,
HWND hwndExclude,
HWND hwndGrip,
POINT *pPtSize,
LPINT pTop);
BOOL_PTR CALLBACK
OpenDlgProc(
HWND hDlg,
UINT message,
WPARAM wParam,
LPARAM lParam);
void
StoreLengthInString(
LPTSTR lpStr,
UINT cchLen,
UINT cchStore);
//
// Context Help IDs.
//
DWORD aFileOpenHelpIDs[] =
{
stc2, IDH_OPEN_FILETYPE, // The positions of these array elements
cmb1, IDH_OPEN_FILETYPE, // shouldn't be changed without updating
stc4, IDH_OPEN_LOCATION, // InitSaveAsControls().
cmb2, IDH_OPEN_LOCATION,
stc1, IDH_OPEN_FILES32,
lst2, IDH_OPEN_FILES32, // defview
stc3, IDH_OPEN_FILENAME,
edt1, IDH_OPEN_FILENAME,
cmb13, IDH_OPEN_FILENAME,
chx1, IDH_OPEN_READONLY,
IDOK, IDH_OPEN_BUTTON,
ctl1, IDH_OPEN_SHORTCUT_BAR,
0, 0
};
DWORD aFileSaveHelpIDs[] =
{
stc2, IDH_SAVE_FILETYPE, // The positions of these array elements
cmb1, IDH_SAVE_FILETYPE, // shouldn't be changed without updating
stc4, IDH_OPEN_LOCATION, // InitSaveAsControls().
cmb2, IDH_OPEN_LOCATION,
stc1, IDH_OPEN_FILES32,
lst2, IDH_OPEN_FILES32, // defview
stc3, IDH_OPEN_FILENAME,
edt1, IDH_OPEN_FILENAME,
cmb13, IDH_OPEN_FILENAME,
chx1, IDH_OPEN_READONLY,
IDOK, IDH_SAVE_BUTTON,
ctl1, IDH_OPEN_SHORTCUT_BAR,
0, 0
};
////////////////////////////////////////////////////////////////////////////
//
// CD_SendShareMsg
//
////////////////////////////////////////////////////////////////////////////
WORD CD_SendShareMsg(
HWND hwnd,
LPTSTR szFile,
UINT ApiType)
{
if (ApiType == COMDLG_ANSI)
{
CHAR szFileA[MAX_PATH + 1];
SHUnicodeToAnsi(szFile,szFileA,SIZECHARS(szFileA));
return ((WORD)SendMessage(hwnd,
msgSHAREVIOLATIONA,
0,
(LONG_PTR)(LPSTR)(szFileA)));
}
else
{
return ((WORD)SendMessage(hwnd,
msgSHAREVIOLATIONW,
0,
(LONG_PTR)(LPTSTR)(szFile)));
}
}
////////////////////////////////////////////////////////////////////////////
//
// CD_SendHelpMsg
//
////////////////////////////////////////////////////////////////////////////
VOID CD_SendHelpMsg(
LPOPENFILENAME pOFN,
HWND hwndDlg,
UINT ApiType)
{
if (ApiType == COMDLG_ANSI)
{
if (msgHELPA && pOFN->hwndOwner)
{
SendMessage(pOFN->hwndOwner,
msgHELPA,
(WPARAM)hwndDlg,
(LPARAM)pOFN);
}
}
else
{
if (msgHELPW && pOFN->hwndOwner)
{
SendMessage(pOFN->hwndOwner,
msgHELPW,
(WPARAM)hwndDlg,
(LPARAM)pOFN);
}
}
}
////////////////////////////////////////////////////////////////////////////
//
// CD_SendOKMsg
//
////////////////////////////////////////////////////////////////////////////
LRESULT CD_SendOKMsg(
HWND hwnd,
LPOPENFILENAME pOFN,
LPOPENFILEINFO pOFI)
{
LRESULT Result;
if (pOFI->ApiType == COMDLG_ANSI)
{
ThunkOpenFileNameW2A(pOFI);
Result = SendMessage(hwnd, msgFILEOKA, 0, (LPARAM)(pOFI->pOFNA));
//
// For apps that side-effect pOFNA stuff and expect it to
// be preserved through dialog exit, update internal
// struct after the hook proc is called.
//
ThunkOpenFileNameA2W(pOFI);
}
else
{
Result = SendMessage(hwnd, msgFILEOKW, 0, (LPARAM)(pOFN));
}
return (Result);
}
////////////////////////////////////////////////////////////////////////////
//
// CD_SendLBChangeMsg
//
////////////////////////////////////////////////////////////////////////////
LRESULT CD_SendLBChangeMsg(
HWND hwnd,
int Id,
short Index,
short Code,
UINT ApiType)
{
if (ApiType == COMDLG_ANSI)
{
return (SendMessage(hwnd, msgLBCHANGEA, Id, MAKELONG(Index, Code)));
}
else
{
return (SendMessage(hwnd, msgLBCHANGEW, Id, MAKELONG(Index, Code)));
}
}
////////////////////////////////////////////////////////////////////////////
//
// Macro calls to SendOFNotify
//
////////////////////////////////////////////////////////////////////////////
#define CD_SendShareNotify(_hwndTo, _hwndFrom, _szFile, _pofn, _pofi) \
(WORD)SendOFNotify(_hwndTo, _hwndFrom, CDN_SHAREVIOLATION, _szFile, _pofn, _pofi)
#define CD_SendHelpNotify(_hwndTo, _hwndFrom, _pofn, _pofi) \
SendOFNotify(_hwndTo, _hwndFrom, CDN_HELP, NULL, _pofn, _pofi)
#define CD_SendOKNotify(_hwndTo, _hwndFrom, _pofn, _pofi) \
SendOFNotify(_hwndTo, _hwndFrom, CDN_FILEOK, NULL, _pofn, _pofi)
#define CD_SendTypeChangeNotify(_hwndTo, _hwndFrom, _pofn, _pofi) \
SendOFNotify(_hwndTo, _hwndFrom, CDN_TYPECHANGE, NULL, _pofn, _pofi)
#define CD_SendInitDoneNotify(_hwndTo, _hwndFrom, _pofn, _pofi) \
SendOFNotify(_hwndTo, _hwndFrom, CDN_INITDONE, NULL, _pofn, _pofi)
#define CD_SendSelChangeNotify(_hwndTo, _hwndFrom, _pofn, _pofi) \
SendOFNotify(_hwndTo, _hwndFrom, CDN_SELCHANGE, NULL, _pofn, _pofi)
#define CD_SendFolderChangeNotify(_hwndTo, _hwndFrom, _pofn, _pofi) \
SendOFNotify(_hwndTo, _hwndFrom, CDN_FOLDERCHANGE, NULL, _pofn, _pofi)
#define CD_SendIncludeItemNotify(_hwndTo, _hwndFrom, _psf, _pidl, _pofn, _pofi) \
SendOFNotifyEx(_hwndTo, _hwndFrom, CDN_INCLUDEITEM, (void *)_psf, (void *)_pidl, _pofn, _pofi)
////////////////////////////////////////////////////////////////////////////
//
// SendOFNotifyEx
//
////////////////////////////////////////////////////////////////////////////
LRESULT SendOFNotifyEx(
HWND hwndTo,
HWND hwndFrom,
UINT code,
void * psf,
void * pidl,
LPOPENFILENAME pOFN,
LPOPENFILEINFO pOFI)
{
OFNOTIFYEX ofnex;
if (pOFI->ApiType == COMDLG_ANSI)
{
OFNOTIFYEXA ofnexA;
LRESULT Result;
ofnexA.psf = psf;
ofnexA.pidl = pidl;
//
// Convert the OFN from Unicode to Ansi.
//
ThunkOpenFileNameW2A(pOFI);
ofnexA.lpOFN = pOFI->pOFNA;
#ifdef NEED_WOWGETNOTIFYSIZE_HELPER
ASSERT(WOWGetNotifySize(code) == sizeof(OFNOTIFYEXA));
#endif
Result = SendNotify(hwndTo, hwndFrom, code, &ofnexA.hdr);
//
// For apps that side-effect pOFNA stuff and expect it to
// be preserved through dialog exit, update internal
// struct after the hook proc is called.
//
ThunkOpenFileNameA2W(pOFI);
return (Result);
}
else
{
ofnex.psf = psf;
ofnex.pidl = pidl;
ofnex.lpOFN = pOFN;
#ifdef NEED_WOWGETNOTIFYSIZE_HELPER
ASSERT(WOWGetNotifySize(code) == sizeof(OFNOTIFYEXW));
#endif
return (SendNotify(hwndTo, hwndFrom, code, &ofnex.hdr));
}
}
////////////////////////////////////////////////////////////////////////////
//
// SendOFNotify
//
////////////////////////////////////////////////////////////////////////////
LRESULT SendOFNotify(
HWND hwndTo,
HWND hwndFrom,
UINT code,
LPTSTR szFile,
LPOPENFILENAME pOFN,
LPOPENFILEINFO pOFI)
{
OFNOTIFY ofn;
if (pOFI->ApiType == COMDLG_ANSI)
{
OFNOTIFYA ofnA;
LRESULT Result;
//
// Convert the file name from Unicode to Ansi.
//
if (szFile)
{
CHAR szFileA[MAX_PATH + 1];
SHUnicodeToAnsi(szFile,szFileA,SIZECHARS(szFileA));
ofnA.pszFile = szFileA;
}
else
{
ofnA.pszFile = NULL;
}
//
// Convert the OFN from Unicode to Ansi.
//
ThunkOpenFileNameW2A(pOFI);
ofnA.lpOFN = pOFI->pOFNA;
#ifdef NEED_WOWGETNOTIFYSIZE_HELPER
ASSERT(WOWGetNotifySize(code) == sizeof(OFNOTIFYA));
#endif
Result = SendNotify(hwndTo, hwndFrom, code, &ofnA.hdr);
//
// For apps that side-effect pOFNA stuff and expect it to
// be preserved through dialog exit, update internal
// struct after the hook proc is called.
//
ThunkOpenFileNameA2W(pOFI);
return (Result);
}
else
{
ofn.pszFile = szFile;
ofn.lpOFN = pOFN;
#ifdef NEED_WOWGETNOTIFYSIZE_HELPER
ASSERT(WOWGetNotifySize(code) == sizeof(OFNOTIFY));
#endif
return (SendNotify(hwndTo, hwndFrom, code, &ofn.hdr));
}
}
////////////////////////////////////////////////////////////////////////////
//
// TEMPMEM::Resize
//
////////////////////////////////////////////////////////////////////////////
BOOL TEMPMEM::Resize(
UINT cb)
{
UINT uOldSize = m_uSize;
m_uSize = cb;
if (!cb)
{
if (m_pMem)
{
LocalFree(m_pMem);
m_pMem = NULL;
}
return TRUE;
}
if (!m_pMem)
{
m_pMem = LocalAlloc(LPTR, cb);
return (m_pMem != NULL);
}
void * pTemp = LocalReAlloc(m_pMem, cb, LHND);
if (pTemp)
{
m_pMem = pTemp;
return TRUE;
}
m_uSize = uOldSize;
return FALSE;
}
////////////////////////////////////////////////////////////////////////////
//
// TEMPSTR::StrCpy
//
////////////////////////////////////////////////////////////////////////////
BOOL TEMPSTR::StrCpy(
LPCTSTR pszText)
{
if (!pszText)
{
StrSize(0);
return TRUE;
}
UINT uNewSize = lstrlen(pszText) + 1;
if (!StrSize(uNewSize))
{
return FALSE;
}
lstrcpy(*this, pszText);
return TRUE;
}
////////////////////////////////////////////////////////////////////////////
//
// TEMPSTR::StrCat
//
////////////////////////////////////////////////////////////////////////////
BOOL TEMPSTR::StrCat(
LPCTSTR pszText)
{
if (!(LPTSTR)*this)
{
//
// This should 0 init.
//
if (!StrSize(MAX_PATH))
{
return FALSE;
}
}
UINT uNewSize = lstrlen(*this) + lstrlen(pszText) + 1;
if (m_uSize < uNewSize * sizeof(TCHAR))
{
//
// Add on some more so we do not ReAlloc too often.
//
uNewSize += MAX_PATH;
if (!StrSize(uNewSize))
{
return FALSE;
}
}
lstrcat(*this, pszText);
return TRUE;
}
////////////////////////////////////////////////////////////////////////////
//
// IsVolumeLFN
//
////////////////////////////////////////////////////////////////////////////
BOOL IsVolumeLFN(LPCTSTR pszRoot)
{
DWORD dwVolumeSerialNumber;
DWORD dwMaximumComponentLength;
DWORD dwFileSystemFlags;
//
// We need to find out what kind of a drive we are running
// on in order to determine if spaces are valid in a filename
// or not.
//
if (GetVolumeInformation(pszRoot,
NULL,
0,
&dwVolumeSerialNumber,
&dwMaximumComponentLength,
&dwFileSystemFlags,
NULL,
0))
{
if (dwMaximumComponentLength != (MAXDOSFILENAMELEN - 1))
return TRUE;
}
return FALSE;
}
////////////////////////////////////////////////////////////////////////////
//
// CDMessageBox
//
////////////////////////////////////////////////////////////////////////////
int _cdecl CDMessageBox(
HWND hwndParent,
UINT idText,
UINT uFlags,
...)
{
TCHAR szText[MAX_PATH + WARNINGMSGLENGTH];
TCHAR szTitle[WARNINGMSGLENGTH];
va_list ArgList;
CDLoadString(g_hinst, idText, szTitle, ARRAYSIZE(szTitle));
va_start(ArgList, uFlags);
wvsprintf(szText, szTitle, ArgList);
va_end(ArgList);
GetWindowText(hwndParent, szTitle, ARRAYSIZE(szTitle));
return (MessageBox(hwndParent, szText, szTitle, uFlags));
}
int OFErrFromHresult(HRESULT hr)
{
switch (hr)
{
case HRESULT_FROM_WIN32(ERROR_FILE_NOT_FOUND):
return OF_FILENOTFOUND;
case E_ACCESSDENIED:
return OF_ACCESSDENIED;
default:
return -1;
}
}
BOOL CFileOpenBrowser::_SaveAccessDenied(LPCTSTR pszFile)
{
if (CDMessageBox(_hwndDlg, iszDirSaveAccessDenied, MB_YESNO | MB_ICONEXCLAMATION, pszFile) == IDYES)
{
LPITEMIDLIST pidl;
if (SUCCEEDED(SHGetFolderLocation(_hwndDlg, CSIDL_PERSONAL, NULL, 0, &pidl)))
{
JumpToIDList(pidl);
ILFree(pidl);
}
}
return FALSE;
}
////////////////////////////////////////////////////////////////////////////
//
// InvalidFileWarningNew
//
////////////////////////////////////////////////////////////////////////////
VOID InvalidFileWarningNew(
HWND hWnd,
LPCTSTR pszFile,
int wErrCode)
{
int isz;
BOOL bDriveLetter = FALSE;
switch (wErrCode)
{
case (OF_ACCESSDENIED) :
{
isz = iszFileAccessDenied;
break;
}
case (ERROR_NOT_READY) :
{
isz = iszNoDiskInDrive;
bDriveLetter = TRUE;
break;
}
case (OF_NODRIVE) :
{
isz = iszDriveDoesNotExist;
bDriveLetter = TRUE;
break;
}
case (OF_NOFILEHANDLES) :
{
isz = iszNoFileHandles;
break;
}
case (OF_PATHNOTFOUND) :
{
isz = iszPathNotFound;
break;
}
case (OF_FILENOTFOUND) :
{
isz = iszFileNotFound;
break;
}
case (OF_DISKFULL) :
case (OF_DISKFULL2) :
{
isz = iszDiskFull;
bDriveLetter = TRUE;
break;
}
case (OF_WRITEPROTECTION) :
{
isz = iszWriteProtection;
bDriveLetter = TRUE;
break;
}
case (OF_SHARINGVIOLATION) :
{
isz = iszSharingViolation;
break;
}
case (OF_CREATENOMODIFY) :
{
isz = iszCreateNoModify;
break;
}
case (OF_NETACCESSDENIED) :
{
isz = iszNetworkAccessDenied;
break;
}
case (OF_PORTNAME) :
{
isz = iszPortName;
break;
}
case (OF_LAZYREADONLY) :
{
isz = iszReadOnly;
break;
}
case (OF_INT24FAILURE) :
{
isz = iszInt24Error;
break;
}
default :
{
isz = iszInvalidFileName;
break;
}
}
if (bDriveLetter)
{
CDMessageBox(hWnd, isz, MB_OK | MB_ICONEXCLAMATION, *pszFile);
}
else
{
CDMessageBox(hWnd, isz, MB_OK | MB_ICONEXCLAMATION, pszFile);
}
if (isz == iszInvalidFileName)
{
CFileOpenBrowser *pDlgStruct = HwndToBrowser(hWnd);
if (pDlgStruct && pDlgStruct->_bUseCombo)
{
PostMessage(hWnd, WM_NEXTDLGCTL, (WPARAM)GetDlgItem(hWnd, cmb13), 1);
}
else
{
PostMessage(hWnd, WM_NEXTDLGCTL, (WPARAM)GetDlgItem(hWnd, edt1), 1);
}
}
}
////////////////////////////////////////////////////////////////////////////
//
// GetControlRect
//
////////////////////////////////////////////////////////////////////////////
void GetControlRect(
HWND hwndDlg,
UINT idOldCtrl,
LPRECT lprc)
{
HWND hwndOldCtrl = GetDlgItem(hwndDlg, idOldCtrl);
GetWindowRect(hwndOldCtrl, lprc);
MapWindowRect(HWND_DESKTOP, hwndDlg, lprc);
}
////////////////////////////////////////////////////////////////////////////
//
// HideControl
//
// Subroutine to hide a dialog control.
//
// WARNING WARNING WARNING: Some code in the new look depends on hidden
// controls remaining where they originally were, even when disabled,
// because they're templates for where to create new controls (the toolbar,
// or the main list). Therefore, HideControl() must not MOVE the control
// being hidden - it may only hide and disable it. If this needs to change,
// there must be a separate hiding subroutine used for template controls.
//
////////////////////////////////////////////////////////////////////////////
void HideControl(
HWND hwndDlg,
UINT idControl)
{
HWND hCtrl = ::GetDlgItem(hwndDlg, idControl);
::ShowWindow(hCtrl, SW_HIDE);
::EnableWindow(hCtrl, FALSE);
}
////////////////////////////////////////////////////////////////////////////
//
// SelectEditText
//
////////////////////////////////////////////////////////////////////////////
void SelectEditText(
HWND hwndDlg)
{
CFileOpenBrowser *pDlgStruct = HwndToBrowser(hwndDlg);
if (pDlgStruct && pDlgStruct->_bUseCombo)
{
HWND hwndEdit = (HWND)SendMessage(GetDlgItem(hwndDlg, cmb13), CBEM_GETEDITCONTROL, 0, 0L);
Edit_SetSel(hwndEdit, 0, -1);
}
else
{
Edit_SetSel(GetDlgItem(hwndDlg, edt1), 0, -1);
}
}
////////////////////////////////////////////////////////////////////////////
//
// GetPathFromLocation
//
////////////////////////////////////////////////////////////////////////////
BOOL GetPathFromLocation(
MYLISTBOXITEM *pLocation,
LPTSTR pszBuf)
{
BOOL fRet = FALSE;
//
// Zero out the return buffer in case of error.
//
*pszBuf = 0;
//
// Try normal channels first.
//
//See if the IShellFolder we have is a shorcut if so get path from shortcut
if (pLocation->psfSub)
{
IShellLink *psl;
if (SUCCEEDED(pLocation->psfSub->QueryInterface(IID_PPV_ARG(IShellLink, &psl))))
{
fRet = SUCCEEDED(psl->GetPath(pszBuf, MAX_PATH, 0, 0));
psl->Release();
}
}
if (!fRet)
fRet = SHGetPathFromIDList(pLocation->pidlFull, pszBuf);
if (!fRet)
{
//
// Call GetDisplayNameOf with empty pidl.
//
if (pLocation->psfSub)
{
STRRET str;
ITEMIDLIST idNull = {0};
if (SUCCEEDED(pLocation->psfSub->GetDisplayNameOf(&idNull,
SHGDN_FORPARSING,
&str)))
{
fRet = TRUE;
StrRetToBuf(&str, &idNull, pszBuf, MAX_PATH);
}
}
}
//
// Return the result.
//
return (fRet);
}
inline _IsSaveContainer(SFGAOF f)
{
return ((f & (SFGAO_FOLDER | SFGAO_FILESYSANCESTOR)) == (SFGAO_FOLDER | SFGAO_FILESYSANCESTOR));
}
inline _IsOpenContainer(SFGAOF f)
{
return ((f & SFGAO_FOLDER) && (f & (SFGAO_STORAGEANCESTOR | SFGAO_FILESYSANCESTOR)));
}
inline _IncludeSaveItem(SFGAOF f)
{
return (f & (SFGAO_FILESYSANCESTOR | SFGAO_FILESYSTEM));
}
inline _IncludeOpenItem(SFGAOF f)
{
return (f & (SFGAO_FILESYSANCESTOR | SFGAO_STORAGEANCESTOR | SFGAO_STREAM | SFGAO_FILESYSTEM));
}
inline _IsFolderShortcut(SFGAOF f)
{
return ((f & (SFGAO_FOLDER | SFGAO_LINK)) == (SFGAO_FOLDER | SFGAO_LINK));
}
inline _IsStream(SFGAOF f)
{
return ((f & SFGAO_STREAM) || ((f & SFGAO_FILESYSTEM) && !(f & SFGAO_FILESYSANCESTOR)));
}
inline _IsCollection(SFGAOF f)
{
return ((f & (SFGAO_STREAM | SFGAO_FOLDER)) == (SFGAO_STREAM | SFGAO_FOLDER));
}
#define MLBI_PERMANENT 0x0001
#define MLBI_PSFFROMPARENT 0x0002
MYLISTBOXITEM::MYLISTBOXITEM() : _cRef(1)
{
}
// This is a special Case Init Function for Initializing Recent Files folder at the top
// of namespace in the look in control.
BOOL MYLISTBOXITEM::Init(
HWND hwndCmb,
IShellFolder *psf,
LPCITEMIDLIST pidl,
DWORD c,
DWORD f,
DWORD dwAttribs,
int iImg,
int iSelImg)
{
_hwndCmb = hwndCmb;
cIndent = c;
dwFlags = f;
pidlThis = ILClone(pidl);
pidlFull = ILClone(pidl);
psfSub = psf;
psfSub->AddRef();
dwAttrs = dwAttribs;
iImage = iImg;
iSelectedImage = iSelImg;
return TRUE;
}
BOOL MYLISTBOXITEM::Init(
HWND hwndCmb,
MYLISTBOXITEM *pParentItem,
IShellFolder *psf,
LPCITEMIDLIST pidl,
DWORD c,
DWORD f,
IShellTaskScheduler* pScheduler)
{
if (psf == NULL)
{
// Invalid parameter passed.
return FALSE;
}
_hwndCmb = hwndCmb;
cIndent = c;
dwFlags = f;
pidlThis = ILClone(pidl);
if (pParentItem == NULL)
{
pidlFull = ILClone(pidl);
}
else
{
pidlFull = ILCombine(pParentItem->pidlFull, pidl);
}
if (pidlThis == NULL || pidlFull == NULL)
{
psfSub = NULL;
}
if (dwFlags & MLBI_PSFFROMPARENT)
{
psfParent = psf;
}
else
{
psfSub = psf;
}
psf->AddRef();
dwAttrs = SHGetAttributes(psf, pidl, SFGAO_FILESYSANCESTOR | SFGAO_STORAGEANCESTOR | SFGAO_STREAM | SFGAO_FILESYSTEM | SFGAO_FOLDER | SFGAO_SHARE);
AddRef();
if (E_PENDING != SHMapIDListToImageListIndexAsync(pScheduler, psf, pidl, 0,
_AsyncIconTaskCallback, this, NULL, &iImage, &iSelectedImage))
{
Release();
}
return TRUE;
}
ULONG MYLISTBOXITEM::AddRef()
{
return InterlockedIncrement(&_cRef);
}
ULONG MYLISTBOXITEM::Release()
{
if (InterlockedDecrement(&_cRef))
return _cRef;
delete this;
return 0;
}
MYLISTBOXITEM::~MYLISTBOXITEM()
{
if (psfSub != NULL)
{
psfSub->Release();
}
if (psfParent != NULL)
{
psfParent->Release();
}
if (pidlThis != NULL)
{
SHFree(pidlThis);
}
if (pidlFull != NULL)
{
SHFree(pidlFull);
}
}
void MYLISTBOXITEM::_AsyncIconTaskCallback(LPCITEMIDLIST pidl, void * pvData,
void * pvHint, INT iIconIndex, INT iOpenIconIndex)
{
MYLISTBOXITEM *plbItem = (MYLISTBOXITEM *)pvData;
plbItem->iImage = iIconIndex;
plbItem->iSelectedImage = iOpenIconIndex;
// Make sure the combobox redraws.
if (plbItem->_hwndCmb)
{
RECT rc;
if (GetClientRect(plbItem->_hwndCmb, &rc))
{
InvalidateRect(plbItem->_hwndCmb, &rc, FALSE);
}
}
plbItem->Release();
}
BOOL IsContainer(
IShellFolder *psf,
LPCITEMIDLIST pidl)
{
return _IsOpenContainer(SHGetAttributes(psf, pidl, SFGAO_FOLDER | SFGAO_STORAGEANCESTOR | SFGAO_FILESYSANCESTOR));
}
BOOL IsLink(
IShellFolder *psf,
LPCITEMIDLIST pidl)
{
return SHGetAttributes(psf, pidl, SFGAO_LINK);
}
IShellFolder *MYLISTBOXITEM::GetShellFolder()
{
if (!psfSub)
{
HRESULT hr;
if (ILIsEmpty(pidlThis)) // Some caller passes an empty pidl
hr = psfParent->QueryInterface(IID_PPV_ARG(IShellFolder, &psfSub));
else
hr = psfParent->BindToObject(pidlThis, NULL, IID_PPV_ARG(IShellFolder, &psfSub));
if (FAILED(hr))
{
psfSub = NULL;
}
else
{
psfParent->Release();
psfParent = NULL;
}
}
return (psfSub);
}
////////////////////////////////////////////////////////////////////////////
//
// MYLISTBOXITEM::SwitchCurrentDirectory
//
////////////////////////////////////////////////////////////////////////////
void MYLISTBOXITEM::SwitchCurrentDirectory(
ICurrentWorkingDirectory * pcwd)
{
TCHAR szDir[MAX_PATH + 1];
if (!pidlFull)
{
SHGetSpecialFolderPath(NULL, szDir, CSIDL_DESKTOPDIRECTORY, FALSE);
}
else
{
GetPathFromLocation(this, szDir);
}
if (szDir[0])
{
SetCurrentDirectory(szDir);
//
// Let AutoComplete know our Current Working Directory.
//
if (pcwd)
pcwd->SetDirectory(szDir);
}
}
////////////////////////////////////////////////////////////////////////////
//
// ShouldIncludeObject
//
////////////////////////////////////////////////////////////////////////////
BOOL ShouldIncludeObject(
CFileOpenBrowser *that,
LPSHELLFOLDER psfParent,
LPCITEMIDLIST pidl,
DWORD dwFlags)
{
BOOL fInclude = FALSE;
DWORD dwAttrs = SHGetAttributes(psfParent, pidl, SFGAO_FILESYSANCESTOR | SFGAO_STORAGEANCESTOR | SFGAO_STREAM | SFGAO_FILESYSTEM);
if (dwAttrs)
{
if ((dwFlags & OFN_ENABLEINCLUDENOTIFY) && that)
{
fInclude = BOOLFROMPTR(CD_SendIncludeItemNotify(that->_hSubDlg,
that->_hwndDlg,
psfParent,
pidl,
that->_pOFN,
that->_pOFI));
}
if (!fInclude)
{
fInclude = that->_bSave ? _IncludeSaveItem(dwAttrs) : _IncludeOpenItem(dwAttrs);
}
}
return (fInclude);
}
////////////////////////////////////////////////////////////////////////////
//
// CFileOpenBrowser::EnableFileMRU
//
//
////////////////////////////////////////////////////////////////////////////
void CFileOpenBrowser::EnableFileMRU(BOOL fEnable)
{
HWND hwnd = NULL;
if (fEnable)
{
HWND hwndCombo;
//Make sure combobox is there
hwndCombo = GetDlgItem(_hwndDlg, cmb13);
if (hwndCombo)
{
// if we are using the combobox then remove the edit box
_bUseCombo = TRUE;
SetFocus(hwndCombo);
hwnd = GetDlgItem(_hwndDlg,edt1);
}
else
{
goto UseEdit;
}
}
else
{
UseEdit:
//We are not going to use combobox.
_bUseCombo = FALSE;
//SetFocus to the edit window
SetFocus(GetDlgItem(_hwndDlg,edt1));
//Destroy the combo box
hwnd = GetDlgItem(_hwndDlg, cmb13);
}
if (hwnd)
{
DestroyWindow(hwnd);
}
}
////////////////////////////////////////////////////////////////////////////
//
// CFileOpenBrowser::CreateToolbar
//
// CreateToolbar member function.
// creates and initializes the places bar in the dialog
//
//
////////////////////////////////////////////////////////////////////////////
BOOL CFileOpenBrowser::CreateToolbar()
{
TBBUTTON atbButtons[] =
{
{ 0, IDC_BACK, 0, BTNS_BUTTON, { 0, 0 }, 0, -1 },
{ VIEW_PARENTFOLDER, IDC_PARENT, TBSTATE_ENABLED, BTNS_BUTTON, { 0, 0 }, 0, -1 },
{ VIEW_NEWFOLDER, IDC_NEWFOLDER, TBSTATE_ENABLED, BTNS_BUTTON, { 0, 0 }, 0, -1 },
{ VIEW_LIST, IDC_VIEWMENU, TBSTATE_ENABLED, BTNS_WHOLEDROPDOWN, { 0, 0 }, 0, -1 },
};
TBBUTTON atbButtonsNT4[] =
{
{ 0, 0, 0, BTNS_SEP, { 0, 0 }, 0, 0 },
{ VIEW_PARENTFOLDER, IDC_PARENT, TBSTATE_ENABLED, BTNS_BUTTON, { 0, 0 }, 0, -1 },
{ 0, 0, 0, BTNS_SEP, { 0, 0 }, 0, 0 },
{ VIEW_NEWFOLDER, IDC_NEWFOLDER, TBSTATE_ENABLED, BTNS_BUTTON, { 0, 0 }, 0, -1 },
{ 0, 0, 0, BTNS_SEP, { 0, 0 }, 0, 0 },
{ VIEW_LIST, IDC_VIEWLIST, TBSTATE_ENABLED | TBSTATE_CHECKED, BTNS_CHECKGROUP, { 0, 0 }, 0, -1 },
{ VIEW_DETAILS, IDC_VIEWDETAILS, TBSTATE_ENABLED, BTNS_CHECKGROUP, { 0, 0 }, 0, -1 }
};
LPTBBUTTON lpButton = atbButtons;
int iNumButtons = ARRAYSIZE(atbButtons);
RECT rcToolbar;
BOOL bBogusCtrlID = SHGetAppCompatFlags(ACF_FILEOPENBOGUSCTRLID) & ACF_FILEOPENBOGUSCTRLID;
DWORD dwStyle = WS_TABSTOP | TBSTYLE_TOOLTIPS | TBSTYLE_FLAT | WS_CHILD | CCS_NORESIZE |WS_GROUP | CCS_NODIVIDER;
// If app wants toolbar to have bogus ctrl ID, make it not a tabstop.
if (bBogusCtrlID)
dwStyle &= ~WS_TABSTOP;
BOOL bAppHack = (CDGetAppCompatFlags() & CDACF_NT40TOOLBAR) ? TRUE : FALSE;
if (bAppHack)
{
lpButton = atbButtonsNT4;
iNumButtons =ARRAYSIZE(atbButtonsNT4);
dwStyle &= ~TBSTYLE_FLAT;
}
GetControlRect(_hwndDlg, stc1, &rcToolbar);
_hwndToolbar = CreateToolbarEx(_hwndDlg,
dwStyle,
// stc1: use static text ctrlID
// For apps that expect the old bad way, use IDOK.
bBogusCtrlID ? IDOK : stc1,
12,
HINST_COMMCTRL,
IDB_VIEW_SMALL_COLOR,
lpButton,
iNumButtons,
0,
0,
0,
0,
sizeof(TBBUTTON));
if (_hwndToolbar)
{
TBADDBITMAP ab;
SendMessage(_hwndToolbar, TB_SETEXTENDEDSTYLE, TBSTYLE_EX_DRAWDDARROWS, TBSTYLE_EX_DRAWDDARROWS);
//Documentation says that we need to send TB_BUTTONSTRUCTSIZE before we add bitmaps
SendMessage(_hwndToolbar, TB_BUTTONSTRUCTSIZE, (WPARAM)sizeof(TBBUTTON), (LPARAM)0);
SendMessage(_hwndToolbar, TB_SETMAXTEXTROWS, (WPARAM)0, (LPARAM)0);
if (!bAppHack)
{
if (!IsRestricted(REST_NOBACKBUTTON))
{
//Add the back/forward navigation buttons
ab.hInst = HINST_COMMCTRL;
ab.nID = IDB_HIST_SMALL_COLOR;
int iIndex = (int) SendMessage(_hwndToolbar, TB_ADDBITMAP, 5, (LPARAM)&ab);
//Now set the image index for back button
TBBUTTONINFO tbbi;
tbbi.cbSize = sizeof(TBBUTTONINFO);
tbbi.dwMask = TBIF_IMAGE | TBIF_BYINDEX;
SendMessage(_hwndToolbar, TB_GETBUTTONINFO, (WPARAM)0, (LPARAM)&tbbi);
tbbi.iImage = iIndex + HIST_BACK;
SendMessage(_hwndToolbar, TB_SETBUTTONINFO, (WPARAM)0, (LPARAM)&tbbi);
}
else
{
//Back button is restricted. Delete the back button from the toolbar
SendMessage(_hwndToolbar, TB_DELETEBUTTON, (WPARAM)0, (LPARAM)0);
}
}
::SetWindowPos(_hwndToolbar,
// Place it after its static control (unless app expects old way)
bBogusCtrlID ? NULL : GetDlgItem(_hwndDlg, stc1),
rcToolbar.left,
rcToolbar.top,
rcToolbar.right - rcToolbar.left,
rcToolbar.bottom - rcToolbar.top,
SWP_NOACTIVATE | SWP_SHOWWINDOW | (bBogusCtrlID ? SWP_NOZORDER : 0));
return TRUE;
}
return FALSE;
}
////////////////////////////////////////////////////////////////////////////
//
// CFileOpenBrowser::_GetPBItemFromCSIDL(DWORD csidl, SHFILEINFO * psfi, LPITEMIDLIST *ppidl)
// Gets a SHFileInfo and pidl for a CSIDL which is used in the places bar
////////////////////////////////////////////////////////////////////////////
BOOL CFileOpenBrowser::_GetPBItemFromCSIDL(DWORD csidl, SHFILEINFO * psfi, LPITEMIDLIST *ppidl)
{
if (SUCCEEDED(SHGetSpecialFolderLocation(NULL, csidl, ppidl)))
{
// Are there restrictions on mydocuments or mycomputer? Check for SFGAO_NONENUMERATED
// This is for the policies that hide mydocs and mycomputer.
if ((csidl == CSIDL_PERSONAL) || (csidl == CSIDL_DRIVES))
{
DWORD dwAttr = SFGAO_NONENUMERATED;
if (SUCCEEDED(SHGetAttributesOf(*ppidl, &dwAttr)) && (dwAttr & SFGAO_NONENUMERATED))
{
// We won't create a placesbar item for this guy.
ILFree(*ppidl);
return FALSE;
}
}
return SHGetFileInfo((LPCTSTR)*ppidl, 0, psfi, sizeof(*psfi), SHGFI_SYSICONINDEX | SHGFI_PIDL | SHGFI_DISPLAYNAME);
}
return FALSE;
}
typedef struct
{
LPCWSTR pszToken;
int nFolder; //CSIDL
} STRINGTOCSIDLMAP;
static const STRINGTOCSIDLMAP g_rgStringToCSIDL[] =
{
{ L"MyDocuments", CSIDL_PERSONAL },
{ L"MyMusic", CSIDL_MYMUSIC },
{ L"MyPictures", CSIDL_MYPICTURES },
{ L"MyVideo", CSIDL_MYVIDEO },
{ L"CommonDocuments", CSIDL_COMMON_DOCUMENTS },
{ L"CommonPictures", CSIDL_COMMON_PICTURES },
{ L"CommonMusic", CSIDL_COMMON_MUSIC },
{ L"CommonVideo", CSIDL_COMMON_VIDEO },
{ L"Desktop", CSIDL_DESKTOP },
{ L"Recent", CSIDL_RECENT },
{ L"MyNetworkPlaces", CSIDL_NETHOOD },
{ L"MyFavorites", CSIDL_FAVORITES },
{ L"MyComputer", CSIDL_DRIVES },
{ L"Printers", CSIDL_PRINTERS },
{ L"ProgramFiles", CSIDL_PROGRAM_FILES },
};
////////////////////////////////////////////////////////////////////////////
//
// CFileOpenBrowser::_GetPBItemFromTokenStrings(LPTSTR lpszPath, SHFILEINFO * psfi, LPITEMIDLIST *ppidl)
// Gets a SHFileInfo and pidl for a path which is used in the places bar
////////////////////////////////////////////////////////////////////////////
BOOL CFileOpenBrowser::_GetPBItemFromTokenStrings(LPTSTR lpszPath, SHFILEINFO * psfi, LPITEMIDLIST *ppidl)
{
for (int i = 0; i < ARRAYSIZE(g_rgStringToCSIDL); i++)
{
if (StrCmpI(lpszPath, g_rgStringToCSIDL[i].pszToken) == 0)
{
return _GetPBItemFromCSIDL(g_rgStringToCSIDL[i].nFolder, psfi, ppidl);
}
}
return FALSE;
}
////////////////////////////////////////////////////////////////////////////
//
// CFileOpenBrowser::_GetPBItemFromPath(LPTSTR lpszPath, SHFILEINFO * psfi, LPITEMIDLIST *ppidl)
// Gets a SHFileInfo and pidl for a path which is used in the places bar
////////////////////////////////////////////////////////////////////////////
BOOL CFileOpenBrowser::_GetPBItemFromPath(LPTSTR lpszPath, SHFILEINFO * psfi, LPITEMIDLIST *ppidl)
{
TCHAR szTemp[MAX_PATH];
//Expand environment strings if any
if (ExpandEnvironmentStrings(lpszPath, szTemp, SIZECHARS(szTemp)))
{
lstrcpy(lpszPath, szTemp);
}
SHGetFileInfo(lpszPath,0,psfi,sizeof(*psfi), SHGFI_ICON|SHGFI_LARGEICON | SHGFI_DISPLAYNAME);
SHILCreateFromPath(lpszPath, ppidl, NULL);
return TRUE;
}
////////////////////////////////////////////////////////////////////////////
//
// CFileOpenBrowser::_EnumPlacesBarItem(HKEY, int, SHFILEINFO)
// Enumerates the Place bar item in the registry
////////////////////////////////////////////////////////////////////////////
BOOL CFileOpenBrowser::_EnumPlacesBarItem(HKEY hkey, int i , SHFILEINFO * psfi, LPITEMIDLIST *ppidl)
{
BOOL bRet = FALSE;
if (hkey == NULL)
{
static const int aPlaces[] =
{
CSIDL_RECENT,
CSIDL_DESKTOP,
CSIDL_PERSONAL,
CSIDL_DRIVES,
CSIDL_NETWORK,
};
if (i >= 0 && i < MAXPLACESBARITEMS)
{
bRet = _GetPBItemFromCSIDL(aPlaces[i], psfi, ppidl);
}
}
else
{
TCHAR szName[MAX_PATH];
TCHAR szValue[MAX_PATH];
DWORD cbValue;
DWORD dwType;
cbValue = ARRAYSIZE(szValue);
wsprintf(szName, TEXT("Place%d"), i);
if (RegQueryValueEx(hkey, szName, NULL, &dwType, (LPBYTE)szValue, &cbValue) == ERROR_SUCCESS)
{
if ((dwType != REG_DWORD) && (dwType != REG_EXPAND_SZ) && (dwType != REG_SZ))
{
return FALSE;
}
if (dwType == REG_DWORD)
{
bRet = _GetPBItemFromCSIDL((DWORD)*szValue, psfi, ppidl);
}
else
{
if (dwType == REG_SZ)
{
// Check for special strings that indicate places.
bRet = _GetPBItemFromTokenStrings(szValue, psfi, ppidl);
}
if (!bRet)
{
bRet = _GetPBItemFromPath(szValue, psfi, ppidl);
}
}
}
}
return bRet;
}
////////////////////////////////////////////////////////////////////////////
//
// CFileOpenBrowser::_GetPlacesBarItemToolTip
//
////////////////////////////////////////////////////////////////////////////
BOOL CFileOpenBrowser::_GetPlacesBarItemToolTip(int idCmd, LPTSTR pText, DWORD dwSize)
{
TBBUTTONINFO tbbi;
LPITEMIDLIST pidl;
BOOL bRet = FALSE;
// Return null string in case anything goes wrong
pText[0] = TEXT('\0');
tbbi.cbSize = SIZEOF(tbbi);
tbbi.lParam = 0;
tbbi.dwMask = TBIF_LPARAM;
if (SendMessage(_hwndPlacesbar, TB_GETBUTTONINFO, idCmd, (LPARAM)&tbbi) < 0)
return FALSE;
pidl = (LPITEMIDLIST)tbbi.lParam;
if (pidl)
{
IShellFolder *psf;
LPITEMIDLIST pidlLast;
HRESULT hres = CDBindToIDListParent(pidl, IID_PPV_ARG(IShellFolder, &psf), (LPCITEMIDLIST *)&pidlLast);
if (SUCCEEDED(hres))
{
IQueryInfo *pqi;
if (SUCCEEDED(psf->GetUIObjectOf(NULL, 1, (LPCITEMIDLIST *)&pidlLast, IID_IQueryInfo, NULL, (void**)&pqi)))
{
WCHAR *pwszTip;
if (SUCCEEDED(pqi->GetInfoTip(0, &pwszTip)) && pwszTip)
{
SHUnicodeToTChar(pwszTip, pText, dwSize);
SHFree(pwszTip);
bRet = TRUE;
}
pqi->Release();
}
psf->Release();
}
}
return bRet;
}
///////////////////////////////////////////////////////////////////////////
//
// CFileOpenBrorwser::_RecreatePlacesbar
//
// called when something changes that requires the placesbar be recreated (e.g. icons change)
//
///////////////////////////////////////////////////////////////////////////
void CFileOpenBrowser::_RecreatePlacesbar()
{
if (_hwndPlacesbar)
{
// Free any pidls in the places bar
_CleanupPlacesbar();
// Remove all buttons in places bar
int cButtons = (int)SendMessage(_hwndPlacesbar, TB_BUTTONCOUNT, 0, 0);
for (int i = 0; i < cButtons; i++)
{
SendMessage(_hwndPlacesbar, TB_DELETEBUTTON, 0, 0);
}
// Put them back in, with potentially new images.
_FillPlacesbar(_hwndPlacesbar);
}
}
////////////////////////////////////////////////////////////////////////////
//
// CFileOpenBrowser::CreatePlacesBar
//
// CreatePlacesBar member function.
// creates and initializes the places bar in the dialog
//
//
////////////////////////////////////////////////////////////////////////////
HWND CFileOpenBrowser::CreatePlacesbar(HWND hwndDlg)
{
HWND hwndTB = GetDlgItem(hwndDlg, ctl1);
if (hwndTB)
{
//Set the version for the toolbar
SendMessage(hwndTB, CCM_SETVERSION, COMCTL32_VERSION, 0);
// Sets the size of the TBBUTTON structure.
SendMessage(hwndTB, TB_BUTTONSTRUCTSIZE, sizeof(TBBUTTON), 0);
SetWindowTheme(hwndTB, L"Placesbar", NULL);
SendMessage(hwndTB, TB_SETMAXTEXTROWS, 2, 0); // Try to set toolbar to show 2 rows
// For themes, we'll change the default padding, so we need to save it
// off in case we need to restore it.
_dwPlacesbarPadding = SendMessage(hwndTB, TB_GETPADDING, 0, 0);
_FillPlacesbar(hwndTB);
}
return hwndTB;
}
void CFileOpenBrowser::_FillPlacesbar(HWND hwndPlacesbar)
{
HKEY hkey = NULL;
int i;
TBBUTTON tbb;
SHFILEINFO sfi;
LPITEMIDLIST pidl;
HIMAGELIST himl;
//See if Places bar key is available
RegOpenKey(HKEY_CURRENT_USER, REGSTR_PATH_PLACESBAR, &hkey);
Shell_GetImageLists(&himl, NULL);
for (i=0; i < MAXPLACESBARITEMS; i++)
{
if (_EnumPlacesBarItem(hkey, i, &sfi, &pidl))
{
//Now Add the item to the toolbar
tbb.iBitmap = sfi.iIcon;
tbb.fsState = TBSTATE_ENABLED;
tbb.fsStyle = BTNS_BUTTON;
tbb.idCommand = IDC_PLACESBAR_BASE + _iCommandID;
tbb.iString = (INT_PTR)&sfi.szDisplayName;
tbb.dwData = (INT_PTR)pidl;
SendMessage(hwndPlacesbar, TB_ADDBUTTONS, (UINT)1, (LPARAM)&tbb);
//Increment the command ID
_iCommandID++;
}
}
//Close the reg key
if (hkey)
{
RegCloseKey(hkey);
}
HIMAGELIST himlOld = (HIMAGELIST) SendMessage(hwndPlacesbar, TB_SETIMAGELIST, 0, (LPARAM)himl);
// Destroy the old imagelist only the first time. After this, the imagelist we get back is the
// one we've set, the system imagelist.
if ((himlOld != NULL) && _bDestroyPlacesbarImageList)
{
ImageList_Destroy(himlOld);
}
_bDestroyPlacesbarImageList = FALSE;
OnThemeActive(_hwndDlg, IsAppThemed());
// Add the buttons
SendMessage(hwndPlacesbar, TB_AUTOSIZE, (WPARAM)0, (LPARAM)0);
}
void CFileOpenBrowser::_CleanupPlacesbar()
{
if (_hwndPlacesbar)
{
TBBUTTONINFO tbbi;
LPITEMIDLIST pidl;
for (int i=0; i < MAXPLACESBARITEMS; i++)
{
tbbi.cbSize = SIZEOF(tbbi);
tbbi.lParam = 0;
tbbi.dwMask = TBIF_LPARAM | TBIF_BYINDEX;
if (SendMessage(_hwndPlacesbar, TB_GETBUTTONINFO, i, (LPARAM)&tbbi) >= 0)
{
pidl = (LPITEMIDLIST)tbbi.lParam;
if (pidl)
{
ILFree(pidl);
}
}
}
}
}
// Less padding for themes
#define PLACESBAR_THEMEPADDING MAKELPARAM(2, 2)
void CFileOpenBrowser::OnThemeActive(HWND hwndDlg, BOOL bActive)
{
HWND hwndPlacesBar = GetDlgItem(hwndDlg, ctl1);
if (hwndPlacesBar)
{
// For themes, use the default colour scheme for the places toolbar:
COLORSCHEME cs;
cs.dwSize = SIZEOF(cs);
cs.clrBtnHighlight = bActive ? CLR_DEFAULT : GetSysColor(COLOR_BTNHIGHLIGHT);
cs.clrBtnShadow = bActive ? CLR_DEFAULT : GetSysColor(COLOR_3DDKSHADOW);
SendMessage(hwndPlacesBar, TB_SETCOLORSCHEME, 0, (LPARAM) &cs);
// For themes, we have a background, so make the toolbar background non-transparent
// (the resource specifies TBSTYLE_FLAT, which includes TBSTYLE_TRANSPARENT)
DWORD_PTR dwTBStyle = SendMessage(hwndPlacesBar, TB_GETSTYLE, 0, 0);
SendMessage(hwndPlacesBar, TB_SETSTYLE, 0, bActive ? (dwTBStyle & ~TBSTYLE_TRANSPARENT) : (dwTBStyle | TBSTYLE_TRANSPARENT));
// Special padding for themes on comctlv6 only (RAID #424528)
if (SendMessage(hwndPlacesBar, CCM_GETVERSION, 0, 0) >= 0x600)
{
SendMessage(hwndPlacesBar, TB_SETPADDING, 0, bActive? PLACESBAR_THEMEPADDING : _dwPlacesbarPadding);
}
// Remove the clientedge extended style for themes
LONG_PTR dwPlacesExStyle = GetWindowLongPtr(hwndPlacesBar, GWL_EXSTYLE);
SetWindowLongPtr(hwndPlacesBar, GWL_EXSTYLE, bActive ? (dwPlacesExStyle & ~WS_EX_CLIENTEDGE) : (dwPlacesExStyle | WS_EX_CLIENTEDGE));
// And apply these frame style changes...
SetWindowPos(hwndPlacesBar, NULL, 0, 0, 0, 0, SWP_NOSIZE | SWP_NOZORDER | SWP_NOMOVE | SWP_FRAMECHANGED);
// Ensure buttons go right to edge of client area (client area has changed)
RECT rc;
GetClientRect(hwndPlacesBar, &rc);
SendMessage(hwndPlacesBar, TB_SETBUTTONWIDTH, 0, (LPARAM)MAKELONG(RECTWIDTH(rc), RECTWIDTH(rc)));
}
}
////////////////////////////////////////////////////////////////////////////
//
// CFileOpenBrowser::CFileOpenBrowser
//
// CFileOpenBrowser constructor.
// Minimal construction of the object. Much more construction in
// InitLocation.
//
////////////////////////////////////////////////////////////////////////////
CFileOpenBrowser::CFileOpenBrowser(
HWND hDlg,
BOOL fIsSaveAs)
: _cRef(1),
_iCurrentLocation(-1),
_iVersion(OPENFILEVERSION),
_pCurrentLocation(NULL),
_psv(NULL),
_hwndDlg(hDlg),
_hwndView(NULL),
_hwndToolbar(NULL),
_psfCurrent(NULL),
_bSave(fIsSaveAs),
_iComboIndex(-1),
_hwndTips(NULL),
_ptlog(NULL),
_iCheckedButton(-1),
_pidlSelection(NULL),
_lpOKProc(NULL)
{
_iNodeDesktop = NODE_DESKTOP;
_iNodeDrives = NODE_DRIVES;
_szLastFilter[0] = CHAR_NULL;
_bEnableSizing = FALSE;
_bUseCombo = TRUE;
_hwndGrip = NULL;
_ptLastSize.x = 0;
_ptLastSize.y = 0;
_sizeView.cx = 0;
_bUseSizeView = FALSE;
_bAppRedrawn = FALSE;
_bDestroyPlacesbarImageList = TRUE;
HMENU hMenu;
hMenu = GetSystemMenu(hDlg, FALSE);
DeleteMenu(hMenu, SC_MINIMIZE, MF_BYCOMMAND);
DeleteMenu(hMenu, SC_MAXIMIZE, MF_BYCOMMAND);
DeleteMenu(hMenu, SC_RESTORE, MF_BYCOMMAND);
Shell_GetImageLists(NULL, &_himl);
//
// This setting could change on the fly, but I really don't care
// about that rare case.
//
SHELLSTATE ss;
SHGetSetSettings(&ss, SSF_SHOWEXTENSIONS, FALSE);
_fShowExtensions = ss.fShowExtensions;
_pScheduler = NULL;
CoCreateInstance(CLSID_ShellTaskScheduler, NULL, CLSCTX_INPROC, IID_PPV_ARG(IShellTaskScheduler, &_pScheduler));
}
////////////////////////////////////////////////////////////////////////////
//
// CFileOpenBrowser::~CFileOpenBrowser
//
// CFileOpenBrowser destructor.
//
////////////////////////////////////////////////////////////////////////////
CFileOpenBrowser::~CFileOpenBrowser()
{
if (_uRegister)
{
SHChangeNotifyDeregister(_uRegister);
_uRegister = 0;
}
//
// Ensure that we discard the tooltip window.
//
if (_hwndTips)
{
DestroyWindow(_hwndTips);
_hwndTips = NULL; // handle is no longer valid
}
if (_hwndGrip)
{
DestroyWindow(_hwndGrip);
_hwndGrip = NULL;
}
_CleanupPlacesbar();
if (_pcwd)
{
_pcwd->Release();
}
if (_ptlog)
{
_ptlog->Release();
}
Pidl_Set(&_pidlSelection,NULL);
if (_pScheduler)
_pScheduler->Release();
}
HRESULT CFileOpenBrowser::QueryInterface(REFIID riid, void **ppvObj)
{
static const QITAB qit[] = {
QITABENT(CFileOpenBrowser, IShellBrowser), // IID_IShellBrowser
QITABENT(CFileOpenBrowser, ICommDlgBrowser2), // IID_ICommDlgBrowser2
QITABENTMULTI(CFileOpenBrowser, ICommDlgBrowser, ICommDlgBrowser2), // IID_ICommDlgBrowser
QITABENT(CFileOpenBrowser, IServiceProvider), // IID_IServiceProvider
{ 0 },
};
return QISearch(this, qit, riid, ppvObj);
}
ULONG CFileOpenBrowser::AddRef()
{
return InterlockedIncrement(&_cRef);
}
ULONG CFileOpenBrowser::Release()
{
if (InterlockedDecrement(&_cRef))
return _cRef;
delete this;
return 0;
}
STDMETHODIMP CFileOpenBrowser::GetWindow(HWND *phwnd)
{
*phwnd = _hwndDlg;
return S_OK;
}
////////////////////////////////////////////////////////////////////////////
//
// CFileOpenBrowser::ContextSensitiveHelp
//
////////////////////////////////////////////////////////////////////////////
STDMETHODIMP CFileOpenBrowser::ContextSensitiveHelp(
BOOL fEnable)
{
//
// Shouldn't need in a common dialog.
//
return S_OK;
}
////////////////////////////////////////////////////////////////////////////
//
// CFileOpenBrowser::SetStatusTextSB
//
////////////////////////////////////////////////////////////////////////////
STDMETHODIMP CFileOpenBrowser::SetStatusTextSB(
LPCOLESTR pwch)
{
//
// We don't have any status bar.
//
return S_OK;
}
////////////////////////////////////////////////////////////////////////////
//
// GetFocusedChild
//
////////////////////////////////////////////////////////////////////////////
HWND GetFocusedChild(
HWND hwndDlg,
HWND hwndFocus)
{
HWND hwndParent;
if (!hwndDlg)
{
return (NULL);
}
if (!hwndFocus)
{
hwndFocus = ::GetFocus();
}
//
// Go up the parent chain until the parent is the main dialog.
//
while ((hwndParent = ::GetParent(hwndFocus)) != hwndDlg)
{
if (!hwndParent)
{
return (NULL);
}
hwndFocus = hwndParent;
}
return (hwndFocus);
}
////////////////////////////////////////////////////////////////////////////
//
// CFileOpenBrowser::EnableModelessSB
//
////////////////////////////////////////////////////////////////////////////
typedef struct
{
UINT idExcept;
BOOL fEnable;
} ENABLEKIDS;
#define PROP_WASDISABLED TEXT("Comdlg32_WasDisabled")
BOOL CALLBACK _EnableKidsEnum(HWND hwnd, LPARAM lp)
{
ENABLEKIDS *pek = (ENABLEKIDS *)lp;
if (pek->idExcept != GetDlgCtrlID(hwnd))
{
if (pek->fEnable)
{
// When re-enabling, don't re-enable windows that were
// previously disabled
if (!RemoveProp(hwnd, PROP_WASDISABLED))
{
EnableWindow(hwnd, TRUE);
}
}
else
{
// When disabling, remember whether the window was already
// disabled so we don't accidentally re-enable it
if (EnableWindow(hwnd, pek->fEnable))
{
SetProp(hwnd, PROP_WASDISABLED, IntToPtr(TRUE));
}
}
}
return TRUE;
}
void EnableChildrenWithException(HWND hwndDlg, UINT idExcept, BOOL fEnable)
{
ENABLEKIDS ek = {idExcept, fEnable};
::EnumChildWindows(hwndDlg, _EnableKidsEnum, (LPARAM)&ek);
}
STDMETHODIMP CFileOpenBrowser::EnableModelessSB(BOOL fEnable)
{
LONG cBefore = _cRefCannotNavigate;
if (fEnable)
{
_cRefCannotNavigate--;
}
else
{
_cRefCannotNavigate++;
}
ASSERT(_cRefCannotNavigate >= 0);
if (!cBefore || !_cRefCannotNavigate)
{
// we changed state
ASSERT(_cRefCannotNavigate >= 0);
if (!fEnable)
_hwndModelessFocus = GetFocusedChild(_hwndDlg, NULL);
EnableChildrenWithException(_hwndDlg, IDCANCEL, fEnable);
if (fEnable && _hwndModelessFocus)
SetFocus(_hwndModelessFocus);
}
return S_OK;
}
////////////////////////////////////////////////////////////////////////////
//
// CFileOpenBrowser::TranslateAcceleratorSB
//
////////////////////////////////////////////////////////////////////////////
STDMETHODIMP CFileOpenBrowser::TranslateAcceleratorSB(
LPMSG pmsg,
WORD wID)
{
//
// We don't use the Key Stroke.
//
return S_FALSE;
}
////////////////////////////////////////////////////////////////////////////
//
// CFileOpenBrowser::BrowseObject
//
////////////////////////////////////////////////////////////////////////////
STDMETHODIMP CFileOpenBrowser::BrowseObject(
LPCITEMIDLIST pidl,
UINT wFlags)
{
return JumpToIDList(pidl);
}
BOOL _IsRecentFolder(LPCITEMIDLIST pidl)
{
ASSERT(pidl);
BOOL fRet = FALSE;
LPITEMIDLIST pidlRecent = SHCloneSpecialIDList(NULL, CSIDL_RECENT, TRUE);
if (pidlRecent)
{
fRet = ILIsEqual(pidlRecent, pidl);
ILFree(pidlRecent);
}
return fRet;
}
// My Pictures or My Videos
BOOL CFileOpenBrowser::_IsThumbnailFolder(LPCITEMIDLIST pidl)
{
BOOL fThumbnailFolder = FALSE;
WCHAR szPath[MAX_PATH + 1];
if (SHGetPathFromIDList(pidl, szPath))
{
fThumbnailFolder = PathIsEqualOrSubFolder(MAKEINTRESOURCE(CSIDL_MYPICTURES), szPath) ||
PathIsEqualOrSubFolder(MAKEINTRESOURCE(CSIDL_MYVIDEO), szPath);
}
return fThumbnailFolder;
}
static const GUID CLSID_WIA_FOLDER1 =
{ 0xe211b736, 0x43fd, 0x11d1, { 0x9e, 0xfb, 0x00, 0x00, 0xf8, 0x75, 0x7f, 0xcd} };
static const GUID CLSID_WIA_FOLDER2 =
{ 0xFB0C9C8A, 0x6C50, 0x11D1, { 0x9F, 0x1D, 0x00, 0x00, 0xf8, 0x75, 0x7f, 0xcd} };
LOCTYPE CFileOpenBrowser::_GetLocationType(MYLISTBOXITEM *pLocation)
{
if (_IsRecentFolder(pLocation->pidlFull))
return LOCTYPE_RECENT_FOLDER;
if (_IsThumbnailFolder(pLocation->pidlFull))
return LOCTYPE_MYPICTURES_FOLDER;
IShellFolder *psf = pLocation->GetShellFolder(); // Note: this is a MYLISTBOXITEM member variable, don't need to Release()
if (_IsWIAFolder(psf))
{
return LOCTYPE_WIA_FOLDER;
}
return LOCTYPE_OTHERS;
}
// Is it a windows image acquisition folder?
BOOL CFileOpenBrowser::_IsWIAFolder(IShellFolder *psf)
{
CLSID clsid;
return (psf &&
SUCCEEDED(IUnknown_GetClassID(psf, &clsid)) &&
(IsEqualGUID(clsid, CLSID_WIA_FOLDER1) || IsEqualGUID(clsid, CLSID_WIA_FOLDER2)));
}
////////////////////////////////////////////////////////////////////////////
//
// CFileOpenBrowser::GetViewStateStream
//
////////////////////////////////////////////////////////////////////////////
STDMETHODIMP CFileOpenBrowser::GetViewStateStream(
DWORD grfMode,
LPSTREAM *pStrm)
{
//
// FEATURE: We should implement this so there is some persistence
// for the file open dailog.
//
ASSERT(_pCurrentLocation);
ASSERT(pStrm);
*pStrm = NULL;
if ((grfMode == STGM_READ) && _IsRecentFolder(_pCurrentLocation->pidlFull))
{
// we want to open the stream from the registry...
*pStrm = SHOpenRegStream(HKEY_LOCAL_MACHINE, TEXT("Software\\microsoft\\windows\\currentversion\\explorer\\recentdocs"),
TEXT("ViewStream"), grfMode);
}
return (*pStrm ? S_OK : E_FAIL);
}
////////////////////////////////////////////////////////////////////////////
//
// CFileOpenBrowser::GetControlWindow
//
// Get the handles of the various windows in the File Cabinet.
//
////////////////////////////////////////////////////////////////////////////
STDMETHODIMP CFileOpenBrowser::GetControlWindow(
UINT id,
HWND *lphwnd)
{
if (id == FCW_TOOLBAR)
{
*lphwnd = _hwndToolbar;
return S_OK;
}
return (E_NOTIMPL);
}
////////////////////////////////////////////////////////////////////////////
//
// CFileOpenBrowser::SendControlMsg
//
////////////////////////////////////////////////////////////////////////////
STDMETHODIMP CFileOpenBrowser::SendControlMsg(
UINT id,
UINT uMsg,
WPARAM wParam,
LPARAM lParam,
LRESULT *pret)
{
LRESULT lres = 0;
if (id == FCW_TOOLBAR)
{
//
// We need to translate messages from defview intended for these
// buttons to our own.
//
switch (uMsg)
{
case (TB_CHECKBUTTON) :
{
#if 0 // we don't do this anymore because we use the viewmenu dropdown
switch (wParam)
{
case (SFVIDM_VIEW_DETAILS) :
{
wParam = IDC_VIEWDETAILS;
break;
}
case (SFVIDM_VIEW_LIST) :
{
wParam = IDC_VIEWLIST;
break;
}
default :
{
goto Bail;
}
}
break;
#endif
}
default :
{
goto Bail;
break;
}
}
lres = SendMessage(_hwndToolbar, uMsg, wParam, lParam);
}
Bail:
if (pret)
{
*pret = lres;
}
return S_OK;
}
////////////////////////////////////////////////////////////////////////////
//
// CFileOpenBrowser::QueryActiveShellView
//
////////////////////////////////////////////////////////////////////////////
STDMETHODIMP CFileOpenBrowser::QueryActiveShellView(
LPSHELLVIEW *ppsv)
{
if (_psv)
{
*ppsv = _psv;
_psv->AddRef();
return S_OK;
}
*ppsv = NULL;
return (E_NOINTERFACE);
}
////////////////////////////////////////////////////////////////////////////
//
// CFileOpenBrowser::OnViewWindowActive
//
////////////////////////////////////////////////////////////////////////////
STDMETHODIMP CFileOpenBrowser::OnViewWindowActive(
LPSHELLVIEW _psv)
{
//
// No need to process this. We don't do menus.
//
return S_OK;
}
////////////////////////////////////////////////////////////////////////////
//
// CFileOpenBrowser::InsertMenusSB
//
////////////////////////////////////////////////////////////////////////////
STDMETHODIMP CFileOpenBrowser::InsertMenusSB(
HMENU hmenuShared,
LPOLEMENUGROUPWIDTHS lpMenuWidths)
{
return (E_NOTIMPL);
}
////////////////////////////////////////////////////////////////////////////
//
// CFileOpenBrowser::SetMenuSB
//
////////////////////////////////////////////////////////////////////////////
STDMETHODIMP CFileOpenBrowser::SetMenuSB(
HMENU hmenuShared,
HOLEMENU holemenu,
HWND hwndActiveObject)
{
return (E_NOTIMPL);
}
////////////////////////////////////////////////////////////////////////////
//
// CFileOpenBrowser::RemoveMenusSB
//
////////////////////////////////////////////////////////////////////////////
STDMETHODIMP CFileOpenBrowser::RemoveMenusSB(
HMENU hmenuShared)
{
return (E_NOTIMPL);
}
////////////////////////////////////////////////////////////////////////////
//
// CFileOpenBrowser::SetToolbarItems
//
////////////////////////////////////////////////////////////////////////////
STDMETHODIMP CFileOpenBrowser::SetToolbarItems(
LPTBBUTTON lpButtons,
UINT nButtons,
UINT uFlags)
{
//
// We don't let containers customize our toolbar.
//
return S_OK;
}
////////////////////////////////////////////////////////////////////////////
//
// CFileOpenBrowser::OnDefaultCommand
//
// Process a double-click or Enter keystroke in the view control.
//
////////////////////////////////////////////////////////////////////////////
STDMETHODIMP CFileOpenBrowser::OnDefaultCommand(
struct IShellView *ppshv)
{
if (ppshv != _psv)
{
return (E_INVALIDARG);
}
OnDblClick(FALSE);
return S_OK;
}
///////////////////////////////////
// *** IServiceProvider methods ***
///////////////////////////////////
HRESULT CFileOpenBrowser::QueryService(REFGUID guidService, REFIID riid, void **ppvObj)
{
HRESULT hr = E_FAIL;
*ppvObj = NULL;
if (IsEqualGUID(guidService, SID_SCommDlgBrowser))
{
hr = QueryInterface(riid, ppvObj);
}
return hr;
}
////////////////////////////////////////////////////////////////////////////
//
// CFileOpenBrowser::SetCurrentFilter
//
////////////////////////////////////////////////////////////////////////////
void CFileOpenBrowser::SetCurrentFilter(
LPCTSTR pszFilter,
OKBUTTONFLAGS Flags)
{
LPTSTR lpNext;
//
// Don't do anything if it's the same filter.
//
if (lstrcmp(_szLastFilter, pszFilter) == 0)
{
return;
}
lstrcpyn(_szLastFilter, pszFilter, ARRAYSIZE(_szLastFilter));
int nLeft = ARRAYSIZE(_szLastFilter) - lstrlen(_szLastFilter) - 1;
//
// Do nothing if quoted.
//
if (Flags & OKBUTTON_QUOTED)
{
return;
}
//
// If pszFilter matches a filter spec, select that spec.
//
HWND hCmb = GetDlgItem(_hwndDlg, cmb1);
if (hCmb)
{
int nMax = ComboBox_GetCount(hCmb);
int n;
BOOL bCustomFilter = _pOFN->lpstrCustomFilter && *_pOFN->lpstrCustomFilter;
for (n = 0; n < nMax; n++)
{
LPTSTR pFilter = (LPTSTR)ComboBox_GetItemData(hCmb, n);
if (pFilter && pFilter != (LPTSTR)CB_ERR)
{
if (!lstrcmpi(pFilter, pszFilter))
{
if (n != ComboBox_GetCurSel(hCmb))
{
ComboBox_SetCurSel(hCmb, n);
}
break;
}
}
}
}
//
// For LFNs, tack on a '*' after non-wild extensions.
//
for (lpNext = _szLastFilter; nLeft > 0;)
{
LPTSTR lpSemiColon = StrChr(lpNext, CHAR_SEMICOLON);
if (!lpSemiColon)
{
lpSemiColon = lpNext + lstrlen(lpNext);
}
TCHAR cTemp = *lpSemiColon;
*lpSemiColon = CHAR_NULL;
LPTSTR lpDot = StrChr(lpNext, CHAR_DOT);
//
// See if there is an extension that is not wild.
//
if (lpDot && *(lpDot + 1) && !IsWild(lpDot))
{
//
// Tack on a star.
// We know there is still enough room because nLeft > 0.
//
if (cTemp != CHAR_NULL)
{
MoveMemory(lpSemiColon + 2,
lpSemiColon + 1,
(lstrlen(lpSemiColon + 1) + 1) * sizeof(TCHAR)); // plus 1 for terminating NULL
}
*lpSemiColon = CHAR_STAR;
++lpSemiColon;
--nLeft;
}
*lpSemiColon = cTemp;
if (cTemp == CHAR_NULL)
{
break;
}
else
{
lpNext = lpSemiColon + 1;
}
}
}
////////////////////////////////////////////////////////////////////////////
//
// CFileOpenBrowser::SwitchView
//
// Switch the view control to a new container.
//
////////////////////////////////////////////////////////////////////////////
HRESULT CFileOpenBrowser::SwitchView(
IShellFolder *psfNew,
LPCITEMIDLIST pidlNew,
FOLDERSETTINGS *pfs,
SHELLVIEWID const *pvid,
BOOL fUseDefaultView)
{
IShellView *psvNew;
IShellView2 *psv2New;
RECT rc;
if (!psfNew)
{
return (E_INVALIDARG);
}
GetControlRect(_hwndDlg, lst1, &rc);
if (_bEnableSizing)
{
if (_hwndView)
{
//
// Don't directly use the rect but instead use the size as
// applications like VB may move the window off the screen.
//
RECT rcView;
GetWindowRect(_hwndView, &rcView);
_sizeView.cx = rcView.right - rcView.left;
_sizeView.cy = rcView.bottom - rcView.top;
rc.right = rc.left + _sizeView.cx;
rc.bottom = rc.top + _sizeView.cy;
}
else if (_bUseSizeView && _sizeView.cx)
{
//
// If we previously failed then use cached size.
//
rc.right = rc.left + _sizeView.cx;
rc.bottom = rc.top + _sizeView.cy;
}
}
HRESULT hres = psfNew->CreateViewObject(_hwndDlg, IID_PPV_ARG(IShellView, &psvNew));
if (FAILED(hres))
{
return hres;
}
IShellView *psvOld;
HWND hwndNew;
WAIT_CURSOR w(this);
//
// The view window itself won't take the focus. But we can set
// focus there and see if it bounces to the same place it is
// currently. If that's the case, we want the new view window
// to get the focus; otherwise, we put it back where it was.
//
BOOL bViewFocus = (GetFocusedChild(_hwndDlg, NULL) == _hwndView);
psvOld = _psv;
//
// We attempt to blow off drawing on the main dialog. Note that
// we should leave in SETREDRAW stuff to minimize flicker in case
// this fails.
//
BOOL bLocked = LockWindowUpdate(_hwndDlg);
//
// We need to kill the current _psv before creating the new one in case
// the current one has a background thread going that is trying to
// call us back (IncludeObject).
//
if (psvOld)
{
SendMessage(_hwndView, WM_SETREDRAW, FALSE, 0);
psvOld->DestroyViewWindow();
_hwndView = NULL;
_psv = NULL;
//
// Don't release yet. We will pass this to CreateViewWindow().
//
}
//
// At this point, there should be no background processing happening.
//
_psfCurrent = psfNew;
SHGetPathFromIDList(pidlNew, _szCurDir);
//
// New windows (like the view window about to be created) show up at
// the bottom of the Z order, so I need to disable drawing of the
// subdialog while creating the view window; drawing will be enabled
// after the Z-order has been set properly.
//
if (_hSubDlg)
{
SendMessage(_hSubDlg, WM_SETREDRAW, FALSE, 0);
}
//
// _psv must be set before creating the view window since we
// validate it on the IncludeObject callback.
//
_psv = psvNew;
if ((pvid || fUseDefaultView) && SUCCEEDED(psvNew->QueryInterface(IID_PPV_ARG(IShellView2, &psv2New))))
{
SV2CVW2_PARAMS cParams;
SHELLVIEWID vidCurrent = {0};
cParams.cbSize = SIZEOF(SV2CVW2_PARAMS);
cParams.psvPrev = psvOld;
cParams.pfs = pfs;
cParams.psbOwner = this;
cParams.prcView = &rc;
if (pvid)
cParams.pvid = pvid; // View id; for example, &CLSID_ThumbnailViewExt;
else
{
psv2New->GetView(&vidCurrent, SV2GV_DEFAULTVIEW);
// We don't want filmstrip view in fileopen, so we'll switch that to thumbnail.
if (IsEqualIID(VID_ThumbStrip, vidCurrent))
cParams.pvid = &VID_Thumbnails;
else
cParams.pvid = &vidCurrent;
}
hres = psv2New->CreateViewWindow2(&cParams);
hwndNew = cParams.hwndView;
psv2New->Release();
}
else
hres = _psv->CreateViewWindow(psvOld, pfs, this, &rc, &hwndNew);
_bUseSizeView = FAILED(hres);
if (SUCCEEDED(hres))
{
hres = psvNew->UIActivate(SVUIA_INPLACEACTIVATE);
}
if (psvOld)
{
psvOld->Release();
}
if (_hSubDlg)
{
//
// Turn REDRAW back on before changing the focus in case the
// SubDlg has the focus.
//
SendMessage(_hSubDlg, WM_SETREDRAW, TRUE, 0);
}
if (SUCCEEDED(hres))
{
DWORD dwAttr = SFGAO_STORAGE | SFGAO_READONLY;
SHGetAttributesOf(pidlNew, &dwAttr);
BOOL bNewFolder = (dwAttr & SFGAO_STORAGE) && !(dwAttr & SFGAO_READONLY);
::SendMessage(_hwndToolbar, TB_ENABLEBUTTON, IDC_NEWFOLDER, bNewFolder);
_hwndView = hwndNew;
//
// Move the view window to the right spot in the Z (tab) order.
//
SetWindowPos(hwndNew,
GetDlgItem(_hwndDlg, lst1),
0,
0,
0,
0,
SWP_NOMOVE | SWP_NOSIZE);
//
// Give it the right window ID for WinHelp.
//
SetWindowLong(hwndNew, GWL_ID, lst2);
::RedrawWindow(_hwndView,
NULL,
NULL,
RDW_INVALIDATE | RDW_ERASE |
RDW_ALLCHILDREN | RDW_UPDATENOW);
if (bViewFocus)
{
::SetFocus(_hwndView);
}
}
else
{
_psv = NULL;
psvNew->Release();
}
//
// Let's draw again!
//
if (bLocked)
{
LockWindowUpdate(NULL);
}
return hres;
}
void CFileOpenBrowser::_WaitCursor(BOOL fWait)
{
if (fWait)
_cWaitCursor++;
else
_cWaitCursor--;
SetCursor(LoadCursor(NULL, _cWaitCursor ? IDC_WAIT : IDC_ARROW));
}
BOOL CFileOpenBrowser::OnSetCursor()
{
if (_cWaitCursor)
{
SetCursor(LoadCursor(NULL, IDC_WAIT));
return TRUE;
}
return FALSE;
}
////////////////////////////////////////////////////////////////////////////
//
// JustGetToolTipText
//
////////////////////////////////////////////////////////////////////////////
void JustGetToolTipText(
UINT idCommand,
LPTOOLTIPTEXT pTtt)
{
if (!CDLoadString(::g_hinst,
idCommand + MH_TOOLTIPBASE,
pTtt->szText,
ARRAYSIZE(pTtt->szText)))
{
*pTtt->lpszText = 0;
}
}
////////////////////////////////////////////////////////////////////////////
//
// CFileOpenBrowser::OnNotify
//
// Process notify messages from the view -- for tooltips.
//
////////////////////////////////////////////////////////////////////////////
LRESULT CFileOpenBrowser::OnNotify(
LPNMHDR pnm)
{
LRESULT lres = 0;
switch (pnm->code)
{
case (TTN_NEEDTEXT) :
{
HWND hCtrl = GetDlgItem(_hwndDlg, cmb2);
LPTOOLTIPTEXT lptt = (LPTOOLTIPTEXT)pnm;
int iTemp;
//
// If this is the combo control which shows the current drive,
// then convert this into a suitable tool-tip message giving
// the 'full' path to this object.
//
if (pnm->idFrom == (UINT_PTR)hCtrl)
{
//
// iTemp will contain index of first path element.
//
GetDirectoryFromLB(_szTipBuf, &iTemp);
lptt->lpszText = _szTipBuf;
lptt->szText[0] = CHAR_NULL;
lptt->hinst = NULL; // no instance needed
}
else if (IsInRange(pnm->idFrom, FCIDM_SHVIEWFIRST, FCIDM_SHVIEWLAST))
{
if (_hwndView)
{
lres = ::SendMessage(_hwndView, WM_NOTIFY, 0, (LPARAM)pnm);
}
}
else if (IsInRange(pnm->idFrom, IDC_PLACESBAR_BASE, IDC_PLACESBAR_BASE + _iCommandID))
{
_GetPlacesBarItemToolTip((int)pnm->idFrom, _szTipBuf, ARRAYSIZE(_szTipBuf));
lptt->lpszText = _szTipBuf;
}
else
{
JustGetToolTipText((UINT) pnm->idFrom, lptt);
}
lres = TRUE;
break;
}
case (NM_STARTWAIT) :
case (NM_ENDWAIT) :
{
//
// What we really want is for the user to simulate a mouse
// move/setcursor.
//
_WaitCursor(pnm->code == NM_STARTWAIT);
break;
}
case (TBN_DROPDOWN) :
{
RECT r;
VARIANT v = {VT_INT_PTR};
TBNOTIFY *ptbn = (TBNOTIFY*)pnm;
DFVCMDDATA cd;
// v.vt = VT_I4;
v.byref = &r;
SendMessage(_hwndToolbar, TB_GETRECT, ptbn->iItem, (LPARAM)&r);
MapWindowRect(_hwndToolbar, HWND_DESKTOP, &r);
cd.pva = &v;
cd.hwnd = _hwndToolbar;
cd.nCmdIDTranslated = 0;
SendMessage(_hwndView, WM_COMMAND, SFVIDM_VIEW_VIEWMENU, (LONG_PTR)&cd);
break;
}
case (NM_CUSTOMDRAW) :
if (!IsAppThemed())
{
LPNMTBCUSTOMDRAW lpcust = (LPNMTBCUSTOMDRAW)pnm;
//Make sure its from places bar
if (lpcust->nmcd.hdr.hwndFrom == _hwndPlacesbar)
{
switch (lpcust->nmcd.dwDrawStage)
{
case (CDDS_PREERASE) :
{
HDC hdc = (HDC)lpcust->nmcd.hdc;
RECT rc;
GetClientRect(_hwndPlacesbar, &rc);
SHFillRectClr(hdc, &rc, GetSysColor(COLOR_BTNSHADOW));
lres = CDRF_SKIPDEFAULT;
SetDlgMsgResult(_hwndDlg, WM_NOTIFY, lres);
break;
}
case (CDDS_PREPAINT) :
{
lres = CDRF_NOTIFYITEMDRAW;
SetDlgMsgResult(_hwndDlg, WM_NOTIFY, lres);
break;
}
case (CDDS_ITEMPREPAINT) :
{
//Set the text color to window
lpcust->clrText = GetSysColor(COLOR_HIGHLIGHTTEXT);
lpcust->clrBtnFace = GetSysColor(COLOR_BTNSHADOW);
lpcust->nStringBkMode = TRANSPARENT;
lres = CDRF_DODEFAULT;
if (lpcust->nmcd.uItemState & CDIS_CHECKED)
{
lpcust->hbrMonoDither = NULL;
}
SetDlgMsgResult(_hwndDlg, WM_NOTIFY, lres);
break;
}
}
}
}
}
return (lres);
}
// Get the display name of a shell object.
void GetViewItemText(IShellFolder *psf, LPCITEMIDLIST pidl, LPTSTR pBuf, UINT cchBuf, DWORD flags = SHGDN_INFOLDER | SHGDN_FORPARSING)
{
DisplayNameOf(psf, pidl, flags, pBuf, cchBuf);
}
////////////////////////////////////////////////////////////////////////////
//
// GetListboxItem
//
// Get a MYLISTBOXITEM object out of the location dropdown.
//
////////////////////////////////////////////////////////////////////////////
MYLISTBOXITEM *GetListboxItem(
HWND hCtrl,
WPARAM iItem)
{
MYLISTBOXITEM *p = (MYLISTBOXITEM *)SendMessage(hCtrl,
CB_GETITEMDATA,
iItem,
NULL);
if (p == (MYLISTBOXITEM *)CB_ERR)
{
return NULL;
}
else
{
return p;
}
}
////////////////////////////////////////////////////////////////////////////
//
// _ReleaseStgMedium
//
////////////////////////////////////////////////////////////////////////////
HRESULT _ReleaseStgMedium(
LPSTGMEDIUM pmedium)
{
if (pmedium->pUnkForRelease)
{
pmedium->pUnkForRelease->Release();
}
else
{
switch (pmedium->tymed)
{
case (TYMED_HGLOBAL) :
{
GlobalFree(pmedium->hGlobal);
break;
}
default :
{
//
// Not fully implemented.
//
MessageBeep(0);
break;
}
}
}
return S_OK;
}
////////////////////////////////////////////////////////////////////////////
//
// CFileOpenBrowser::SetSaveButton
//
////////////////////////////////////////////////////////////////////////////
void CFileOpenBrowser::SetSaveButton(
UINT idSaveButton)
{
PostMessage(_hwndDlg, CDM_SETSAVEBUTTON, idSaveButton, 0);
}
////////////////////////////////////////////////////////////////////////////
//
// CFileOpenBrowser::RealSetSaveButton
//
////////////////////////////////////////////////////////////////////////////
void CFileOpenBrowser::RealSetSaveButton(
UINT idSaveButton)
{
MSG msg;
if (PeekMessage(&msg,
_hwndDlg,
CDM_SETSAVEBUTTON,
CDM_SETSAVEBUTTON,
PM_NOREMOVE))
{
//
// There is another SETSAVEBUTTON message in the queue, so blow off
// this one.
//
return;
}
if (_bSave)
{
TCHAR szTemp[40];
LPTSTR pszTemp = _tszDefSave;
//
// Load the string if not the "Save" string or there is no
// app-specified default.
//
if ((idSaveButton != iszFileSaveButton) || !pszTemp)
{
CDLoadString(g_hinst, idSaveButton, szTemp, ARRAYSIZE(szTemp));
pszTemp = szTemp;
}
GetDlgItemText(_hwndDlg, IDOK, _szBuf, ARRAYSIZE(_szBuf));
if (lstrcmp(_szBuf, pszTemp))
{
//
// Avoid some flicker.
//
SetDlgItemText(_hwndDlg, IDOK, pszTemp);
}
}
}
////////////////////////////////////////////////////////////////////////////
//
// CFileOpenBrowser::SetEditFile
//
////////////////////////////////////////////////////////////////////////////
void CFileOpenBrowser::SetEditFile(
LPCTSTR pszFile,
LPCTSTR pszFriendlyName,
BOOL bShowExt,
BOOL bSaveNullExt)
{
BOOL bHasHiddenExt = FALSE;
//
// Save the whole file name.
//
if (!_pszHideExt.StrCpy(pszFile))
{
_pszHideExt.StrCpy(NULL);
bShowExt = TRUE;
}
//
// FEATURE: This is bogus -- we only want to hide KNOWN extensions,
// not all extensions.
//
if (!bShowExt && !IsWild(pszFile) && !pszFriendlyName)
{
LPTSTR pszExt = PathFindExtension(pszFile);
if (*pszExt)
{
//
// If there was an extension, hide it.
//
*pszExt = 0;
bHasHiddenExt = TRUE;
}
}
else if (pszFriendlyName)
{
// A friendly name was provided. Use it.
pszFile = pszFriendlyName;
// Not technically true, but this bit indicates that an app sends a CDM_GETSPEC, we give the for-parsing
// value in _pszHideExt, not the "friendly name" in the edit box
bHasHiddenExt = TRUE;
}
if (_bUseCombo)
{
HWND hwndEdit = (HWND)SendMessage(GetDlgItem(_hwndDlg, cmb13), CBEM_GETEDITCONTROL, 0, 0L);
SetWindowText(hwndEdit, pszFile);
}
else
{
SetDlgItemText(_hwndDlg, edt1, pszFile);
}
//
// If the initial file name has no extension, we want to do our normal
// extension finding stuff. Any other time we get a file with no
// extension, we should not do this.
//
_bUseHideExt = (LPTSTR)_pszHideExt
? (bSaveNullExt ? TRUE : bHasHiddenExt)
: FALSE;
}
////////////////////////////////////////////////////////////////////////////
//
// FindEOF
//
////////////////////////////////////////////////////////////////////////////
LPTSTR FindEOF(
LPTSTR pszFiles)
{
BOOL bQuoted;
LPTSTR pszBegin = pszFiles;
while (*pszBegin == CHAR_SPACE)
{
++pszBegin;
}
//
// Note that we always assume a quoted string, even if no quotes exist,
// so the only file delimiters are '"' and '\0'. This allows somebody to
// type <Start Menu> or <My Document> in the edit control and the right
// thing happens.
//
bQuoted = TRUE;
if (*pszBegin == CHAR_QUOTE)
{
++pszBegin;
}
//Remove the quote from the file list if one exist
lstrcpy(pszFiles, pszBegin);
//
// Find the end of the filename (first quote or unquoted space).
//
for (; ; pszFiles = CharNext(pszFiles))
{
switch (*pszFiles)
{
case (CHAR_NULL) :
{
return (pszFiles);
}
case (CHAR_SPACE) :
{
if (!bQuoted)
{
return (pszFiles);
}
break;
}
case (CHAR_QUOTE) :
{
//
// Note we only support '"' at the very beginning and very
// end of a file name.
//
return (pszFiles);
}
default :
{
break;
}
}
}
}
////////////////////////////////////////////////////////////////////////////
//
// ConvertToNULLTerm
//
////////////////////////////////////////////////////////////////////////////
DWORD ConvertToNULLTerm(
LPTSTR pchRead)
{
LPTSTR pchWrite = pchRead;
DWORD cFiles = 0;
// The input string is of the form "file1.ext" "file2.ext" ... "filen.ext"
// convert this string of this form into doubly null terminated string
// ie file1.ext\0file2.ext\0....filen.ext\0\0
for (; ;)
{
// Finds the end of the first file name in the list of
// remaining file names.Also this function removes the initial
// quote character
LPTSTR pchEnd = FindEOF(pchRead);
//
// Mark the end of the filename with a NULL.
//
if (*pchEnd)
{
*pchEnd = NULL;
cFiles++;
lstrcpy(pchWrite, pchRead);
pchWrite += pchEnd - pchRead + 1;
}
else
{
//
// Found EOL. Make sure we did not end with spaces.
//
if (*pchRead)
{
lstrcpy(pchWrite, pchRead);
pchWrite += pchEnd - pchRead + 1;
cFiles++;
}
break;
}
pchRead = pchEnd + 1;
}
//
// Double-NULL terminate.
//
*pchWrite = CHAR_NULL;
return (cFiles);
}
////////////////////////////////////////////////////////////////////////////
//
// SelFocusEnumCB
//
////////////////////////////////////////////////////////////////////////////
typedef struct _SELFOCUS
{
BOOL bSelChange;
UINT idSaveButton;
int nSel;
TEMPSTR sHidden;
TEMPSTR sDisplayed;
} SELFOCUS;
BOOL SelFocusEnumCB(
CFileOpenBrowser *that,
LPCITEMIDLIST pidl,
LPARAM lParam)
{
if (!pidl)
{
return TRUE;
}
SELFOCUS *psf = (SELFOCUS *)lParam;
TCHAR szBuf[MAX_PATH + 1];
TCHAR szBufFriendly[MAX_PATH + 1];
DWORD dwAttrs = SHGetAttributes(that->_psfCurrent, pidl, SFGAO_STORAGECAPMASK);
if (dwAttrs)
{
if (_IsOpenContainer(dwAttrs))
{
psf->idSaveButton = iszFileOpenButton;
}
else
{
if (psf->bSelChange && (((that->_pOFN->Flags & OFN_ENABLEINCLUDENOTIFY) &&
(that->_bSelIsObject =
CD_SendIncludeItemNotify(that->_hSubDlg,
that->_hwndDlg,
that->_psfCurrent,
pidl,
that->_pOFN,
that->_pOFI))) ||
(_IsStream(dwAttrs))))
{
++psf->nSel;
if (that->_pOFN->Flags & OFN_ALLOWMULTISELECT)
{
//
// Mark if this is an OBJECT we just selected.
//
if (that->_bSelIsObject)
{
ITEMIDLIST idl;
idl.mkid.cb = 0;
//
// Get full path to this folder.
//
GetViewItemText(that->_psfCurrent, &idl, szBuf, ARRAYSIZE(szBuf), SHGDN_FORPARSING);
if (szBuf[0])
{
that->_pszObjectCurDir.StrCpy(szBuf);
}
//
// Get full path to this item (in case we only get one
// selection).
//
GetViewItemText(that->_psfCurrent, pidl, szBuf, ARRAYSIZE(szBuf), SHGDN_FORPARSING);
that->_pszObjectPath.StrCpy(szBuf);
}
*szBuf = CHAR_QUOTE;
GetViewItemText(that->_psfCurrent, pidl, szBuf + 1, ARRAYSIZE(szBuf) - 3);
lstrcat(szBuf, TEXT("\" "));
if (!psf->sHidden.StrCat(szBuf))
{
psf->nSel = -1;
return FALSE;
}
if (!that->_fShowExtensions)
{
LPTSTR pszExt = PathFindExtension(szBuf + 1);
if (*pszExt)
{
*pszExt = 0;
lstrcat(szBuf, TEXT("\" "));
}
}
if (!psf->sDisplayed.StrCat(szBuf))
{
psf->nSel = -1;
return FALSE;
}
}
else
{
SHTCUTINFO info;
info.dwAttr = SFGAO_FOLDER;
info.fReSolve = FALSE;
info.pszLinkFile = NULL;
info.cchFile = 0;
info.ppidl = NULL;
if ((that->GetLinkStatus(pidl, &info)) &&
(info.dwAttr & SFGAO_FOLDER))
{
// This means that the pidl is a link and the link points to a folder
// in this case We Should not update the edit box and treat the link like
// a directory
psf->idSaveButton = iszFileOpenButton;
}
else
{
TCHAR *pszFriendlyName = NULL;
GetViewItemText(that->_psfCurrent, pidl, szBuf, ARRAYSIZE(szBuf));
// Special case WIA folders. They want friendly names. Might want to do this for all
// folders, but that might cause app compat nightmare.
if (that->_IsWIAFolder(that->_psfCurrent))
{
GetViewItemText(that->_psfCurrent, pidl, szBufFriendly, ARRAYSIZE(szBufFriendly), SHGDN_INFOLDER);
pszFriendlyName = szBufFriendly;
}
else
{
IShellFolder *psfItem;
if (SUCCEEDED(that->_psfCurrent->BindToObject(pidl, NULL, IID_PPV_ARG(IShellFolder, &psfItem))))
{
if (that->_IsWIAFolder(psfItem))
{
GetViewItemText(that->_psfCurrent, pidl, szBufFriendly, ARRAYSIZE(szBufFriendly), SHGDN_INFOLDER);
pszFriendlyName = szBufFriendly;
}
psfItem->Release();
}
}
that->SetEditFile(szBuf, pszFriendlyName, that->_fShowExtensions);
if (that->_bSelIsObject)
{
GetViewItemText(that->_psfCurrent, pidl, szBuf, ARRAYSIZE(szBuf), SHGDN_FORPARSING);
that->_pszObjectPath.StrCpy(szBuf);
}
}
}
}
}
}
//if there is an item selected then cache that items pidl
Pidl_Set(&that->_pidlSelection,pidl);
return TRUE;
}
////////////////////////////////////////////////////////////////////////////
//
// CFileOpenBrowser::SelFocusChange
//
////////////////////////////////////////////////////////////////////////////
void CFileOpenBrowser::SelFocusChange(
BOOL bSelChange)
{
SELFOCUS sf;
sf.bSelChange = bSelChange;
sf.idSaveButton = iszFileSaveButton;
sf.nSel = 0;
_bSelIsObject = FALSE;
EnumItemObjects(SVGIO_SELECTION, SelFocusEnumCB, (LPARAM)&sf);
if (_pOFN->Flags & OFN_ALLOWMULTISELECT)
{
switch (sf.nSel)
{
case (-1) :
{
//
// Oops! We ran out of memory.
//
MessageBeep(0);
return;
}
case (0) :
{
//
// No files selected; do not change edit control.
//
break;
}
case (1) :
{
//
// Strip off quotes so the single file case looks OK.
//
ConvertToNULLTerm(sf.sHidden);
LPITEMIDLIST pidlSel = ILClone(_pidlSelection);
SetEditFile(sf.sHidden, NULL, _fShowExtensions);
if (pidlSel)
{
// The SetEditFile above will nuke any _pidlSelection that was set as a result
// of EnumItemObjects, by causing a CBN_EDITCHANGE notification (edit box changed, so we
// think we should nuked the _pidlSelection - doh!).
// So here we restore it, if there was one set.
Pidl_Set(&_pidlSelection, pidlSel);
ILFree(pidlSel);
}
sf.idSaveButton = iszFileSaveButton;
break;
}
default :
{
SetEditFile(sf.sDisplayed, NULL, TRUE);
_pszHideExt.StrCpy(sf.sHidden);
sf.idSaveButton = iszFileSaveButton;
//More than one item selected so free selected item pidl
Pidl_Set(&_pidlSelection,NULL);;
break;
}
}
}
SetSaveButton(sf.idSaveButton);
}
////////////////////////////////////////////////////////////////////////////
//
// SelRenameCB
//
////////////////////////////////////////////////////////////////////////////
BOOL SelRenameCB(
CFileOpenBrowser *that,
LPCITEMIDLIST pidl,
LPARAM lParam)
{
if (!pidl)
{
return TRUE;
}
Pidl_Set(&that->_pidlSelection, pidl);
if (!SHGetAttributes(that->_psfCurrent, pidl, SFGAO_FOLDER))
{
//
// If it is not a folder then set the selection to nothing
// so that whatever is in the edit box will be used.
//
that->_psv->SelectItem(NULL, SVSI_DESELECTOTHERS);
}
return FALSE;
}
////////////////////////////////////////////////////////////////////////////
//
// CFileOpenBrowser::SelRename
//
////////////////////////////////////////////////////////////////////////////
void CFileOpenBrowser::SelRename(void)
{
EnumItemObjects(SVGIO_SELECTION, SelRenameCB, NULL);
}
////////////////////////////////////////////////////////////////////////////
//
// CFileOpenBrowser::OnStateChange
//
// Process selection change in the view control.
//
////////////////////////////////////////////////////////////////////////////
STDMETHODIMP CFileOpenBrowser::OnStateChange(
struct IShellView *ppshv,
ULONG uChange)
{
if (ppshv != _psv)
{
return (E_INVALIDARG);
}
switch (uChange)
{
case (CDBOSC_SETFOCUS) :
{
if (_bSave)
{
SelFocusChange(FALSE);
}
break;
}
case (CDBOSC_KILLFOCUS) :
{
SetSaveButton(iszFileSaveButton);
break;
}
case (CDBOSC_SELCHANGE) :
{
//
// Post one of these messages, since we seem to get a whole bunch
// of them.
//
if (!_fSelChangedPending)
{
_fSelChangedPending = TRUE;
PostMessage(_hwndDlg, CDM_SELCHANGE, 0, 0);
}
break;
}
case (CDBOSC_RENAME) :
{
SelRename();
break;
}
default :
{
return (E_NOTIMPL);
}
}
return S_OK;
}
////////////////////////////////////////////////////////////////////////////
//
// CFileOpenBrowser::IncludeObject
//
// Tell the view control which objects to include in its enumerations.
//
////////////////////////////////////////////////////////////////////////////
STDMETHODIMP CFileOpenBrowser::IncludeObject(
struct IShellView *ppshv,
LPCITEMIDLIST pidl)
{
if (ppshv != _psv)
{
return (E_INVALIDARG);
}
BOOL bIncludeItem = FALSE;
//
// See if the callback is enabled.
//
if (_pOFN->Flags & OFN_ENABLEINCLUDENOTIFY)
{
//
// See what the callback says.
//
bIncludeItem = BOOLFROMPTR(CD_SendIncludeItemNotify(_hSubDlg,
_hwndDlg,
_psfCurrent,
pidl,
_pOFN,
_pOFI));
}
if (!bIncludeItem)
{
DWORD dwAttrs = SHGetAttributes(_psfCurrent, pidl, SFGAO_FILESYSANCESTOR | SFGAO_STORAGEANCESTOR | SFGAO_STREAM | SFGAO_FILESYSTEM | SFGAO_FOLDER);
bIncludeItem = _bSave ? _IncludeSaveItem(dwAttrs) : _IncludeOpenItem(dwAttrs);
if (!bIncludeItem)
{
return (S_FALSE);
}
// Apply filter if this thing is filesystem or canmoniker, except:
// If it is an item that contains filesystem items (SFGAO_STORAGEANCESTOR - typical folder)
// OR if it is a folder that canmoniker (ftp folder)
if (bIncludeItem && *_szLastFilter)
{
BOOL fContainer = _bSave ? _IsSaveContainer(dwAttrs) : _IsOpenContainer(dwAttrs);
if (!fContainer)
{
GetViewItemText(_psfCurrent, (LPITEMIDLIST)pidl, _szBuf, ARRAYSIZE(_szBuf));
if (!LinkMatchSpec(pidl, _szLastFilter) &&
!PathMatchSpec(_szBuf, _szLastFilter))
{
return (S_FALSE);
}
}
}
}
return S_OK;
}
////////////////////////////////////////////////////////////////////////////
//
// CFileOpenBrowser::Notify
//
// Notification to decide whether or not a printer should be selected.
//
////////////////////////////////////////////////////////////////////////////
STDMETHODIMP CFileOpenBrowser::Notify(
struct IShellView *ppshv,
DWORD dwNotify)
{
return S_FALSE;
}
////////////////////////////////////////////////////////////////////////////
//
// CFileOpenBrowser::GetDefaultMenuText
//
// Returns the default menu text.
//
////////////////////////////////////////////////////////////////////////////
STDMETHODIMP CFileOpenBrowser::GetDefaultMenuText(
struct IShellView *ppshv,
WCHAR *pszText,
INT cchMax)
{
return S_FALSE;
}
////////////////////////////////////////////////////////////////////////////
//
// CFileOpenBrowser::GetViewFlags
//
// Returns Flags to customize the view .
//
////////////////////////////////////////////////////////////////////////////
STDMETHODIMP CFileOpenBrowser::GetViewFlags(DWORD *pdwFlags)
{
DWORD dwFlags = 0;
if (pdwFlags)
{
if (_pOFN->Flags & OFN_FORCESHOWHIDDEN)
{
dwFlags |= CDB2GVF_SHOWALLFILES;
}
*pdwFlags = dwFlags;
}
return S_OK;
}
// Insert a single item into the location dropdown.
BOOL InsertItem(HWND hCtrl, int iItem, MYLISTBOXITEM *pItem, TCHAR *pszName)
{
LPTSTR pszChar;
for (pszChar = pszName; *pszChar != CHAR_NULL; pszChar = CharNext(pszChar))
{
if (pszChar - pszName >= MAX_DRIVELIST_STRING_LEN - 1)
{
*pszChar = CHAR_NULL;
break;
}
}
if (SendMessage(hCtrl, CB_INSERTSTRING, iItem, (LPARAM)(LPCTSTR)pszName) == CB_ERR)
{
return FALSE;
}
SendMessage(hCtrl, CB_SETITEMDATA, iItem, (LPARAM)pItem);
return TRUE;
}
int CALLBACK LBItemCompareProc(void * p1, void * p2, LPARAM lParam)
{
IShellFolder *psfParent = (IShellFolder *)lParam;
MYLISTBOXITEM *pItem1 = (MYLISTBOXITEM *)p1;
MYLISTBOXITEM *pItem2 = (MYLISTBOXITEM *)p2;
HRESULT hres = psfParent->CompareIDs(0, pItem1->pidlThis, pItem2->pidlThis);
return (short)SCODE_CODE(GetScode(hres));
}
////////////////////////////////////////////////////////////////////////////
//
// CFileOpenBrowser::UpdateLevel
//
// Insert the contents of a shell container into the location dropdown.
//
////////////////////////////////////////////////////////////////////////////
void CFileOpenBrowser::UpdateLevel(
HWND hwndLB,
int iInsert,
MYLISTBOXITEM *pParentItem)
{
if (!pParentItem)
{
return;
}
LPENUMIDLIST penum;
HDPA hdpa;
DWORD cIndent = pParentItem->cIndent + 1;
IShellFolder *psfParent = pParentItem->GetShellFolder();
if (!psfParent)
{
return;
}
hdpa = DPA_Create(4);
if (!hdpa)
{
//
// No memory: Cannot enum this level.
//
return;
}
if (S_OK == psfParent->EnumObjects(hwndLB, SHCONTF_FOLDERS, &penum))
{
ULONG celt;
LPITEMIDLIST pidl;
while (penum->Next(1, &pidl, &celt) == S_OK && celt == 1)
{
//
// Note: We need to avoid creation of pItem if this is not
// a file system object (or ancestor) to avoid extra
// bindings.
//
if (ShouldIncludeObject(this, psfParent, pidl, _pOFN->Flags))
{
MYLISTBOXITEM *pItem = new MYLISTBOXITEM();
if (pItem)
{
if (pItem->Init(GetDlgItem(_hwndDlg, cmb2), pParentItem, psfParent, pidl, cIndent, MLBI_PERMANENT | MLBI_PSFFROMPARENT, _pScheduler) &&
(DPA_AppendPtr(hdpa, pItem) >= 0))
{
//empty body
}
else
{
pItem->Release();
}
}
}
SHFree(pidl);
}
penum->Release();
}
DPA_Sort(hdpa, LBItemCompareProc, (LPARAM)psfParent);
int nLBIndex, nDPAIndex, nDPAItems;
BOOL bCurItemGone;
nDPAItems = DPA_GetPtrCount(hdpa);
nLBIndex = iInsert;
bCurItemGone = FALSE;
//
// Make sure the user is not playing with the selection right now.
//
ComboBox_ShowDropdown(hwndLB, FALSE);
//
// We're all sorted, so now we can do a merge.
//
for (nDPAIndex = 0; ; ++nDPAIndex)
{
MYLISTBOXITEM *pNewItem;
TCHAR szBuf[MAX_DRIVELIST_STRING_LEN];
MYLISTBOXITEM *pOldItem;
if (nDPAIndex < nDPAItems)
{
pNewItem = (MYLISTBOXITEM *)DPA_FastGetPtr(hdpa, nDPAIndex);
}
else
{
//
// Signal that we got to the end of the list.
//
pNewItem = NULL;
}
for (pOldItem = GetListboxItem(hwndLB, nLBIndex);
pOldItem != NULL;
pOldItem = GetListboxItem(hwndLB, ++nLBIndex))
{
int nCmp;
if (pOldItem->cIndent < cIndent)
{
//
// We went up a level, so insert here.
//
break;
}
else if (pOldItem->cIndent > cIndent)
{
//
// We went down a level so ignore this.
//
continue;
}
//
// Set this to 1 at the end of the DPA to clear out deleted items
// at the end.
//
nCmp = !pNewItem
? 1
: LBItemCompareProc(pNewItem,
pOldItem,
(LPARAM)psfParent);
if (nCmp < 0)
{
//
// We found the first item greater than the new item, so
// add it in.
//
break;
}
else if (nCmp > 0)
{
//
// Oops! It looks like this item no longer exists, so
// delete it.
//
for (; ;)
{
if (pOldItem == _pCurrentLocation)
{
bCurItemGone = TRUE;
_pCurrentLocation = NULL;
}
pOldItem->Release();
SendMessage(hwndLB, CB_DELETESTRING, nLBIndex, NULL);
pOldItem = GetListboxItem(hwndLB, nLBIndex);
if (!pOldItem || pOldItem->cIndent <= cIndent)
{
break;
}
}
//
// We need to continue from the current position, not the
// next.
//
--nLBIndex;
}
else
{
//
// This item already exists, so no need to add it.
// Make sure we do not check this LB item again.
//
pOldItem->dwFlags |= MLBI_PERMANENT;
++nLBIndex;
goto NotThisItem;
}
}
if (!pNewItem)
{
//
// Got to the end of the list.
//
break;
}
GetViewItemText(psfParent, pNewItem->pidlThis, szBuf, ARRAYSIZE(szBuf), SHGDN_NORMAL);
if (szBuf[0] && InsertItem(hwndLB, nLBIndex, pNewItem, szBuf))
{
++nLBIndex;
}
else
{
NotThisItem:
pNewItem->Release();
}
}
DPA_Destroy(hdpa);
if (bCurItemGone)
{
//
// If we deleted the current selection, go back to the desktop.
//
ComboBox_SetCurSel(hwndLB, 0);
OnSelChange(-1, TRUE);
}
_iCurrentLocation = ComboBox_GetCurSel(hwndLB);
}
////////////////////////////////////////////////////////////////////////////
//
// ClearListbox
//
// Clear the location dropdown and delete all entries.
//
////////////////////////////////////////////////////////////////////////////
void ClearListbox(
HWND hwndList)
{
SendMessage(hwndList, WM_SETREDRAW, FALSE, NULL);
int cItems = (int) SendMessage(hwndList, CB_GETCOUNT, NULL, NULL);
while (cItems--)
{
MYLISTBOXITEM *pItem = GetListboxItem(hwndList, 0);
if (pItem)
pItem->Release();
SendMessage(hwndList, CB_DELETESTRING, 0, NULL);
}
SendMessage(hwndList, WM_SETREDRAW, TRUE, NULL);
InvalidateRect(hwndList, NULL, FALSE);
}
////////////////////////////////////////////////////////////////////////////
//
// InitFilterBox
//
// Places the double null terminated list of filters in the combo box.
//
// The list consists of pairs of null terminated strings, with an
// additional null terminating the list.
//
////////////////////////////////////////////////////////////////////////////
DWORD InitFilterBox(
HWND hDlg,
LPCTSTR lpszFilter)
{
DWORD nIndex = 0;
UINT nLen;
HWND hCmb = GetDlgItem(hDlg, cmb1);
if (hCmb)
{
while (*lpszFilter)
{
//
// First string put in as string to show.
//
nIndex = ComboBox_AddString(hCmb, lpszFilter);
nLen = lstrlen(lpszFilter) + 1;
lpszFilter += nLen;
//
// Second string put in as itemdata.
//
ComboBox_SetItemData(hCmb, nIndex, lpszFilter);
//
// Advance to next element.
//
nLen = lstrlen(lpszFilter) + 1;
lpszFilter += nLen;
}
}
//
// nIndex could be CB_ERR, which could cause problems.
//
if (nIndex == CB_ERR)
{
nIndex = 0;
}
return (nIndex);
}
////////////////////////////////////////////////////////////////////////////
//
// MoveControls
//
////////////////////////////////////////////////////////////////////////////
void MoveControls(
HWND hDlg,
BOOL bBelow,
int nStart,
int nXMove,
int nYMove)
{
HWND hwnd;
RECT rcWnd;
if (nXMove == 0 && nYMove == 0)
{
//
// Quick out if nothing to do.
//
return;
}
for (hwnd = GetWindow(hDlg, GW_CHILD);
hwnd;
hwnd = GetWindow(hwnd, GW_HWNDNEXT))
{
GetWindowRect(hwnd, &rcWnd);
MapWindowRect(HWND_DESKTOP, hDlg, &rcWnd);
if (bBelow)
{
if (rcWnd.top < nStart)
{
continue;
}
}
else
{
if (rcWnd.left < nStart)
{
continue;
}
}
SetWindowPos(hwnd,
NULL,
rcWnd.left + nXMove,
rcWnd.top + nYMove,
0,
0,
SWP_NOZORDER | SWP_NOSIZE);
}
}
////////////////////////////////////////////////////////////////////////////
//
// DummyDlgProc
//
////////////////////////////////////////////////////////////////////////////
BOOL_PTR CALLBACK DummyDlgProc(
HWND hDlg,
UINT uMsg,
WPARAM wParam,
LPARAM lParam)
{
switch (uMsg)
{
case (WM_INITDIALOG) :
{
break;
}
default :
{
return FALSE;
}
}
return TRUE;
}
/*
--------
| Cancel |
-------- --
|
-------- |
x Open As Read | Help | | Height by which all controls below view needs to be moved
-------- | and also height by which View window height should be increased.
--
*/
void CFileOpenBrowser::ReAdjustDialog()
{
int iDelta = 0;
RECT rc1,rc2;
//Make sure all our assumptions are valid
if ((_iVersion < OPENFILEVERSION_NT5) || //if this dialog version is less than NT5 or
IsWindowEnabled(GetDlgItem(_hwndDlg, chx1)) || // if Open As Read Only is still enabled or
IsWindowEnabled(GetDlgItem(_hwndDlg, pshHelp))) // If the Help button is still enabled then
{
//Dont do anything
return ;
}
GetWindowRect(GetDlgItem(_hwndDlg, pshHelp), &rc1);
GetWindowRect(GetDlgItem(_hwndDlg, IDCANCEL), &rc2);
//Add the height of the button
iDelta += RECTHEIGHT(rc1);
//Add the gap between buttons
iDelta += rc1.top - rc2.bottom;
RECT rcView;
GetWindowRect(GetDlgItem(_hwndDlg, lst1), &rcView);
MapWindowRect(HWND_DESKTOP, _hwndDlg, &rcView);
HDWP hdwp;
hdwp = BeginDeferWindowPos(10);
HWND hwnd;
RECT rc;
hwnd = ::GetWindow(_hwndDlg, GW_CHILD);
while (hwnd && hdwp)
{
GetWindowRect(hwnd, &rc);
MapWindowRect(HWND_DESKTOP, _hwndDlg, &rc);
switch (GetDlgCtrlID(hwnd))
{
case pshHelp:
case chx1:
break;
default :
//
// See if the control needs to be adjusted.
//
if (rc.top > rcView.bottom)
{
//Move Y position of these controls
hdwp = DeferWindowPos(hdwp,
hwnd,
NULL,
rc.left,
rc.top + iDelta,
RECTWIDTH(rc),
RECTHEIGHT(rc),
SWP_NOZORDER);
}
}
hwnd = ::GetWindow(hwnd, GW_HWNDNEXT);
}
//Adjust the size of the view window
if (hdwp)
{
hdwp = DeferWindowPos(hdwp,
GetDlgItem(_hwndDlg, lst1),
NULL,
rcView.left,
rcView.top,
RECTWIDTH(rcView),
RECTHEIGHT(rcView) + iDelta,
SWP_NOZORDER);
}
EndDeferWindowPos(hdwp);
}
////////////////////////////////////////////////////////////////////////////
//
// CFileOpenBrowser::ResetDialogHeight
//
// Hack for Borland JBuilder Professional (pah!)
//
// These guys relied on a bug in Win95/NT4's Comdlg32 that we fixed in IE4.
// So instead of reintroducing the bug, we detect that they are relying
// on the bug and hack around them.
//
// These guys do a SetWindowLong(GWL_STYLE) on the dialog box and
// then reparent it! Unfortunately, they didn't quite get their
// bookkeeping right: They forgot to do a RedrawWindow after removing
// the WS_CAPTION style. You see, just editing the style doesn't do
// anything - the style changes don't take effect until the next
// RedrawWindow. When they scratched their heads ("Hey, why is
// the caption still there?"), they decided to brute-force the
// solution: They slide the window so the caption goes "off the screen".
//
// Problem: We fixed a bug for IE4 where ResetDialogHeight would screw
// up and not resize the dialog when it should've, if the app did a
// SetWindowPos on the window to change its vertical position downward
// by more than the amount we needed to grow.
//
// So now when we resize it properly, this generates an internal
// RedrawWindow, which means that Borland's brute-force hack tries
// to fix a problem that no longer exists!
//
// Therefore, ResetDialogHeight now checks if the app has
//
// 1. Changed the dialog window style,
// 2. Moved the dialog downward by more than we needed to grow,
// 3. Forgotten to call RedrawWindow.
//
// If so, then we temporarily restore the original dialog window style,
// do the (correct) resize, then restore the window style. Reverting
// the window style means that all the non-client stuff retains its old
// (incorrect, but what the app is expecting) size.
//
////////////////////////////////////////////////////////////////////////////
void CFileOpenBrowser::ResetDialogHeight(
HWND hDlg,
HWND hwndExclude,
HWND hwndGrip,
int nCtlsBottom)
{
POINT ptCurrent;
int topNew;
GetControlsArea(hDlg, hwndExclude, hwndGrip, &ptCurrent, &topNew);
int nDiffBottom = nCtlsBottom - ptCurrent.y;
if (nDiffBottom > 0)
{
RECT rcFull;
int Height;
GetWindowRect(hDlg, &rcFull);
Height = RECTHEIGHT(rcFull) - nDiffBottom;
if (Height >= ptCurrent.y)
{
// Borland JBuilder hack! This SetWindowPos will generate
// a RedrawWindow which the app might not be expecting.
// Detect this case and create a set of temporary styles
// which will neutralize the frame recalc implicit in the
// RedrawWindow.
//
LONG lStylePrev;
BOOL bBorlandHack = FALSE;
if (!_bAppRedrawn && // App didn't call RedrawWindow
_topOrig + nCtlsBottom <= topNew + ptCurrent.y) // Win95 didn't resize
{
// Since the app didn't call RedrawWindow, it still
// thinks that there is a WS_CAPTION. So put the caption
// back while we do frame recalcs.
bBorlandHack = TRUE;
lStylePrev = GetWindowLong(hDlg, GWL_STYLE);
SetWindowLong(hDlg, GWL_STYLE, lStylePrev | WS_CAPTION);
}
SetWindowPos(hDlg,
NULL,
0,
0,
RECTWIDTH(rcFull),
Height,
SWP_NOZORDER | SWP_NOMOVE);
if (bBorlandHack)
{
// Restore the original style after we temporarily
// messed with it.
SetWindowLong(hDlg, GWL_STYLE, lStylePrev);
}
}
}
}
////////////////////////////////////////////////////////////////////////////
//
// CFileOpenBrowser::CreateHookDialog
//
////////////////////////////////////////////////////////////////////////////
BOOL CFileOpenBrowser::CreateHookDialog(
POINT *pPtSize)
{
DWORD Flags = _pOFN->Flags;
BOOL bRet = FALSE;
HANDLE hTemplate;
HINSTANCE hinst;
LPCTSTR lpDlg;
HWND hCtlCmn;
RECT rcReal, rcSub, rcToolbar, rcAppToolbar;
int nXMove, nXRoom, nYMove, nYRoom, nXStart, nYStart;
DWORD dwStyle;
DLGPROC lpfnHookProc;
if (!(Flags & (OFN_ENABLEHOOK | OFN_ENABLETEMPLATE | OFN_ENABLETEMPLATEHANDLE)))
{
//
// No hook or template; nothing to do.
//
ResetDialogHeight(_hwndDlg, NULL, _hwndGrip, pPtSize->y);
GetWindowRect(_hwndDlg, &rcReal);
_ptLastSize.x = rcReal.right - rcReal.left;
_ptLastSize.y = rcReal.bottom - rcReal.top;
return TRUE;
}
if (Flags & OFN_ENABLETEMPLATEHANDLE)
{
hTemplate = _pOFN->hInstance;
hinst = ::g_hinst;
}
else
{
if (Flags & OFN_ENABLETEMPLATE)
{
if (!_pOFN->lpTemplateName)
{
StoreExtendedError(CDERR_NOTEMPLATE);
return FALSE;
}
if (!_pOFN->hInstance)
{
StoreExtendedError(CDERR_NOHINSTANCE);
return FALSE;
}
lpDlg = _pOFN->lpTemplateName;
hinst = _pOFN->hInstance;
}
else
{
hinst = ::g_hinst;
lpDlg = MAKEINTRESOURCE(DUMMYFILEOPENORD);
}
HRSRC hRes = FindResource(hinst, lpDlg, RT_DIALOG);
if (hRes == NULL)
{
StoreExtendedError(CDERR_FINDRESFAILURE);
return FALSE;
}
if ((hTemplate = LoadResource(hinst, hRes)) == NULL)
{
StoreExtendedError(CDERR_LOADRESFAILURE);
return FALSE;
}
}
if (!LockResource(hTemplate))
{
StoreExtendedError(CDERR_LOADRESFAILURE);
return FALSE;
}
dwStyle = ((LPDLGTEMPLATE)hTemplate)->style;
if (!(dwStyle & WS_CHILD))
{
//
// I don't want to go poking in their template, and I don't want to
// make a copy, so I will just fail. This also helps us weed out
// "old-style" templates that were accidentally used.
//
StoreExtendedError(CDERR_DIALOGFAILURE);
return FALSE;
}
if (Flags & OFN_ENABLEHOOK)
{
lpfnHookProc = (DLGPROC)GETHOOKFN(_pOFN);
}
else
{
lpfnHookProc = DummyDlgProc;
}
//
// WOW apps are not allowed to get the new explorer look, so there
// is no need to do any special WOW checking before calling the create
// dialog function.
//
if (_pOFI->ApiType == COMDLG_ANSI)
{
ThunkOpenFileNameW2A(_pOFI);
_hSubDlg = CreateDialogIndirectParamA(hinst,
(LPDLGTEMPLATE)hTemplate,
_hwndDlg,
lpfnHookProc,
(LPARAM)(_pOFI->pOFNA));
ThunkOpenFileNameA2W(_pOFI);
}
else
{
_hSubDlg = CreateDialogIndirectParam(hinst,
(LPDLGTEMPLATE)hTemplate,
_hwndDlg,
lpfnHookProc,
(LPARAM)_pOFN);
}
if (!_hSubDlg)
{
StoreExtendedError(CDERR_DIALOGFAILURE);
return FALSE;
}
//
// We reset the height of the dialog after creating the hook dialog so
// the hook can hide controls in its WM_INITDIALOG message.
//
ResetDialogHeight(_hwndDlg, _hSubDlg, _hwndGrip, pPtSize->y);
//
// Now move all of the controls around.
//
GetClientRect(_hwndDlg, &rcReal);
GetClientRect(_hSubDlg, &rcSub);
hCtlCmn = GetDlgItem(_hSubDlg, stc32);
if (hCtlCmn)
{
RECT rcCmn;
GetWindowRect(hCtlCmn, &rcCmn);
MapWindowRect(HWND_DESKTOP, _hSubDlg, &rcCmn);
//
// Move the controls in our dialog to make room for the hook's
// controls above and to the left.
//
MoveControls(_hwndDlg, FALSE, 0, rcCmn.left, rcCmn.top);
//
// Calculate how far sub dialog controls need to move, and how much
// more room our dialog needs.
//
nXStart = rcCmn.right;
nYStart = rcCmn.bottom;
//See how far part the cotrols are in the template
nXMove = (rcReal.right - rcReal.left) - (rcCmn.right - rcCmn.left);
nYMove = (rcReal.bottom - rcReal.top) - (rcCmn.bottom - rcCmn.top);
//See how much room we need to leave at the bottom and right
// for the sub dialog controls at the botton and right
nXRoom = rcSub.right - (rcCmn.right - rcCmn.left);
nYRoom = rcSub.bottom - (rcCmn.bottom - rcCmn.top);
if (nXMove < 0)
{
//
// If the template size is too big, we need more room in the
// dialog.
//
nXRoom -= nXMove;
nXMove = 0;
}
if (nYMove < 0)
{
//
// If the template size is too big, we need more room in the
// dialog.
//
nYRoom -= nYMove;
nYMove = 0;
}
//
// Resize the "template" control so the hook knows the size of our
// stuff.
//
SetWindowPos(hCtlCmn,
NULL,
0,
0,
rcReal.right - rcReal.left,
rcReal.bottom - rcReal.top,
SWP_NOMOVE | SWP_NOZORDER);
}
else
{
//
// Extra controls go on the bottom by default.
//
nXStart = nYStart = nXMove = nXRoom = 0;
nYMove = rcReal.bottom;
nYRoom = rcSub.bottom;
}
MoveControls(_hSubDlg, FALSE, nXStart, nXMove, 0);
MoveControls(_hSubDlg, TRUE, nYStart, 0, nYMove);
//
// Resize our dialog and the sub dialog.
// FEATURE: We need to check whether part of the dialog is off screen.
//
GetWindowRect(_hwndDlg, &rcReal);
_ptLastSize.x = (rcReal.right - rcReal.left) + nXRoom;
_ptLastSize.y = (rcReal.bottom - rcReal.top) + nYRoom;
SetWindowPos(_hwndDlg,
NULL,
0,
0,
_ptLastSize.x,
_ptLastSize.y,
SWP_NOZORDER | SWP_NOMOVE);
//
// Note that we are moving this to (0,0) and the bottom of the Z order.
//
GetWindowRect(_hSubDlg, &rcReal);
SetWindowPos(_hSubDlg,
HWND_BOTTOM,
0,
0,
(rcReal.right - rcReal.left) + nXMove,
(rcReal.bottom - rcReal.top) + nYMove,
0);
ShowWindow(_hSubDlg, SW_SHOW);
CD_SendInitDoneNotify(_hSubDlg, _hwndDlg, _pOFN, _pOFI);
//
// Make sure the toolbar is still large enough. Apps like Visio move
// the toolbar control and may make it too small now that we added the
// View Desktop toolbar button.
//
if (_hwndToolbar && IsVisible(_hwndToolbar))
{
LONG Width;
//
// Get the default toolbar coordinates.
//
GetControlRect(_hwndDlg, stc1, &rcToolbar);
//
// Get the app adjusted toolbar coordinates.
//
GetWindowRect(_hwndToolbar, &rcAppToolbar);
MapWindowRect(HWND_DESKTOP, _hwndDlg, &rcAppToolbar);
//
// See if the default toolbar size is greater than the current
// toolbar size.
//
Width = rcToolbar.right - rcToolbar.left;
if (Width > (rcAppToolbar.right - rcAppToolbar.left))
{
//
// Set rcToolbar to be the new toolbar rectangle.
//
rcToolbar.left = rcAppToolbar.left;
rcToolbar.top = rcAppToolbar.top;
rcToolbar.right = rcAppToolbar.left + Width;
rcToolbar.bottom = rcAppToolbar.bottom;
//
// Get the dialog coordinates.
//
GetWindowRect(_hwndDlg, &rcReal);
MapWindowRect(HWND_DESKTOP, _hwndDlg, &rcReal);
//
// Make sure the new toolbar doesn't go off the end of
// the dialog.
//
if (rcToolbar.right < rcReal.right)
{
//
// Make sure there are no controls to the right of the
// toolbar that overlap the new toolbar.
//
for (hCtlCmn = ::GetWindow(_hwndDlg, GW_CHILD);
hCtlCmn;
hCtlCmn = ::GetWindow(hCtlCmn, GW_HWNDNEXT))
{
if ((hCtlCmn != _hwndToolbar) && IsVisible(hCtlCmn))
{
RECT rcTemp;
//
// Get the coordinates of the window.
//
GetWindowRect(hCtlCmn, &rcSub);
MapWindowRect(HWND_DESKTOP, _hwndDlg, &rcSub);
//
// If the App's toolbar rectangle does not
// intersect the window and the the new toolbar
// does intersect the window, then we cannot
// increase the size of the toolbar.
//
if (!IntersectRect(&rcTemp, &rcAppToolbar, &rcSub) &&
IntersectRect(&rcTemp, &rcToolbar, &rcSub))
{
break;
}
}
}
//
// Reset the size of the toolbar if there were no conflicts.
//
if (!hCtlCmn)
{
::SetWindowPos(_hwndToolbar,
NULL,
rcToolbar.left,
rcToolbar.top,
Width,
rcToolbar.bottom - rcToolbar.top,
SWP_NOACTIVATE | SWP_NOZORDER |
SWP_SHOWWINDOW);
}
}
}
}
bRet = TRUE;
return (bRet);
}
////////////////////////////////////////////////////////////////////////////
//
// InitSaveAsControls
//
// Change the captions of a bunch of controls to say saveas-like things.
//
////////////////////////////////////////////////////////////////////////////
const struct
{
UINT idControl;
UINT idString;
} aSaveAsControls[] =
{
{ (UINT)-1, iszFileSaveTitle }, // -1 means the dialog itself
{ stc2, iszSaveAsType },
{ IDOK, iszFileSaveButton },
{ stc4, iszFileSaveIn }
};
void InitSaveAsControls(
HWND hDlg)
{
for (UINT iControl = 0; iControl < ARRAYSIZE(aSaveAsControls); iControl++)
{
HWND hwnd = hDlg;
TCHAR szText[80];
if (aSaveAsControls[iControl].idControl != -1)
{
hwnd = GetDlgItem(hDlg, aSaveAsControls[iControl].idControl);
}
CDLoadString(g_hinst,
aSaveAsControls[iControl].idString,
szText,
ARRAYSIZE(szText));
SetWindowText(hwnd, szText);
}
}
////////////////////////////////////////////////////////////////////////////
//
// GetControlsArea
//
// Returns the leftmost edge and bottom-most edge of the
// controls farthest right and down (in screen coordinates).
//
////////////////////////////////////////////////////////////////////////////
void
GetControlsArea(
HWND hDlg,
HWND hwndExclude,
HWND hwndGrip,
POINT *pPtSize,
LPINT pTop)
{
RECT rc;
HWND hwnd;
int uBottom;
int uRight;
uBottom = 0x80000000;
uRight = 0x80000000;
for (hwnd = GetWindow(hDlg, GW_CHILD);
hwnd;
hwnd = GetWindow(hwnd, GW_HWNDNEXT))
{
//
// Note we cannot use IsWindowVisible, since the parent is not visible.
// We do not want the magic static to be included.
//
if (!IsVisible(hwnd) || (hwnd == hwndExclude) || (hwnd == hwndGrip))
{
continue;
}
GetWindowRect(hwnd, &rc);
if (uRight < rc.right)
{
uRight = rc.right;
}
if (uBottom < rc.bottom)
{
uBottom = rc.bottom;
}
}
GetWindowRect(hDlg, &rc);
pPtSize->x = uRight - rc.left;
pPtSize->y = uBottom - rc.top;
if (pTop)
*pTop = rc.top;
}
// Initializes the Look In Drop Down combobox
BOOL CFileOpenBrowser::InitLookIn(HWND hDlg)
{
TCHAR szScratch[MAX_PATH];
LPITEMIDLIST pidl;
IShellFolder *psf;
HWND hCtrl = GetDlgItem(hDlg, cmb2);
// Add the History Location.
if (_iVersion >= OPENFILEVERSION_NT5)
{
int iImage, iSelectedImage;
if (SUCCEEDED(SHGetSpecialFolderLocation(NULL, CSIDL_RECENT, &pidl)))
{
LPITEMIDLIST pidlLast;
IShellFolder *psfParent;
HRESULT hr = CDBindToIDListParent(pidl, IID_PPV_ARG(IShellFolder, &psfParent), (LPCITEMIDLIST *)&pidlLast);
if (SUCCEEDED(hr))
{
DWORD dwAttribs = SHGetAttributes(psfParent, pidlLast, SFGAO_STORAGECAPMASK | SFGAO_SHARE);
//Get the image corresponding to this pidl
iImage = SHMapPIDLToSystemImageListIndex(psfParent, pidlLast, &iSelectedImage);
hr = psfParent->BindToObject(pidlLast, NULL, IID_PPV_ARG(IShellFolder, &psf));
if (SUCCEEDED(hr))
{
MYLISTBOXITEM *pItem = new MYLISTBOXITEM();
if (pItem)
{
pItem->Init(GetDlgItem(_hwndDlg, cmb2), psf, pidl, 0, MLBI_PERMANENT, dwAttribs, iImage, iSelectedImage);
DisplayNameOf(psfParent, pidlLast, SHGDN_INFOLDER, szScratch, ARRAYSIZE(szScratch));
if (!InsertItem(hCtrl, 0, pItem, szScratch))
{
pItem->Release();
}
else
{
//Update the index of Desktop in Look In dropdown from 0 to 1
_iNodeDesktop = 1;
}
}
psf->Release();
}
psfParent->Release();
}
SHFree(pidl);
}
}
BOOL bRet = FALSE;
// Insert the Desktop in the Lookin dropdown
if (SUCCEEDED(SHGetDesktopFolder(&psf)))
{
pidl = SHCloneSpecialIDList(hDlg, CSIDL_DESKTOP, FALSE);
if (pidl)
{
// Add the desktop item
MYLISTBOXITEM *pItem = new MYLISTBOXITEM();
if (pItem)
{
if (pItem->Init(GetDlgItem(_hwndDlg, cmb2), NULL, psf, pidl, 0, MLBI_PERMANENT, _pScheduler))
{
GetViewItemText(psf, NULL, szScratch, ARRAYSIZE(szScratch));
if (InsertItem(hCtrl, _iNodeDesktop, pItem, szScratch))
{
pItem->AddRef();
_pCurrentLocation = pItem;
bRet = TRUE;
}
}
pItem->Release();
}
SHFree(pidl);
}
psf->Release();
}
if (!bRet)
{
ClearListbox(hCtrl);
}
return bRet;
}
// Main initialization (WM_INITDIALOG phase).
BOOL InitLocation(HWND hDlg, LPOFNINITINFO poii)
{
HWND hCtrl = GetDlgItem(hDlg, cmb2);
LPOPENFILENAME lpOFN = poii->lpOFI->pOFN;
BOOL fIsSaveAs = poii->bSave;
POINT ptSize;
GetControlsArea(hDlg, NULL, NULL, &ptSize, NULL);
CFileOpenBrowser *pDlgStruct = new CFileOpenBrowser(hDlg, FALSE);
if (pDlgStruct == NULL)
{
StoreExtendedError(CDERR_INITIALIZATION);
return FALSE;
}
StoreBrowser(hDlg, pDlgStruct);
if ((poii->lpOFI->iVersion < OPENFILEVERSION_NT5) &&
(poii->lpOFI->pOFN->Flags & (OFN_ENABLEHOOK | OFN_ENABLETEMPLATE | OFN_ENABLETEMPLATEHANDLE)))
{
pDlgStruct->_iVersion = OPENFILEVERSION_NT4;
}
//See if we need to use dropdown combobox or edit box for filename
if (pDlgStruct->_iVersion >= OPENFILEVERSION_NT5)
{
pDlgStruct->EnableFileMRU(!IsRestricted(REST_NOFILEMRU));
}
else
{
pDlgStruct->EnableFileMRU(FALSE);
}
pDlgStruct->CreateToolbar();
GetControlsArea(hDlg, NULL, NULL, &ptSize, &pDlgStruct->_topOrig);
if (!pDlgStruct->InitLookIn(hDlg))
{
StoreExtendedError(CDERR_INITIALIZATION);
return FALSE;
}
pDlgStruct->_pOFN = lpOFN;
pDlgStruct->_bSave = fIsSaveAs;
pDlgStruct->_pOFI = poii->lpOFI;
pDlgStruct->_pszDefExt.StrCpy(lpOFN->lpstrDefExt);
//
// Here follows all the caller-parameter-based initialization.
//
pDlgStruct->_lpOKProc = (WNDPROC)::SetWindowLongPtr(::GetDlgItem(hDlg, IDOK),
GWLP_WNDPROC,
(LONG_PTR)OKSubclass);
if (lpOFN->Flags & OFN_CREATEPROMPT)
{
lpOFN->Flags |= (OFN_PATHMUSTEXIST | OFN_FILEMUSTEXIST);
}
else if (lpOFN->Flags & OFN_FILEMUSTEXIST)
{
lpOFN->Flags |= OFN_PATHMUSTEXIST;
}
//
// We need to make sure the Ansi flags are up to date.
//
if (poii->lpOFI->ApiType == COMDLG_ANSI)
{
poii->lpOFI->pOFNA->Flags = lpOFN->Flags;
}
//
// Limit the text to the maximum path length instead of limiting it to
// the buffer length. This allows users to type ..\..\.. and move
// around when the app gives an extremely small buffer.
//
if (pDlgStruct->_bUseCombo)
{
SendDlgItemMessage(hDlg, cmb13, CB_LIMITTEXT, MAX_PATH -1, 0);
}
else
{
SendDlgItemMessage(hDlg, edt1, EM_LIMITTEXT, MAX_PATH - 1, 0);
}
SendDlgItemMessage(hDlg, cmb2, CB_SETEXTENDEDUI, 1, 0);
SendDlgItemMessage(hDlg, cmb1, CB_SETEXTENDEDUI, 1, 0);
//
// Save original directory for later restoration, if necessary.
//
pDlgStruct->_szStartDir[0] = TEXT('\0');
GetCurrentDirectory(ARRAYSIZE(pDlgStruct->_szStartDir),
pDlgStruct->_szStartDir);
//
// Initialize all provided filters.
//
if (lpOFN->lpstrCustomFilter && *lpOFN->lpstrCustomFilter)
{
SendDlgItemMessage(hDlg,
cmb1,
CB_INSERTSTRING,
0,
(LONG_PTR)lpOFN->lpstrCustomFilter);
SendDlgItemMessage(hDlg,
cmb1,
CB_SETITEMDATA,
0,
(LPARAM)(lpOFN->lpstrCustomFilter +
lstrlen(lpOFN->lpstrCustomFilter) + 1));
SendDlgItemMessage(hDlg,
cmb1,
CB_LIMITTEXT,
(WPARAM)(lpOFN->nMaxCustFilter),
0L);
}
else
{
//
// Given no custom filter, the index will be off by one.
//
if (lpOFN->nFilterIndex != 0)
{
lpOFN->nFilterIndex--;
}
}
//
// Listed filters next.
//
if (lpOFN->lpstrFilter)
{
if (lpOFN->nFilterIndex > InitFilterBox(hDlg, lpOFN->lpstrFilter))
{
lpOFN->nFilterIndex = 0;
}
}
else
{
lpOFN->nFilterIndex = 0;
}
//
// If an entry exists, select the one indicated by nFilterIndex.
//
if ((lpOFN->lpstrFilter) ||
(lpOFN->lpstrCustomFilter && *lpOFN->lpstrCustomFilter))
{
HWND hCmb1 = GetDlgItem(hDlg, cmb1);
ComboBox_SetCurSel(hCmb1, lpOFN->nFilterIndex);
pDlgStruct->RefreshFilter(hCmb1);
}
//Check if this Object Open Dialog
if (lpOFN->Flags & OFN_ENABLEINCLUDENOTIFY)
{
//Yes, change the text so that it looks like a object open
TCHAR szTemp[256];
//Change the File &Name: to Object &Name:
CDLoadString((HINSTANCE)g_hinst, iszObjectName, (LPTSTR)szTemp, sizeof(szTemp));
SetWindowText(GetDlgItem(hDlg, stc3), szTemp);
//Change the Files of &type: to Objects of &type:
CDLoadString((HINSTANCE)g_hinst, iszObjectType, (LPTSTR)szTemp, sizeof(szTemp));
SetWindowText(GetDlgItem(hDlg, stc2), szTemp);
}
//
// Make sure to do this before checking if there is a title specified.
//
if (fIsSaveAs)
{
//
// Note we can do this even if there is a hook/template.
//
InitSaveAsControls(hDlg);
// In Save As Dialog there is no need for Open As Read Only.
HideControl(hDlg, chx1);
}
if (lpOFN->lpstrTitle && *lpOFN->lpstrTitle)
{
SetWindowText(hDlg, lpOFN->lpstrTitle);
}
// BOOL Variables to check whether both the Hide Read only and Help button
// are being hidden. if so we need to readjust the dialog to reclaim the space
// occupied by these two controls
BOOL fNoReadOnly = FALSE;
BOOL fNoHelp = FALSE;
if (lpOFN->Flags & OFN_HIDEREADONLY)
{
HideControl(hDlg, chx1);
fNoReadOnly = TRUE;
}
else
{
CheckDlgButton(hDlg, chx1, (lpOFN->Flags & OFN_READONLY) ? 1 : 0);
}
if (!(lpOFN->Flags & OFN_SHOWHELP))
{
HideControl(hDlg, pshHelp);
fNoHelp = TRUE;
}
if (fNoReadOnly && fNoHelp)
{
//Readjust the dialog to reclaim space occupied by the Open as Read Only and Help Button controls
pDlgStruct->ReAdjustDialog();
}
RECT rc;
::GetClientRect(hDlg, &rc);
//
// If sizing is enabled, then we need to create the sizing grip.
//
if (pDlgStruct->_bEnableSizing = poii->bEnableSizing)
{
pDlgStruct->_hwndGrip =
CreateWindow(TEXT("Scrollbar"),
NULL,
WS_VISIBLE | WS_CHILD | WS_CLIPSIBLINGS | WS_GROUP |
WS_CLIPCHILDREN | SBS_BOTTOMALIGN | SBS_SIZEGRIP |
SBS_SIZEBOXBOTTOMRIGHTALIGN,
rc.right - g_cxGrip,
rc.bottom - g_cyGrip,
g_cxGrip,
g_cyGrip,
hDlg,
(HMENU)-1,
g_hinst,
NULL);
}
if (!pDlgStruct->CreateHookDialog(&ptSize))
{
return FALSE;
}
// Create Placebar right after Creating Hook Dialog as we need to get information
// from the Hook Procedure if any customization needs to be done
if ((pDlgStruct->_iVersion >= OPENFILEVERSION_NT5) &&
(!IsRestricted(REST_NOPLACESBAR)) && (!IS_NEW_OFN(lpOFN) || !(lpOFN->FlagsEx & OFN_EX_NOPLACESBAR))
)
{
pDlgStruct->_hwndPlacesbar = pDlgStruct->CreatePlacesbar(pDlgStruct->_hwndDlg);
}
else
{
pDlgStruct->_hwndPlacesbar = NULL;
}
GetWindowRect(pDlgStruct->_hwndDlg, &rc);
pDlgStruct->_ptMinTrack.x = rc.right - rc.left;
pDlgStruct->_ptMinTrack.y = rc.bottom - rc.top;
if (pDlgStruct->_bUseCombo)
{
HWND hwndComboBox = GetDlgItem(hDlg, cmb13);
if (hwndComboBox)
{
HWND hwndEdit = (HWND)SendMessage(hwndComboBox, CBEM_GETEDITCONTROL, 0, 0L);
AutoComplete(hwndEdit, &(pDlgStruct->_pcwd), 0);
//
// Explicitly set the focus since this is no longer the first item
// in the dialog template and it will start AutoComplete.
//
SetFocus(hwndComboBox);
}
}
else
{
HWND hwndEdit = GetDlgItem(hDlg, edt1);
if (hwndEdit)
{
AutoComplete(hwndEdit, &(pDlgStruct->_pcwd), 0);
//
// Explicitly set the focus since this is no longer the first item
// in the dialog template and it will start AutoComplete.
//
SetFocus(hwndEdit);
}
}
// Before jumping to a particular directory, Create the travel log
Create_TravelLog(&pDlgStruct->_ptlog);
// jump to the first ShellFolder
LPCTSTR lpInitialText = pDlgStruct->JumpToInitialLocation(lpOFN->lpstrInitialDir, lpOFN->lpstrFile);
// make sure we jumped somewhere.
if (!pDlgStruct->_psv)
{
//
// This would be very bad.
//
// DO NOT CALL StoreExtendedError() here! Corel Envoy relies
// on receiving exactly FNERR_INVALIDFILENAME when it passes
// an invalid filename.
//
ASSERT(GetStoredExtendedError());
return FALSE;
}
//
// Read the cabinet state. If the full title is enabled, then add
// the tooltip. Otherwise, don't bother as they obviously don't care.
//
CABINETSTATE cCabState;
//
// Will set defaults if cannot read registry.
//
ReadCabinetState(&cCabState, SIZEOF(cCabState));
if (cCabState.fFullPathTitle)
{
pDlgStruct->_hwndTips = CreateWindow(TOOLTIPS_CLASS,
NULL,
WS_POPUP | WS_GROUP | TTS_NOPREFIX,
CW_USEDEFAULT,
CW_USEDEFAULT,
CW_USEDEFAULT,
CW_USEDEFAULT,
hDlg,
NULL,
::g_hinst,
NULL);
if (pDlgStruct->_hwndTips)
{
TOOLINFO ti;
ti.cbSize = sizeof(ti);
ti.uFlags = TTF_IDISHWND | TTF_SUBCLASS;
ti.hwnd = hDlg;
ti.uId = (UINT_PTR)hCtrl;
ti.hinst = NULL;
ti.lpszText = LPSTR_TEXTCALLBACK;
SendMessage(pDlgStruct->_hwndTips,
TTM_ADDTOOL,
0,
(LPARAM)&ti);
}
}
//
// Show the window after creating the ShellView so we do not get a
// big ugly gray spot.
// if we have cached in the size of previously opened dialog then use
// the size and position of that window.
if (pDlgStruct->_bEnableSizing && (g_rcDlg.right > g_rcDlg.left))
{
::SetWindowPos(hDlg,
NULL,
g_rcDlg.left,
g_rcDlg.top,
g_rcDlg.right - g_rcDlg.left,
g_rcDlg.bottom - g_rcDlg.top,
0);
}
else
{
::ShowWindow(hDlg, SW_SHOW);
::UpdateWindow(hDlg);
}
if (lpInitialText)
{
//
// This is the one time I will show a file spec, since it would be
// too strange to have "All Files" showing in the Type box, while
// only text files are in the view.
//
pDlgStruct->SetEditFile(lpInitialText, NULL, pDlgStruct->_fShowExtensions, FALSE);
SelectEditText(hDlg);
}
return TRUE;
}
BOOL IsValidPath(LPCTSTR pszPath)
{
TCHAR szPath[MAX_PATH];
lstrcpyn(szPath, pszPath, SIZECHARS(szPath));
int nFileOffset = ParseFileNew(szPath, NULL, FALSE, TRUE);
//
// Is the filename invalid?
//
if ((nFileOffset < 0) &&
(nFileOffset != PARSE_EMPTYSTRING))
{
return FALSE;
}
return TRUE;
}
BOOL CFileOpenBrowser::_IsRestrictedDrive(LPCTSTR pszPath, LPCITEMIDLIST pidl)
{
TCHAR szDrivePath[5]; // Don't need much... just want a drive letter.
BOOL bRet = FALSE;
DWORD dwRest = SHRestricted(REST_NOVIEWONDRIVE);
if (dwRest)
{
// There are some drive restrictions.
// Convert pidl, if supplied, to full path.
if (pidl)
{
if (SUCCEEDED(SHGetNameAndFlags(pidl, SHGDN_FORPARSING, szDrivePath, ARRAYSIZE(szDrivePath), NULL)))
{
pszPath = szDrivePath;
}
}
if (pszPath)
{
int iDrive = PathGetDriveNumber(pszPath);
if (iDrive != -1)
{
// is the drive restricted
if (dwRest & (1 << iDrive))
{
bRet = TRUE;
}
}
}
}
return bRet;
}
// When the dialog first appears, we want to prevent the the pop message that appears from
// CFSFolder if you try to navigate to a drive that has been restricted due to group policy.
// So in these cases, we do the group policy check before attempting to navigate there.
void CFileOpenBrowser::JumpToLocationIfUnrestricted(LPCTSTR pszPath, LPCITEMIDLIST pidl, BOOL bTranslate)
{
if (!_IsRestrictedDrive(pszPath, pidl))
{
if (pszPath)
{
JumpToPath(pszPath, bTranslate);
}
else if (pidl)
{
JumpToIDList(pidl, bTranslate);
}
}
}
LPCTSTR CFileOpenBrowser::JumpToInitialLocation(LPCTSTR pszDir, LPTSTR pszFile)
{
//
// Check out if the filename contains a path. If so, override whatever
// is contained in pszDir. Chop off the path and put up only
// the filename.
//
TCHAR szDir[MAX_PATH];
LPCTSTR pszRet = NULL;
BOOL fFileIsTemp = PathIsTemporary(pszFile);
szDir[0] = 0;
//If we have a Directory specified then use that Directory.
if (pszDir)
{
ExpandEnvironmentStrings(pszDir, szDir, ARRAYSIZE(szDir));
}
//Check to see if the pszFile contains a Path.
if (pszFile && *pszFile)
{
// clean up the path a little
PathRemoveBlanks(pszFile);
// WARNING - this must me some kind of APPCOMPAT thing - ZekeL - 13-AUG-98
// Apps that are not UNC-aware often pass <C:\\server\share> and
// we want to change it to the prettier <\\server\share>. - raymondc
if (DBL_BSLASH(pszFile + 2) &&
(*(pszFile + 1) == CHAR_COLON))
{
lstrcpy(pszFile, pszFile + 2);
}
pszRet = PathFindFileName(pszFile);
if (IsValidPath(pszFile))
{
if (IsWild(pszRet))
{
SetCurrentFilter(pszRet);
}
if (!fFileIsTemp)
{
DWORD cch = pszRet ? (unsigned long) (pszRet-pszFile) : ARRAYSIZE(szDir);
cch = min(cch, ARRAYSIZE(szDir));
// this will null terminate for us on
// the backslash if pszRet was true
StrCpyN(szDir, pszFile, cch);
}
}
else if (!(_pOFN->Flags & OFN_NOVALIDATE))
{
// Failed validation and app wanted validation
StoreExtendedError(FNERR_INVALIDFILENAME);
return NULL;
}
else
{
// Failed validation but app suppressed validation,
// so continue onward with the "filename" part of the
// pszFile (even though it's not valid).
}
}
// if we have a directory then use that directory
if (*szDir)
{
JumpToLocationIfUnrestricted(szDir, NULL, TRUE);
}
// See if this application contains a entry in the registry for the last visited Directory
if (!_psv)
{
// Change the return value to full incoming name.
if (!fFileIsTemp)
pszRet = pszFile;
if (GetPathFromLastVisitedMRU(szDir, ARRAYSIZE(szDir)))
{
JumpToLocationIfUnrestricted(szDir, NULL, TRUE);
}
}
// Try Current Directory
if (!_psv)
{
//Does current directory contain any files that match the filter ?
if (GetCurrentDirectory(ARRAYSIZE(szDir), szDir)
&& !PathIsTemporary(szDir) && FoundFilterMatch(_szLastFilter, IsVolumeLFN(NULL)))
{
//Yes. Jump to Current Directory.
JumpToLocationIfUnrestricted(szDir, NULL, TRUE);
}
}
// Try My Documents
if (!_psv)
{
LPITEMIDLIST pidl;
if (SUCCEEDED(SHGetSpecialFolderLocation(NULL, CSIDL_PERSONAL, &pidl)))
{
JumpToLocationIfUnrestricted(NULL, pidl, FALSE);
ILFree(pidl);
}
}
// finally try the desktop - don't check for restriction here.
if (!_psv)
{
ITEMIDLIST idl = { 0 };
// Do not try to translate this.
JumpToIDList(&idl, FALSE);
}
// If nothing worked, then set the error code so our parent knows.
if (!_psv)
{
StoreExtendedError(CDERR_INITIALIZATION);
}
//Add the initial directory where we jumped to the travel log
if (_ptlog && _pCurrentLocation && _pCurrentLocation->pidlFull)
{
_ptlog->AddEntry(_pCurrentLocation->pidlFull);
}
return pszRet;
}
////////////////////////////////////////////////////////////////////////////
//
// _CleanupDialog
//
// Dialog cleanup, memory deallocation.
//
////////////////////////////////////////////////////////////////////////////
void CFileOpenBrowser::_CleanupDialog(BOOL fRet)
{
ASSERT(!_cRefCannotNavigate);
if (_pOFN->lpstrCustomFilter)
{
UINT len = lstrlen(_pOFN->lpstrCustomFilter) + 1;
UINT sCount = lstrlen(_szLastFilter);
if (_pOFN->nMaxCustFilter > sCount + len)
{
lstrcpy(_pOFN->lpstrCustomFilter + len, _szLastFilter);
}
}
if ((fRet == TRUE) && _hSubDlg &&
(CD_SendOKNotify(_hSubDlg, _hwndDlg, _pOFN, _pOFI) ||
CD_SendOKMsg(_hSubDlg, _pOFN, _pOFI)))
{
// Give the hook a chance to validate the file name.
return;
}
// We need to make sure the IShellBrowser is still around during
// destruction.
if (_psv)
{
_psv->DestroyViewWindow();
ATOMICRELEASE(_psv);
}
if (((_pOFN->Flags & OFN_NOCHANGEDIR) || g_bUserPressedCancel) &&
(*_szStartDir))
{
SetCurrentDirectory(_szStartDir);
}
::EndDialog(_hwndDlg, fRet);
}
////////////////////////////////////////////////////////////////////////////
//
// GetParentItem
//
// Given an item index in the location dropdown, get its parent item.
//
////////////////////////////////////////////////////////////////////////////
MYLISTBOXITEM *GetParentItem(HWND hwndCombo, int *piItem)
{
int iItem = *piItem;
MYLISTBOXITEM *pItem = GetListboxItem(hwndCombo, iItem);
if (pItem)
{
for (--iItem; iItem >= 0; iItem--)
{
MYLISTBOXITEM *pPrev = GetListboxItem(hwndCombo, iItem);
if (pPrev && pPrev->cIndent < pItem->cIndent)
{
*piItem = iItem;
return (pPrev);
}
}
}
return (NULL);
}
////////////////////////////////////////////////////////////////////////////
//
// GetFullPathEnumCB
//
////////////////////////////////////////////////////////////////////////////
BOOL GetFullPathEnumCB(
CFileOpenBrowser *that,
LPCITEMIDLIST pidl,
LPARAM lParam)
{
if (pidl)
{
LPITEMIDLIST pidlFull = ILCombine(that->_pCurrentLocation->pidlFull, pidl);
if (pidlFull)
{
SHGetPathFromIDList(pidlFull, (LPTSTR)lParam);
ILFree(pidlFull);
}
return FALSE;
}
return TRUE;
}
////////////////////////////////////////////////////////////////////////////
//
// CFileOpenBrowser::GetFullPath
//
// Calculate the full path to the selected object in the view.
//
////////////////////////////////////////////////////////////////////////////
void CFileOpenBrowser::GetFullPath(
LPTSTR pszBuf)
{
*pszBuf = CHAR_NULL;
EnumItemObjects(SVGIO_SELECTION, GetFullPathEnumCB, (LPARAM)pszBuf);
}
////////////////////////////////////////////////////////////////////////////
//
// CFileOpenBrowser::RemoveOldPath
//
// Removes old path elements from the location dropdown. *piNewSel is the
// listbox index of the leaf item which the caller wants to save. All non-
// permanent items that are not ancestors of that item are deleted. The
// index is updated appropriately if any items before it are deleted.
//
////////////////////////////////////////////////////////////////////////////
void CFileOpenBrowser::RemoveOldPath(
int *piNewSel)
{
HWND hwndCombo = ::GetDlgItem(_hwndDlg, cmb2);
int iStart = *piNewSel;
int iItem;
UINT cIndent = 0;
int iSubOnDel = 0;
//
// Flush all non-permanent non-ancestor items before this one.
//
for (iItem = ComboBox_GetCount(hwndCombo) - 1; iItem >= 0; --iItem)
{
MYLISTBOXITEM *pItem = GetListboxItem(hwndCombo, iItem);
if (iItem == iStart)
{
//
// Begin looking for ancestors and adjusting the sel position.
//
iSubOnDel = 1;
cIndent = pItem->cIndent;
continue;
}
if (pItem->cIndent < cIndent)
{
//
// We went back a level, so this must be an ancestor of the
// selected item.
//
cIndent = pItem->cIndent;
continue;
}
//
// Make sure to check this after adjusting cIndent.
//
if (pItem->dwFlags & MLBI_PERMANENT)
{
continue;
}
SendMessage(hwndCombo, CB_DELETESTRING, iItem, NULL);
pItem->Release();
*piNewSel -= iSubOnDel;
}
}
////////////////////////////////////////////////////////////////////////////
//
// FindLocation
//
// Given a listbox item, find the index.
// Just a linear search, but we shouldn't have more than ~10-20 items.
//
////////////////////////////////////////////////////////////////////////////
int FindLocation(
HWND hwndCombo,
MYLISTBOXITEM *pFindItem)
{
int iItem;
for (iItem = ComboBox_GetCount(hwndCombo) - 1; iItem >= 0; --iItem)
{
MYLISTBOXITEM *pItem = GetListboxItem(hwndCombo, iItem);
if (pItem == pFindItem)
{
break;
}
}
return (iItem);
}
////////////////////////////////////////////////////////////////////////////
//
// CFileOpenBrowser::OnSelChange
//
// Process the selection change in the location dropdown.
//
// Chief useful feature is that it removes the items for the old path.
// Returns TRUE only if it was possible to switch to the specified item.
//
////////////////////////////////////////////////////////////////////////////
BOOL CFileOpenBrowser::OnSelChange(
int iItem,
BOOL bForceUpdate)
{
HWND hwndCombo = GetDlgItem(_hwndDlg, cmb2);
BOOL bRet = TRUE;
if (iItem == -1)
{
iItem = (int) SendMessage(hwndCombo, CB_GETCURSEL, NULL, NULL);
}
MYLISTBOXITEM *pNewLocation = GetListboxItem(hwndCombo, iItem);
MYLISTBOXITEM *pOldLocation = _pCurrentLocation;
BOOL bFirstTry = TRUE;
BOOL bSwitchedBack = FALSE;
if (bForceUpdate || (pNewLocation != pOldLocation))
{
FOLDERSETTINGS fs;
if (_psv)
{
_psv->GetCurrentInfo(&fs);
}
else
{
fs.ViewMode = FVM_LIST;
fs.fFlags = _pOFN->Flags & OFN_ALLOWMULTISELECT ? 0 : FWF_SINGLESEL;
}
// we always want the recent folder to come up
// in details mode
// We also want the My Pictures folder and it's subfolders to comeup in ThumbView.
// So, let's detect if the current and new locations are any of these special folders.
LOCTYPE NewLocType = (pNewLocation ? _GetLocationType(pNewLocation) : LOCTYPE_OTHERS);
LOCTYPE CurLocType = (_pCurrentLocation ? _GetLocationType(_pCurrentLocation) : LOCTYPE_OTHERS);
const SHELLVIEWID *pvid = NULL; //Most of the time this will continue to be null;
SHELLVIEWID vidCurrent = {0};
BOOL fUseDefaultView = FALSE;
switch (NewLocType)
{
case LOCTYPE_MYPICTURES_FOLDER:
if (CurLocType == LOCTYPE_MYPICTURES_FOLDER)
{
IShellView2 *psv2;
//We need to get the current pvid
//Note: the end-user could have changed this view.
pvid = &VID_Thumbnails; //Assume this by default.
if (SUCCEEDED(_psv->QueryInterface(IID_PPV_ARG(IShellView2, &psv2))))
{
if (SUCCEEDED(psv2->GetView(&vidCurrent, SV2GV_CURRENTVIEW)))
pvid = &vidCurrent;
psv2->Release();
}
}
else
{
//We are moving to My pictures folder or sub-folder; set the thumb nail view.
pvid = &VID_Thumbnails;
//If we are moving from other folders, save the ViewMode.
if (CurLocType == LOCTYPE_OTHERS)
{
_CachedViewMode = fs.ViewMode;
_fCachedViewFlags = fs.fFlags;
}
}
break;
case LOCTYPE_RECENT_FOLDER:
//We are moving to Recent folder.
if (CurLocType == LOCTYPE_OTHERS)
{
_CachedViewMode = fs.ViewMode;
_fCachedViewFlags = fs.fFlags;
}
fs.ViewMode = FVM_DETAILS;
break;
case LOCTYPE_WIA_FOLDER:
if (CurLocType == LOCTYPE_OTHERS)
{
_CachedViewMode = fs.ViewMode;
_fCachedViewFlags = fs.fFlags;
}
// ask view for default view for WIA extentions
fUseDefaultView = TRUE;
break;
case LOCTYPE_OTHERS:
//Check if we are coming from Recent, My Pictures, or WIA folders,
// and restore the viewmode we had before that.
if (CurLocType != LOCTYPE_OTHERS)
{
fs.ViewMode = _CachedViewMode;
fs.fFlags = _fCachedViewFlags;
}
break;
}
_iCurrentLocation = iItem;
_pCurrentLocation = pNewLocation;
OnSelChange_TryAgain:
if (!_pCurrentLocation || FAILED(SwitchView(_pCurrentLocation->GetShellFolder(),
_pCurrentLocation->pidlFull,
&fs,
pvid,
fUseDefaultView)))
{
//
// We could not create the view for this location.
//
bRet = FALSE;
//
// Try the previous folder.
//
if (bFirstTry)
{
bFirstTry = FALSE;
_pCurrentLocation = pOldLocation;
int iOldItem = FindLocation(hwndCombo, pOldLocation);
if (iOldItem >= 0)
{
_iCurrentLocation = iOldItem;
ComboBox_SetCurSel(hwndCombo, _iCurrentLocation);
if (_psv)
{
bSwitchedBack = TRUE;
goto SwitchedBack;
}
else
{
goto OnSelChange_TryAgain;
}
}
}
//
// Try the parent of the old item.
//
if (_iCurrentLocation)
{
_pCurrentLocation = GetParentItem(hwndCombo, &_iCurrentLocation);
if (_pCurrentLocation)
{
ComboBox_SetCurSel(hwndCombo, _iCurrentLocation);
goto OnSelChange_TryAgain;
}
}
//
// We cannot create the Desktop view. I think we are in
// real trouble. We had better bail out.
//
StoreExtendedError(CDERR_DIALOGFAILURE);
_CleanupDialog(FALSE);
return FALSE;
}
//if _iCurrentLocation is _iNodeDesktop then it means we are at Desktop so disable the IDC_PARENT button
::SendMessage(_hwndToolbar,
TB_SETSTATE,
IDC_PARENT,
((_iCurrentLocation == _iNodeDesktop) || (_iCurrentLocation == 0)) ? 0 :TBSTATE_ENABLED);
if (_IsSaveContainer(_pCurrentLocation->dwAttrs))
{
_pCurrentLocation->SwitchCurrentDirectory(_pcwd);
}
TCHAR szFile[MAX_PATH + 1];
int nFileOffset;
//
// We've changed folders; we'd better strip whatever is in the edit
// box down to the file name.
//
if (_bUseCombo)
{
HWND hwndEdit = (HWND)SendMessage(GetDlgItem(_hwndDlg, cmb13), CBEM_GETEDITCONTROL, 0, 0L);
GetWindowText(hwndEdit, szFile, ARRAYSIZE(szFile));
}
else
{
GetDlgItemText(_hwndDlg, edt1, szFile, ARRAYSIZE(szFile));
}
nFileOffset = ParseFileNew(szFile, NULL, FALSE, TRUE);
if (nFileOffset > 0 && !IsDirectory(szFile))
{
//
// The user may have typed an extension, so make sure to show it.
//
SetEditFile(szFile + nFileOffset, NULL, TRUE);
}
SetSaveButton(iszFileSaveButton);
SwitchedBack:
RemoveOldPath(&_iCurrentLocation);
}
if (!bSwitchedBack && _hSubDlg)
{
CD_SendFolderChangeNotify(_hSubDlg, _hwndDlg, _pOFN, _pOFI);
}
return (bRet);
}
////////////////////////////////////////////////////////////////////////////
//
// CFileOpenBrowser::OnDotDot
//
// Process the open-parent-folder button on the toolbar.
//
////////////////////////////////////////////////////////////////////////////
void CFileOpenBrowser::OnDotDot()
{
HWND hwndCombo = GetDlgItem(_hwndDlg, cmb2);
int iItem = ComboBox_GetCurSel(hwndCombo);
MYLISTBOXITEM *pItem = GetParentItem(hwndCombo, &iItem);
SendMessage(hwndCombo, CB_SETCURSEL, iItem, NULL);
//
// Delete old path from combo.
//
OnSelChange();
UpdateNavigation();
}
////////////////////////////////////////////////////////////////////////////
//
// DblClkEnumCB
//
////////////////////////////////////////////////////////////////////////////
#define PIDL_NOTHINGSEL (LPCITEMIDLIST)0
#define PIDL_MULTIPLESEL (LPCITEMIDLIST)-1
#define PIDL_FOLDERSEL (LPCITEMIDLIST)-2
BOOL DblClkEnumCB(
CFileOpenBrowser *that,
LPCITEMIDLIST pidl,
LPARAM lParam)
{
MYLISTBOXITEM *pLoc = that->_pCurrentLocation;
LPCITEMIDLIST *ppidl = (LPCITEMIDLIST *)lParam;
if (!pidl)
{
pidl = *ppidl;
if (pidl == PIDL_NOTHINGSEL)
{
//
// Nothing selected.
//
return FALSE;
}
if (pidl == PIDL_MULTIPLESEL)
{
//
// More than one thing selected.
//
return FALSE;
}
// check if the pidl is a container (ie, a folder)
if (IsContainer(that->_psfCurrent, pidl))
{
LPITEMIDLIST pidlDest = ILCombine(pLoc->pidlFull,pidl);
if (pidlDest)
{
that->JumpToIDList(pidlDest);
SHFree(pidlDest);
}
*ppidl = PIDL_FOLDERSEL;
}
else if (IsLink(that->_psfCurrent,pidl))
{
//
// This link might be pointing to a folder in which case
// we want to go ahead and open it. If the link points
// to a file then its taken care of in ProcessEdit command.
//
SHTCUTINFO info;
LPITEMIDLIST pidlLinkTarget = NULL;
info.dwAttr = SFGAO_FOLDER;
info.fReSolve = FALSE;
info.pszLinkFile = NULL;
info.cchFile = 0;
info.ppidl = &pidlLinkTarget;
//psf can be NULL in which case ResolveLink uses _psfCurrent IShellFolder
if (SUCCEEDED(that->ResolveLink(pidl, &info, that->_psfCurrent)))
{
if (info.dwAttr & SFGAO_FOLDER)
{
that->JumpToIDList(pidlLinkTarget);
*ppidl = PIDL_FOLDERSEL;
}
Pidl_Set(&pidlLinkTarget, NULL);
}
}
return FALSE;
}
if (*ppidl)
{
//
// More than one thing selected.
//
*ppidl = PIDL_MULTIPLESEL;
return FALSE;
}
*ppidl = pidl;
return TRUE;
}
////////////////////////////////////////////////////////////////////////////
//
// CFileOpenBrowser::OnDblClick
//
// Process a double-click in the view control, either by choosing the
// selected non-container object or by opening the selected container.
//
////////////////////////////////////////////////////////////////////////////
void CFileOpenBrowser::OnDblClick(
BOOL bFromOKButton)
{
LPCITEMIDLIST pidlFirst = PIDL_NOTHINGSEL;
//if we have a saved pidl then use it instead
if (_pidlSelection && _ProcessPidlSelection())
{
return;
}
if (_psv)
{
EnumItemObjects(SVGIO_SELECTION, DblClkEnumCB, (LPARAM)&pidlFirst);
}
if (pidlFirst == PIDL_NOTHINGSEL)
{
//
// Nothing selected.
//
if (bFromOKButton)
{
//
// This means we got an IDOK when the focus was in the view,
// but nothing was selected. Let's get the edit text and go
// from there.
//
ProcessEdit();
}
}
else if (pidlFirst != PIDL_FOLDERSEL)
{
//
// This will change the edit box, but that's OK, since it probably
// already has. This should take care of files with no extension.
//
SelFocusChange(TRUE);
//
// This part will take care of resolving links.
//
ProcessEdit();
}
}
////////////////////////////////////////////////////////////////////////////
//
// CFileOpenBrowser::JumpToPath
//
// Refocus the entire dialog on a different directory.
//
////////////////////////////////////////////////////////////////////////////
BOOL CFileOpenBrowser::JumpToPath(LPCTSTR pszDirectory, BOOL bTranslate)
{
TCHAR szTemp[MAX_PATH + 1];
TCHAR szCurDir[MAX_PATH + 1];
//
// This should do the whole job of canonicalizing the directory.
//
GetCurrentDirectory(ARRAYSIZE(szCurDir), szCurDir);
PathCombine(szTemp, szCurDir, pszDirectory);
LPITEMIDLIST pidlNew = ILCreateFromPath(szTemp);
if (pidlNew == NULL)
{
return FALSE;
}
//
// Need to make sure the pidl points to a folder. If not, then remove
// items from the end until we find one that is.
// This must be done before the translation.
//
DWORD dwAttrib;
do
{
dwAttrib = SFGAO_FOLDER;
SHGetAttributesOf(pidlNew, &dwAttrib);
if (!(dwAttrib & SFGAO_FOLDER))
{
ILRemoveLastID(pidlNew);
}
} while(!(dwAttrib & SFGAO_FOLDER) && !ILIsEmpty(pidlNew));
if (!(dwAttrib & SFGAO_FOLDER))
{
SHFree(pidlNew);
return FALSE;
}
BOOL bRet = JumpToIDList(pidlNew, bTranslate);
SHFree(pidlNew);
return bRet;
}
////////////////////////////////////////////////////////////////////////////
//
// CFileOpenBrowser::JumpTOIDList
//
// Refocus the entire dialog on a different IDList.
//
// Parameter:
// bTranslate specifies whether the given pidl should be translated to
// logical pidl
// bAddToNavStack specifies whether the pidl given for jumping should be
// added to the back/forward navigation stack
//
////////////////////////////////////////////////////////////////////////////
BOOL CFileOpenBrowser::JumpToIDList(
LPCITEMIDLIST pidlNew,
BOOL bTranslate,
BOOL bAddToNavStack)
{
LPITEMIDLIST pidlLog = NULL;
if (bTranslate)
{
//
// Translate IDList's on the Desktop into the appropriate
// logical IDList.
//
pidlLog = SHLogILFromFSIL(pidlNew);
if (pidlLog)
{
pidlNew = pidlLog;
}
}
//
// Find the entry in the location dropdown that is the closest parent
// to the new location.
//
HWND hwndCombo = ::GetDlgItem(_hwndDlg, cmb2);
MYLISTBOXITEM *pBestParent = GetListboxItem(hwndCombo, 0);
int iBestParent = 0;
LPCITEMIDLIST pidlRelative = pidlNew;
UINT cIndent = 0;
BOOL fExact = FALSE;
for (UINT iItem = 0; ; iItem++)
{
MYLISTBOXITEM *pNextItem = GetListboxItem(hwndCombo, iItem);
if (pNextItem == NULL)
{
break;
}
if (pNextItem->cIndent != cIndent)
{
//
// Not the depth we want.
//
continue;
}
if (ILIsEqual(pNextItem->pidlFull, pidlNew))
{
// Never treat FTP Pidls as Equal because the username/password may
// have changed so we need to do the navigation. The two pidls
// still pass ILIsEqual() because the server name is the same.
// This is required for a different back compat bug.
if (!ILIsFTP(pidlNew))
fExact = TRUE;
break;
}
LPCITEMIDLIST pidlChild = ILFindChild(pNextItem->pidlFull, pidlNew);
if (pidlChild != NULL)
{
pBestParent = pNextItem;
iBestParent = iItem;
cIndent++;
pidlRelative = pidlChild;
}
}
//
// The path provided might have matched an existing item exactly. In
// that case, just select the item.
//
if (fExact)
{
goto FoundIDList;
}
//
// Now, pBestParent is the closest parent to the item, iBestParent is
// its index, and cIndent is the next appropriate indent level. Begin
// creating new items for the rest of the path.
//
iBestParent++; // begin inserting after parent item
for (; ;)
{
LPITEMIDLIST pidlFirst = ILCloneFirst(pidlRelative);
if (pidlFirst == NULL)
{
break;
}
MYLISTBOXITEM *pNewItem = new MYLISTBOXITEM();
if (pNewItem)
{
if (!pNewItem->Init(GetDlgItem(_hwndDlg, cmb2),
pBestParent,
pBestParent->GetShellFolder(),
pidlFirst,
cIndent,
MLBI_PSFFROMPARENT,
_pScheduler))
{
pNewItem->Release();
pNewItem = NULL;
//iBestParent is off by 1 in error case . Correct it
iBestParent--;
break;
}
}
else
{
//iBestParent is off by 1 in error case . Correct it
iBestParent--;
break;
}
GetViewItemText(pBestParent->psfSub, pidlFirst, _szBuf, ARRAYSIZE(_szBuf), SHGDN_NORMAL);
InsertItem(hwndCombo, iBestParent, pNewItem, _szBuf);
SHFree(pidlFirst);
pidlRelative = ILGetNext(pidlRelative);
if (ILIsEmpty(pidlRelative))
{
break;
}
cIndent++; // next one is indented one more level
iBestParent++; // and inserted after this one
pBestParent = pNewItem; // and is a child of the one we just inserted
}
iItem = iBestParent;
FoundIDList:
if (pidlLog)
{
SHFree(pidlLog);
}
SendMessage(hwndCombo, CB_SETCURSEL, iItem, NULL);
BOOL bRet = OnSelChange(iItem, TRUE);
//Update our Navigation stack
if (bRet && bAddToNavStack)
{
UpdateNavigation();
}
//We naviagated to a new location so invalidate the cached Pidl
Pidl_Set(&_pidlSelection,NULL);
return bRet;
}
////////////////////////////////////////////////////////////////////////////
//
// CFileOpenBrowser::ViewCommand
//
// Process the new-folder button on the toolbar.
//
////////////////////////////////////////////////////////////////////////////
void CFileOpenBrowser::ViewCommand(
UINT uIndex)
{
IContextMenu *pcm;
if (SUCCEEDED(_psv->GetItemObject(SVGIO_BACKGROUND, IID_PPV_ARG(IContextMenu, &pcm))))
{
CMINVOKECOMMANDINFOEX ici = {0};
ici.cbSize = sizeof(ici);
ici.fMask = 0L;
ici.hwnd = _hwndDlg;
ici.lpVerb = ::c_szCommandsA[uIndex];
ici.lpParameters = NULL;
ici.lpDirectory = NULL;
ici.nShow = SW_NORMAL;
ici.lpParametersW = NULL;
ici.lpDirectoryW = NULL;
ici.lpVerbW = ::c_szCommandsW[uIndex];
ici.fMask |= CMIC_MASK_UNICODE;
IObjectWithSite *pObjSite = NULL;
if (SUCCEEDED(pcm->QueryInterface(IID_IObjectWithSite, (void**)&pObjSite)))
{
pObjSite->SetSite(SAFECAST(_psv,IShellView*));
}
HMENU hmContext = CreatePopupMenu();
pcm->QueryContextMenu(hmContext, 0, 1, 256, 0);
pcm->InvokeCommand((LPCMINVOKECOMMANDINFO)(&ici));
if (pObjSite)
{
pObjSite->SetSite(NULL);
pObjSite->Release();
}
DestroyMenu(hmContext);
pcm->Release();
}
}
//
HRESULT CFileOpenBrowser::ResolveLink(LPCITEMIDLIST pidl, PSHTCUTINFO pinfo, IShellFolder *psf)
{
BOOL fSetPidl = TRUE;
//Do we have IShellFolder passed to us ?
if (!psf)
{
//No use our current shell folder.
psf = _psfCurrent;
}
//Get the IShellLink interface pointer corresponding to given file
IShellLink *psl;
HRESULT hres = psf->GetUIObjectOf(NULL, 1, &pidl, IID_X_PPV_ARG(IShellLink, 0, &psl));
if (SUCCEEDED(hres))
{
//Resolve the link
if (pinfo->fReSolve)
{
hres = psl->Resolve(_hwndDlg, 0);
//If the resolve failed then we can't get correct pidl
if (hres == S_FALSE)
{
fSetPidl = FALSE;
}
}
if (SUCCEEDED(hres))
{
LPITEMIDLIST pidl;
if (SUCCEEDED(psl->GetIDList(&pidl)) && pidl)
{
if (pinfo->dwAttr)
hres = SHGetAttributesOf(pidl, &pinfo->dwAttr);
if (SUCCEEDED(hres) && pinfo->pszLinkFile)
{
// caller wants the path, this may be empty
hres = psl->GetPath(pinfo->pszLinkFile, pinfo->cchFile, 0, 0);
}
if (pinfo->ppidl && fSetPidl)
*(pinfo->ppidl) = pidl;
else
ILFree(pidl);
}
else
hres = E_FAIL; // gota have a pidl
}
psl->Release();
}
if (FAILED(hres))
{
if (pinfo->pszLinkFile)
*pinfo->pszLinkFile = 0;
if (pinfo->ppidl && *pinfo->ppidl)
{
ILFree(*pinfo->ppidl);
*pinfo->ppidl = NULL;
}
pinfo->dwAttr = 0;
}
return hres;
}
//
// This function checks to see if the pidl given is a link and if so resolves the
// link
// PARAMETERS :
//
// LPCITEMIDLIST pidl - the pidl which we want to check for link
// LPTSTR pszLinkFile - if the pidl points to a link then this contains the resolved file
// name
// UINT cchFile - size of the buffer pointed by the pszLinkFile
//
// RETURN VALUE :
// returns TRUE if the pidl is link and was able to resolve the link successfully
// returns FALSE if the pidl is not link or if the link was not able to resolve successfully.
// In this case pszLinkFile and pfd are not valid.
BOOL CFileOpenBrowser::GetLinkStatus(LPCITEMIDLIST pidl, PSHTCUTINFO pinfo)
{
if (IsLink(_psfCurrent, pidl))
{
return SUCCEEDED(ResolveLink(pidl, pinfo));
}
return FALSE;
}
////////////////////////////////////////////////////////////////////////////
//
// CFileOpenBrowser::LinkMatchSpec
//
////////////////////////////////////////////////////////////////////////////
BOOL CFileOpenBrowser::LinkMatchSpec(LPCITEMIDLIST pidl, LPCTSTR pszSpec)
{
TCHAR szFile[MAX_PATH];
SHTCUTINFO info;
info.dwAttr = SFGAO_FOLDER;
info.fReSolve = FALSE;
info.pszLinkFile = szFile;
info.cchFile = ARRAYSIZE(szFile);
info.ppidl = NULL;
if (GetLinkStatus(pidl, &info))
{
if ((info.dwAttr & SFGAO_FOLDER) ||
(szFile[0] && PathMatchSpec(szFile, pszSpec)))
{
return TRUE;
}
}
return FALSE;
}
////////////////////////////////////////////////////////////////////////////
//
// MeasureDriveItems
//
// Standard owner-draw code for the location dropdown.
//
////////////////////////////////////////////////////////////////////////////
#define MINIDRIVE_MARGIN 4
#define MINIDRIVE_WIDTH (g_cxSmIcon)
#define MINIDRIVE_HEIGHT (g_cySmIcon)
#define DRIVELIST_BORDER 3
void MeasureDriveItems(
HWND hwndDlg,
MEASUREITEMSTRUCT *lpmi)
{
HDC hdc;
HFONT hfontOld;
int dyDriveItem;
SIZE siz;
hdc = GetDC(NULL);
hfontOld = (HFONT)SelectObject(hdc,
(HFONT)SendMessage(hwndDlg,
WM_GETFONT,
0,
0));
GetTextExtentPoint(hdc, TEXT("W"), 1, &siz);
dyDriveItem = siz.cy;
if (hfontOld)
{
SelectObject(hdc, hfontOld);
}
ReleaseDC(NULL, hdc);
dyDriveItem += DRIVELIST_BORDER;
if (dyDriveItem < MINIDRIVE_HEIGHT)
{
dyDriveItem = MINIDRIVE_HEIGHT;
}
lpmi->itemHeight = dyDriveItem;
}
////////////////////////////////////////////////////////////////////////////
//
// CFileOpenBrowser::PaintDriveLine
//
////////////////////////////////////////////////////////////////////////////
void CFileOpenBrowser::PaintDriveLine(
DRAWITEMSTRUCT *lpdis)
{
HDC hdc = lpdis->hDC;
RECT rc = lpdis->rcItem;
TCHAR szText[MAX_DRIVELIST_STRING_LEN];
int offset = 0;
int xString, yString, xMiniDrive, dyString;
SIZE siz;
if ((int)lpdis->itemID < 0)
{
return;
}
MYLISTBOXITEM *pItem = GetListboxItem(lpdis->hwndItem, lpdis->itemID);
if (pItem)
{
::SendDlgItemMessage(_hwndDlg,
cmb2,
CB_GETLBTEXT,
lpdis->itemID,
(LPARAM)szText);
//
// Before doing anything, calculate the actual rectangle for the text.
//
if (!(lpdis->itemState & ODS_COMBOBOXEDIT))
{
offset = 10 * pItem->cIndent;
}
xMiniDrive = rc.left + DRIVELIST_BORDER + offset;
rc.left = xString = xMiniDrive + MINIDRIVE_WIDTH + MINIDRIVE_MARGIN;
GetTextExtentPoint(hdc, szText, lstrlen(szText), &siz);
dyString = siz.cy;
rc.right = rc.left + siz.cx;
rc.left--;
rc.right++;
if (lpdis->itemAction != ODA_FOCUS)
{
FillRect(hdc, &lpdis->rcItem, GetSysColorBrush(COLOR_WINDOW));
yString = rc.top + (rc.bottom - rc.top - dyString) / 2;
SetBkColor(hdc,
GetSysColor((lpdis->itemState & ODS_SELECTED)
? COLOR_HIGHLIGHT
: COLOR_WINDOW));
SetTextColor(hdc,
GetSysColor((lpdis->itemState & ODS_SELECTED)
? COLOR_HIGHLIGHTTEXT
: COLOR_WINDOWTEXT));
if ((lpdis->itemState & ODS_COMBOBOXEDIT) &&
(rc.right > lpdis->rcItem.right))
{
//
// Need to clip as user does not!
//
rc.right = lpdis->rcItem.right;
ExtTextOut(hdc,
xString,
yString,
ETO_OPAQUE | ETO_CLIPPED,
&rc,
szText,
lstrlen(szText),
NULL);
}
else
{
ExtTextOut(hdc,
xString,
yString,
ETO_OPAQUE,
&rc,
szText,
lstrlen(szText),
NULL);
}
ImageList_Draw(_himl,
(lpdis->itemID == (UINT)_iCurrentLocation)
? pItem->iSelectedImage
: pItem->iImage,
hdc,
xMiniDrive,
rc.top + (rc.bottom - rc.top - MINIDRIVE_HEIGHT) / 2,
(pItem->IsShared()
? INDEXTOOVERLAYMASK(IDOI_SHARE)
: 0) |
((lpdis->itemState & ODS_SELECTED)
? (ILD_SELECTED | ILD_FOCUS | ILD_TRANSPARENT)
: ILD_TRANSPARENT));
}
}
if (lpdis->itemAction == ODA_FOCUS ||
(lpdis->itemState & ODS_FOCUS))
{
DrawFocusRect(hdc, &rc);
}
}
////////////////////////////////////////////////////////////////////////////
//
// CFileOpenBrowser::RefreshFilter
//
// Refresh the view given any change in the user's choice of wildcard
// filter.
//
////////////////////////////////////////////////////////////////////////////
void CFileOpenBrowser::RefreshFilter(
HWND hwndFilter)
{
WAIT_CURSOR w(this);
_pOFN->Flags &= ~OFN_FILTERDOWN;
short nIndex = (short) SendMessage(hwndFilter, CB_GETCURSEL, 0, 0L);
if (nIndex < 0)
{
//
// No current selection.
//
return;
}
BOOL bCustomFilter = _pOFN->lpstrCustomFilter && *_pOFN->lpstrCustomFilter;
_pOFN->nFilterIndex = nIndex;
if (!bCustomFilter)
{
_pOFN->nFilterIndex++;
}
LPTSTR lpFilter;
//
// Must also check if filter contains anything.
//
lpFilter = (LPTSTR)ComboBox_GetItemData(hwndFilter, nIndex);
if (*lpFilter)
{
SetCurrentFilter(lpFilter);
//
// Provide dynamic _pszDefExt updating when lpstrDefExt is app
// initialized.
//
if (!_bNoInferDefExt && _pOFN->lpstrDefExt)
{
//
// We are looking for "foo*.ext[;...]". We will grab ext as the
// default extension. If not of this form, use the default
// extension passed in.
//
LPTSTR lpDot = StrChr(lpFilter, CHAR_DOT);
//
// Skip past the CHAR_DOT.
//
if (lpDot && _pszDefExt.StrCpy(lpDot + 1))
{
LPTSTR lpSemiColon = StrChr(_pszDefExt, CHAR_SEMICOLON);
if (lpSemiColon)
{
*lpSemiColon = CHAR_NULL;
}
if (IsWild(_pszDefExt))
{
_pszDefExt.StrCpy(_pOFN->lpstrDefExt);
}
}
else
{
_pszDefExt.StrCpy(_pOFN->lpstrDefExt);
}
}
if (_bUseCombo)
{
HWND hwndEdit = (HWND)SendMessage(GetDlgItem(_hwndDlg, cmb13), CBEM_GETEDITCONTROL, 0, 0L);
GetWindowText(hwndEdit, _szBuf, ARRAYSIZE(_szBuf));
}
else
{
GetDlgItemText(_hwndDlg, edt1, _szBuf, ARRAYSIZE(_szBuf));
}
if (IsWild(_szBuf))
{
//
// We should not show a filter that we are not using.
//
*_szBuf = CHAR_NULL;
SetEditFile(_szBuf, NULL, TRUE);
}
if (_psv)
{
_psv->Refresh();
}
}
if (_hSubDlg)
{
if (!CD_SendTypeChangeNotify(_hSubDlg, _hwndDlg, _pOFN, _pOFI))
{
CD_SendLBChangeMsg(_hSubDlg, cmb1, nIndex, CD_LBSELCHANGE, _pOFI->ApiType);
}
}
}
////////////////////////////////////////////////////////////////////////////
//
// CFileOpenBrowser::GetDirectoryFromLB
//
// Return the dropdown's directory and its length.
// Set *pichRoot to the start of the path (C:\ or \\server\share\).
//
////////////////////////////////////////////////////////////////////////////
UINT CFileOpenBrowser::GetDirectoryFromLB(
LPTSTR pszBuf,
int *pichRoot)
{
*pszBuf = 0;
if (_pCurrentLocation->pidlFull != NULL)
{
GetPathFromLocation(_pCurrentLocation, pszBuf);
}
if (*pszBuf)
{
PathAddBackslash(pszBuf);
LPTSTR pszBackslash = StrChr(pszBuf + 2, CHAR_BSLASH);
if (pszBackslash != NULL)
{
//
// For UNC paths, the "root" is on the next backslash.
//
if (DBL_BSLASH(pszBuf))
{
pszBackslash = StrChr(pszBackslash + 1, CHAR_BSLASH);
}
UINT cchRet = lstrlen(pszBuf);
*pichRoot = (pszBackslash != NULL) ? (int)(pszBackslash - pszBuf) : cchRet;
return (cchRet);
}
}
*pichRoot = 0;
return (0);
}
////////////////////////////////////////////////////////////////////////////
//
// CFileOpenBrowser::EnumItemObjects
//
////////////////////////////////////////////////////////////////////////////
typedef BOOL (*EIOCALLBACK)(
CFileOpenBrowser *that,
LPCITEMIDLIST pidl,
LPARAM lParam);
BOOL CFileOpenBrowser::EnumItemObjects(
UINT uItem,
EIOCALLBACK pfnCallBack,
LPARAM lParam)
{
FORMATETC fmte = { (CLIPFORMAT) g_cfCIDA, NULL, DVASPECT_CONTENT, -1, TYMED_HGLOBAL };
BOOL bRet = FALSE;
LPCITEMIDLIST pidl;
LPIDA pida;
int cItems, i;
IDataObject *pdtobj;
STGMEDIUM medium;
if (!_psv || FAILED(_psv->GetItemObject(uItem,
IID_PPV_ARG(IDataObject, &pdtobj))))
{
goto Error0;
}
if (FAILED(pdtobj->GetData(&fmte, &medium)))
{
goto Error1;
}
pida = (LPIDA)GlobalLock(medium.hGlobal);
cItems = pida->cidl;
for (i = 1; ; ++i)
{
if (i > cItems)
{
//
// We got to the end of the list without a failure.
// Call back one last time with NULL.
//
bRet = pfnCallBack(this, NULL, lParam);
break;
}
pidl = LPIDL_GetIDList(pida, i);
if (!pfnCallBack(this, pidl, lParam))
{
break;
}
}
GlobalUnlock(medium.hGlobal);
_ReleaseStgMedium(&medium);
Error1:
pdtobj->Release();
Error0:
return (bRet);
}
////////////////////////////////////////////////////////////////////////////
//
// FindNameEnumCB
//
////////////////////////////////////////////////////////////////////////////
#define FE_INVALID_VALUE 0x0000
#define FE_OUTOFMEM 0x0001
#define FE_TOOMANY 0x0002
#define FE_CHANGEDDIR 0x0003
#define FE_FILEERR 0x0004
#define FE_FOUNDNAME 0x0005
typedef struct _FINDNAMESTRUCT
{
LPTSTR pszFile;
UINT uRet;
LPCITEMIDLIST pidlFound;
} FINDNAMESTRUCT;
BOOL FindNameEnumCB(
CFileOpenBrowser *that,
LPCITEMIDLIST pidl,
LPARAM lParam)
{
SHFILEINFO sfi;
FINDNAMESTRUCT *pfns = (FINDNAMESTRUCT *)lParam;
if (!pidl)
{
if (!pfns->pidlFound)
{
return FALSE;
}
GetViewItemText(that->_psfCurrent, pfns->pidlFound, pfns->pszFile, MAX_PATH);
if (IsContainer(that->_psfCurrent, pfns->pidlFound))
{
LPITEMIDLIST pidlFull = ILCombine(that->_pCurrentLocation->pidlFull,
pfns->pidlFound);
if (pidlFull)
{
if (that->JumpToIDList(pidlFull))
{
pfns->uRet = FE_CHANGEDDIR;
}
else if (!that->_psv)
{
pfns->uRet = FE_OUTOFMEM;
}
SHFree(pidlFull);
if (pfns->uRet != FE_INVALID_VALUE)
{
return TRUE;
}
}
}
pfns->uRet = FE_FOUNDNAME;
return TRUE;
}
if (!SHGetFileInfo((LPCTSTR)pidl,
0,
&sfi,
sizeof(sfi),
SHGFI_DISPLAYNAME | SHGFI_PIDL))
{
//
// This will never happen, right?
//
return TRUE;
}
if (lstrcmpi(sfi.szDisplayName, pfns->pszFile) != 0)
{
//
// Continue the enumeration.
//
return TRUE;
}
if (!pfns->pidlFound)
{
pfns->pidlFound = pidl;
//
// Continue looking for more matches.
//
return TRUE;
}
//
// We already found a match, so select the first one and stop the search.
//
// The focus must be set to _hwndView before changing selection or
// the GetItemObject may not work.
//
FORWARD_WM_NEXTDLGCTL(that->_hwndDlg, that->_hwndView, 1, SendMessage);
that->_psv->SelectItem(pfns->pidlFound,
SVSI_SELECT | SVSI_DESELECTOTHERS |
SVSI_ENSUREVISIBLE | SVSI_FOCUSED);
pfns->pidlFound = NULL;
pfns->uRet = FE_TOOMANY;
//
// Stop enumerating.
//
return FALSE;
}
////////////////////////////////////////////////////////////////////////////
//
// CDPathQualify
//
////////////////////////////////////////////////////////////////////////////
void CDPathQualify(
LPCTSTR lpFile,
LPTSTR pszPathName)
{
TCHAR szCurDir[MAX_PATH + 1];
lstrcpy(pszPathName, lpFile);
//
// This should do the whole job of canonicalizing the directory.
//
GetCurrentDirectory(ARRAYSIZE(szCurDir), szCurDir);
PathCombine(pszPathName, szCurDir, pszPathName);
}
////////////////////////////////////////////////////////////////////////////
//
// VerifyOpen
//
// Returns: 0 success
// !0 dos error code
//
////////////////////////////////////////////////////////////////////////////
int VerifyOpen(
LPCTSTR lpFile,
LPTSTR pszPathName)
{
HANDLE hf;
CDPathQualify(lpFile, pszPathName);
hf = CreateFile(pszPathName,
GENERIC_READ,
FILE_SHARE_READ | FILE_SHARE_WRITE,
NULL,
OPEN_EXISTING,
FILE_ATTRIBUTE_NORMAL,
NULL);
if (hf == INVALID_HANDLE_VALUE)
{
return GetLastError();
}
else
{
CloseHandle(hf);
return (0);
}
}
////////////////////////////////////////////////////////////////////////////
//
// CFileOpenBrowser::IsKnownExtension
//
////////////////////////////////////////////////////////////////////////////
BOOL CFileOpenBrowser::IsKnownExtension(
LPCTSTR pszExtension)
{
if ((LPTSTR)_pszDefExt && lstrcmpi(pszExtension + 1, _pszDefExt) == 0)
{
//
// It's the default extension, so no need to add it again.
//
return TRUE;
}
if (lstrcmp(_szLastFilter, szStarDotStar) == 0)
{
//Current Filter is *.*, so allow whatever extension user enters.
return TRUE;
}
if (RegQueryValue(HKEY_CLASSES_ROOT, pszExtension, NULL, 0) == ERROR_SUCCESS)
{
//
// It's a registered extension, so the user is trying to force
// the type.
//
return TRUE;
}
if (_pOFN->lpstrFilter)
{
LPCTSTR pFilter = _pOFN->lpstrFilter;
while (*pFilter)
{
//
// Skip visual.
//
pFilter = pFilter + lstrlen(pFilter) + 1;
//
// Search extension list.
//
while (*pFilter)
{
//
// Check extensions of the form '*.ext' only.
//
if (*pFilter == CHAR_STAR && *(++pFilter) == CHAR_DOT)
{
LPCTSTR pExt = pszExtension + 1;
pFilter++;
while (*pExt && *pExt == *pFilter)
{
pExt++;
pFilter++;
}
if (!*pExt && (*pFilter == CHAR_SEMICOLON || !*pFilter))
{
//
// We have a match.
//
return TRUE;
}
}
//
// Skip to next extension.
//
while (*pFilter)
{
TCHAR ch = *pFilter;
pFilter = CharNext(pFilter);
if (ch == CHAR_SEMICOLON)
{
break;
}
}
}
//
// Skip extension string's terminator.
//
pFilter++;
}
}
return FALSE;
}
BOOL CFileOpenBrowser::_IsNoDereferenceLinks(LPCWSTR pszFile, IShellItem *psi)
{
if (_pOFN->Flags & OFN_NODEREFERENCELINKS)
return TRUE;
LPWSTR psz = NULL;
if (!pszFile)
{
psi->GetDisplayName(SIGDN_PARENTRELATIVEPARSING, &psz);
pszFile = psz;
}
// if the filter equals what ever we are looking at
// we assume the caller is actually looking for
// this file.
BOOL fRet = (NULL == StrStr(_szLastFilter, TEXT(".*"))) && PathMatchSpec(pszFile, _szLastFilter);
if (psz)
CoTaskMemFree(psz);
return fRet;
}
////////////////////////////////////////////////////////////////////////////
//
// CFileOpenBrowser::FindNameInView
//
// We will only resolve a link once. If you have a link to a link, then
// we will return the second link.
//
// If nExtOffset is non-zero, it is the offset to the character following
// the dot.
//
////////////////////////////////////////////////////////////////////////////
#define NUM_LINKLOOPS 1
UINT CFileOpenBrowser::FindNameInView(
LPTSTR pszFile,
OKBUTTONFLAGS Flags,
LPTSTR pszPathName,
int nFileOffset,
int nExtOffset,
int *pnErrCode,
BOOL bTryAsDir)
{
UINT uRet;
FINDNAMESTRUCT fns =
{
pszFile,
FE_INVALID_VALUE,
NULL,
};
BOOL bGetOut = TRUE;
BOOL bAddExt = FALSE;
BOOL bHasExt = nExtOffset;
TCHAR szTemp[MAX_PATH + 1];
int nNewExt = lstrlen(pszFile);
//
// If no extension, point at the end of the file name.
//
if (!nExtOffset)
{
nExtOffset = nNewExt;
}
//
// HACK: We could have a link that points to another link that points to
// another link, ..., that points back to the original file. We will not
// loop more than NUM_LINKLOOPS times before giving up.
int nLoop = NUM_LINKLOOPS;
if (Flags & (OKBUTTON_NODEFEXT | OKBUTTON_QUOTED))
{
goto VerifyTheName;
}
if (bHasExt)
{
if (IsKnownExtension(pszFile + nExtOffset))
{
goto VerifyTheName;
}
//
// Don't attempt 2 extensions on SFN volume.
//
CDPathQualify(pszFile, pszPathName);
if (!IsLFNDrive(pszPathName))
{
goto VerifyTheName;
}
}
bGetOut = FALSE;
if ((LPTSTR)_pszDefExt &&
((DWORD)nNewExt + lstrlen(_pszDefExt) < _pOFN->nMaxFile))
{
bAddExt = TRUE;
//
// Note that we check lpstrDefExt to see if they want an automatic
// extension, but actually copy _pszDefExt.
//
AppendExt(pszFile, _pszDefExt, FALSE);
//
// So we've added the default extension. If there's a directory
// that matches this name, all attempts to open/create the file
// will fail, so simply change to the directory as if they had
// typed it in. Note that by putting this test here, if there
// was a directory without the extension, we would have already
// switched to it.
//
VerifyTheName:
//
// Note that this also works for a UNC name, even on a net that
// does not support using UNC's directly. It will also do the
// right thing for links to things. We do not validate if we
// have not dereferenced any links, since that should have
// already been done.
//
if (bTryAsDir && SetDirRetry(pszFile, nLoop == NUM_LINKLOOPS))
{
return (FE_CHANGEDDIR);
}
*pnErrCode = VerifyOpen(pszFile, pszPathName);
if (*pnErrCode == 0 || *pnErrCode == OF_SHARINGVIOLATION)
{
//
// This may be a link to something, so we should try to
// resolve it.
//
if (!_IsNoDereferenceLinks(pszFile, NULL) && nLoop > 0)
{
--nLoop;
LPITEMIDLIST pidl;
IShellFolder *psf = NULL;
DWORD dwAttr = SFGAO_LINK;
HRESULT hRes;
//
// ILCreateFromPath is slow (especially on a Net path),
// so just try to parse the name in the current folder if
// possible.
//
if (nFileOffset || nLoop < NUM_LINKLOOPS - 1)
{
LPITEMIDLIST pidlTemp;
hRes = SHILCreateFromPath(pszPathName, &pidlTemp, &dwAttr);
//We are getting a pidl corresponding to a path. Get the IShellFolder corresponding to this pidl
// to pass it to ResolveLink
if (SUCCEEDED(hRes))
{
LPCITEMIDLIST pidlLast;
hRes = CDBindToIDListParent(pidlTemp, IID_PPV_ARG(IShellFolder, &psf), (LPCITEMIDLIST *)&pidlLast);
if (SUCCEEDED(hRes))
{
//Get the child pidl relative to the IShellFolder
pidl = ILClone(pidlLast);
}
ILFree(pidlTemp);
}
}
else
{
WCHAR wszDisplayName[MAX_PATH + 1];
ULONG chEaten;
SHTCharToUnicode(pszFile, wszDisplayName , ARRAYSIZE(wszDisplayName));
hRes = _psfCurrent->ParseDisplayName(NULL,
NULL,
wszDisplayName,
&chEaten,
&pidl,
&dwAttr);
}
if (SUCCEEDED(hRes))
{
if (dwAttr & SFGAO_LINK)
{
SHTCUTINFO info;
info.dwAttr = 0;
info.fReSolve = FALSE;
info.pszLinkFile = szTemp;
info.cchFile = ARRAYSIZE(szTemp);
info.ppidl = NULL;
//psf can be NULL in which case ResolveLink uses _psfCurrent IShellFolder
if (SUCCEEDED(ResolveLink(pidl, &info, psf)) && szTemp[0])
{
//
// It was a link, and it "dereferenced" to something,
// so we should try again with that new file.
//
lstrcpy(pszFile, szTemp);
if (pidl)
{
SHFree(pidl);
}
if (psf)
{
psf->Release();
psf = NULL;
}
goto VerifyTheName;
}
}
if (pidl)
{
SHFree(pidl);
}
if (psf)
{
psf->Release();
psf = NULL;
}
}
}
return (FE_FOUNDNAME);
}
if (bGetOut ||
(*pnErrCode != OF_FILENOTFOUND && *pnErrCode != OF_PATHNOTFOUND))
{
return (FE_FILEERR);
}
if (_bSave)
{
//
// Do no more work if creating a new file.
//
return (FE_FOUNDNAME);
}
}
//
// Make sure we do not loop forever.
//
bGetOut = TRUE;
if (_bSave)
{
//
// Do no more work if creating a new file.
//
goto VerifyTheName;
}
pszFile[nNewExt] = CHAR_NULL;
if (bTryAsDir && (nFileOffset > 0))
{
TCHAR cSave = *(pszFile + nFileOffset);
*(pszFile + nFileOffset) = CHAR_NULL;
//
// We need to have the view on the dir with the file to do the
// next steps.
//
BOOL bOK = JumpToPath(pszFile);
*(pszFile + nFileOffset) = cSave;
if (!_psv)
{
//
// We're dead.
//
return (FE_OUTOFMEM);
}
if (bOK)
{
lstrcpy(pszFile, pszFile + nFileOffset);
nNewExt -= nFileOffset;
SetEditFile(pszFile, NULL, TRUE);
}
else
{
*pnErrCode = OF_PATHNOTFOUND;
return (FE_FILEERR);
}
}
EnumItemObjects(SVGIO_ALLVIEW, FindNameEnumCB, (LPARAM)&fns);
switch (fns.uRet)
{
case (FE_INVALID_VALUE) :
{
break;
}
case (FE_FOUNDNAME) :
{
goto VerifyTheName;
}
default :
{
uRet = fns.uRet;
goto VerifyAndRet;
}
}
if (bAddExt)
{
//
// Before we fail, check to see if the file typed sans default
// extension exists.
//
*pnErrCode = VerifyOpen(pszFile, pszPathName);
if (*pnErrCode == 0 || *pnErrCode == OF_SHARINGVIOLATION)
{
//
// We will never hit this case for links (because they
// have registered extensions), so we don't need
// to goto VerifyTheName (which also calls VerifyOpen again).
//
return (FE_FOUNDNAME);
}
//
// I still can't find it? Try adding the default extension and
// return failure.
//
AppendExt(pszFile, _pszDefExt, FALSE);
}
uRet = FE_FILEERR;
VerifyAndRet:
*pnErrCode = VerifyOpen(pszFile, pszPathName);
return (uRet);
}
////////////////////////////////////////////////////////////////////////////
//
// CFileOpenBrowser::SetDirRetry
//
////////////////////////////////////////////////////////////////////////////
BOOL CFileOpenBrowser::SetDirRetry(
LPTSTR pszDir,
BOOL bNoValidate)
{
if (SetCurrentDirectory(pszDir))
{
JumpThere:
JumpToPath(TEXT("."));
return TRUE;
}
if (bNoValidate || !IsUNC(pszDir))
{
return FALSE;
}
//
// It may have been a password problem, so try to add the connection.
// Note that if we are on a net that does not support CD'ing to UNC's
// directly, this call will connect it to a drive letter.
//
if (!SHValidateUNC(_hwndDlg, pszDir, 0))
{
switch (GetLastError())
{
case ERROR_CANCELLED:
{
//
// We don't want to put up an error message if they
// canceled the password dialog.
//
return TRUE;
}
case ERROR_NETWORK_UNREACHABLE:
{
LPTSTR lpMsgBuf;
TCHAR szTitle[MAX_PATH];
FormatMessage(
FORMAT_MESSAGE_ALLOCATE_BUFFER |
FORMAT_MESSAGE_FROM_SYSTEM |
FORMAT_MESSAGE_IGNORE_INSERTS,
NULL,
GetLastError(),
MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT), // Default language
(LPTSTR) &lpMsgBuf,
0,
NULL);
GetWindowText(_hwndDlg, szTitle, ARRAYSIZE(szTitle));
MessageBox(NULL, lpMsgBuf, szTitle, MB_OK | MB_ICONINFORMATION);
// Free the buffer.
LocalFree(lpMsgBuf);
return TRUE;
}
default:
{
//
// Some other error we don't know about.
//
return FALSE;
}
}
}
//
// We connected to it, so try to switch to it again.
//
if (SetCurrentDirectory(pszDir))
{
goto JumpThere;
}
return FALSE;
}
////////////////////////////////////////////////////////////////////////////
//
// CFileOpenBrowser::MultiSelectOKButton
//
////////////////////////////////////////////////////////////////////////////
BOOL CFileOpenBrowser::MultiSelectOKButton(
LPCTSTR pszFiles,
OKBUTTONFLAGS Flags)
{
TCHAR szPathName[MAX_PATH];
int nErrCode;
LPTSTR pchRead, pchWrite, lpCurDir;
UINT cch, cchCurDir, cchFiles;
WAIT_CURSOR w(this);
//
// This doesn't really mean anything for multiselection.
//
_pOFN->nFileExtension = 0;
if (!_pOFN->lpstrFile)
{
return TRUE;
}
//
// Check for space for first full path element.
//
if ((_pOFN->Flags & OFN_ENABLEINCLUDENOTIFY) && lstrlen(_pszObjectCurDir))
{
lpCurDir = _pszObjectCurDir;
}
else
{
lpCurDir = _szCurDir;
}
cchCurDir = lstrlen(lpCurDir) + 1;
cchFiles = lstrlen(pszFiles) + 1;
cch = cchCurDir + cchFiles;
if (cch > (UINT)_pOFN->nMaxFile)
{
//
// Buffer is too small, so return the size of the buffer
// required to hold the string.
//
// cch is not really the number of characters needed, but it
// should be close.
//
StoreLengthInString((LPTSTR)_pOFN->lpstrFile, (UINT)_pOFN->nMaxFile, (UINT)cch);
return TRUE;
}
TEMPSTR psFiles(cchFiles + FILE_PADDING);
pchRead = psFiles;
if (!pchRead)
{
//
// Out of memory.
// FEATURE There should be some sort of error message here.
//
return FALSE;
}
//
// Copy in the full path as the first element.
//
lstrcpy(_pOFN->lpstrFile, lpCurDir);
//
// Set nFileOffset to 1st file.
//
_pOFN->nFileOffset = (WORD) cchCurDir;
pchWrite = _pOFN->lpstrFile + cchCurDir;
//
// We know there is enough room for the whole string.
//
lstrcpy(pchRead, pszFiles);
//
// This should only compact the string.
//
if (!ConvertToNULLTerm(pchRead))
{
return FALSE;
}
for (; *pchRead; pchRead += lstrlen(pchRead) + 1)
{
int nFileOffset, nExtOffset;
TCHAR szBasicPath[MAX_PATH];
lstrcpy(szBasicPath, pchRead);
nFileOffset = ParseFileNew(szBasicPath, &nExtOffset, FALSE, TRUE);
if (nFileOffset < 0)
{
InvalidFileWarningNew(_hwndDlg, pchRead, nFileOffset);
return FALSE;
}
//
// Pass in 0 for the file offset to make sure we do not switch
// to another folder.
//
switch (FindNameInView(szBasicPath,
Flags,
szPathName,
nFileOffset,
nExtOffset,
&nErrCode,
FALSE))
{
case (FE_OUTOFMEM) :
case (FE_CHANGEDDIR) :
{
return FALSE;
}
case (FE_TOOMANY) :
{
CDMessageBox(_hwndDlg,
iszTooManyFiles,
MB_OK | MB_ICONEXCLAMATION,
pchRead);
return FALSE;
}
default :
{
break;
}
}
if (nErrCode &&
((_pOFN->Flags & OFN_FILEMUSTEXIST) ||
(nErrCode != OF_FILENOTFOUND)) &&
((_pOFN->Flags & OFN_PATHMUSTEXIST) ||
(nErrCode != OF_PATHNOTFOUND)) &&
(!(_pOFN->Flags & OFN_SHAREAWARE) ||
(nErrCode != OF_SHARINGVIOLATION)))
{
if ((nErrCode == OF_SHARINGVIOLATION) && _hSubDlg)
{
int nShareCode = CD_SendShareNotify(_hSubDlg,
_hwndDlg,
szPathName,
_pOFN,
_pOFI);
if (nShareCode == OFN_SHARENOWARN)
{
return FALSE;
}
else if (nShareCode == OFN_SHAREFALLTHROUGH)
{
goto EscapedThroughShare;
}
else
{
//
// They might not have handled the notification, so try
// the registered message.
//
nShareCode = CD_SendShareMsg(_hSubDlg, szPathName, _pOFI->ApiType);
if (nShareCode == OFN_SHARENOWARN)
{
return FALSE;
}
else if (nShareCode == OFN_SHAREFALLTHROUGH)
{
goto EscapedThroughShare;
}
}
}
else if (nErrCode == OF_ACCESSDENIED)
{
szPathName[0] |= 0x60;
if (GetDriveType(szPathName) != DRIVE_REMOVABLE)
{
nErrCode = OF_NETACCESSDENIED;
}
}
//
// These will never be set.
//
if ((nErrCode == OF_WRITEPROTECTION) ||
(nErrCode == OF_DISKFULL) ||
(nErrCode == OF_DISKFULL2) ||
(nErrCode == OF_ACCESSDENIED))
{
*pchRead = szPathName[0];
}
MultiWarning:
InvalidFileWarningNew(_hwndDlg, pchRead, nErrCode);
return FALSE;
}
EscapedThroughShare:
if (nErrCode == 0)
{
if (!_ValidateSelectedFile(szPathName, &nErrCode))
{
if (nErrCode)
{
goto MultiWarning;
}
else
{
return FALSE;
}
}
}
//
// Add some more in case the file name got larger.
//
cch += lstrlen(szBasicPath) - lstrlen(pchRead);
if (cch > (UINT)_pOFN->nMaxFile)
{
//
// Buffer is too small, so return the size of the buffer
// required to hold the string.
//
StoreLengthInString((LPTSTR)_pOFN->lpstrFile, (UINT)_pOFN->nMaxFile, (UINT)cch);
return TRUE;
}
//
// We already know we have anough room.
//
lstrcpy(pchWrite, szBasicPath);
pchWrite += lstrlen(pchWrite) + 1;
}
//
// double-NULL terminate.
//
*pchWrite = CHAR_NULL;
return TRUE;
}
////////////////////////////////////////////////////////////////////////////
//
// StoreLengthInString
//
////////////////////////////////////////////////////////////////////////////
void StoreLengthInString(
LPTSTR lpStr,
UINT cchLen,
UINT cchStore)
{
if (cchLen >= 3)
{
//
// For single file requests, we will never go over 64K
// because the filesystem is limited to 256.
//
lpStr[0] = (TCHAR)LOWORD(cchStore);
lpStr[1] = CHAR_NULL;
}
else
{
lpStr[0] = (TCHAR)LOWORD(cchStore);
if (cchLen == 2)
{
lpStr[1] = (TCHAR)HIWORD(cchStore);
}
}
}
////////////////////////////////////////////////////////////////////////////
//
// CFileOpenBrowser::CheckForRestrictedFolder
//
////////////////////////////////////////////////////////////////////////////
BOOL CFileOpenBrowser::CheckForRestrictedFolder(LPCTSTR lpszPath, int nFileOffset)
{
TCHAR szPath[MAX_PATH];
TCHAR szTemp[MAX_PATH];
LPITEMIDLIST pidl;
BOOL bPidlAllocated = FALSE;
BOOL bRet = FALSE;
DWORD dwAttrib = SFGAO_FILESYSTEM;
HRESULT hr = S_OK;
if (nFileOffset > 0)
{
//There's a path in the given filename. Get the directory part of the filename.
lstrcpy(szTemp, lpszPath);
szTemp[nFileOffset] = 0;
//The directory path might be a relative path. Resolve it to get fully qualified path.
CDPathQualify(szTemp, szPath);
//Create the pidl for this path as well as get the attributes.
hr = SHILCreateFromPath(szPath, &pidl, &dwAttrib);
if (SUCCEEDED(hr))
{
bPidlAllocated = TRUE;
}
else
{
// WE are failing b'cos the user might have typed some path which doesn't exist.
// if the path doesn't exist then it can't be one of the directory we are trying restrict.
// let's bail out and let the code that checks for valid path take care of it
return bRet;
}
}
else
{
IShellLink *psl;
pidl = _pCurrentLocation->pidlFull;
if (SUCCEEDED(CDGetUIObjectFromFullPIDL(pidl,_hwndDlg, IID_PPV_ARG(IShellLink, &psl))))
{
LPITEMIDLIST pidlTarget;
if (S_OK == psl->GetIDList(&pidlTarget))
{
SHGetAttributesOf(pidlTarget, &dwAttrib);
ILFree(pidlTarget);
}
psl->Release();
}
else
{
SHGetAttributesOf(pidl, &dwAttrib);
}
}
// 1. We cannot save to the non file system folders.
// 2. We should not allow user to save in recent files folder as the file might get deleted.
if (!(dwAttrib & SFGAO_FILESYSTEM) || _IsRecentFolder(pidl))
{
int iMessage = UrlIs(lpszPath, URLIS_URL) ? iszNoSaveToURL : iszSaveRestricted;
HCURSOR hcurOld = SetCursor(LoadCursor(NULL, IDC_ARROW));
CDMessageBox(_hwndDlg, iMessage, MB_OK | MB_ICONEXCLAMATION);
SetCursor(hcurOld);
bRet = TRUE;
}
if (bPidlAllocated)
{
ILFree(pidl);
}
return bRet;
}
STDAPI_(LPITEMIDLIST) GetIDListFromFolder(IShellFolder *psf)
{
LPITEMIDLIST pidl = NULL;
IPersistFolder2 *ppf;
if (psf && SUCCEEDED(psf->QueryInterface(IID_PPV_ARG(IPersistFolder2, &ppf))))
{
ppf->GetCurFolder(&pidl);
ppf->Release();
}
return pidl;
}
////////////////////////////////////////////////////////////////////////////
//
// CFileOpenBrowser::OKButtonPressed
//
// Process the OK button being pressed. This may involve jumping to a path,
// changing the filter, actually choosing a file to open or save as, or who
// knows what else.
//
// Note: There are 4 cases for validation of a file name:
// 1) OFN_NOVALIDATE Allows invalid characters
// 2) No validation flags No invalid characters, but path need not exist
// 3) OFN_PATHMUSTEXIST No invalid characters, path must exist
// 4) OFN_FILEMUSTEXIST No invalid characters, path & file must exist
//
////////////////////////////////////////////////////////////////////////////
BOOL CFileOpenBrowser::OKButtonPressed(
LPCTSTR pszFile,
OKBUTTONFLAGS Flags)
{
TCHAR szExpFile[MAX_PATH];
TCHAR szPathName[MAX_PATH];
TCHAR szBasicPath[MAX_PATH];
LPTSTR pExpFile = NULL;
int nErrCode;
ECODE eCode = ECODE_S_OK;
DWORD cch;
int nFileOffset, nExtOffset, nOldExt;
TCHAR ch;
BOOL bAddExt = FALSE;
BOOL bUNCName = FALSE;
int nTempOffset;
BOOL bIsDir;
BOOL bRet = FALSE;
WAIT_CURSOR w(this);
EnableModelessSB(FALSE);
if (_bSelIsObject)
{
if ((INT)(lstrlen(_pszObjectPath) + 1) <= (INT)_pOFN->nMaxFile)
{
lstrcpy((LPTSTR)_pOFN->lpstrFile, (LPTSTR)_pszObjectPath);
}
else
{
StoreLengthInString(_pOFN->lpstrFile,
_pOFN->nMaxFile,
lstrlen(_pszObjectPath) + 1);
}
}
//
// Expand any environment variables.
//
cch = _pOFN->nMaxFile;
if (cch > MAX_PATH)
{
pExpFile = (LPTSTR)LocalAlloc(LPTR, (cch * sizeof(TCHAR)));
}
if (!pExpFile)
{
pExpFile = szExpFile;
cch = MAX_PATH;
}
pExpFile[0] = 0;
ExpandEnvironmentStrings(pszFile, pExpFile, cch);
pExpFile[cch - 1] = 0;
//
// See if we're in Multi Select mode.
//
if (StrChr(pExpFile, CHAR_QUOTE) && (_pOFN->Flags & OFN_ALLOWMULTISELECT))
{
bRet = MultiSelectOKButton(pExpFile, Flags);
goto ReturnFromOKButtonPressed;
}
//
// We've only got a single selection...if we're in
// multi-select mode & it's an object, we need to do a little
// work before continuing...
//
if ((_pOFN->Flags & OFN_ALLOWMULTISELECT) && _bSelIsObject)
{
if (pExpFile != szExpFile) // since szExpFile is stack memory.
{
LocalFree(pExpFile);
}
pExpFile = _pszObjectPath;
}
if ((pExpFile[1] == CHAR_COLON) || DBL_BSLASH(pExpFile))
{
//
// If a drive or UNC was specified, use it.
//
lstrcpyn(szBasicPath, pExpFile, ARRAYSIZE(szBasicPath) - 1);
nTempOffset = 0;
}
else
{
//
// Grab the directory from the listbox.
//
cch = GetDirectoryFromLB(szBasicPath, &nTempOffset);
if (pExpFile[0] == CHAR_BSLASH)
{
//
// If a directory from the root was given, put it
// immediately off the root (\\server\share or a:).
//
lstrcpyn(szBasicPath + nTempOffset,
pExpFile,
ARRAYSIZE(szBasicPath) - nTempOffset - 1);
}
else
{
//
// Tack the file to the end of the path.
//
lstrcpyn(szBasicPath + cch, pExpFile, ARRAYSIZE(szBasicPath) - cch - 1);
}
}
nFileOffset = ParseFileOld(szBasicPath, &nExtOffset, &nOldExt, FALSE, TRUE);
if (nFileOffset == PARSE_EMPTYSTRING)
{
if (_psv)
{
_psv->Refresh();
}
goto ReturnFromOKButtonPressed;
}
else if ((nFileOffset != PARSE_DIRECTORYNAME) &&
(_pOFN->Flags & OFN_NOVALIDATE))
{
if (_bSelIsObject)
{
_pOFN->nFileOffset = _pOFN->nFileExtension = 0;
}
else
{
_pOFN->nFileOffset = (WORD) nFileOffset;
_pOFN->nFileExtension = (WORD) nOldExt;
}
if (_pOFN->lpstrFile)
{
cch = lstrlen(szBasicPath);
if (cch <= LOWORD(_pOFN->nMaxFile))
{
lstrcpy(_pOFN->lpstrFile, szBasicPath);
}
else
{
//
// Buffer is too small, so return the size of the buffer
// required to hold the string.
//
StoreLengthInString(_pOFN->lpstrFile, _pOFN->nMaxFile, cch);
}
}
bRet = TRUE;
goto ReturnFromOKButtonPressed;
}
else if (nFileOffset == PARSE_DIRECTORYNAME)
{
//
// See if it ends in slash.
//
if (nExtOffset > 0)
{
if (ISBACKSLASH(szBasicPath, nExtOffset - 1))
{
//
// "\\server\share\" and "c:\" keep the trailing backslash,
// all other paths remove the trailing backslash. Note that
// we don't remove the slash if the user typed the path directly
// (nTempOffset is 0 in that case).
//
if ((nExtOffset != 1) &&
(szBasicPath[nExtOffset - 2] != CHAR_COLON) &&
(nExtOffset != nTempOffset + 1))
{
szBasicPath[nExtOffset - 1] = CHAR_NULL;
}
}
else if ((szBasicPath[nExtOffset - 1] == CHAR_DOT) &&
((szBasicPath[nExtOffset - 2] == CHAR_DOT) ||
ISBACKSLASH(szBasicPath, nExtOffset - 2)) &&
IsUNC(szBasicPath))
{
//
// Add a trailing slash to UNC paths ending with ".." or "\."
//
szBasicPath[nExtOffset] = CHAR_BSLASH;
szBasicPath[nExtOffset + 1] = CHAR_NULL;
}
}
//
// Fall through to Directory Checking.
//
}
else if (nFileOffset < 0)
{
nErrCode = nFileOffset;
//
// I don't recognize this, so try to jump there.
// This is where servers get processed.
//
if (JumpToPath(szBasicPath))
{
goto ReturnFromOKButtonPressed;
}
//
// Fall through to the rest of the processing to warn the user.
//
Warning:
if (bUNCName)
{
cch = lstrlen(szBasicPath) - 1;
if ((szBasicPath[cch] == CHAR_BSLASH) &&
(szBasicPath[cch - 1] == CHAR_DOT) &&
(ISBACKSLASH(szBasicPath, cch - 2)))
{
szBasicPath[cch - 2] = CHAR_NULL;
}
}
// For file names of form c:filename.txt , we hacked and changed it to c:.\filename.txt
// check for that hack and if so change the file name back as it was given by user.
else if ((nFileOffset == 2) && (szBasicPath[2] == CHAR_DOT))
{
lstrcpy(szBasicPath + 2, szBasicPath + 4);
}
// If the disk is not a floppy and they tell me there's no
// disk in the drive, don't believe them. Instead, put up the
// error message that they should have given us. (Note that the
// error message is checked first since checking the drive type
// is slower.)
//
//
// I will assume that if we get error 0 or 1 or removable
// that we will assume removable.
//
if (nErrCode == OF_ACCESSDENIED)
{
TCHAR szD[4];
szPathName[0] |= 0x60;
szD[0] = *szBasicPath;
szD[1] = CHAR_COLON;
szD[2] = CHAR_BSLASH;
szD[3] = 0;
if (bUNCName || GetDriveType(szD) <= DRIVE_REMOVABLE)
{
nErrCode = OF_NETACCESSDENIED;
}
}
if ((nErrCode == OF_WRITEPROTECTION) ||
(nErrCode == OF_DISKFULL) ||
(nErrCode == OF_DISKFULL2) ||
(nErrCode == OF_ACCESSDENIED))
{
szBasicPath[0] = szPathName[0];
}
HRESULT hr = E_FAIL;
if (_bSave)
{
hr = CheckForRestrictedFolder(pszFile, 0) ? S_FALSE : E_FAIL;
}
// we might only want use ShellItem's for some errors
if (FAILED(hr)/*&& (nErrCode == OF_FILENOTFOUND || (nErrCode == OF_PATHNOTFOUND))*/)
{
IShellItem *psi;
hr = _ParseShellItem(pszFile, &psi, TRUE);
if (S_OK == hr)
{
hr = _ProcessItemAsFile(psi);
psi->Release();
}
}
if (FAILED(hr) && hr != HRESULT_FROM_WIN32(ERROR_CANCELLED))
{
// Special case
// If the error was ACCESS_DENIED in a save dialog.
if (_bSave && (nErrCode == OF_ACCESSDENIED))
{
// Ask if the user wants to switch to My Documents.
_SaveAccessDenied(pszFile);
}
else
{
InvalidFileWarningNew(_hwndDlg, pszFile, nErrCode);
}
}
else if (S_OK == hr)
{
bRet = TRUE;
}
goto ReturnFromOKButtonPressed;
}
//
// We either have a file pattern or a real file.
// If it's a UNC name
// (1) Fall through to file name testing
// Else if it's a directory
// (1) Add on default pattern
// (2) Act like it's a pattern (goto pattern (1))
// Else if it's a pattern
// (1) Update everything
// (2) display files in whatever dir we're now in
// Else if it's a file name!
// (1) Check out the syntax
// (2) End the dialog given OK
// (3) Beep/message otherwise
//
//
// Directory ?? this must succeed for relative paths.
// NOTE: It won't succeed for relative paths that walk off the root.
//
bIsDir = SetDirRetry(szBasicPath);
//
// We need to parse again in case SetDirRetry changed a UNC path to use
// a drive letter.
//
nFileOffset = ParseFileOld(szBasicPath, &nExtOffset, &nOldExt, FALSE, TRUE);
nTempOffset = nFileOffset;
if (bIsDir)
{
goto ReturnFromOKButtonPressed;
}
else if (IsUNC(szBasicPath))
{
//
// UNC Name.
//
bUNCName = TRUE;
}
else if (nFileOffset > 0)
{
TCHAR szBuf[MAX_PATH];
//
// There is a path in the string.
//
if ((nFileOffset > 1) &&
(szBasicPath[nFileOffset - 1] != CHAR_COLON) &&
(szBasicPath[nFileOffset - 2] != CHAR_COLON))
{
nTempOffset--;
}
GetCurrentDirectory(ARRAYSIZE(szBuf), szBuf);
ch = szBasicPath[nTempOffset];
szBasicPath[nTempOffset] = 0;
if (SetCurrentDirectory(szBasicPath))
{
SetCurrentDirectory(szBuf);
}
else
{
switch (GetLastError())
{
case (ERROR_NOT_READY) :
{
eCode = ECODE_BADDRIVE;
break;
}
default :
{
eCode = ECODE_BADPATH;
break;
}
}
}
szBasicPath[nTempOffset] = ch;
}
else if (nFileOffset == PARSE_DIRECTORYNAME)
{
TCHAR szD[4];
szD[0] = *szBasicPath;
szD[1] = CHAR_COLON;
szD[2] = CHAR_BSLASH;
szD[3] = 0;
if (PathFileExists(szD))
{
eCode = ECODE_BADPATH;
}
else
{
eCode = ECODE_BADDRIVE;
}
}
//
// Was there a path and did it fail?
//
if (!bUNCName &&
nFileOffset &&
eCode != ECODE_S_OK &&
(_pOFN->Flags & OFN_PATHMUSTEXIST))
{
if (eCode == ECODE_BADPATH)
{
nErrCode = OF_PATHNOTFOUND;
}
else if (eCode == ECODE_BADDRIVE)
{
TCHAR szD[4];
//
// We can get here without performing an OpenFile call. As
// such the szPathName can be filled with random garbage.
// Since we only need one character for the error message,
// set szPathName[0] to the drive letter.
//
szPathName[0] = szD[0] = *szBasicPath;
szD[1] = CHAR_COLON;
szD[2] = CHAR_BSLASH;
szD[3] = 0;
switch (GetDriveType(szD))
{
case (DRIVE_REMOVABLE) :
{
nErrCode = ERROR_NOT_READY;
break;
}
case (1) :
{
//
// Drive does not exist.
//
nErrCode = OF_NODRIVE;
break;
}
default :
{
nErrCode = OF_PATHNOTFOUND;
}
}
}
else
{
nErrCode = OF_FILENOTFOUND;
}
goto Warning;
}
//
// Full pattern?
//
if (IsWild(szBasicPath + nFileOffset))
{
if (!bUNCName)
{
SetCurrentFilter(szBasicPath + nFileOffset, Flags);
if (nTempOffset)
{
szBasicPath[nTempOffset] = 0;
JumpToPath(szBasicPath, TRUE);
}
else if (_psv)
{
_psv->Refresh();
}
goto ReturnFromOKButtonPressed;
}
else
{
SetCurrentFilter(szBasicPath + nFileOffset, Flags);
szBasicPath[nFileOffset] = CHAR_NULL;
JumpToPath(szBasicPath);
goto ReturnFromOKButtonPressed;
}
}
if (PortName(szBasicPath + nFileOffset))
{
nErrCode = OF_PORTNAME;
goto Warning;
}
// In save as dialog check to see if the folder user trying to save a file is
// a restricted folder (Network Folder). if so bail out
if (_bSave && CheckForRestrictedFolder(szBasicPath, nFileOffset))
{
goto ReturnFromOKButtonPressed;
}
//
// Check if we've received a string in the form "C:filename.ext".
// If we have, convert it to the form "C:.\filename.ext". This is done
// because the kernel will search the entire path, ignoring the drive
// specification after the initial search. Making it include a slash
// causes kernel to only search at that location.
//
// Note: Only increment nExtOffset, not nFileOffset. This is done
// because only nExtOffset is used later, and nFileOffset can then be
// used at the Warning: label to determine if this hack has occurred,
// and thus it can strip out the ".\" when putting up the error.
//
if ((nFileOffset == 2) && (szBasicPath[1] == CHAR_COLON))
{
lstrcpy(_szBuf, szBasicPath + 2);
lstrcpy(szBasicPath + 4, _szBuf);
szBasicPath[2] = CHAR_DOT;
szBasicPath[3] = CHAR_BSLASH;
nExtOffset += 2;
}
//
// Add the default extension unless filename ends with period or no
// default extension exists. If the file exists, consider asking
// permission to overwrite the file.
//
// NOTE: When no extension given, default extension is tried 1st.
// FindNameInView calls VerifyOpen before returning.
//
szPathName[0] = 0;
switch (FindNameInView(szBasicPath,
Flags,
szPathName,
nFileOffset,
nExtOffset,
&nErrCode))
{
case (FE_OUTOFMEM) :
case (FE_CHANGEDDIR) :
{
goto ReturnFromOKButtonPressed;
}
case (FE_TOOMANY) :
{
SetCursor(LoadCursor(NULL, IDC_ARROW));
CDMessageBox(_hwndDlg,
iszTooManyFiles,
MB_OK | MB_ICONEXCLAMATION,
szBasicPath);
goto ReturnFromOKButtonPressed;
}
default :
{
break;
}
}
switch (nErrCode)
{
case (0) :
{
if (!_ValidateSelectedFile(szPathName, &nErrCode))
{
if (nErrCode)
{
goto Warning;
}
else
{
goto ReturnFromOKButtonPressed;
}
}
break;
}
case (OF_SHARINGVIOLATION) :
{
//
// If the app is "share aware", fall through.
// Otherwise, ask the hook function.
//
if (!(_pOFN->Flags & OFN_SHAREAWARE))
{
if (_hSubDlg)
{
int nShareCode = CD_SendShareNotify(_hSubDlg,
_hwndDlg,
szPathName,
_pOFN,
_pOFI);
if (nShareCode == OFN_SHARENOWARN)
{
goto ReturnFromOKButtonPressed;
}
else if (nShareCode != OFN_SHAREFALLTHROUGH)
{
//
// They might not have handled the notification,
// so try the registered message.
//
nShareCode = CD_SendShareMsg(_hSubDlg, szPathName, _pOFI->ApiType);
if (nShareCode == OFN_SHARENOWARN)
{
goto ReturnFromOKButtonPressed;
}
else if (nShareCode != OFN_SHAREFALLTHROUGH)
{
goto Warning;
}
}
}
else
{
goto Warning;
}
}
break;
}
case (OF_FILENOTFOUND) :
case (OF_PATHNOTFOUND) :
{
if (!_bSave)
{
//
// The file or path wasn't found.
// If this is a save dialog, we're ok, but if it's not,
// we're toast.
//
if (_pOFN->Flags & OFN_FILEMUSTEXIST)
{
if (_pOFN->Flags & OFN_CREATEPROMPT)
{
int nCreateCode = CreateFileDlg(_hwndDlg, szBasicPath);
if (nCreateCode != IDYES)
{
goto ReturnFromOKButtonPressed;
}
}
else
{
goto Warning;
}
}
}
goto VerifyPath;
}
default :
{
if (!_bSave)
{
goto Warning;
}
//
// The file doesn't exist. Can it be created? This is needed
// because there are many extended characters which are invalid
// which won't be caught by ParseFile.
//
// Two more good reasons: Write-protected disks & full disks.
//
// BUT, if they don't want the test creation, they can request
// that we not do it using the OFN_NOTESTFILECREATE flag. If
// they want to create files on a share that has
// create-but-no-modify privileges, they should set this flag
// but be ready for failures that couldn't be caught, such as
// no create privileges, invalid extended characters, a full
// disk, etc.
//
VerifyPath:
//
// Verify the path.
//
if (_pOFN->Flags & OFN_PATHMUSTEXIST)
{
if (!(_pOFN->Flags & OFN_NOTESTFILECREATE))
{
HANDLE hf = CreateFile(szBasicPath,
GENERIC_WRITE,
FILE_SHARE_READ | FILE_SHARE_WRITE,
NULL,
CREATE_NEW,
FILE_ATTRIBUTE_NORMAL,
NULL);
if (hf != INVALID_HANDLE_VALUE)
{
CloseHandle(hf);
//
// This test is here to see if we were able to
// create it, but couldn't delete it. If so,
// warn the user that the network admin has given
// him create-but-no-modify privileges. As such,
// the file has just been created, but we can't
// do anything with it, it's of 0 size.
//
if (!DeleteFile(szBasicPath))
{
nErrCode = OF_CREATENOMODIFY;
goto Warning;
}
}
else
{
//
// Unable to create it.
//
// If it's not write-protection, a full disk,
// network protection, or the user popping the
// drive door open, assume that the filename is
// invalid.
//
nErrCode = GetLastError();
switch (nErrCode)
{
case (OF_WRITEPROTECTION) :
case (OF_DISKFULL) :
case (OF_DISKFULL2) :
case (OF_NETACCESSDENIED) :
case (OF_ACCESSDENIED) :
{
break;
}
default :
{
nErrCode = 0;
break;
}
}
goto Warning;
}
}
}
}
}
nFileOffset = _CopyFileNameToOFN(szPathName, NULL);
_CopyTitleToOFN(szPathName + nFileOffset);
_PostProcess(szPathName);
bRet = TRUE;
ReturnFromOKButtonPressed:
EnableModelessSB(TRUE);
if ((pExpFile != szExpFile) && (pExpFile != _pszObjectPath))
{
LocalFree(pExpFile);
}
return (bRet);
}
void CFileOpenBrowser::_CopyTitleToOFN(LPCTSTR pszTitle)
{
//
// File Title.
// Note that it's cut off at whatever the buffer length
// is, so if the buffer's too small, no notice is given.
//
if (_pOFN->lpstrFileTitle)
{
StrCpyN(_pOFN->lpstrFileTitle, pszTitle, _pOFN->nMaxFileTitle);
}
}
int CFileOpenBrowser::_CopyFileNameToOFN(LPTSTR pszFile, DWORD *pdwError)
{
int nExtOffset, nOldExt, nFileOffset = ParseFileOld(pszFile, &nExtOffset, &nOldExt, FALSE, TRUE);
//NULL can be passed in to this function if we don't care about the error condition!
if (pdwError)
*pdwError = 0; //Assume no error.
_pOFN->nFileOffset = (WORD) (nFileOffset == -1? lstrlen(pszFile) : nFileOffset);
_pOFN->nFileExtension = (WORD) nOldExt;
_pOFN->Flags &= ~OFN_EXTENSIONDIFFERENT;
if (_pOFN->lpstrDefExt && _pOFN->nFileExtension)
{
TCHAR szPrivateExt[MIN_DEFEXT_LEN];
//
// Check against _pOFN->lpstrDefExt, not _pszDefExt.
//
lstrcpyn(szPrivateExt, _pOFN->lpstrDefExt, MIN_DEFEXT_LEN);
if (lstrcmpi(szPrivateExt, pszFile + nOldExt))
{
_pOFN->Flags |= OFN_EXTENSIONDIFFERENT;
}
}
if (_pOFN->lpstrFile)
{
DWORD cch = lstrlen(pszFile) + 1;
if (_pOFN->Flags & OFN_ALLOWMULTISELECT)
{
//
// Extra room for double-NULL.
//
++cch;
}
if (cch <= LOWORD(_pOFN->nMaxFile))
{
lstrcpy(_pOFN->lpstrFile, pszFile);
if (_pOFN->Flags & OFN_ALLOWMULTISELECT)
{
//
// Double-NULL terminate.
//
*(_pOFN->lpstrFile + cch - 1) = CHAR_NULL;
}
if (!(_pOFN->Flags & OFN_NOCHANGEDIR) && !PathIsUNC(pszFile) && nFileOffset)
{
TCHAR ch = _pOFN->lpstrFile[nFileOffset];
_pOFN->lpstrFile[nFileOffset] = CHAR_NULL;
SetCurrentDirectory(_pOFN->lpstrFile);
_pOFN->lpstrFile[nFileOffset] = ch;
}
}
else
{
//
// Buffer is too small, so return the size of the buffer
// required to hold the string.
//
StoreLengthInString((LPTSTR)_pOFN->lpstrFile, (UINT)_pOFN->nMaxFile, (UINT)cch);
if (pdwError)
*pdwError = FNERR_BUFFERTOOSMALL; //This is an error!
}
}
return nFileOffset;
}
HRESULT CFileOpenBrowser::_MakeFakeCopy(IShellItem *psi, LPWSTR *ppszPath)
{
//
// now we have to create a temp file
// to pass back to the client.
// we will do this in the internet cache.
//
// FEATURE - this should be a service in shell32 - zekel 11-AUG-98
// we should create a dependancy on wininet from
// comdlg32. this should really be some sort of
// service in shell32 that we call. CreateShellItemTempFile()..
//
ILocalCopy *plc;
HRESULT hr = psi->BindToHandler(NULL, BHID_LocalCopyHelper, IID_PPV_ARG(ILocalCopy, &plc));
if (SUCCEEDED(hr))
{
IBindCtx *pbc = NULL;
// hr = SIAddBindCtxOfProgressUI(_hwndDlg, NULL, NULL, &pbc);
if (SUCCEEDED(hr))
{
hr = plc->Download(LCDOWN_READONLY, pbc, ppszPath);
}
plc->Release();
}
return hr;
}
class CAsyncParseHelper
{
public:
CAsyncParseHelper(IUnknown *punkSite, IBindCtx *pbc);
STDMETHODIMP_(ULONG) AddRef()
{
return InterlockedIncrement(&_cRef);
}
STDMETHODIMP_(ULONG) Release()
{
if (InterlockedDecrement(&_cRef))
return _cRef;
delete this;
return 0;
}
HRESULT ParseAsync(IShellFolder *psf, LPCWSTR pszName, LPITEMIDLIST *ppidl, ULONG *pdwAttribs);
protected: // methods
~CAsyncParseHelper();
static DWORD WINAPI CAsyncParseHelper::s_ThreadProc(void *pv);
HRESULT _Prepare(IShellFolder *psf, LPCWSTR pszName);
HRESULT _GetFolder(IShellFolder **ppsf);
void _Parse();
HRESULT _Pump();
protected: // members
LONG _cRef;
IUnknown *_punkSite;
IBindCtx *_pbc;
LPWSTR _pszName;
DWORD _dwAttribs;
HWND _hwnd;
HANDLE _hEvent;
LPITEMIDLIST _pidl;
HRESULT _hrParse;
IShellFolder *_psfFree; // is alright dropping between threads
LPITEMIDLIST _pidlFolder; // bind to it in the right thread
};
CAsyncParseHelper::~CAsyncParseHelper()
{
if (_pszName)
LocalFree(_pszName);
if (_punkSite)
_punkSite->Release();
if (_psfFree)
_psfFree->Release();
if (_pbc)
_pbc->Release();
if (_hEvent)
CloseHandle(_hEvent);
ILFree(_pidl);
ILFree(_pidlFolder);
}
CAsyncParseHelper::CAsyncParseHelper(IUnknown *punkSite, IBindCtx *pbc)
: _cRef(1), _hrParse(E_UNEXPECTED)
{
if (punkSite)
{
_punkSite = punkSite;
punkSite->AddRef();
IUnknown_GetWindow(_punkSite, &_hwnd);
}
if (pbc)
{
_pbc = pbc;
pbc->AddRef();
}
}
HRESULT CAsyncParseHelper::_GetFolder(IShellFolder **ppsf)
{
HRESULT hr;
if (_psfFree)
{
_psfFree->AddRef();
*ppsf = _psfFree;
hr = S_OK;
}
else if (_pidlFolder)
{
hr = SHBindToObjectEx(NULL, _pidlFolder, NULL, IID_PPV_ARG(IShellFolder, ppsf));
}
else
hr = SHGetDesktopFolder(ppsf);
return hr;
}
void CAsyncParseHelper::_Parse()
{
IShellFolder *psf;
_hrParse = _GetFolder(&psf);
if (SUCCEEDED(_hrParse))
{
_hrParse = IShellFolder_ParseDisplayName(psf, _hwnd, _pbc, _pszName, NULL, &_pidl, _dwAttribs ? &_dwAttribs : NULL);
psf->Release();
}
SetEvent(_hEvent);
}
DWORD WINAPI CAsyncParseHelper::s_ThreadProc(void *pv)
{
CAsyncParseHelper *paph = (CAsyncParseHelper *)pv;
paph->_Parse();
paph->Release();
return 0;
}
HRESULT CAsyncParseHelper::_Prepare(IShellFolder *psf, LPCWSTR pszName)
{
_pszName = StrDupW(pszName);
_hEvent = CreateEvent(NULL, FALSE, FALSE, NULL);
HRESULT hr = _pszName && _hEvent ? S_OK : E_OUTOFMEMORY;
if (SUCCEEDED(hr) && psf)
{
IPersistFreeThreadedObject *pfto;
hr = psf->QueryInterface(IID_PPV_ARG(IPersistFreeThreadedObject, &pfto));
if (SUCCEEDED(hr))
{
_psfFree = psf;
psf->AddRef();
pfto->Release();
}
else
{
hr = SHGetIDListFromUnk(psf, &_pidlFolder);
}
}
return hr;
}
HRESULT CAsyncParseHelper::ParseAsync(IShellFolder *psf, LPCWSTR pszName, LPITEMIDLIST *ppidl, ULONG *pdwAttribs)
{
HRESULT hr = _Prepare(psf, pszName);
if (pdwAttribs)
_dwAttribs = *pdwAttribs;
// take one for the thread
AddRef();
if (SUCCEEDED(hr) && SHCreateThread(CAsyncParseHelper::s_ThreadProc, this, CTF_COINIT, NULL))
{
// lets go modal
IUnknown_EnableModeless(_punkSite, FALSE);
hr = _Pump();
IUnknown_EnableModeless(_punkSite, TRUE);
if (SUCCEEDED(hr))
{
ASSERT(_pidl);
*ppidl = _pidl;
_pidl = NULL;
if (pdwAttribs)
*pdwAttribs = _dwAttribs;
}
else
{
ASSERT(!_pidl);
}
}
else
{
// release because the thread wont
Release();
// hr = IShellFolder_ParseDisplayName(_psf, _hwnd, _pbc, pszName, NULL, ppidl, pdwAttribs);
}
if (FAILED(hr))
*ppidl = NULL;
return hr;
}
HRESULT CAsyncParseHelper::_Pump()
{
BOOL fCancelled = FALSE;
while (!fCancelled)
{
DWORD dwWaitResult = MsgWaitForMultipleObjects(1, &_hEvent, FALSE,
INFINITE, QS_ALLINPUT);
if (dwWaitResult != (DWORD)-1)
{
if (dwWaitResult == WAIT_OBJECT_0)
{
// our event was triggered
// that means that we have finished
break;
}
else
{
// there is a message
MSG msg;
// There was some message put in our queue, so we need to dispose
// of it
while (PeekMessage(&msg, NULL, 0, 0, PM_REMOVE))
{
// maybe there should be a flag to allow this??
if (msg.message == WM_KEYDOWN && msg.wParam == VK_ESCAPE)
{
fCancelled = TRUE;
break;
}
else
{
TranslateMessage(&msg);
DispatchMessage(&msg);
}
if (g_bUserPressedCancel)
{
fCancelled = TRUE;
break;
}
}
}
}
else
{
ASSERT(FAILED(_hrParse));
break;
}
}
if (fCancelled)
{
// Better NULL the pidl out. ParseAsync expects a NULL _pidl if _Pump returns an error code.
ILFree(_pidl);
_pidl = NULL;
// clear this for the parse
g_bUserPressedCancel = FALSE;
return HRESULT_FROM_WIN32(ERROR_CANCELLED);
}
else
return _hrParse;
}
STDAPI SHParseNameAsync(IShellFolder *psf, IBindCtx *pbc, LPCWSTR pszName, IUnknown *punkSite, LPITEMIDLIST *ppidl, DWORD *pdwAttribs)
{
HRESULT hr = E_OUTOFMEMORY;
CAsyncParseHelper *paph = new CAsyncParseHelper(punkSite, pbc);
if (paph)
{
hr = paph->ParseAsync(psf, pszName, ppidl, pdwAttribs);
paph->Release();
}
return hr;
}
//
// _ParseName()
// psf = the shell folder to bind/parse with if NULL, use desktop
// pszIn= the string that should parsed into a ppmk
// ppmk = the IShellItem * that is returned with S_OK
//
// WARNING: this will jumpto a folder if that was what was passed in...
//
// returns S_OK if it got an IShellItem for the item with the specified folder
// S_FALSE if it was the wrong shellfolder; try again with a different one
// ERROR for any problems
//
HRESULT CFileOpenBrowser::_ParseName(LPCITEMIDLIST pidlParent, IShellFolder *psf, IBindCtx *pbc, LPCOLESTR psz, IShellItem **ppsi)
{
IBindCtx *pbcLocal;
HRESULT hr = BindCtx_RegisterObjectParam(pbc, STR_PARSE_PREFER_FOLDER_BROWSING, SAFECAST(this, IShellBrowser *), &pbcLocal);
*ppsi = NULL;
if (SUCCEEDED(hr))
{
LPITEMIDLIST pidl = NULL;
hr = SHParseNameAsync(psf, pbcLocal, psz, SAFECAST(this, IShellBrowser *), &pidl, NULL);
if (SUCCEEDED(hr))
{
ASSERT(pidl);
hr = SHCreateShellItem(pidlParent, pidlParent ? psf : NULL, pidl, ppsi);
ILFree(pidl);
}
else if (hr == HRESULT_FROM_WIN32(ERROR_CANCELLED))
{
hr = S_FALSE;
}
else if (psf && !pbc)
{
if (SUCCEEDED(pbcLocal->RegisterObjectParam(STR_DONT_PARSE_RELATIVE, psf)))
{
// try to hit it from the desktop
HRESULT hrNew = _ParseName(NULL, NULL, pbcLocal, psz, ppsi);
// else prop back the original error
hr = SUCCEEDED(hrNew) ? hrNew : hr;
}
}
pbcLocal->Release();
}
return hr;
}
BOOL CFileOpenBrowser::_OpenAsContainer(IShellItem *psi, SFGAOF sfgao)
{
BOOL fRet = _bSave ? _IsSaveContainer(sfgao) : _IsOpenContainer(sfgao);
if (fRet && (sfgao & SFGAO_STREAM))
{
// this is really both a folder and a file
// we guess which the caller wants by looking
// at the extension
LPWSTR psz;
if (SUCCEEDED(psi->GetDisplayName(SIGDN_PARENTRELATIVEPARSING, &psz)))
{
// if the filter equals what ever we are looking at
// we assume the caller is actually looking for
// this file.
fRet = !PathMatchSpec(psz, _szLastFilter);
CoTaskMemFree(psz);
}
}
return fRet;
}
HRESULT CFileOpenBrowser::_TestShellItem(IShellItem *psi, BOOL fAllowJump, IShellItem **ppsiReal)
{
SFGAOF flags;
psi->GetAttributes(SFGAO_STORAGECAPMASK, &flags);
HRESULT hr = E_ACCESSDENIED;
*ppsiReal = NULL;
if (_OpenAsContainer(psi, flags))
{
// we have a subfolder that has been selected.
// jumpto it instead
if (fAllowJump)
{
LPITEMIDLIST pidl;
if (SUCCEEDED(SHGetIDListFromUnk(psi, &pidl)))
{
JumpToIDList(pidl);
ILFree(pidl);
}
}
hr = S_FALSE;
}
else if ((flags & SFGAO_LINK) && ((flags & SFGAO_FOLDER) || !_IsNoDereferenceLinks(NULL, psi)))
{
// If this is a link, and (we should dereference links, or it's also a folder [folder shortcut])
IShellItem *psiTarget;
if (SUCCEEDED(psi->BindToHandler(NULL, BHID_LinkTargetItem, IID_PPV_ARG(IShellItem, &psiTarget))))
{
hr = _TestShellItem(psiTarget, fAllowJump, ppsiReal);
psiTarget->Release();
}
}
else if (_IsStream(flags))
{
*ppsiReal = psi;
psi->AddRef();
hr = S_OK;
}
return hr;
}
HRESULT CFileOpenBrowser::_ParseNameAndTest(LPCOLESTR pszIn, IBindCtx *pbc, IShellItem **ppsi, BOOL fAllowJump)
{
IShellItem *psi;
HRESULT hr = _ParseName(_pCurrentLocation->pidlFull, _psfCurrent, pbc, pszIn, &psi);
if (S_OK == hr)
{
hr = _TestShellItem(psi, fAllowJump, ppsi);
psi->Release();
}
return hr;
}
BOOL _FailedBadPath(HRESULT hr)
{
switch (hr)
{
case HRESULT_FROM_WIN32(ERROR_FILE_NOT_FOUND):
case HRESULT_FROM_WIN32(ERROR_PATH_NOT_FOUND):
case HRESULT_FROM_WIN32(ERROR_BAD_NET_NAME):
case HRESULT_FROM_WIN32(ERROR_BAD_NETPATH):
return TRUE;
}
return FALSE;
}
#define STR_ACTIONPROGRESS L"ActionProgress"
STDAPI BindCtx_BeginActionProgress(IBindCtx *pbc, SPACTION action, SPBEGINF flags, IActionProgress **ppap)
{
HRESULT hr = E_NOINTERFACE; // default to no
IUnknown *punk;
*ppap = NULL;
if (pbc && SUCCEEDED(pbc->GetObjectParam(STR_ACTIONPROGRESS, &punk)))
{
IActionProgress *pap;
if (SUCCEEDED(punk->QueryInterface(IID_PPV_ARG(IActionProgress, &pap))))
{
hr = pap->Begin(action, flags);
if (SUCCEEDED(hr))
*ppap = pap;
else
pap->Release();
}
punk->Release();
}
return hr;
}
HRESULT CFileOpenBrowser::_ParseShellItem(LPCOLESTR pszIn, IShellItem **ppsi, BOOL fAllowJump)
{
WAIT_CURSOR w(this);
EnableModelessSB(FALSE);
HRESULT hr = _ParseNameAndTest(pszIn, NULL, ppsi, fAllowJump);
if (_FailedBadPath(hr))
{
// try again with a better string
SHSTR str;
if ((LPTSTR)_pszDefExt && (0 == *(PathFindExtension(pszIn)))
&& SUCCEEDED(str.SetSize(lstrlen(pszIn) + lstrlen(_pszDefExt) + 2)))
{
str.SetStr(pszIn);
AppendExt(str.GetInplaceStr(), _pszDefExt, FALSE);
pszIn = str.GetStr();
hr = _ParseNameAndTest(pszIn, NULL, ppsi, fAllowJump);
}
if (_FailedBadPath(hr) && _bSave)
{
// when we are saving, then we
// try to force the creation of this item
IBindCtx *pbc;
if (SUCCEEDED(CreateBindCtx(0, &pbc)))
{
BIND_OPTS bo = {0};
bo.cbStruct = SIZEOF(bo);
bo.grfMode = STGM_CREATE;
pbc->SetBindOptions(&bo);
hr = _ParseNameAndTest(pszIn, pbc, ppsi, fAllowJump);
pbc->Release();
}
}
}
EnableModelessSB(TRUE);
return hr;
}
class CShellItemList : IEnumShellItems
{
public:
CShellItemList() : _cRef(1) {}
// IUnknown methods
STDMETHODIMP QueryInterface(REFIID riid, void **ppvOut);
STDMETHODIMP_(ULONG) AddRef();
STDMETHODIMP_(ULONG) Release();
STDMETHODIMP Next(ULONG celt, IShellItem **rgelt, ULONG *pceltFetched);
STDMETHODIMP Skip(ULONG celt);
STDMETHODIMP Reset();
STDMETHODIMP Clone(IEnumShellItems **ppenum);
HRESULT Add(IShellItem *psi);
private: // methods
~CShellItemList();
BOOL _NextOne(IShellItem **ppsi);
private: // members
LONG _cRef;
CDPA<IShellItem> _dpaItems;
int _iItem;
};
STDMETHODIMP CShellItemList::QueryInterface(REFIID riid, void **ppv)
{
static const QITAB qit[] =
{
QITABENT(CShellItemList, IEnumShellItems),
{ 0 },
};
return QISearch(this, qit, riid, ppv);
}
STDMETHODIMP_(ULONG) CShellItemList::AddRef()
{
return InterlockedIncrement(&_cRef);
}
STDMETHODIMP_(ULONG) CShellItemList::Release()
{
if (InterlockedDecrement(&_cRef))
return _cRef;
delete this;
return 0;
}
STDMETHODIMP CShellItemList::Next(ULONG celt, IShellItem **rgelt, ULONG *pceltFetched)
{
HRESULT hr = S_FALSE;
ULONG cFetched = 0;
while (celt-- && SUCCEEDED(hr))
{
if (_NextOne(&rgelt[cFetched]))
cFetched++;
else
break;
}
if (cFetched)
{
*pceltFetched = cFetched;
hr = S_OK;
}
else
hr = S_FALSE;
return hr;
}
STDMETHODIMP CShellItemList::Skip(ULONG celt)
{
_iItem += celt;
return S_OK;
}
STDMETHODIMP CShellItemList::Reset()
{
_iItem = 0;
return S_OK;
}
STDMETHODIMP CShellItemList::Clone(IEnumShellItems **ppenum)
{
return E_NOTIMPL;
}
HRESULT CShellItemList::Add(IShellItem *psi)
{
HRESULT hr = E_OUTOFMEMORY;
if (!_dpaItems)
{
_dpaItems.Create(4);
}
if (_dpaItems)
{
if (-1 != _dpaItems.AppendPtr(psi))
{
psi->AddRef();
hr = S_OK;
}
}
return hr;
}
CShellItemList::~CShellItemList()
{
if (_dpaItems)
{
for (int i = 0; i < _dpaItems.GetPtrCount(); i++)
{
_dpaItems.FastGetPtr(i)->Release();
}
_dpaItems.Destroy();
}
}
BOOL CShellItemList::_NextOne(IShellItem **ppsi)
{
if (_dpaItems && _iItem < _dpaItems.GetPtrCount())
{
*ppsi = _dpaItems.GetPtr(_iItem);
if (*ppsi)
{
(*ppsi)->AddRef();
_iItem++;
return TRUE;
}
}
return FALSE;
}
#ifdef RETURN_SHELLITEMS
HRESULT CFileOpenBrowser::_ItemOKButtonPressed(LPCWSTR pszFile, OKBUTTONFLAGS Flags)
{
CShellItemList *psil = new CShellItemList();
HRESULT hr = psil ? S_OK : E_OUTOFMEMORY;
ASSERT(IS_NEW_OFN(_pOFN));
if (SUCCEEDED(hr))
{
SHSTR str;
hr = str.SetSize(lstrlen(pszFile) * 2);
if (SUCCEEDED(hr))
{
WAIT_CURSOR w(this);
DWORD cFiles = 1;
SHExpandEnvironmentStrings(pszFile, str, str.GetSize());
if ((_pOFN->Flags & OFN_ALLOWMULTISELECT) && StrChr(str, CHAR_QUOTE))
{
// need to handle MULTISEL here...
// str points to a bunch of quoted strings.
// alloc enough for the strings and an extra NULL terminator
hr = str.SetSize(str.GetLen() + 1);
if (SUCCEEDED(hr))
{
cFiles = ConvertToNULLTerm(str);
}
}
if (SUCCEEDED(hr))
{
BOOL fSingle = cFiles == 1;
LPTSTR pch = str;
for (; cFiles; cFiles--)
{
IShellItem *psi;
hr = _ParseShellItem(pch, &psi, fSingle);
// go to the next item
if (S_OK == hr)
{
hr = psil->Add(psi);
psi->Release();
}
else // S_FALSE or failure we stop parsing
{
if (FAILED(hr))
InvalidFileWarningNew(_hwndDlg, pch, OFErrFromHresult(hr));
break;
}
// goto the next string
pch += lstrlen(pch) + 1;
}
// we have added everything to our list
if (hr == S_OK)
{
hr = psil->QueryInterface(IID_PPV_ARG(IEnumShellItems, &(_pOFN->penum)));
}
}
}
psil->Release();
}
return hr;
}
#endif RETURN_SHELLITEMS
////////////////////////////////////////////////////////////////////////////
//
// DriveList_OpenClose
//
// Change the state of a drive list.
//
////////////////////////////////////////////////////////////////////////////
#define OCDL_TOGGLE 0x0000
#define OCDL_OPEN 0x0001
#define OCDL_CLOSE 0x0002
void DriveList_OpenClose(
UINT uAction,
HWND hwndDriveList)
{
if (!hwndDriveList || !IsWindowVisible(hwndDriveList))
{
return;
}
OpenClose_TryAgain:
switch (uAction)
{
case (OCDL_TOGGLE) :
{
uAction = SendMessage(hwndDriveList, CB_GETDROPPEDSTATE, 0, 0L)
? OCDL_CLOSE
: OCDL_OPEN;
goto OpenClose_TryAgain;
break;
}
case (OCDL_OPEN) :
{
SetFocus(hwndDriveList);
SendMessage(hwndDriveList, CB_SHOWDROPDOWN, TRUE, 0);
break;
}
case (OCDL_CLOSE) :
{
if (SHIsChildOrSelf(hwndDriveList,GetFocus()) == S_OK)
{
SendMessage(hwndDriveList, CB_SHOWDROPDOWN, FALSE, 0);
}
break;
}
}
}
////////////////////////////////////////////////////////////////////////////
//
// CFileOpenBrowser::GetFullEditName
//
// Returns the number of characters needed to get the full path, including
// the NULL.
//
////////////////////////////////////////////////////////////////////////////
UINT CFileOpenBrowser::GetFullEditName(
LPTSTR pszBuf,
UINT cLen,
TEMPSTR *pTempStr,
BOOL *pbNoDefExt)
{
UINT cTotalLen;
HWND hwndEdit;
if (_bUseHideExt)
{
cTotalLen = lstrlen(_pszHideExt) + 1;
}
else
{
if (_bUseCombo)
{
hwndEdit = (HWND)SendMessage(GetDlgItem(_hwndDlg, cmb13), CBEM_GETEDITCONTROL, 0, 0L);
}
else
{
hwndEdit = GetDlgItem(_hwndDlg, edt1);
}
cTotalLen = GetWindowTextLength(hwndEdit) + 1;
}
if (pTempStr)
{
if (!pTempStr->StrSize(cTotalLen))
{
return ((UINT)-1);
}
pszBuf = *pTempStr;
cLen = cTotalLen;
}
if (_bUseHideExt)
{
lstrcpyn(pszBuf, _pszHideExt, cLen);
}
else
{
GetWindowText(hwndEdit, pszBuf, cLen);
}
if (pbNoDefExt)
{
*pbNoDefExt = _bUseHideExt;
}
return (cTotalLen);
}
////////////////////////////////////////////////////////////////////////////
//
// CFileOpenBrowser::ProcessEdit
//
////////////////////////////////////////////////////////////////////////////
void CFileOpenBrowser::ProcessEdit()
{
TEMPSTR pMultiSel;
LPTSTR pszFile;
BOOL bNoDefExt = TRUE;
OKBUTTONFLAGS Flags = OKBUTTON_NONE;
TCHAR szBuf[MAX_PATH + 4];
//if we have a saved pidl then use it instead
if (_pidlSelection && _ProcessPidlSelection())
{
return;
}
if (_pOFN->Flags & OFN_ALLOWMULTISELECT)
{
if (GetFullEditName(szBuf,
ARRAYSIZE(szBuf),
&pMultiSel,
&bNoDefExt) == (UINT)-1)
{
//
// FEATURE There should be some error message here.
//
return;
}
pszFile = pMultiSel;
}
else
{
if (_bSelIsObject)
{
pszFile = _pszObjectPath;
}
else
{
GetFullEditName(szBuf, ARRAYSIZE(szBuf), NULL, &bNoDefExt);
pszFile = szBuf;
PathRemoveBlanks(pszFile);
int nLen = lstrlen(pszFile);
if (*pszFile == CHAR_QUOTE)
{
LPTSTR pPrev = CharPrev(pszFile, pszFile + nLen);
if (*pPrev == CHAR_QUOTE && pszFile != pPrev)
{
Flags |= OKBUTTON_QUOTED;
//
// Strip the quotes.
//
*pPrev = CHAR_NULL;
lstrcpy(pszFile, pszFile + 1);
}
}
}
}
if (bNoDefExt)
{
Flags |= OKBUTTON_NODEFEXT;
}
//
// Visual Basic passes in an uninitialized lpDefExts string.
// Since we only have to use it in OKButtonPressed, update
// lpstrDefExts here along with whatever else is only needed
// in OKButtonPressed.
//
if (_pOFI->ApiType == COMDLG_ANSI)
{
ThunkOpenFileNameA2WDelayed(_pOFI);
}
// handle special case parsing right here.
// our current folder and the desktop both failed
// to figure out what this is.
if (PathIsDotOrDotDot(pszFile))
{
if (pszFile[1] == CHAR_DOT)
{
// this is ".."
LPITEMIDLIST pidl = GetIDListFromFolder(_psfCurrent);
if (pidl)
{
ILRemoveLastID(pidl);
JumpToIDList(pidl);
ILFree(pidl);
}
}
}
else if (OKButtonPressed(pszFile, Flags))
{
BOOL bReturn = TRUE;
if (_pOFN->lpstrFile)
{
if (!(_pOFN->Flags & OFN_NOVALIDATE))
{
if (_pOFN->nMaxFile >= 3)
{
if ((_pOFN->lpstrFile[0] == 0) ||
(_pOFN->lpstrFile[1] == 0) ||
(_pOFN->lpstrFile[2] == 0))
{
bReturn = FALSE;
StoreExtendedError(FNERR_BUFFERTOOSMALL);
}
}
else
{
bReturn = FALSE;
StoreExtendedError(FNERR_BUFFERTOOSMALL);
}
}
}
_CleanupDialog(bReturn);
}
}
////////////////////////////////////////////////////////////////////////////
//
// CFileOpenBrowser::InitializeDropDown
//
////////////////////////////////////////////////////////////////////////////
void CFileOpenBrowser::InitializeDropDown(HWND hwndCtl)
{
if (!_bDropped)
{
MYLISTBOXITEM *pParentItem;
SHChangeNotifyEntry fsne[2];
//
// Expand the Desktop item.
//
pParentItem = GetListboxItem(hwndCtl, _iNodeDesktop);
if (pParentItem)
{
UpdateLevel(hwndCtl, _iNodeDesktop + 1, pParentItem);
fsne[0].pidl = pParentItem->pidlFull;
fsne[0].fRecursive = FALSE;
//
// Look for the My Computer item, since it may not necessarily
// be the next one after the Desktop.
//
LPITEMIDLIST pidlDrives;
if (SHGetFolderLocation(NULL, CSIDL_DRIVES, NULL, 0, &pidlDrives) == S_OK)
{
int iNode = _iNodeDesktop;
while (pParentItem = GetListboxItem(hwndCtl, iNode))
{
if (ILIsEqual(pParentItem->pidlFull, pidlDrives))
{
_iNodeDrives = iNode;
break;
}
iNode++;
}
ILFree(pidlDrives);
}
//
// Make sure My Computer was found. If not, then just assume it's
// in the first spot after the desktop (this shouldn't happen).
//
if (pParentItem == NULL)
{
pParentItem = GetListboxItem(hwndCtl, _iNodeDesktop + 1);
_iNodeDrives = _iNodeDesktop +1;
}
if (pParentItem)
{
//
// Expand the My Computer item.
//
UpdateLevel(hwndCtl, _iNodeDrives + 1, pParentItem);
_bDropped = TRUE;
fsne[1].pidl = pParentItem->pidlFull;
fsne[1].fRecursive = FALSE;
}
_uRegister = SHChangeNotifyRegister(
_hwndDlg,
SHCNRF_ShellLevel | SHCNRF_InterruptLevel | SHCNRF_NewDelivery,
SHCNE_ALLEVENTS &
~(SHCNE_CREATE | SHCNE_DELETE | SHCNE_RENAMEITEM),
CDM_FSNOTIFY, pParentItem ? ARRAYSIZE(fsne) : ARRAYSIZE(fsne) - 1,
fsne);
}
}
}
////////////////////////////////////////////////////////////////////////////
//
// CFileOpenBrowser::OnCommandMessage
//
// Process a WM_COMMAND message for the dialog.
//
////////////////////////////////////////////////////////////////////////////
LRESULT CFileOpenBrowser::OnCommandMessage(
WPARAM wParam,
LPARAM lParam)
{
int idCmd = GET_WM_COMMAND_ID(wParam, lParam);
switch (idCmd)
{
case (edt1) :
{
switch (GET_WM_COMMAND_CMD(wParam, lParam))
{
case (EN_CHANGE) :
{
_bUseHideExt = FALSE;
Pidl_Set(&_pidlSelection,NULL);;
break;
}
}
break;
}
case (cmb13) :
{
switch (GET_WM_COMMAND_CMD(wParam, lParam))
{
case (CBN_EDITCHANGE) :
{
_bUseHideExt = FALSE;
Pidl_Set(&_pidlSelection,NULL);;
break;
}
case (CBN_DROPDOWN) :
{
LoadMRU(_szLastFilter,
GET_WM_COMMAND_HWND(wParam, lParam),
MAX_MRU);
break;
}
case (CBN_SETFOCUS) :
{
SetModeBias(MODEBIASMODE_FILENAME);
break;
}
case (CBN_KILLFOCUS) :
{
SetModeBias(MODEBIASMODE_DEFAULT);
break;
}
}
break;
}
case (cmb2) :
{
switch (GET_WM_COMMAND_CMD(wParam, lParam))
{
case (CBN_CLOSEUP) :
{
OnSelChange();
UpdateNavigation();
SelectEditText(_hwndDlg);
return TRUE;
}
case (CBN_DROPDOWN) :
{
InitializeDropDown(GET_WM_COMMAND_HWND(wParam, lParam));
break;
}
}
break;
}
case (cmb1) :
{
switch (GET_WM_COMMAND_CMD(wParam, lParam))
{
case (CBN_DROPDOWN) :
{
_iComboIndex = (int) SendMessage(GET_WM_COMMAND_HWND(wParam, lParam),
CB_GETCURSEL,
NULL,
NULL);
break;
}
//
// We're trying to see if anything changed after
// (and only after) the user is done scrolling through the
// drop down. When the user tabs away from the combobox, we
// do not get a CBN_SELENDOK.
// Why not just use CBN_SELCHANGE? Because then we'd refresh
// the view (very slow) as the user scrolls through the
// combobox.
//
case (CBN_CLOSEUP) :
case (CBN_SELENDOK) :
{
//
// Did anything change?
//
if (_iComboIndex >= 0 &&
_iComboIndex == SendMessage(GET_WM_COMMAND_HWND(wParam, lParam),
CB_GETCURSEL,
NULL,
NULL))
{
break;
}
}
case (MYCBN_DRAW) :
{
RefreshFilter(GET_WM_COMMAND_HWND(wParam, lParam));
_iComboIndex = -1;
return TRUE;
}
default :
{
break;
}
}
break;
}
case (IDC_PARENT) :
{
OnDotDot();
SelectEditText(_hwndDlg);
break;
}
case (IDC_NEWFOLDER) :
{
ViewCommand(VC_NEWFOLDER);
break;
}
case (IDC_VIEWLIST) :
{
SendMessage(_hwndView, WM_COMMAND, (WPARAM)SFVIDM_VIEW_LIST, 0);
break;
}
case (IDC_VIEWDETAILS) :
{
SendMessage(_hwndView, WM_COMMAND, (WPARAM)SFVIDM_VIEW_DETAILS,0);
break;
}
case (IDC_VIEWMENU) :
{
//
// Pass off the nCmdID to the view for processing / translation.
//
DFVCMDDATA cd;
cd.pva = NULL;
cd.hwnd = _hwndDlg;
cd.nCmdIDTranslated = 0;
SendMessage(_hwndView, WM_COMMAND, SFVIDM_VIEW_VIEWMENU, (LONG_PTR)&cd);
break;
}
case (IDOK) :
{
HWND hwndFocus = ::GetFocus();
if (hwndFocus == ::GetDlgItem(_hwndDlg, IDOK))
{
hwndFocus = _hwndLastFocus;
}
hwndFocus = GetFocusedChild(_hwndDlg, hwndFocus);
if (hwndFocus == _hwndView)
{
OnDblClick(TRUE);
}
else if (_hwndPlacesbar && (hwndFocus == _hwndPlacesbar))
{
//Places bar has the focus. Get the current hot item.
INT_PTR i = SendMessage(_hwndPlacesbar, TB_GETHOTITEM, 0,0);
if (i >= 0)
{
//Get the Pidl for this button.
TBBUTTONINFO tbbi;
tbbi.cbSize = SIZEOF(tbbi);
tbbi.lParam = 0;
tbbi.dwMask = TBIF_LPARAM | TBIF_BYINDEX;
if (SendMessage(_hwndPlacesbar, TB_GETBUTTONINFO, i, (LPARAM)&tbbi) >= 0)
{
LPITEMIDLIST pidl= (LPITEMIDLIST)tbbi.lParam;
if (pidl)
{
//Jump to the location corresponding to this Button
JumpToIDList(pidl, FALSE, TRUE);
}
}
}
}
else
{
ProcessEdit();
}
SelectEditText(_hwndDlg);
break;
}
case (IDCANCEL) :
{
// the parse async can listen for this
g_bUserPressedCancel = TRUE;
_hwndModelessFocus = NULL;
if (!_cRefCannotNavigate)
{
_CleanupDialog(FALSE);
}
return TRUE;
}
case (pshHelp) :
{
if (_hSubDlg)
{
CD_SendHelpNotify(_hSubDlg, _hwndDlg, _pOFN, _pOFI);
}
if (_pOFN->hwndOwner)
{
CD_SendHelpMsg(_pOFN, _hwndDlg, _pOFI->ApiType);
}
break;
}
case (IDC_DROPDRIVLIST) : // VK_F4
{
//
// If focus is on the "File of type" combobox,
// then F4 should open that combobox, not the "Look in" one.
//
HWND hwnd = GetFocus();
if (_bUseCombo &&
(SHIsChildOrSelf(GetDlgItem(_hwndDlg, cmb13), hwnd) == S_OK)
)
{
hwnd = GetDlgItem(_hwndDlg, cmb13);
}
if ((hwnd != GetDlgItem(_hwndDlg, cmb1)) &&
(hwnd != GetDlgItem(_hwndDlg, cmb13))
)
{
//
// We shipped Win95 where F4 *always* opens the "Look in"
// combobox, so keep F4 opening that even when it shouldn't.
//
hwnd = GetDlgItem(_hwndDlg, cmb2);
}
DriveList_OpenClose(OCDL_TOGGLE, hwnd);
break;
}
case (IDC_REFRESH) :
{
if (_psv)
{
_psv->Refresh();
}
break;
}
case (IDC_PREVIOUSFOLDER) :
{
OnDotDot();
break;
}
//Back Navigation
case (IDC_BACK) :
// Try to travel in the directtion
if (_ptlog && SUCCEEDED(_ptlog->Travel(TRAVEL_BACK)))
{
LPITEMIDLIST pidl;
//Able to travel in the given direction.
//Now Get the new pidl
_ptlog->GetCurrent(&pidl);
//Update the UI to reflect the current state
UpdateUI(pidl);
//Jump to the new location
// second paremeter is whether to translate to logical pidl
// and third parameter is whether to add to the navigation stack
// since this pidl comes from the stack , we should not add this to
// the navigation stack
JumpToIDList(pidl, FALSE, FALSE);
ILFree(pidl);
}
break;
}
if ((idCmd >= IDC_PLACESBAR_BASE) && (idCmd <= (IDC_PLACESBAR_BASE + _iCommandID)))
{
TBBUTTONINFO tbbi;
LPITEMIDLIST pidl;
tbbi.cbSize = SIZEOF(tbbi);
tbbi.lParam = 0;
tbbi.dwMask = TBIF_LPARAM;
if (SendMessage(_hwndPlacesbar, TB_GETBUTTONINFO, idCmd, (LPARAM)&tbbi) >= 0)
{
pidl = (LPITEMIDLIST)tbbi.lParam;
if (pidl)
{
JumpToIDList(pidl, FALSE, TRUE);
}
}
}
return FALSE;
}
////////////////////////////////////////////////////////////////////////////
//
// CFileOpenBrowser::OnCDMessage
//
// Process a special CommDlg message for the dialog.
//
////////////////////////////////////////////////////////////////////////////
BOOL CFileOpenBrowser::OnCDMessage(
UINT uMsg,
WPARAM wParam,
LPARAM lParam)
{
LONG lResult = -1;
LPCITEMIDLIST pidl;
LPTSTR pBuf = (LPTSTR)lParam;
LPWSTR pBufW = NULL;
int cbLen;
// we should make some better thunk wrappers for COMDLG_ANSI
// like OnCDMessageAorW() calls OnCDMessage()
switch (uMsg)
{
case (CDM_GETSPEC) :
case (CDM_GETFILEPATH) :
case (CDM_GETFOLDERPATH) :
{
if (_pOFI->ApiType == COMDLG_ANSI)
{
if (pBufW = (LPWSTR)LocalAlloc(LPTR,
(int)wParam * sizeof(WCHAR)))
{
pBuf = pBufW;
}
else
{
break;
}
}
if (uMsg == CDM_GETSPEC)
{
lResult = GetFullEditName(pBuf, (UINT) wParam, NULL, NULL);
break;
}
// else, fall thru...
}
case (CDM_GETFOLDERIDLIST) :
{
TCHAR szDir[MAX_PATH];
pidl = _pCurrentLocation->pidlFull;
if (uMsg == CDM_GETFILEPATH)
{
// We can't necessarily use the (current folder) + (edit box name) thing in this case
// because the (current folder) could be incorrect, for example in the case
// where the current folder is the desktop folder. Items _could_ be in the
// All Users desktop folder - in which case we want to return All Users\Desktop\file, not
// <username>\Desktop\file
// So we'll key off _pidlSelection... if that doesn't work, we fall back to the old
// behaviour, which could be incorrect in some cases.
if (pidl && _pidlSelection)
{
LPITEMIDLIST pidlFull = ILCombine(pidl, _pidlSelection);
if (pidlFull)
{
if (SHGetPathFromIDList(pidlFull, szDir))
{
goto CopyAndReturn;
}
ILFree(pidlFull);
}
}
}
lResult = ILGetSize(pidl);
if (uMsg == CDM_GETFOLDERIDLIST)
{
if ((LONG)wParam < lResult)
{
break;
}
CopyMemory((LPBYTE)pBuf, (LPBYTE)pidl, lResult);
break;
}
if (!SHGetPathFromIDList(pidl, szDir))
{
*szDir = 0;
}
if (!*szDir)
{
lResult = -1;
break;
}
if (uMsg == CDM_GETFOLDERPATH)
{
CopyAndReturn:
lResult = lstrlen(szDir) + 1;
if ((LONG)wParam >= lResult)
{
lstrcpyn(pBuf, szDir, lResult);
}
if (_pOFI->ApiType == COMDLG_ANSI)
{
lResult = WideCharToMultiByte(CP_ACP,
0,
szDir,
-1,
NULL,
0,
NULL,
NULL);
}
if ((int)wParam > lResult)
{
wParam = lResult;
}
break;
}
//
// We'll just fall through to the error case for now, since
// doing the full combine is not an easy thing.
//
TCHAR szFile[MAX_PATH];
if (GetFullEditName(szFile, ARRAYSIZE(szFile), NULL, NULL) >
ARRAYSIZE(szFile) - 5)
{
//
// Oops! It looks like we filled our buffer!
//
lResult = -1;
break;
}
PathCombine(szDir, szDir, szFile);
goto CopyAndReturn;
}
case (CDM_SETCONTROLTEXT) :
{
if (_pOFI->ApiType == COMDLG_ANSI)
{
//
// Need to convert pBuf (lParam) to Unicode.
//
cbLen = lstrlenA((LPSTR)pBuf) + 1;
if (pBufW = (LPWSTR)LocalAlloc(LPTR, (cbLen * sizeof(WCHAR))))
{
SHAnsiToUnicode((LPSTR)pBuf,pBufW,cbLen);
pBuf = pBufW;
}
}
//Are we using combobox and the control they are setting is edit box?
if (_bUseCombo && wParam == edt1)
{
//Change it to combo box.
wParam = cmb13;
}
if (_bSave && wParam == IDOK)
{
_tszDefSave.StrCpy(pBuf);
//
// Do this to set the OK button correctly.
//
SelFocusChange(TRUE);
}
else
{
SetDlgItemText(_hwndDlg, (int) wParam, pBuf);
}
break;
}
case (CDM_HIDECONTROL) :
{
//Make sure the control id is not zero (0 is child dialog)
if ((int)wParam != 0)
{
ShowWindow(GetDlgItem(_hwndDlg, (int) wParam), SW_HIDE);
}
break;
}
case (CDM_SETDEFEXT) :
{
if (_pOFI->ApiType == COMDLG_ANSI)
{
//
// Need to convert pBuf (lParam) to Unicode.
//
cbLen = lstrlenA((LPSTR)pBuf) + 1;
if (pBufW = (LPWSTR)LocalAlloc(LPTR, (cbLen * sizeof(WCHAR))))
{
SHAnsiToUnicode((LPSTR)pBuf,pBufW,cbLen);
pBuf = pBufW;
}
}
_pszDefExt.StrCpy(pBuf);
_bNoInferDefExt = TRUE;
break;
}
default:
{
lResult = -1;
break;
}
}
SetWindowLongPtr(_hwndDlg, DWLP_MSGRESULT, lResult);
if (_pOFI->ApiType == COMDLG_ANSI)
{
switch (uMsg)
{
case (CDM_GETSPEC) :
case (CDM_GETFILEPATH) :
case (CDM_GETFOLDERPATH) :
{
//
// Need to convert pBuf (pBufW) to Ansi and store in lParam.
//
if (wParam && lParam)
{
SHUnicodeToAnsi(pBuf,(LPSTR)lParam,(int) wParam);
}
break;
}
}
if (pBufW)
{
LocalFree(pBufW);
}
}
return TRUE;
}
////////////////////////////////////////////////////////////////////////////
//
// OKSubclass
//
// Subclass window proc for the OK button.
//
// The OK button is subclassed so we know which control had focus before
// the user clicked OK. This in turn lets us know whether to process OK
// based on the current selection in the listview, or the current text
// in the edit control.
//
////////////////////////////////////////////////////////////////////////////
LRESULT CALLBACK OKSubclass(
HWND hOK,
UINT msg,
WPARAM wParam,
LPARAM lParam)
{
HWND hwndDlg = ::GetParent(hOK);
CFileOpenBrowser *pDlgStruct = HwndToBrowser(hwndDlg);
WNDPROC pOKProc = pDlgStruct ? pDlgStruct->_lpOKProc : NULL;
if (pDlgStruct)
{
switch (msg)
{
case WM_SETFOCUS:
pDlgStruct->_hwndLastFocus = (HWND)wParam;
break;
}
}
return ::CallWindowProc(pOKProc, hOK, msg, wParam, lParam);
}
////////////////////////////////////////////////////////////////////////////
//
// CFileOpenBrowser::GetNodeFromIDList
//
////////////////////////////////////////////////////////////////////////////
int CFileOpenBrowser::GetNodeFromIDList(
LPCITEMIDLIST pidl)
{
int i;
HWND hwndCB = GetDlgItem(_hwndDlg, cmb2);
Assert(this->_bDropped);
//
// Just check DRIVES and DESKTOP.
//
for (i = _iNodeDrives; i >= NODE_DESKTOP; --i)
{
MYLISTBOXITEM *pItem = GetListboxItem(hwndCB, i);
if (pItem && ILIsEqual(pidl, pItem->pidlFull))
{
break;
}
}
return (i);
}
////////////////////////////////////////////////////////////////////////////
//
// CFileOpenBrowser::FSChange
//
////////////////////////////////////////////////////////////////////////////
BOOL CFileOpenBrowser::FSChange(
LONG lNotification,
LPCITEMIDLIST *ppidl)
{
int iNode = -1;
LPCITEMIDLIST pidl = ppidl[0];
switch (lNotification)
{
case (SHCNE_RENAMEFOLDER) :
{
LPCITEMIDLIST pidlExtra = ppidl[1];
//
// Rename is special. We need to invalidate both
// the pidl and the pidlExtra, so we call ourselves.
//
FSChange(0, &pidlExtra);
}
case (0) :
case (SHCNE_MKDIR) :
case (SHCNE_RMDIR) :
{
LPITEMIDLIST pidlClone = ILClone(pidl);
if (!pidlClone)
{
break;
}
ILRemoveLastID(pidlClone);
iNode = GetNodeFromIDList(pidlClone);
ILFree(pidlClone);
break;
}
case (SHCNE_UPDATEITEM) :
case (SHCNE_NETSHARE) :
case (SHCNE_NETUNSHARE) :
case (SHCNE_UPDATEDIR) :
{
iNode = GetNodeFromIDList(pidl);
break;
}
case (SHCNE_DRIVEREMOVED) :
case (SHCNE_DRIVEADD) :
case (SHCNE_MEDIAINSERTED) :
case (SHCNE_MEDIAREMOVED) :
case (SHCNE_DRIVEADDGUI) :
{
iNode = _iNodeDrives;
break;
}
}
if (iNode >= 0)
{
//
// We want to delay the processing a little because we always do
// a full update, so we should accumulate.
//
SetTimer(_hwndDlg, TIMER_FSCHANGE + iNode, 100, NULL);
}
return FALSE;
}
////////////////////////////////////////////////////////////////////////////
//
// CFileOpenBrowser::Timer
//
////////////////////////////////////////////////////////////////////////////
void CFileOpenBrowser::Timer(
WPARAM wID)
{
KillTimer(_hwndDlg, (UINT) wID);
wID -= TIMER_FSCHANGE;
ASSERT(this->_bDropped);
HWND hwndCB;
MYLISTBOXITEM *pParentItem;
hwndCB = GetDlgItem(_hwndDlg, cmb2);
pParentItem = GetListboxItem(hwndCB, wID);
UpdateLevel(hwndCB, (int) wID + 1, pParentItem);
}
////////////////////////////////////////////////////////////////////////////
//
// CFileOpenBrowser::OnGetMinMax
//
////////////////////////////////////////////////////////////////////////////
void CFileOpenBrowser::OnGetMinMax(
LPMINMAXINFO pmmi)
{
if ((_ptMinTrack.x != 0) || (_ptMinTrack.y != 0))
{
pmmi->ptMinTrackSize = _ptMinTrack;
}
}
////////////////////////////////////////////////////////////////////////////
//
// CFileOpenBrowser::OnSize
//
////////////////////////////////////////////////////////////////////////////
void CFileOpenBrowser::OnSize(
int width,
int height)
{
RECT rcMaster;
RECT rcView;
RECT rc;
HWND hwnd;
HDWP hdwp;
int dx;
int dy;
//
// Set the sizing grip to the correct location.
//
SetWindowPos(_hwndGrip,
NULL,
width - g_cxGrip,
height - g_cyGrip,
g_cxGrip,
g_cyGrip,
SWP_NOZORDER | SWP_NOACTIVATE);
//
// Ignore sizing until we are initialized.
//
if ((_ptLastSize.x == 0) && (_ptLastSize.y == 0))
{
return;
}
GetWindowRect(_hwndDlg, &rcMaster);
//
// Calculate the deltas in the x and y positions that we need to move
// each of the child controls.
//
dx = (rcMaster.right - rcMaster.left) - _ptLastSize.x;
dy = (rcMaster.bottom - rcMaster.top) - _ptLastSize.y;
//Dont do anything if the size remains the same
if ((dx == 0) && (dy == 0))
{
return;
}
//
// Update the new size.
//
_ptLastSize.x = rcMaster.right - rcMaster.left;
_ptLastSize.y = rcMaster.bottom - rcMaster.top;
//
// Size the view.
//
GetWindowRect(_hwndView, &rcView);
MapWindowRect(HWND_DESKTOP, _hwndDlg, &rcView);
hdwp = BeginDeferWindowPos(10);
if (hdwp)
{
hdwp = DeferWindowPos(hdwp,
_hwndGrip,
NULL,
width - g_cxGrip,
height - g_cyGrip,
g_cxGrip,
g_cyGrip,
SWP_NOZORDER | SWP_NOACTIVATE);
if (hdwp)
{
hdwp = DeferWindowPos(hdwp,
_hwndView,
NULL,
0,
0,
rcView.right - rcView.left + dx, // resize x
rcView.bottom - rcView.top + dy, // resize y
SWP_NOMOVE | SWP_NOZORDER | SWP_NOACTIVATE);
}
#if 0
//
// Can't do this because some sub-dialogs are dependent on the
// original size of this control. Instead we just try to rely on
// the size of the _hwndView above.
//
hwnd = GetDlgItem(_hwndDlg, lst1);
if (hdwp)
{
hdwp = DeferWindowPos(hdwp,
hwnd,
NULL,
0,
0,
rcView.right - rcView.left + dx, // resize x
rcView.bottom - rcView.top + dy, // resize y
SWP_NOMOVE | SWP_NOZORDER | SWP_NOACTIVATE);
}
#endif
}
//
// Move the controls.
//
hwnd = ::GetWindow(_hwndDlg, GW_CHILD);
while (hwnd && hdwp)
{
if ((hwnd != _hSubDlg) && (hwnd != _hwndGrip) && (hdwp))
{
GetWindowRect(hwnd, &rc);
MapWindowRect(HWND_DESKTOP, _hwndDlg, &rc);
//
// See if the control needs to be adjusted.
//
if (rc.top > rcView.bottom)
{
switch (GetDlgCtrlID(hwnd))
{
case (edt1) :
case (cmb13) :
case (cmb1) :
{
//Increase the width of these controls
hdwp = DeferWindowPos(hdwp,
hwnd,
NULL,
rc.left,
rc.top + dy,
RECTWIDTH(rc) + dx,
RECTHEIGHT(rc),
SWP_NOZORDER);
break;
}
case (IDOK):
case (IDCANCEL):
case (pshHelp):
{
//Move these controls to the right
hdwp = DeferWindowPos(hdwp,
hwnd,
NULL,
rc.left + dx,
rc.top + dy,
0,
0,
SWP_NOZORDER | SWP_NOSIZE);
break;
}
default :
{
//
// The control is below the view, so adjust the y
// coordinate appropriately.
//
hdwp = DeferWindowPos(hdwp,
hwnd,
NULL,
rc.left,
rc.top + dy,
0,
0,
SWP_NOZORDER | SWP_NOSIZE);
}
}
}
else if (rc.left > rcView.right)
{
//
// The control is to the right of the view, so adjust the
// x coordinate appropriately.
//
hdwp = DeferWindowPos(hdwp,
hwnd,
NULL,
rc.left + dx,
rc.top,
0,
0,
SWP_NOZORDER | SWP_NOSIZE);
}
else
{
int id = GetDlgCtrlID(hwnd);
switch (id)
{
case (cmb2) :
{
//
// Size this one larger.
//
hdwp = DeferWindowPos(hdwp,
hwnd,
NULL,
0,
0,
RECTWIDTH(rc) + dx,
RECTHEIGHT(rc),
SWP_NOZORDER | SWP_NOMOVE);
break;
}
case ( IDOK) :
if ((SHGetAppCompatFlags(ACF_FILEOPENBOGUSCTRLID) & ACF_FILEOPENBOGUSCTRLID) == 0)
break;
// else continue through - toolbar bar has ctrlid == IDOK, so we will resize that.
case ( stc1 ) :
//
// Move the toolbar right by dx.
//
hdwp = DeferWindowPos(hdwp,
hwnd,
NULL,
rc.left + dx,
rc.top,
0,
0,
SWP_NOZORDER | SWP_NOSIZE);
break;
case ( ctl1 ) :
{
// Size the places bar vertically
hdwp = DeferWindowPos(hdwp,
hwnd,
NULL,
0,
0,
RECTWIDTH(rc),
RECTHEIGHT(rc) + dy,
SWP_NOZORDER | SWP_NOMOVE);
break;
}
}
}
}
hwnd = ::GetWindow(hwnd, GW_HWNDNEXT);
}
if (!hdwp)
{
return;
}
EndDeferWindowPos(hdwp);
if (_hSubDlg)
{
hdwp = NULL;
hwnd = ::GetWindow(_hSubDlg, GW_CHILD);
while (hwnd)
{
GetWindowRect(hwnd, &rc);
MapWindowRect(HWND_DESKTOP, _hSubDlg, &rc);
//
// See if the control needs to be adjusted.
//
if (rc.top > rcView.bottom)
{
//
// The control is below the view, so adjust the y
// coordinate appropriately.
//
if (hdwp == NULL)
{
hdwp = BeginDeferWindowPos(10);
}
if (hdwp)
{
hdwp = DeferWindowPos(hdwp,
hwnd,
NULL,
rc.left,
rc.top + dy,
0,
0,
SWP_NOZORDER | SWP_NOSIZE);
}
}
else if (rc.left > rcView.right)
{
//
// The control is to the right of the view, so adjust the
// x coordinate appropriately.
//
if (hdwp == NULL)
{
hdwp = BeginDeferWindowPos(10);
}
if (hdwp)
{
hdwp = DeferWindowPos(hdwp,
hwnd,
NULL,
rc.left + dx,
rc.top,
0,
0,
SWP_NOZORDER | SWP_NOSIZE);
}
}
hwnd = ::GetWindow(hwnd, GW_HWNDNEXT);
}
if (hdwp)
{
EndDeferWindowPos(hdwp);
//
// Size the sub dialog.
//
SetWindowPos(_hSubDlg,
NULL,
0,
0,
_ptLastSize.x, // make it the same
_ptLastSize.y, // make it the same
SWP_NOMOVE | SWP_NOZORDER | SWP_NOACTIVATE);
}
}
}
////////////////////////////////////////////////////////////////////////////
//
// CFileOpenBrowser::VerifyListViewPosition
//
////////////////////////////////////////////////////////////////////////////
void CFileOpenBrowser::VerifyListViewPosition()
{
RECT rcList, rcView;
FOLDERSETTINGS fs;
//
// Get the rectangle for both the list view and the hidden list box.
//
GetControlRect(_hwndDlg, lst1, &rcList);
rcView.left = 0;
if ((!GetWindowRect(_hwndView, &rcView)) ||
(!MapWindowRect(HWND_DESKTOP, _hwndDlg, &rcView)))
{
return;
}
//
// See if the list view is off the screen and the list box is not.
//
if ((rcView.left < 0) && (rcList.left >= 0))
{
//
// Reset the list view to the list box position.
//
if (_pCurrentLocation)
{
if (_psv)
{
_psv->GetCurrentInfo(&fs);
}
else
{
fs.ViewMode = FVM_LIST;
fs.fFlags = _pOFN->Flags & OFN_ALLOWMULTISELECT ? 0 : FWF_SINGLESEL;
}
SwitchView(_pCurrentLocation->GetShellFolder(),
_pCurrentLocation->pidlFull,
&fs,
NULL,
FALSE);
}
}
}
////////////////////////////////////////////////////////////////////////////
//
// CFileOpenBrowser::UpdateNavigation
// This function updates the navigation stack by adding the current
// pidl to the stack
////////////////////////////////////////////////////////////////////////////
void CFileOpenBrowser::UpdateNavigation()
{
WPARAM iItem;
HWND hwndCombo = GetDlgItem(_hwndDlg, cmb2);
iItem = SendMessage(hwndCombo, CB_GETCURSEL, NULL, NULL);
MYLISTBOXITEM *pNewLocation = GetListboxItem(hwndCombo, iItem);
if (_ptlog && pNewLocation && pNewLocation->pidlFull)
{
LPITEMIDLIST pidl;
_ptlog->GetCurrent(&pidl);
if (pidl && (!ILIsEqual(pNewLocation->pidlFull, pidl)))
{
_ptlog->AddEntry(pNewLocation->pidlFull);
}
if (pidl)
{
ILFree(pidl);
}
}
//Update the UI
UpdateUI(_pCurrentLocation ? _pCurrentLocation->pidlFull : NULL);
}
////////////////////////////////////////////////////////////////////////////
//
// CFileOpenBrowser::UpdateUI
//
////////////////////////////////////////////////////////////////////////////
void CFileOpenBrowser::UpdateUI(LPITEMIDLIST pidlNew)
{
TBBUTTONINFO tbbi;
LPITEMIDLIST pidl;
::SendMessage(_hwndToolbar, TB_ENABLEBUTTON, IDC_BACK, _ptlog ? _ptlog->CanTravel(TRAVEL_BACK) : 0);
if (_iCheckedButton >= 0)
{
//Reset the Hot Button
::SendMessage(_hwndPlacesbar, TB_CHECKBUTTON, (WPARAM)_iCheckedButton, MAKELONG(FALSE,0));
_iCheckedButton = -1;
}
if (pidlNew)
{
//Get Each Toolbar Buttons pidl and see if the current pidl matches
for (int i=0; i < MAXPLACESBARITEMS; i++)
{
tbbi.cbSize = SIZEOF(tbbi);
tbbi.lParam = 0;
tbbi.dwMask = TBIF_LPARAM | TBIF_BYINDEX | TBIF_COMMAND;
if (SendMessage(_hwndPlacesbar, TB_GETBUTTONINFO, i, (LPARAM)&tbbi) >= 0)
{
pidl = (LPITEMIDLIST)tbbi.lParam;
if (pidl && ILIsEqual(pidlNew, pidl))
{
_iCheckedButton = tbbi.idCommand;
break;
}
}
}
if (_iCheckedButton >= 0)
{
::SendMessage(_hwndPlacesbar, TB_CHECKBUTTON, (WPARAM)_iCheckedButton, MAKELONG(TRUE,0));
}
}
}
////////////////////////////////////////////////////////////////////////////
//
// OpenDlgProc
//
// Main dialog procedure for file open dialogs.
//
////////////////////////////////////////////////////////////////////////////
BOOL_PTR CALLBACK OpenDlgProc(
HWND hDlg, // window handle of the dialog box
UINT message, // type of message
WPARAM wParam, // message-specific information
LPARAM lParam)
{
CFileOpenBrowser *pDlgStruct = HwndToBrowser(hDlg);
// we divide the message processing into two switch statments:
// those who don't use pDlgStruct first and then those who do.
switch (message)
{
case WM_INITDIALOG:
{
//
// Initialize dialog box.
//
LPOFNINITINFO poii = (LPOFNINITINFO)lParam;
if (CDGetAppCompatFlags() & CDACF_MATHCAD)
{
if (FAILED(CoInitializeEx(NULL, COINIT_APARTMENTTHREADED | COINIT_DISABLE_OLE1DDE)))
::EndDialog(hDlg, FALSE);
}
poii->hrOleInit = SHOleInitialize(0);
if (!InitLocation(hDlg, poii))
{
::EndDialog(hDlg, FALSE);
}
if (!gp_uQueryCancelAutoPlay)
{
// try to register for autoplay messages
gp_uQueryCancelAutoPlay = RegisterWindowMessage(TEXT("QueryCancelAutoPlay"));
}
//
// Always return FALSE to indicate we have already set the focus.
//
return FALSE;
}
break;
case WM_DESTROY:
{
RECT r;
//Cache in this dialogs size and position so that new
//dialog are created at this location and size
GetWindowRect(hDlg, &r);
if (pDlgStruct && (pDlgStruct->_bEnableSizing))
{
g_rcDlg = r;
}
//
// Make sure we do not respond to any more messages.
//
StoreBrowser(hDlg, NULL);
ClearListbox(GetDlgItem(hDlg, cmb2));
if (pDlgStruct)
{
pDlgStruct->Release();
}
return FALSE;
}
break;
case WM_ACTIVATE:
{
if (wParam == WA_INACTIVE)
{
//
// Make sure some other Open dialog has not already grabbed
// the focus. This is a process global, so it should not
// need to be protected.
//
if (gp_hwndActiveOpen == hDlg)
{
gp_hwndActiveOpen = NULL;
}
}
else
{
gp_hwndActiveOpen = hDlg;
}
return FALSE;
}
break;
case WM_MEASUREITEM:
{
if (!g_cxSmIcon && !g_cySmIcon)
{
HIMAGELIST himl;
Shell_GetImageLists(NULL, &himl);
ImageList_GetIconSize(himl, &g_cxSmIcon, &g_cySmIcon);
}
MeasureDriveItems(hDlg, (MEASUREITEMSTRUCT*)lParam);
return TRUE;
}
break;
case CWM_GETISHELLBROWSER:
{
::SetWindowLongPtr(hDlg, DWLP_MSGRESULT, (LRESULT)pDlgStruct);
return TRUE;
}
break;
case WM_DEVICECHANGE:
{
if (DBT_DEVICEARRIVAL == wParam)
{
// and refresh our view in case this was a notification for the folder
// we are viewing. avoids making the user do a manual refresh
DEV_BROADCAST_VOLUME *pbv = (DEV_BROADCAST_VOLUME *)lParam;
if (pbv->dbcv_flags & DBTF_MEDIA)
{
int chRoot;
TCHAR szPath[MAX_PATH];
if (pDlgStruct->GetDirectoryFromLB(szPath, &chRoot))
{
int iDrive = PathGetDriveNumber(szPath);
if (iDrive != -1 && ((1 << iDrive) & pbv->dbcv_unitmask))
{
// refresh incase this was this folder
PostMessage(hDlg, WM_COMMAND, IDC_REFRESH, 0);
}
}
}
}
return TRUE;
}
break;
default:
if (message == gp_uQueryCancelAutoPlay)
{
// cancel the autoplay
SetWindowLongPtr(hDlg, DWLP_MSGRESULT, 1);
return TRUE;
}
break;
}
// NOTE:
// all of the messages below require that we have a valid pDlgStruct. if you
// don't refrence pDlgStruct, then add your msg to the switch statement above.
if (pDlgStruct)
{
switch (message)
{
case WM_COMMAND:
{
return ((BOOL_PTR)pDlgStruct->OnCommandMessage(wParam, lParam));
}
break;
case WM_DRAWITEM:
{
pDlgStruct->PaintDriveLine((DRAWITEMSTRUCT *)lParam);
//
// Make sure the list view is in the same place as the
// list box. Apps like VB move the list box off of the
// dialog. If the list view is placed on the list box
// before the list box gets moved back to the dialog, we
// end up with an ugly gray spot.
//
pDlgStruct->VerifyListViewPosition();
return TRUE;
}
break;
case WM_NOTIFY:
{
return (BOOL_PTR)pDlgStruct->OnNotify((LPNMHDR)lParam);
}
break;
case WM_SETCURSOR:
{
if (pDlgStruct->OnSetCursor())
{
SetDlgMsgResult(hDlg, message, (LRESULT)TRUE);
return TRUE;
}
}
break;
case WM_HELP:
{
HWND hwndItem = (HWND)((LPHELPINFO)lParam)->hItemHandle;
if (hwndItem != pDlgStruct->_hwndToolbar)
{
HWND hwndItem = (HWND)((LPHELPINFO)lParam)->hItemHandle;
// We assume that the defview has one child window that
// covers the entire defview window.
HWND hwndDefView = GetDlgItem(hDlg, lst2);
if (GetParent(hwndItem) == hwndDefView)
{
hwndItem = hwndDefView;
}
WinHelp(hwndItem,
NULL,
HELP_WM_HELP,
(ULONG_PTR)(LPTSTR)(pDlgStruct->_bSave ? aFileSaveHelpIDs : aFileOpenHelpIDs));
}
return TRUE;
}
break;
case WM_CONTEXTMENU:
{
if ((HWND)wParam != pDlgStruct->_hwndToolbar)
{
WinHelp((HWND)wParam,
NULL,
HELP_CONTEXTMENU,
(ULONG_PTR)(void *)(pDlgStruct->_bSave ? aFileSaveHelpIDs : aFileOpenHelpIDs));
}
return TRUE;
}
break;
case CDM_SETSAVEBUTTON:
{
pDlgStruct->RealSetSaveButton((UINT)wParam);
}
break;
case CDM_FSNOTIFY:
{
LPITEMIDLIST *ppidl;
LONG lEvent;
BOOL bRet;
LPSHChangeNotificationLock pLock;
// Get the change notification info from the shared memory
// block identified by the handle passed in the wParam.
pLock = SHChangeNotification_Lock((HANDLE)wParam,
(DWORD)lParam,
&ppidl,
&lEvent);
if (pLock == NULL)
{
pDlgStruct->_bDropped = FALSE;
return FALSE;
}
bRet = pDlgStruct->FSChange(lEvent, (LPCITEMIDLIST *)ppidl);
// Release the shared block.
SHChangeNotification_Unlock(pLock);
return bRet;
}
break;
case CDM_SELCHANGE:
{
pDlgStruct->_fSelChangedPending = FALSE;
pDlgStruct->SelFocusChange(TRUE);
if (pDlgStruct->_hSubDlg)
{
CD_SendSelChangeNotify(pDlgStruct->_hSubDlg,
hDlg,
pDlgStruct->_pOFN,
pDlgStruct->_pOFI);
}
}
break;
case WM_TIMER:
{
pDlgStruct->Timer(wParam);
}
break;
case WM_GETMINMAXINFO:
{
if (pDlgStruct->_bEnableSizing)
{
pDlgStruct->OnGetMinMax((LPMINMAXINFO)lParam);
return FALSE;
}
}
break;
case WM_SIZE:
{
if (pDlgStruct->_bEnableSizing)
{
pDlgStruct->OnSize(LOWORD(lParam), HIWORD(lParam));
return TRUE;
}
}
break;
case WM_NCCALCSIZE:
{
// AppHack for Borland JBuilder: Need to keep track of whether
// any redraw requests have come in.
pDlgStruct->_bAppRedrawn = TRUE;
}
break;
case WM_THEMECHANGED:
{
// Need to change some parameters on the placesbar for this.
pDlgStruct->OnThemeActive(hDlg, IsAppThemed());
return TRUE;
}
break;
case WM_SETTINGCHANGE:
{
// If icon size has changed, we need to regenerate the places bar.
pDlgStruct->_RecreatePlacesbar();
return FALSE;
}
break;
default:
{
if (IsInRange(message, CDM_FIRST, CDM_LAST) && pDlgStruct)
{
return pDlgStruct->OnCDMessage(message, wParam, lParam);
}
}
}
}
// Did not process the message.
return FALSE;
}
////////////////////////////////////////////////////////////////////////////
//
// OpenFileHookProc
//
////////////////////////////////////////////////////////////////////////////
LRESULT CALLBACK OpenFileHookProc(
int nCode,
WPARAM wParam,
LPARAM lParam)
{
MSG *lpMsg;
if (nCode < 0)
{
return (DefHookProc(nCode, wParam, lParam, &gp_hHook));
}
if (nCode != MSGF_DIALOGBOX)
{
return (0);
}
lpMsg = (MSG *)lParam;
//
// Check if this message is for the last active OpenDialog in this
// process.
//
// Note: This is only done for WM_KEY* messages so that we do not slow
// down this window too much.
//
if (IsInRange(lpMsg->message, WM_KEYFIRST, WM_KEYLAST))
{
HWND hwndActiveOpen = gp_hwndActiveOpen;
HWND hwndFocus = GetFocusedChild(hwndActiveOpen, lpMsg->hwnd);
CFileOpenBrowser *pDlgStruct;
if (hwndFocus &&
(pDlgStruct = HwndToBrowser(hwndActiveOpen)) != NULL)
{
if (pDlgStruct->_psv && (hwndFocus == pDlgStruct->_hwndView))
{
if (pDlgStruct->_psv->TranslateAccelerator(lpMsg) == S_OK)
{
return (1);
}
if (gp_haccOpenView &&
TranslateAccelerator(hwndActiveOpen, gp_haccOpenView, lpMsg))
{
return (1);
}
}
else
{
if (gp_haccOpen &&
TranslateAccelerator(hwndActiveOpen, gp_haccOpen, lpMsg))
{
return (1);
}
//
// Note that the view won't be allowed to translate when the
// focus is not there.
//
}
}
}
return (0);
}
////////////////////////////////////////////////////////////////////////////
//
// NewGetFileName
//
////////////////////////////////////////////////////////////////////////////
BOOL NewGetFileName(
LPOPENFILEINFO lpOFI,
BOOL bSave)
{
OFNINITINFO oii = { lpOFI, bSave, FALSE, -1};
LPOPENFILENAME lpOFN = lpOFI->pOFN;
BOOL bHooked = FALSE;
WORD wErrorMode;
HRSRC hResInfo;
HGLOBAL hDlgTemplate;
LPDLGTEMPLATE pDlgTemplate;
int nRet;
LANGID LangID;
//Initialize the common controls
INITCOMMONCONTROLSEX icc;
icc.dwSize = sizeof(INITCOMMONCONTROLSEX);
icc.dwICC = ICC_USEREX_CLASSES; //ComboBoxEx class
InitCommonControlsEx(&icc);
if ((lpOFN->lStructSize != sizeof(OPENFILENAME)) &&
(lpOFN->lStructSize != OPENFILENAME_SIZE_VERSION_400)
)
{
StoreExtendedError(CDERR_STRUCTSIZE);
return FALSE;
}
//
// OFN_ENABLEINCLUDENOTIFY requires OFN_EXPLORER and OFN_ENABLEHOOK.
//
if (lpOFN->Flags & OFN_ENABLEINCLUDENOTIFY)
{
if ((!(lpOFN->Flags & OFN_EXPLORER)) ||
(!(lpOFN->Flags & OFN_ENABLEHOOK)))
{
StoreExtendedError(CDERR_INITIALIZATION);
return FALSE;
}
}
wErrorMode = (WORD)SetErrorMode(SEM_NOERROR);
SetErrorMode(SEM_NOERROR | wErrorMode);
//
// There ought to be a better way. I am compelled to keep the hHook in a
// global because my callback needs it, but I have no lData where I could
// possibly store it.
// Note that we initialize nHookRef to -1 so we know when the first
// increment is.
//
if (InterlockedIncrement((LPLONG)&gp_nHookRef) == 0)
{
gp_hHook = SetWindowsHookEx(WH_MSGFILTER,
OpenFileHookProc,
0,
GetCurrentThreadId());
if (gp_hHook)
{
bHooked = TRUE;
}
else
{
--gp_nHookRef;
}
}
else
{
bHooked = TRUE;
}
if (!gp_haccOpen)
{
gp_haccOpen = LoadAccelerators(g_hinst,
MAKEINTRESOURCE(IDA_OPENFILE));
}
if (!gp_haccOpenView)
{
gp_haccOpenView = LoadAccelerators(g_hinst,
MAKEINTRESOURCE(IDA_OPENFILEVIEW));
}
g_cxGrip = GetSystemMetrics(SM_CXVSCROLL);
g_cyGrip = GetSystemMetrics(SM_CYHSCROLL);
//
// Get the dialog resource and load it.
//
nRet = FALSE;
WORD wResID;
// if the version of the structure passed is older than the current version and the application
// has specified hook or template or template handle then use template corresponding to that version
// else use the new file open template
if (((lpOFI->iVersion < OPENFILEVERSION) &&
(lpOFI->pOFN->Flags & (OFN_ENABLEHOOK | OFN_ENABLETEMPLATE | OFN_ENABLETEMPLATEHANDLE))) ||
(IsRestricted(REST_NOPLACESBAR)) || (IS_NEW_OFN(lpOFI->pOFN) && (lpOFI->pOFN->FlagsEx & OFN_EX_NOPLACESBAR))
)
{
wResID = NEWFILEOPENORD;
}
else
{
wResID = NEWFILEOPENV2ORD;
}
LangID = GetDialogLanguage(lpOFN->hwndOwner, NULL);
//
// Warning! Warning! Warning!
//
// We have to set g_tlsLangID before any call for CDLoadString
//
TlsSetValue(g_tlsLangID, (void *) LangID);
if ((hResInfo = FindResourceExFallback(::g_hinst,
RT_DIALOG,
MAKEINTRESOURCE(wResID),
LangID)) &&
(hDlgTemplate = LoadResource(::g_hinst, hResInfo)) &&
(pDlgTemplate = (LPDLGTEMPLATE)LockResource(hDlgTemplate)))
{
ULONG cbTemplate = SizeofResource(::g_hinst, hResInfo);
LPDLGTEMPLATE pDTCopy = (LPDLGTEMPLATE)LocalAlloc(LPTR, cbTemplate);
if (pDTCopy)
{
CopyMemory(pDTCopy, pDlgTemplate, cbTemplate);
UnlockResource(hDlgTemplate);
FreeResource(hDlgTemplate);
if ((lpOFN->Flags & OFN_ENABLESIZING) ||
(!(lpOFN->Flags & (OFN_ENABLEHOOK |
OFN_ENABLETEMPLATE |
OFN_ENABLETEMPLATEHANDLE))))
{
if (((LPDLGTEMPLATE2)pDTCopy)->wSignature == 0xFFFF)
{
//This is a dialogex template
((LPDLGTEMPLATE2)pDTCopy)->style |= WS_SIZEBOX;
}
else
{
//This is a dialog template
((LPDLGTEMPLATE)pDTCopy)->style |= WS_SIZEBOX;
}
oii.bEnableSizing = TRUE;
}
oii.hrOleInit = E_FAIL;
nRet = (BOOL)DialogBoxIndirectParam(::g_hinst,
pDTCopy,
lpOFN->hwndOwner,
OpenDlgProc,
(LPARAM)(LPOFNINITINFO)&oii);
//Unintialize OLE
SHOleUninitialize(oii.hrOleInit);
if (CDGetAppCompatFlags() & CDACF_MATHCAD)
{
CoUninitialize();
}
LocalFree(pDTCopy);
}
}
if (bHooked)
{
//
// Put this in a local so we don't need a critical section.
//
HHOOK hHook = gp_hHook;
if (InterlockedDecrement((LPLONG)&gp_nHookRef) < 0)
{
UnhookWindowsHookEx(hHook);
}
}
switch (nRet)
{
case (TRUE) :
{
break;
}
case (FALSE) :
{
if ((!g_bUserPressedCancel) && (!GetStoredExtendedError()))
{
StoreExtendedError(CDERR_DIALOGFAILURE);
}
break;
}
default :
{
StoreExtendedError(CDERR_DIALOGFAILURE);
nRet = FALSE;
break;
}
}
//
//
// There is a race condition here where we free dlls but a thread
// using this stuff still hasn't terminated so we page fault.
// FreeImports();
SetErrorMode(wErrorMode);
return (nRet);
}
extern "C" {
////////////////////////////////////////////////////////////////////////////
//
// NewGetOpenFileName
//
////////////////////////////////////////////////////////////////////////////
BOOL NewGetOpenFileName(
LPOPENFILEINFO lpOFI)
{
return (NewGetFileName(lpOFI, FALSE));
}
////////////////////////////////////////////////////////////////////////////
//
// NewGetSaveFileName
//
////////////////////////////////////////////////////////////////////////////
BOOL NewGetSaveFileName(
LPOPENFILEINFO lpOFI)
{
return (NewGetFileName(lpOFI, TRUE));
}
} // extern "C"
////////////////////////////////////////////////////////////////////////////
//
// CFileOpenBrowser::_ValidateSelectedFile
//
////////////////////////////////////////////////////////////////////////////
BOOL CFileOpenBrowser::_ValidateSelectedFile(LPCTSTR pszFile, int *pErrCode)
{
//
// Successfully opened.
//
// Note: (pfortier) If/when IShellItem is removed from this version of comdlg, the
// following if statement should probably revert to
// if ((_pOFN->Flags & OFN_NOREADONLYRETURN) &&
// and the next one to
// if (_bSave || (_pOFN->Flags & OFN_NOREADONLYRETURN))
//
// These were changed in order to be consistent with w2k behaviour regarding
// message box errors that appear when OFN_NOREADONLYRETURN is specified and
// the user selects a readonly file - the point of contention is that errors were
// not shown in win2k when it was an OpenFile dialog. IShellItem changes modified
// the codepath such that errors were now produced when in an OpenFile dialog.
// To compensate, the logic has been changed here.
DWORD dwAttrib = GetFileAttributes(pszFile);
if ((_pOFN->Flags & OFN_NOREADONLYRETURN) && _bSave &&
(0xFFFFFFFF != dwAttrib) && (dwAttrib & FILE_ATTRIBUTE_READONLY))
{
*pErrCode = OF_LAZYREADONLY;
return FALSE;
}
if (_bSave)
{
*pErrCode = WriteProtectedDirCheck((LPTSTR)pszFile);
if (*pErrCode)
{
return FALSE;
}
}
if (_pOFN->Flags & OFN_OVERWRITEPROMPT)
{
if (_bSave && PathFileExists(pszFile) && !FOkToWriteOver(_hwndDlg, (LPTSTR)pszFile))
{
if (_bUseCombo)
{
PostMessage(_hwndDlg, WM_NEXTDLGCTL, (WPARAM)GetDlgItem(_hwndDlg, cmb13), 1);
}
else
{
PostMessage(_hwndDlg, WM_NEXTDLGCTL, (WPARAM)GetDlgItem(_hwndDlg, edt1), 1);
}
return FALSE;
}
}
return TRUE;
}
////////////////////////////////////////////////////////////////////////////
//
// CFileOpenBrowser::_ProcessPidlSelection
//
////////////////////////////////////////////////////////////////////////////
BOOL CFileOpenBrowser::_ProcessPidlSelection()
{
IShellItem *psi;
if (SUCCEEDED(SHCreateShellItem(_pCurrentLocation->pidlFull, _psfCurrent, _pidlSelection, &psi)))
{
IShellItem *psiReal;
HRESULT hr = _TestShellItem(psi, TRUE, &psiReal);
if (S_OK == hr)
{
hr = _ProcessItemAsFile(psiReal);
psiReal->Release();
}
psi->Release();
// if there was any kind of error then we fall back
// to the old code to show errors and the like
return SUCCEEDED(hr);
}
return FALSE;
}
///////////////////////////////////////////////////////////////////////////
//
// CFileOpenBrowser::_ProcessItemAsFile
//
////////////////////////////////////////////////////////////////////////////
HRESULT CFileOpenBrowser::_ProcessItemAsFile(IShellItem *psi)
{
LPTSTR pszPath;
HRESULT hr = psi->GetDisplayName(SIGDN_FILESYSPATH, &pszPath);
if (FAILED(hr))
{
hr = _MakeFakeCopy(psi, &pszPath);
}
if (SUCCEEDED(hr))
{
int nErrCode;
hr = E_FAIL;
if (_ValidateSelectedFile(pszPath, &nErrCode))
{
DWORD dwError = 0;
int nFileOffset = _CopyFileNameToOFN(pszPath, &dwError);
_CopyTitleToOFN(pszPath+nFileOffset);
_PostProcess(pszPath);
if (dwError)
StoreExtendedError(dwError);
_CleanupDialog((dwError == NOERROR));
hr = S_OK;
}
else
{
//Check to see if there is an error in the file or user pressed no for overwrite prompt
// if user pressed no to overwritte prompt then return true
if (nErrCode == 0)
hr = S_FALSE; // Otherwise, return failure.
}
CoTaskMemFree(pszPath);
}
return hr;
}
///////////////////////////////////////////////////////////////////////////
//
// CFileOpenBrowser::_ProcessPidlAsShellItem
//
////////////////////////////////////////////////////////////////////////////
#ifdef RETURN_SHELLITEMS
HRESULT CFileOpenBrowser::_ProcessShellItem(IShellItem *psi)
{
CShellItemList *psil = new CShellItemList();
HRESULT hr = E_OUTOFMEMORY;
ASSERT(IS_NEW_OFN(_pOFN));
if (psil)
{
hr = psil->Add(psi);
// we have added everything to our list
if (SUCCEEDED(hr))
{
hr = psil->QueryInterface(IID_PPV_ARG(IEnumShellItems, &(_pOFN->penum)));
}
psil->Release();
}
return hr;
}
#endif RETURN_SHELLITEMS
///////////////////////////////////////////////////////////////////////////
//
// CFileOpenBrowser::_PostProcess
//
// This functions does all the bookkeeping operations that needs to be
// done when File Open/Save Dialog closes.
////////////////////////////////////////////////////////////////////////////
BOOL CFileOpenBrowser::_PostProcess(LPTSTR pszFile)
{
int nFileOffset = ParseFileNew(pszFile, NULL, FALSE, TRUE);
//Set the last visited directory for this application.
//We should this all the time regardless of how we opened b'cos app may specify an initial
//directory(many apps do this in Save As case) but the user might decide to save it in a differnt directory
//in this case we need to save the directory where user saved.
AddToLastVisitedMRU(pszFile, nFileOffset);
//Add to recent documents.
if (!(_pOFN->Flags & OFN_DONTADDTORECENT))
{
SHAddToRecentDocs(SHARD_PATH, pszFile);
//Add to the file mru
AddToMRU(_pOFN);
}
// Check to see if we need to set Read only bit or not
if (!(_pOFN->Flags & OFN_HIDEREADONLY))
{
//
// Read-only checkbox visible?
//
if (IsDlgButtonChecked(_hwndDlg, chx1))
{
_pOFN->Flags |= OFN_READONLY;
}
else
{
_pOFN->Flags &= ~OFN_READONLY;
}
}
return TRUE;
}
Reference in New Issue View Git Blame Copy Permalink