Microsoft/WindowsXP-SP1
Microsoft/WindowsXP-SP1
1
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity
master
WindowsXP-SP1/shell/shell32/finddlg.cpp

6020 lines
174 KiB
C++
Raw Permalink Normal View History

First commit
2001-01-01 00:00:00 +01:00
#include "shellprv.h"
#include "findband.h"
#include "finddlg.h"
#include "findfilter.h" // DFW_xxx warning flags.
#include "enumidlist.h"
void DivWindow_RegisterClass();
// Namespace picker combo methods.
STDAPI PopulateNamespaceCombo(HWND hwndComboEx, ADDCBXITEMCALLBACK pfn, LPARAM lParam);
#define MAX_EDIT 256
#define SUBDLG_BORDERWIDTH 0
#define MIN_NAMESPACELIST_WIDTH 140
#define MIN_FILEASSOCLIST_WIDTH 175
#define LSUIS_WARNING 1 // LoadSaveUIState warning flags
int CSearchWarningDlg_DoModal(HWND hwndParent, USHORT uDlgTemplate, BOOL* pbNoWarn);
int CCISettingsDlg_DoModal(HWND hwndParent);
BOOL IsConstraintName(LPCWSTR pwszConstraint, LPCWSTR pwszName)
{
return pwszName && (0 == StrCmpIW(pwszName, pwszConstraint));
}
BOOL _GetWindowSize(HWND hwndDlg, SIZE *pSize)
{
RECT rc;
if (::GetClientRect(hwndDlg, &rc))
{
pSize->cx = RECTWIDTH(rc);
pSize->cy = RECTHEIGHT(rc);
return TRUE;
}
return FALSE;
}
BOOL _ModifyWindowStyle(HWND hwnd, DWORD dwAdd, DWORD dwRemove)
{
ASSERT(dwAdd || dwRemove);
if (IsWindow(hwnd))
{
DWORD dwStyle = GetWindowLong(hwnd, GWL_STYLE);
if (dwAdd)
dwStyle |= dwAdd;
if (dwRemove)
dwStyle &= ~dwRemove;
SetWindowLong(hwnd, GWL_STYLE, dwStyle);
return TRUE;
}
return FALSE;
}
BOOL _EnforceNumericEditRange(
IN HWND hwndDlg,
IN UINT nIDEdit,
IN UINT nIDSpin,
IN LONG nLow,
IN LONG nHigh,
IN BOOL bSigned = FALSE)
{
BOOL bRet = FALSE;
BOOL bReset = FALSE;
LONG lRet = -1;
if (nIDSpin)
{
lRet = (LONG)SendDlgItemMessage(hwndDlg, nIDSpin, UDM_GETPOS, 0, 0);
bRet = 0 == HIWORD(lRet);
}
if (!bRet)
lRet = (LONG)GetDlgItemInt(hwndDlg, nIDEdit, &bRet, bSigned);
if (lRet < nLow)
{
lRet = nLow;
bReset = TRUE;
}
else if (lRet > nHigh)
{
lRet = nHigh;
bReset = TRUE;
}
if (bReset)
SetDlgItemInt(hwndDlg, nIDEdit, lRet, bSigned);
return bRet;
}
BOOL _IsDirectoryServiceAvailable()
{
BOOL bRet = FALSE;
IShellDispatch2* psd;
if (SUCCEEDED(CoCreateInstance(CLSID_Shell, 0, CLSCTX_INPROC_SERVER,
IID_PPV_ARG(IShellDispatch2, &psd))))
{
BSTR bstrName = SysAllocString(L"DirectoryServiceAvailable");
if (bstrName)
{
VARIANT varRet = {0};
if (SUCCEEDED(psd->GetSystemInformation(bstrName, &varRet)))
{
ASSERT(VT_BOOL == varRet.vt);
bRet = varRet.boolVal;
}
SysFreeString(bstrName);
}
psd->Release();
}
return bRet;
}
// Calculates number of pixels for dialog template units
LONG _PixelsForDbu(HWND hwndDlg, LONG cDbu, BOOL bHorz)
{
RECT rc = {0,0,0,0};
if (bHorz)
rc.right = cDbu;
else
rc.bottom = cDbu;
if (MapDialogRect(hwndDlg, &rc))
return bHorz ? RECTWIDTH(rc) : RECTHEIGHT(rc);
return 0;
}
// Retrieves a localizable horizontal or vertical metric value from
// the resource module.
LONG _GetResourceMetric(HWND hwndDlg, UINT nIDResource, BOOL bHorz /*orientation of metric*/)
{
TCHAR szMetric[48];
if (!EVAL(LoadString(HINST_THISDLL, nIDResource,
szMetric, ARRAYSIZE(szMetric))))
return 0;
LONG n = StrToInt(szMetric);
return _PixelsForDbu(hwndDlg, n, bHorz);
}
// Calculates the date nDays + nMonths from pstSrc. nDays and/or nMonths
// can be negative values.
BOOL _CalcDateOffset(const SYSTEMTIME* pstSrc, int nDays, int nMonths, OUT SYSTEMTIME* pstDest)
{
ASSERT(pstSrc);
ASSERT(pstDest);
// Subtract 90 days from current date and stuff in date low range
FILETIME ft;
SystemTimeToFileTime(pstSrc, &ft);
LARGE_INTEGER t;
t.LowPart = ft.dwLowDateTime;
t.HighPart = ft.dwHighDateTime;
nDays += MulDiv(nMonths, 1461 /*days per 4 yrs*/, 48 /*months per 4 yrs*/);
t.QuadPart += Int32x32To64(nDays * 24 /*hrs per day*/ * 3600 /*seconds per hr*/,
10000000 /*100 ns intervals per sec*/);
ft.dwLowDateTime = t.LowPart;
ft.dwHighDateTime = t.HighPart;
FileTimeToSystemTime(&ft, pstDest);
return TRUE;
}
// Loads a string into a combo box and assigns the string resource ID value
// to the combo item's data.
BOOL _LoadStringToCombo(HWND hwndCombo, int iPos, UINT idString, LPARAM lpData)
{
TCHAR szText[MAX_EDIT];
if (LoadString(HINST_THISDLL, idString, szText, ARRAYSIZE(szText)))
{
INT_PTR idx = ::SendMessage(hwndCombo, CB_INSERTSTRING, iPos, (LPARAM)szText);
if (idx != CB_ERR)
{
::SendMessage(hwndCombo, CB_SETITEMDATA, idx, lpData);
return TRUE;
}
}
return FALSE;
}
// Retrieves combo item's data. If idx == CB_ERR, the currently selected
// item's data will be retrieved.
LPARAM _GetComboData(HWND hwndCombo, INT_PTR idx = CB_ERR)
{
if (CB_ERR == idx)
idx = SendMessage(hwndCombo, CB_GETCURSEL, 0, 0);
if (CB_ERR == idx)
return idx;
return (LPARAM)::SendMessage(hwndCombo, CB_GETITEMDATA, idx, 0);
}
// Selects combo item with matching data, and returns the index
// of the selected item.
INT_PTR _SelectComboData(HWND hwndCombo, LPARAM lpData)
{
for (INT_PTR i = 0, cnt = SendMessage(hwndCombo, CB_GETCOUNT, 0, 0); i < cnt; i++)
{
LPARAM lParam = SendMessage(hwndCombo, CB_GETITEMDATA, i, 0);
if (lParam != CB_ERR && lParam == lpData)
{
SendMessage(hwndCombo, CB_SETCURSEL, i, 0);
return i;
}
}
return CB_ERR;
}
// Draws a focus rect bounding the specified window.
void _DrawCtlFocus(HWND hwnd)
{
HDC hdc;
if ((hdc = GetDC(hwnd)) != NULL)
{
RECT rc;
GetClientRect(hwnd, &rc);
DrawFocusRect(hdc, &rc);
ReleaseDC(hwnd, hdc);
}
}
BOOL _IsPathList(LPCTSTR pszPath)
{
return pszPath ? StrChr(pszPath, TEXT(';')) != NULL : FALSE;
}
HRESULT _IsPathValidUNC(HWND hWndParent, BOOL fNetValidate, LPCTSTR pszPath)
{
HRESULT hr = S_OK;
if (PathIsUNC(pszPath))
{
if (fNetValidate)
{
NETRESOURCE nr = {0};
TCHAR szPathBuffer[MAX_PATH];
StrCpyN(szPathBuffer, pszPath, ARRAYSIZE(szPathBuffer));
nr.dwType = RESOURCETYPE_DISK;
nr.lpRemoteName = szPathBuffer;
if (NO_ERROR != WNetAddConnection3(hWndParent, &nr, NULL, NULL,
CONNECT_TEMPORARY | CONNECT_INTERACTIVE))
{
hr = E_FILE_NOT_FOUND;
}
}
}
else
{
hr = S_FALSE;
}
return hr;
}
BOOL _IsFullPathMinusDriveLetter(LPCTSTR pszPath)
{
if (NULL == pszPath || PathIsUNC(pszPath))
return FALSE;
ASSERT(!PathIsRelative(pszPath));
// Eat whitespace
for (; (0 != *pszPath) && (TEXT(' ') == *pszPath) ; pszPath = CharNext(pszPath));
return TEXT('\\') == *pszPath &&
-1 == PathGetDriveNumber(pszPath);
}
BOOL _PathLooksLikeFilePattern(LPCTSTR pszPath)
{
return StrPBrk(pszPath, TEXT("?*")) != NULL;
}
BOOL _PathIsDblSlash(LPCTSTR pszPath)
{
return pszPath && (pszPath[0] == TEXT('\\')) && (pszPath[1] == TEXT('\\'));
}
BOOL _PathIsUNCServerShareOrSub(LPCTSTR pszPath)
{
int cSlash = 0;
if (_PathIsDblSlash(pszPath))
{
for (LPTSTR psz = (LPTSTR)pszPath; psz && *psz; psz = CharNext(psz))
{
if (*psz == TEXT('\\'))
cSlash++;
}
}
return cSlash >= 3;
}
BOOL _IsPathLocalHarddrive(LPCTSTR pszPath)
{
int iDrive = PathGetDriveNumber(pszPath);
if (iDrive != -1)
{
TCHAR szRoot[16];
return DRIVE_FIXED == GetDriveType(PathBuildRoot(szRoot, iDrive));
}
return FALSE;
}
BOOL _IsPathLocalRoot(LPCTSTR pszPath)
{
int iDrive = PathGetDriveNumber(pszPath);
if (-1 != iDrive)
{
TCHAR szRoot[16];
if (PathBuildRoot(szRoot, iDrive))
{
if (0 == StrCmpI(szRoot, pszPath))
{
switch (GetDriveType(szRoot))
{
case DRIVE_REMOVABLE:
case DRIVE_FIXED:
case DRIVE_REMOTE:
case DRIVE_CDROM:
case DRIVE_RAMDISK:
return TRUE;
}
}
}
}
return FALSE;
}
// from an object in the browser and it's site find the current pidl of what
// we are looking at
HRESULT _GetCurrentFolderIDList(IUnknown* punkSite, LPITEMIDLIST *ppidl)
{
*ppidl = NULL;
IShellBrowser* psb;
HRESULT hr = IUnknown_QueryService(punkSite, SID_STopLevelBrowser, IID_PPV_ARG(IShellBrowser, &psb));
if (SUCCEEDED(hr))
{
IShellView* psv;
hr = psb->QueryActiveShellView(&psv);
if (SUCCEEDED(hr))
{
IFolderView *pfv;
hr = psv->QueryInterface(IID_PPV_ARG(IFolderView, &pfv));
if (SUCCEEDED(hr))
{
IShellFolder* psf;
hr = pfv->GetFolder(IID_PPV_ARG(IShellFolder, &psf));
if (SUCCEEDED(hr))
{
hr = SHGetIDListFromUnk(psf, ppidl);
psf->Release();
}
pfv->Release();
}
psv->Release();
}
psb->Release();
}
return hr;
}
HRESULT _PathValidate(LPCTSTR pszPath, HWND hWndParent, BOOL fNetValidate)
{
HRESULT hr = _IsPathValidUNC(hWndParent, fNetValidate, pszPath);
if (S_OK == hr)
{
// We are done.
}
else if (E_FILE_NOT_FOUND != hr)
{
if (_IsPathList(pszPath) || PathIsSlow(pszPath, -1))
{
hr = S_OK; // Skip check for slow files.
}
else
{
DWORD dwAttr;
if (PathIsRelative(pszPath) || _IsFullPathMinusDriveLetter(pszPath))
{
hr = E_FILE_NOT_FOUND; // don't accept anything but a fully qualified path at this point.
dwAttr = -1;
}
else
{
dwAttr = GetFileAttributes(pszPath); // Does it exist?
if (-1 == dwAttr)
{
HRESULT hrFromPrepareForWrite = S_OK;
// Maybe the disk isn't inserted, so allow the user
// the chance to insert it.
if (hWndParent)
{
hrFromPrepareForWrite = SHPathPrepareForWrite(hWndParent, NULL, pszPath, SHPPFW_IGNOREFILENAME);
if (SUCCEEDED(hrFromPrepareForWrite))
dwAttr = GetFileAttributes(pszPath); // Does it exist now?
}
// If SHPathPrepareForWrite() displays UI, then they will return HRESULT_FROM_WIN32(ERROR_CANCELLED)
// so that the callers (us) will skip displaying our UI. If this is the case, when propagate that error.
if (HRESULT_FROM_WIN32(ERROR_CANCELLED) == hrFromPrepareForWrite)
{
hr = hrFromPrepareForWrite;
}
else
{
if (-1 == dwAttr)
hr = E_FILE_NOT_FOUND; // It doesn't exist.
else
hr = S_OK; // It exists now.
}
}
}
}
}
return hr;
}
BOOL _FmtError(UINT nIDFmt, LPCTSTR pszSub, LPTSTR szBuf, int cchBuf)
{
TCHAR szFmt[MAX_PATH];
if (EVAL(LoadString(HINST_THISDLL, nIDFmt, szFmt, ARRAYSIZE(szFmt))))
{
wnsprintf(szBuf, cchBuf, szFmt, pszSub);
return TRUE;
}
return FALSE;
}
// Retrieves the window text as a variant value of the specified type.
HRESULT _GetWindowValue(HWND hwndDlg, UINT nID, VARIANT* pvar)
{
TCHAR szText[MAX_EDIT];
LPTSTR pszText;
if (::GetDlgItemText(hwndDlg, nID, szText, ARRAYSIZE(szText)))
pszText = szText;
else
pszText = NULL;
return InitVariantFromStr(pvar, pszText);
}
// Loads the window text from a string resource.
BOOL _LoadWindowText(HWND hwnd, UINT nIDString)
{
TCHAR szText[MAX_PATH];
if (LoadString(HINST_THISDLL, nIDString, szText, ARRAYSIZE(szText)))
return SetWindowText(hwnd, szText);
return FALSE;
}
// Retrieves the window text as a variant value of the specified type.
HRESULT _SetWindowValue(HWND hwndDlg, UINT nID, const VARIANT* pvar)
{
switch (pvar->vt)
{
case VT_BSTR:
SetDlgItemTextW(hwndDlg, nID, pvar->bstrVal);
break;
case VT_UI4:
SetDlgItemInt(hwndDlg, nID, pvar->uiVal, FALSE);
break;
case VT_I4:
SetDlgItemInt(hwndDlg, nID, pvar->lVal, TRUE);
break;
default:
return E_NOTIMPL;
}
return S_OK;
}
// Adds a named constraint to the specified search command extension object
HRESULT _AddConstraint(ISearchCommandExt* pSrchCmd, LPCWSTR pwszConstraint, VARIANT* pvarValue)
{
HRESULT hr;
BSTR bstrConstraint = SysAllocString(pwszConstraint);
if (bstrConstraint)
{
hr = pSrchCmd->AddConstraint(bstrConstraint, *pvarValue);
SysFreeString(bstrConstraint);
}
else
hr = E_OUTOFMEMORY;
return hr;
}
void _PaintDlg(HWND hwndDlg, const CMetrics& metrics, HDC hdcPaint = NULL, LPCRECT prc = NULL)
{
RECT rcPaint /* rcLine */;
HDC hdc = hdcPaint;
if (NULL == hdcPaint)
hdc = GetDC(hwndDlg);
if (prc == NULL)
{
GetClientRect(hwndDlg, &rcPaint);
prc = &rcPaint;
}
FillRect(hdc, prc, metrics.BkgndBrush());
if (NULL == hdcPaint)
ReleaseDC(hwndDlg, hdc);
}
void _EnsureVisible(HWND hwndDlg, HWND hwndVis, CFileSearchBand* pfsb)
{
ASSERT(pfsb);
ASSERT(::IsWindow(hwndDlg));
ASSERT(::IsWindow(hwndVis));
RECT rcDlg, rcVis, rcX;
GetWindowRect(hwndDlg, &rcDlg);
GetWindowRect(hwndVis, &rcVis);
if (IntersectRect(&rcX, &rcDlg, &rcVis))
pfsb->EnsureVisible(&rcX);
}
inline BOOL _IsKeyPressed(int virtkey)
{
return (GetKeyState(virtkey) & 8000) != 0;
}
HWND _CreateDivider(HWND hwndParent, UINT nIDC, const POINT& pt, int nThickness = 1, HWND hwndAfter = NULL)
{
HWND hwndDiv = CreateWindowEx(0, DIVWINDOW_CLASS, NULL,
WS_CHILD|WS_CLIPSIBLINGS|WS_VISIBLE,
pt.x, pt.y, 400, 1, hwndParent,
IntToPtr_(HMENU, nIDC), HINST_THISDLL, NULL);
if (IsWindow(hwndDiv))
{
if (IsWindow(hwndAfter))
SetWindowPos(hwndDiv, hwndAfter, 0,0,0,0, SWP_NOSIZE|SWP_NOMOVE|SWP_NOACTIVATE);
SendMessage(hwndDiv, DWM_SETHEIGHT, nThickness, 0);
return hwndDiv;
}
return NULL;
}
HWND _CreateLinkWindow(HWND hwndParent, UINT nIDC, const POINT& pt, UINT nIDCaption, BOOL bShow = TRUE)
{
DWORD dwStyle = WS_CHILD|WS_TABSTOP|WS_CLIPSIBLINGS;
if (bShow)
dwStyle |= WS_VISIBLE;
HWND hwndCtl = CreateWindowEx(0, WC_LINK, NULL, dwStyle,
pt.x, pt.y, 400, 18, hwndParent,
IntToPtr_(HMENU, nIDC), HINST_THISDLL, NULL);
if (IsWindow(hwndCtl))
{
_LoadWindowText(hwndCtl, nIDCaption);
return hwndCtl;
}
return NULL;
}
BOOL _EnableLink(HWND hwndLink, BOOL bEnable)
{
LWITEM item;
item.mask = LWIF_ITEMINDEX|LWIF_STATE;
item.stateMask = LWIS_ENABLED;
item.state = bEnable ? LWIS_ENABLED : 0;
item.iLink = 0;
return (BOOL)SendMessage(hwndLink, LWM_SETITEM, 0, (LPARAM)&item);
}
int _CreateSearchLinks(HWND hwndDlg, const POINT& pt, UINT nCtlIDdlg /* ctl ID of link to hwndDlg */)
{
const UINT rgCtlID[] = {
IDC_SEARCHLINK_FILES,
IDC_SEARCHLINK_COMPUTERS,
IDC_SEARCHLINK_PRINTERS,
IDC_SEARCHLINK_PEOPLE,
IDC_SEARCHLINK_INTERNET,
};
const UINT rgCaptionID[] = {
IDS_FSEARCH_SEARCHLINK_FILES,
IDS_FSEARCH_SEARCHLINK_COMPUTERS,
IDS_FSEARCH_SEARCHLINK_PRINTERS,
IDS_FSEARCH_SEARCHLINK_PEOPLE,
IDS_FSEARCH_SEARCHLINK_INTERNET,
};
int cLinks = 0;
BOOL bDSEnabled = _IsDirectoryServiceAvailable();
for (int i = 0; i < ARRAYSIZE(rgCtlID); i++)
{
// block creation of csearch, psearch search links
// if Directory Service is not available.
if (((IDC_SEARCHLINK_PRINTERS == rgCtlID[i]) && rgCtlID[i] != nCtlIDdlg && !bDSEnabled)
|| (IDC_SEARCHLINK_FILES == rgCtlID[i] && SHRestricted(REST_NOFIND)))
{
continue;
}
if (_CreateLinkWindow(hwndDlg, rgCtlID[i], pt, rgCaptionID[i]))
cLinks++;
}
// Disable link to current dialog:
_EnableLink(GetDlgItem(hwndDlg, nCtlIDdlg), FALSE);
return cLinks;
}
void _LayoutLinkWindow(
IN HWND hwnd, // parent window
IN LONG left, // left position of link
IN LONG right, // right position of link
IN LONG yMargin, // vertical padding between links
IN OUT LONG& y, // IN: where to start (RECT::top). OUT: where the last link was positioned (RECT::bottom).
IN const int nCtlID) // ctl ID
{
HWND hwndLink;
if (nCtlID > 0)
{
hwndLink = GetDlgItem(hwnd, nCtlID);
RECT rcLink;
if (!IsWindow(hwndLink))
return;
::GetWindowRect(hwndLink, &rcLink);
::MapWindowRect(NULL, hwnd, &rcLink);
rcLink.left = left;
rcLink.right = right;
int cyIdeal = (int)::SendMessage(hwndLink, LWM_GETIDEALHEIGHT, RECTWIDTH(rcLink), 0);
if (cyIdeal >= 0)
rcLink.bottom = rcLink.top + cyIdeal;
OffsetRect(&rcLink, 0, y - rcLink.top);
y = rcLink.bottom;
::SetWindowPos(hwndLink, NULL,
rcLink.left, rcLink.top,
RECTWIDTH(rcLink), RECTHEIGHT(rcLink),
SWP_NOZORDER|SWP_NOACTIVATE);
}
else if (nCtlID < 0)
{
// this is a divider window
hwndLink = GetDlgItem(hwnd, -nCtlID);
::SetWindowPos(hwndLink, NULL, left, y + yMargin/2, right - left, 1,
SWP_NOZORDER|SWP_NOACTIVATE);
}
y += yMargin;
}
void _LayoutLinkWindows(
IN HWND hwnd, // parent window
IN LONG left, // left position of links
IN LONG right, // right position of links
IN LONG yMargin, // vertical padding between links
IN OUT LONG& y, // IN: where to start (RECT::top). OUT: where the last link was positioned (RECT::bottom).
IN const int rgCtlID[],// array of link ctl IDs. use IDC_SEPARATOR for separators
IN LONG cCtlID) // number of array elements to layout in rgCtlID.
{
for (int i = 0; i < cCtlID; i++)
_LayoutLinkWindow(hwnd, left, right, yMargin, y, rgCtlID[i]);
}
// Retrieves AutoComplete flags
//
#define SZ_REGKEY_AUTOCOMPLETE_TAB TEXT("Software\\Microsoft\\Windows\\CurrentVersion\\Explorer\\AutoComplete")
#define BOOL_NOT_SET 0x00000005
DWORD _GetAutoCompleteSettings()
{
DWORD dwACOptions = 0;
if (SHRegGetBoolUSValue(REGSTR_PATH_AUTOCOMPLETE, REGSTR_VAL_USEAUTOAPPEND, FALSE, /*default:*/FALSE))
{
dwACOptions |= ACO_AUTOAPPEND;
}
if (SHRegGetBoolUSValue(REGSTR_PATH_AUTOCOMPLETE, REGSTR_VAL_USEAUTOSUGGEST, FALSE, /*default:*/TRUE))
{
dwACOptions |= ACO_AUTOSUGGEST;
}
// Windows uses the TAB key to move between controls in a dialog. UNIX and other
// operating systems that use AutoComplete have traditionally used the TAB key to
// iterate thru the AutoComplete possibilities. We need to default to disable the
// TAB key (ACO_USETAB) unless the caller specifically wants it. We will also
// turn it on
static BOOL s_fAlwaysUseTab = BOOL_NOT_SET;
if (BOOL_NOT_SET == s_fAlwaysUseTab)
s_fAlwaysUseTab = SHRegGetBoolUSValue(SZ_REGKEY_AUTOCOMPLETE_TAB, TEXT("Always Use Tab"), FALSE, FALSE);
if (s_fAlwaysUseTab)
dwACOptions |= ACO_USETAB;
return dwACOptions;
}
// Initializes and enables an MRU autocomplete list on the specified
// edit control
HRESULT _InitializeMru(HWND hwndEdit, IAutoComplete2** ppAutoComplete, LPCTSTR pszSubKey, IStringMru** ppStringMru)
{
*ppAutoComplete = NULL;
*ppStringMru = NULL;
HRESULT hr = CoCreateInstance(CLSID_AutoComplete, NULL, CLSCTX_INPROC_SERVER,
IID_PPV_ARG(IAutoComplete2, ppAutoComplete));
if (SUCCEEDED(hr))
{
TCHAR szKey[MAX_PATH];
if (CFileSearchBand::MakeBandSubKey(pszSubKey, szKey, ARRAYSIZE(szKey)) > 0)
{
hr = CStringMru::CreateInstance(HKEY_CURRENT_USER, szKey, 25, FALSE,
IID_PPV_ARG(IStringMru, ppStringMru));
if (SUCCEEDED(hr))
{
hr = (*ppAutoComplete)->Init(hwndEdit, *ppStringMru, NULL, NULL);
}
}
else
hr = E_FAIL;
}
if (SUCCEEDED(hr))
{
(*ppAutoComplete)->SetOptions(_GetAutoCompleteSettings());
(*ppAutoComplete)->Enable(TRUE);
}
else
{
ATOMICRELEASE((*ppAutoComplete));
ATOMICRELEASE((*ppStringMru));
}
return hr;
}
HRESULT _AddMruStringFromWindow(IStringMru* pmru, HWND hwnd)
{
ASSERT(::IsWindow(hwnd));
HRESULT hr = E_FAIL;
if (pmru)
{
TCHAR szText[MAX_PATH * 3];
if (GetWindowTextW(hwnd, szText, ARRAYSIZE(szText)) > 0)
hr = pmru->Add(szText);
else
hr = S_FALSE;
}
return hr;
}
HRESULT _TestAutoCompleteDropDownState(IAutoComplete2* pac2, DWORD dwTest)
{
IAutoCompleteDropDown* pacdd;
HRESULT hr = pac2->QueryInterface(IID_PPV_ARG(IAutoCompleteDropDown, &pacdd));
if (SUCCEEDED(hr))
{
DWORD dwFlags;
if (SUCCEEDED((hr = pacdd->GetDropDownStatus(&dwFlags, NULL))))
hr = (dwFlags & dwTest) ? S_OK : S_FALSE;
pacdd->Release();
}
return hr;
}
inline HWND _IndexServiceHelp(HWND hwnd)
{
return ::HtmlHelp(hwnd, TEXT("isconcepts.chm"), HH_DISPLAY_TOPIC, 0);
}
LRESULT CSubDlg::OnNcCalcsize(UINT, WPARAM wParam, LPARAM lParam, BOOL& bHandled)
{
InflateRect((LPRECT)lParam, -SUBDLG_BORDERWIDTH, -SUBDLG_BORDERWIDTH);
return 0;
}
LRESULT CSubDlg::OnNcPaint(UINT, WPARAM wParam, LPARAM lParam, BOOL&)
{
RECT rc;
HDC hdc;
HBRUSH hbr = _pfsb->GetMetrics().BorderBrush();
GetWindowRect(Hwnd(), &rc);
OffsetRect(&rc, -rc.left, -rc.top);
if (hbr && (hdc = GetWindowDC(Hwnd())) != NULL)
{
for (int i=0; i < SUBDLG_BORDERWIDTH; i++)
{
FrameRect(hdc, &rc, hbr);
InflateRect(&rc, -1, -1);
}
ReleaseDC(Hwnd(), hdc);
}
return 0;
}
LRESULT CSubDlg::OnCtlColor(UINT, WPARAM wParam, LPARAM, BOOL&)
{
SetTextColor((HDC)wParam, _pfsb->GetMetrics().TextColor());
SetBkColor((HDC)wParam, _pfsb->GetMetrics().BkgndColor());
return (LRESULT)_pfsb->GetMetrics().BkgndBrush();
}
LRESULT CSubDlg::OnPaint(UINT, WPARAM, LPARAM, BOOL&)
{
// Just going to call BeginPaint and EndPaint. All
// painting done in WM_ERASEBKGND handler to avoid flicker.
PAINTSTRUCT ps;
HDC hdc = BeginPaint(_hwnd, &ps);
if (hdc)
{
EndPaint(_hwnd, &ps);
}
return 0;
}
LRESULT CSubDlg::OnSize(UINT, WPARAM, LPARAM, BOOL&)
{
ASSERT(::IsWindow(Hwnd())); // was _Attach() called, e.g. from WM_INITDIALOG?
_PaintDlg(Hwnd(), _pfsb->GetMetrics());
ValidateRect(Hwnd(), NULL);
return 0;
}
LRESULT CSubDlg::OnEraseBkgnd(UINT, WPARAM wParam, LPARAM, BOOL&)
{
_PaintDlg(Hwnd(), _pfsb->GetMetrics(), (HDC)wParam);
ValidateRect(Hwnd(), NULL);
return TRUE;
}
STDMETHODIMP CSubDlg::TranslateAccelerator(MSG *pmsg)
{
if (_pfsb->IsKeyboardScroll(pmsg))
return S_OK;
return _pfsb->IsDlgMessage(Hwnd(), pmsg);
}
LRESULT CSubDlg::OnChildSetFocusCmd(WORD wNotifyCode, WORD wID, HWND hwndCtl, BOOL& bHandled)
{
_EnsureVisible(_hwnd, hwndCtl, _pfsb);
bHandled = FALSE;
return 0;
}
LRESULT CSubDlg::OnChildSetFocusNotify(int, NMHDR *pnmh, BOOL& bHandled)
{
_EnsureVisible(_hwnd, pnmh->hwndFrom, _pfsb);
bHandled = FALSE;
return 0;
}
LRESULT CSubDlg::OnChildKillFocusCmd(WORD, WORD, HWND hwndCtl, BOOL&)
{
if (_pBandDlg)
_pBandDlg->RememberFocus(hwndCtl);
return 0;
}
LRESULT CSubDlg::OnChildKillFocusNotify(int, NMHDR *pnmh, BOOL&)
{
if (_pBandDlg)
_pBandDlg->RememberFocus(pnmh->hwndFrom);
return 0;
}
LRESULT CSubDlg::OnComboExEndEdit(int, NMHDR *pnmh, BOOL&)
{
if (CBENF_KILLFOCUS == ((NMCBEENDEDIT*)pnmh)->iWhy)
{
if (_pBandDlg)
_pBandDlg->RememberFocus(pnmh->hwndFrom);
}
return 0;
}
// CDateDlg impl
#define RECENTMONTHSRANGE_HIGH 999
#define RECENTDAYSRANGE_HIGH RECENTMONTHSRANGE_HIGH
#define RECENTMONTHSRANGE_HIGH_LEN 3 // count of digits in RECENTMONTHSRANGE_HIGH
#define RECENTDAYSRANGE_HIGH_LEN RECENTMONTHSRANGE_HIGH_LEN
#define RECENTMONTHSRANGE_LOW 1
#define RECENTDAYSRANGE_LOW RECENTMONTHSRANGE_LOW
LRESULT CDateDlg::OnInitDialog(UINT uMsg, WPARAM wParam, LPARAM lParam, BOOL& bHandled)
{
ASSERT(_pfsb);
_Attach(m_hWnd);
HWND hwndCombo = GetDlgItem(IDC_WHICH_DATE);
SendDlgItemMessage(IDC_RECENT_MONTHS_SPIN, UDM_SETRANGE32,
RECENTMONTHSRANGE_HIGH, RECENTMONTHSRANGE_LOW);
SendDlgItemMessage(IDC_RECENT_DAYS_SPIN, UDM_SETRANGE32,
RECENTDAYSRANGE_HIGH, RECENTDAYSRANGE_LOW);
SendDlgItemMessage(IDC_RECENT_MONTHS, EM_LIMITTEXT, RECENTMONTHSRANGE_HIGH_LEN, 0);
SendDlgItemMessage(IDC_RECENT_DAYS, EM_LIMITTEXT, RECENTDAYSRANGE_HIGH_LEN, 0);
SYSTEMTIME st[2] = {0};
// lower limit -- dos date does not support anything before 1/1/1980
st[0].wYear = 1980;
st[0].wMonth = 1;
st[0].wDay = 1;
// upper limit
st[1].wYear = 2099;
st[1].wMonth = 12;
st[1].wDay = 31;
SendDlgItemMessage(IDC_DATERANGE_BEGIN, DTM_SETRANGE, GDTR_MIN | GDTR_MAX, (LPARAM)st);
SendDlgItemMessage(IDC_DATERANGE_END, DTM_SETRANGE, GDTR_MIN | GDTR_MAX, (LPARAM)st);
_LoadStringToCombo(hwndCombo, -1, IDS_FSEARCH_MODIFIED_DATE, IDS_FSEARCH_MODIFIED_DATE);
_LoadStringToCombo(hwndCombo, -1, IDS_FSEARCH_CREATION_DATE, IDS_FSEARCH_CREATION_DATE);
_LoadStringToCombo(hwndCombo, -1, IDS_FSEARCH_ACCESSED_DATE, IDS_FSEARCH_ACCESSED_DATE);
Clear();
return TRUE; // Let the system set the focus
}
BOOL CDateDlg::Validate()
{
return TRUE;
}
STDMETHODIMP CDateDlg::AddConstraints(ISearchCommandExt* pSrchCmd)
{
VARIANT var;
BOOL bErr;
UINT_PTR nIDString = _GetComboData(GetDlgItem(IDC_WHICH_DATE));
HRESULT hr;
#if 1
hr = InitVariantFromStr(&var,
(IDS_FSEARCH_MODIFIED_DATE == nIDString) ? L"Write" :
(IDS_FSEARCH_CREATION_DATE == nIDString) ? L"Create" : L"Access");
#else
var.vt = VT_UI4;
var.ulVal = (IDS_FSEARCH_MODIFIED_DATE == nIDString) ? 1 :
(IDS_FSEARCH_CREATION_DATE == nIDString) ? 2 :
(IDS_FSEARCH_ACCESSED_DATE == nIDString) ? 3 : 0;
hr = S_OK;
ASSERT(var.ulVal);
#endif
if (SUCCEEDED(hr))
{
hr = _AddConstraint(pSrchCmd, L"WhichDate", &var);
VariantClear(&var);
}
if (IsDlgButtonChecked(IDC_USE_RECENT_MONTHS))
{
var.vt = VT_I4;
var.ulVal = (ULONG)SendDlgItemMessage(IDC_RECENT_MONTHS_SPIN, UDM_GETPOS32, 0, (LPARAM)&bErr);
if (!bErr)
hr = _AddConstraint(pSrchCmd, L"DateNMonths", &var);
}
else if (IsDlgButtonChecked(IDC_USE_RECENT_DAYS))
{
var.vt = VT_I4;
var.ulVal = (ULONG)SendDlgItemMessage(IDC_RECENT_DAYS_SPIN, UDM_GETPOS32, 0, (LPARAM)&bErr);
if (!bErr)
hr = _AddConstraint(pSrchCmd, L"DateNDays", &var);
}
else if (IsDlgButtonChecked(IDC_USE_DATE_RANGE))
{
SYSTEMTIME stBegin, stEnd;
var.vt = VT_DATE;
LRESULT lRetBegin = SendDlgItemMessage(IDC_DATERANGE_BEGIN, DTM_GETSYSTEMTIME, 0, (LPARAM)&stBegin);
LRESULT lRetEnd = SendDlgItemMessage(IDC_DATERANGE_END, DTM_GETSYSTEMTIME, 0, (LPARAM)&stEnd);
if (GDT_VALID == lRetBegin && GDT_VALID == lRetEnd)
{
#ifdef DEBUG
FILETIME ft;
//validate that we were passed a correct date
//SystemTimeToFileTime calls internal API IsValidSystemTime.
//This will save us from OLE Automation bug# 322789
// the only way we can get a date is through date/time picker
// control which should validate the dates so just assert...
ASSERT(SystemTimeToFileTime(&stBegin, &ft));
#endif
SystemTimeToVariantTime(&stBegin, &var.date);
hr = _AddConstraint(pSrchCmd, L"DateGE", &var);
#ifdef DEBUG
ASSERT(SystemTimeToFileTime(&stEnd, &ft));
#endif
SystemTimeToVariantTime(&stEnd, &var.date);
hr = _AddConstraint(pSrchCmd, L"DateLE", &var);
}
}
return hr;
}
// S_FALSE: constraint restored to UI. S_OK: subdialog should be opened.
// E_FAIL: constraint must be for some other subdlg.
STDMETHODIMP CDateDlg::RestoreConstraint(const BSTR bstrName, const VARIANT* pValue)
{
HRESULT hr = E_FAIL;
BOOL bUseMonths = FALSE,
bUseDays = FALSE,
bUseRange = FALSE;
if (IsConstraintName(L"WhichDate", bstrName))
{
ASSERT(VT_I4 == pValue->vt)
UINT nIDS = pValue->lVal == 1 ? IDS_FSEARCH_MODIFIED_DATE :
pValue->lVal == 2 ? IDS_FSEARCH_CREATION_DATE :
pValue->lVal == 3 ? IDS_FSEARCH_ACCESSED_DATE : 0;
if (nIDS != 0)
_SelectComboData(GetDlgItem(IDC_WHICH_DATE), nIDS);
return nIDS == IDS_FSEARCH_MODIFIED_DATE /*default*/ ?
S_FALSE /* don't open */: S_OK /* open */;
}
if (IsConstraintName(L"DateNMonths", bstrName))
{
ASSERT(VT_I4 == pValue->vt);
bUseMonths = TRUE;
_SetWindowValue(m_hWnd, IDC_RECENT_MONTHS, pValue);
hr = S_OK;
}
else if (IsConstraintName(L"DateNDays", bstrName))
{
ASSERT(VT_I4 == pValue->vt);
bUseDays = TRUE;
_SetWindowValue(m_hWnd, IDC_RECENT_DAYS, pValue);
hr = S_OK;
}
else if (IsConstraintName(L"DateGE", bstrName))
{
ASSERT(VT_DATE == pValue->vt);
bUseRange = TRUE;
SYSTEMTIME st;
VariantTimeToSystemTime(pValue->date, &st);
SendDlgItemMessage(IDC_DATERANGE_BEGIN, DTM_SETSYSTEMTIME, 0, (LPARAM)&st);
hr = S_OK;
}
else if (IsConstraintName(L"DateLE", bstrName))
{
ASSERT(VT_DATE == pValue->vt);
bUseRange = TRUE;
SYSTEMTIME st;
VariantTimeToSystemTime(pValue->date, &st);
SendDlgItemMessage(IDC_DATERANGE_END, DTM_SETSYSTEMTIME, 0, (LPARAM)&st);
hr = S_OK;
}
if (S_OK == hr)
{
CheckDlgButton(IDC_USE_RECENT_MONTHS, bUseMonths);
CheckDlgButton(IDC_USE_RECENT_DAYS, bUseDays);
CheckDlgButton(IDC_USE_DATE_RANGE, bUseRange);
EnableControls();
}
return hr;
}
void CDateDlg::Clear()
{
SendDlgItemMessage(IDC_WHICH_DATE, CB_SETCURSEL, 0, 0);
CheckDlgButton(IDC_USE_RECENT_MONTHS, 0);
SetDlgItemInt(IDC_RECENT_MONTHS, 1, FALSE);
CheckDlgButton(IDC_USE_RECENT_DAYS, 0);
SetDlgItemInt(IDC_RECENT_DAYS, 1, FALSE);
CheckDlgButton(IDC_USE_DATE_RANGE, 1);
SYSTEMTIME stNow, stPrev;
GetLocalTime(&stNow);
SendDlgItemMessage(IDC_DATERANGE_END, DTM_SETSYSTEMTIME, 0, (LPARAM)&stNow);
// Subtract 90 days from current date and stuff in date low range
_CalcDateOffset(&stNow, 0, -1 /* 1 month ago */, &stPrev);
SendDlgItemMessage(IDC_DATERANGE_BEGIN, DTM_SETSYSTEMTIME, 0, (LPARAM)&stPrev);
EnableControls();
}
LRESULT CDateDlg::OnSize(UINT, WPARAM wParam, LPARAM lParam, BOOL&)
{
POINTS pts = MAKEPOINTS(lParam);
_PaintDlg(m_hWnd, _pfsb->GetMetrics());
ValidateRect(NULL);
RECT rc;
HWND hwndCtl = GetDlgItem(IDC_WHICH_DATE);
ASSERT(hwndCtl);
::GetWindowRect(hwndCtl, &rc);
::MapWindowRect(NULL, m_hWnd, &rc);
rc.right = pts.x - _pfsb->GetMetrics().CtlMarginX();
::SetWindowPos(GetDlgItem(IDC_WHICH_DATE), NULL, 0, 0,
RECTWIDTH(rc), RECTHEIGHT(rc),
SWP_NOMOVE|SWP_NOZORDER|SWP_NOACTIVATE);
return 0;
}
LRESULT CDateDlg::OnMonthDaySpin(int nIDSpin, NMHDR *pnmh, BOOL& bHandled)
{
LPNMUPDOWN pud = (LPNMUPDOWN)pnmh;
pud->iDelta *= -1; // increments of 1 month/day
return 0;
}
LRESULT CDateDlg::OnBtnClick(WORD nCode, WORD nID, HWND hwndCtl, BOOL&)
{
EnableControls();
return 0;
}
LRESULT CDateDlg::OnMonthsKillFocus(WORD nCode, WORD nID, HWND hwndCtl, BOOL&)
{
_EnforceNumericEditRange(m_hWnd, IDC_RECENT_MONTHS, IDC_RECENT_MONTHS_SPIN,
RECENTMONTHSRANGE_LOW, RECENTMONTHSRANGE_HIGH);
return 0;
}
LRESULT CDateDlg::OnDaysKillFocus(WORD nCode, WORD nID, HWND hwndCtl, BOOL&)
{
_EnforceNumericEditRange(m_hWnd, IDC_RECENT_DAYS, IDC_RECENT_DAYS_SPIN,
RECENTDAYSRANGE_LOW, RECENTDAYSRANGE_HIGH);
return 0;
}
void CDateDlg::EnableControls()
{
UINT nSel = IsDlgButtonChecked(IDC_USE_RECENT_MONTHS) ? IDC_USE_RECENT_MONTHS :
IsDlgButtonChecked(IDC_USE_RECENT_DAYS) ? IDC_USE_RECENT_DAYS :
IsDlgButtonChecked(IDC_USE_DATE_RANGE) ? IDC_USE_DATE_RANGE : 0;
::EnableWindow(GetDlgItem(IDC_RECENT_MONTHS), IDC_USE_RECENT_MONTHS == nSel);
::EnableWindow(GetDlgItem(IDC_RECENT_MONTHS_SPIN), IDC_USE_RECENT_MONTHS == nSel);
::EnableWindow(GetDlgItem(IDC_RECENT_DAYS), IDC_USE_RECENT_DAYS == nSel);
::EnableWindow(GetDlgItem(IDC_RECENT_DAYS_SPIN), IDC_USE_RECENT_DAYS == nSel);
::EnableWindow(GetDlgItem(IDC_DATERANGE_BEGIN), IDC_USE_DATE_RANGE == nSel);
::EnableWindow(GetDlgItem(IDC_DATERANGE_END), IDC_USE_DATE_RANGE == nSel);
}
// CSizeDlg impl
#define FILESIZERANGE_LOW 0
#define FILESIZERANGE_HIGH 99999999
#define FILESIZERANGE_HIGH_LEN 8 // count of digits in FILESIZERANGE_HIGH
LRESULT CSizeDlg::OnInitDialog(UINT uMsg, WPARAM wParam, LPARAM lParam, BOOL& bHandled)
{
_Attach(m_hWnd);
HWND hwndCombo = GetDlgItem(IDC_WHICH_SIZE);
SendDlgItemMessage(IDC_FILESIZE_SPIN, UDM_SETRANGE32,
FILESIZERANGE_HIGH, FILESIZERANGE_LOW /*Kb*/);
SendDlgItemMessage(IDC_FILESIZE, EM_LIMITTEXT, FILESIZERANGE_HIGH_LEN, 0);
_LoadStringToCombo(hwndCombo, -1,
IDS_FSEARCH_SIZE_GREATEREQUAL,
IDS_FSEARCH_SIZE_GREATEREQUAL);
_LoadStringToCombo(hwndCombo, -1,
IDS_FSEARCH_SIZE_LESSEREQUAL,
IDS_FSEARCH_SIZE_LESSEREQUAL);
Clear();
return TRUE; // Let the system set the focus
}
STDMETHODIMP CSizeDlg::AddConstraints(ISearchCommandExt* pSrchCmd)
{
VARIANT var;
BOOL bErr = FALSE;
HRESULT hr = S_FALSE;
UINT_PTR nIDString = _GetComboData(GetDlgItem(IDC_WHICH_SIZE));
var.vt = VT_UI4;
var.ulVal = (ULONG)SendDlgItemMessage(IDC_FILESIZE_SPIN, UDM_GETPOS32, 0, (LPARAM)&bErr);
if (!bErr)
{
var.ulVal *= 1024; // KB to bytes.
LPCWSTR pwszConstraint = (IDS_FSEARCH_SIZE_GREATEREQUAL == nIDString) ?
L"SizeGE" :
(IDS_FSEARCH_SIZE_LESSEREQUAL == nIDString) ?
L"SizeLE" : NULL;
if (pwszConstraint)
hr = _AddConstraint(pSrchCmd, pwszConstraint, &var);
}
return hr;
}
// S_FALSE: constraint restored to UI. S_OK: subdialog should be opened.
// E_FAIL: constraint must be for some other subdlg.
STDMETHODIMP CSizeDlg::RestoreConstraint(const BSTR bstrName, const VARIANT* pValue)
{
HRESULT hr = E_FAIL;
UINT nID = 0;
if (IsConstraintName(L"SizeGE", bstrName))
{
nID = IDS_FSEARCH_SIZE_GREATEREQUAL;
hr = S_OK;
}
else if (IsConstraintName(L"SizeLE", bstrName))
{
nID = IDS_FSEARCH_SIZE_LESSEREQUAL;
hr = S_OK;
}
if (S_OK == hr)
{
ASSERT(VT_UI4 == pValue->vt);
ULONG ulSize = pValue->ulVal/1024; // convert bytes to KB
SetDlgItemInt(IDC_FILESIZE, ulSize, FALSE);
ASSERT(nID != 0);
_SelectComboData(GetDlgItem(IDC_WHICH_SIZE), nID);
}
return hr;
}
void CSizeDlg::Clear()
{
SendDlgItemMessage(IDC_WHICH_SIZE, CB_SETCURSEL, 0, 0);
SetDlgItemInt(IDC_FILESIZE, 0, FALSE);
}
LRESULT CSizeDlg::OnSizeSpin(int nIDSpin, NMHDR *pnmh, BOOL& bHandled)
{
LPNMUPDOWN pud = (LPNMUPDOWN)pnmh;
pud->iDelta *= -10; // increments of 10KB
return 0;
}
LRESULT CSizeDlg::OnSizeKillFocus(WORD nCode, WORD nID, HWND hwndCtl, BOOL&)
{
_EnforceNumericEditRange(m_hWnd, IDC_FILESIZE, IDC_FILESIZE_SPIN,
FILESIZERANGE_LOW, FILESIZERANGE_HIGH);
return 0;
}
CTypeDlg::CTypeDlg(CFileSearchBand* pfsb) : CSubDlg(pfsb)
{
*_szRestoredExt = 0;
}
CTypeDlg::~CTypeDlg()
{
}
LRESULT CTypeDlg::OnInitDialog(UINT uMsg, WPARAM wParam, LPARAM lParam, BOOL& bHandled)
{
HWND hwndCombo = GetDlgItem(IDC_FILE_TYPE);
HIMAGELIST hil = GetSystemImageListSmallIcons();
_Attach(m_hWnd);
::SendMessage(hwndCombo, CBEM_SETEXTENDEDSTYLE,
CBES_EX_NOSIZELIMIT | CBES_EX_CASESENSITIVE,
CBES_EX_NOSIZELIMIT | CBES_EX_CASESENSITIVE);
::SendMessage(hwndCombo, CBEM_SETIMAGELIST, 0, (LPARAM)hil);
::SendMessage(hwndCombo, CBEM_SETEXSTYLE, 0, 0);
return TRUE; // Let the system set the focus
}
STDMETHODIMP CTypeDlg::AddConstraints(ISearchCommandExt* pSrchCmd)
{
LPTSTR pszText;
HRESULT hr = S_FALSE;
if (GetFileAssocComboSelItemText(GetDlgItem(IDC_FILE_TYPE), &pszText) >= 0 && pszText)
{
VARIANT var = {0};
if (*pszText &&
SUCCEEDED(InitVariantFromStr(&var, pszText)) &&
SUCCEEDED(_AddConstraint(pSrchCmd, L"FileType", &var)))
{
hr = S_OK;
}
VariantClear(&var);
LocalFree((HLOCAL)pszText);
}
return hr;
}
// S_FALSE: constraint restored to UI. S_OK: subdialog should be opened.
// E_FAIL: constraint must be for some other subdlg.
STDMETHODIMP CTypeDlg::RestoreConstraint(const BSTR bstrName, const VARIANT* pValue)
{
if (IsConstraintName(L"FileType", bstrName))
{
ASSERT(VT_BSTR == pValue->vt);
USES_CONVERSION;
lstrcpyn(_szRestoredExt, W2T(pValue->bstrVal), ARRAYSIZE(_szRestoredExt));
INT_PTR i = _FindExtension(GetDlgItem(IDC_FILE_TYPE), _szRestoredExt);
if (i != CB_ERR)
{
SendDlgItemMessage(IDC_FILE_TYPE, CB_SETCURSEL, i, 0);
*_szRestoredExt = 0;
}
return S_OK;
}
return E_FAIL;
}
INT_PTR CTypeDlg::_FindExtension(HWND hwndCombo, TCHAR* pszExt)
{
INT_PTR i, cnt = ::SendMessage(hwndCombo, CB_GETCOUNT, 0, 0);
LPTSTR pszData;
BOOL bAllFileTypes = pszExt && (lstrcmp(TEXT("*.*"), pszExt) == 0);
TCHAR szExt[MAX_PATH];
if (!bAllFileTypes)
{
// Remove wildcard characters.
LPTSTR pszSrc = pszExt, pszDest = szExt;
for (;; pszSrc = CharNext(pszSrc))
{
if (TEXT('*') == *pszSrc)
pszSrc = CharNext(pszSrc);
if ((*(pszDest++) = *pszSrc) == 0)
break;
}
pszExt = szExt;
}
if (pszExt && (bAllFileTypes || *pszExt))
{
for (i = 0; i < cnt; i++)
{
pszData = (LPTSTR)::SendMessage(hwndCombo, CB_GETITEMDATA, i, 0);
if (bAllFileTypes && (FILEASSOCIATIONSID_ALLFILETYPES == (UINT_PTR)pszData))
return i;
if (pszData != (LPTSTR)FILEASSOCIATIONSID_ALLFILETYPES &&
pszData != (LPTSTR)CB_ERR &&
pszData != NULL)
{
if (0 == StrCmpI(pszExt, pszData))
return i;
}
}
}
return CB_ERR;
}
void CTypeDlg::Clear()
{
// Assign combo selection to 'all file types':
HWND hwndCombo = GetDlgItem(IDC_FILE_TYPE);
for (INT_PTR i = 0, cnt = ::SendMessage(hwndCombo, CB_GETCOUNT, 0, 0); i < cnt; i++)
{
if (FILEASSOCIATIONSID_ALLFILETYPES == _GetComboData(hwndCombo, i))
{
::SendMessage(hwndCombo, CB_SETCURSEL, i, 0);
break;
}
}
_szRestoredExt[0] = 0;
}
LRESULT CTypeDlg::OnFileTypeDeleteItem(int idCtrl, NMHDR *pnmh, BOOL& bHandled)
{
return DeleteFileAssocComboItem(pnmh);
}
LRESULT CTypeDlg::OnSize(UINT, WPARAM wParam, LPARAM lParam, BOOL&)
{
POINTS pts = MAKEPOINTS(lParam);
_PaintDlg(m_hWnd, _pfsb->GetMetrics());
ValidateRect(NULL);
RECT rc;
HWND hwndCtl = GetDlgItem(IDC_FILE_TYPE);
ASSERT(hwndCtl);
::GetWindowRect(hwndCtl, &rc);
::MapWindowRect(NULL, m_hWnd, &rc);
rc.right = pts.x - _pfsb->GetMetrics().CtlMarginX();
::SetWindowPos(hwndCtl, NULL, 0, 0,
RECTWIDTH(rc), RECTHEIGHT(rc),
SWP_NOMOVE|SWP_NOZORDER|SWP_NOACTIVATE);
return 0;
}
DWORD CTypeDlg::FileAssocThreadProc(void* pv)
{
FSEARCHTHREADSTATE *pState = (FSEARCHTHREADSTATE *)pv;
CTypeDlg* pThis = (CTypeDlg*)pState->pvParam;
if (PopulateFileAssocCombo(pState->hwndCtl, AddItemNotify, (LPARAM)pv) != E_ABORT)
{
::PostMessage(::GetParent(pState->hwndCtl), WMU_COMBOPOPULATIONCOMPLETE, (WPARAM)pState->hwndCtl, 0);
}
pState->fComplete = TRUE;
ATOMICRELEASE(pState->punkBand);
return 0;
}
HRESULT CTypeDlg::AddItemNotify(ULONG fAction, PCBXITEM pItem, LPARAM lParam)
{
FSEARCHTHREADSTATE *pState = (FSEARCHTHREADSTATE *)lParam;
ASSERT(pState);
ASSERT(pState->hwndCtl);
// Do we want to abort combo population thread?
if (fAction & CBXCB_ADDING && pState->fCancel)
return E_ABORT;
// Set the current selection to 'all file types'
if (fAction & CBXCB_ADDED)
{
BOOL bAllTypesItem = (FILEASSOCIATIONSID_ALLFILETYPES == pItem->lParam);
CTypeDlg* pThis = (CTypeDlg*)pState->pvParam;
ASSERT(pThis);
// If this item is the one restored from a saved query
// override any current selection and select it.
if (*pThis->_szRestoredExt && !bAllTypesItem && pItem->lParam &&
0 == lstrcmpi((LPCTSTR)pItem->lParam, pThis->_szRestoredExt))
{
::SendMessage(pState->hwndCtl, CB_SETCURSEL, pItem->iItem, 0);
*pThis->_szRestoredExt = 0;
}
// If this item is the default ('all file types') and
// nothing else is selected, select it.
else if (bAllTypesItem)
{
if (CB_ERR == ::SendMessage(pState->hwndCtl, CB_GETCURSEL, 0, 0))
::SendMessage(pState->hwndCtl, CB_SETCURSEL, pItem->iItem, 0);
}
}
return S_OK;
}
LRESULT CTypeDlg::OnComboPopulationComplete(UINT, WPARAM, LPARAM, BOOL&)
{
// remove briefcase from type combo because briefcases no longer use this
// extension (now they store clsid in desktop.ini
INT_PTR iBfc = _FindExtension(GetDlgItem(IDC_FILE_TYPE), TEXT(".bfc"));
if (iBfc != CB_ERR)
{
SendDlgItemMessage(IDC_FILE_TYPE, CB_DELETESTRING, (WPARAM)iBfc, 0);
}
if (*_szRestoredExt)
{
INT_PTR iSel = _FindExtension(GetDlgItem(IDC_FILE_TYPE), _szRestoredExt);
if (iSel != CB_ERR)
{
SendDlgItemMessage(IDC_FILE_TYPE, CB_SETCURSEL, (WPARAM)iSel, 0);
*_szRestoredExt = 0;
}
}
return 0;
}
// Called when we are finished doing all the work to display the search band.
// We then launch the thread to populate the file type drop down. By delaying this
// until now, we can speed up the band loading.
// No return becuase it's called async.
void CTypeDlg::DoDelayedInit()
{
// Launch thread to populate the file types combo.
_threadState.hwndCtl = GetDlgItem(IDC_FILE_TYPE);
_threadState.pvParam = this;
_threadState.fComplete = FALSE;
_threadState.fCancel = FALSE;
if (SUCCEEDED(SAFECAST(_pfsb, IFileSearchBand*)->QueryInterface(IID_PPV_ARG(IUnknown, &_threadState.punkBand))))
{
if (!SHCreateThread(FileAssocThreadProc, &_threadState, CTF_COINIT, NULL))
{
ATOMICRELEASE(_threadState.punkBand);
}
}
}
LRESULT CTypeDlg::OnDestroy(UINT, WPARAM, LPARAM, BOOL& bHandled)
{
_threadState.fCancel = TRUE;
bHandled = FALSE;
return 0;
}
void CTypeDlg::OnWinIniChange()
{
SendDlgItemMessage(IDC_FILE_TYPE, CB_SETDROPPEDWIDTH,
_PixelsForDbu(m_hWnd, MIN_FILEASSOCLIST_WIDTH, TRUE), 0);
}
LRESULT CAdvancedDlg::OnInitDialog(UINT uMsg, WPARAM wParam, LPARAM lParam, BOOL& bHandled)
{
_Attach(m_hWnd);
Clear();
return TRUE; // Let the system set the focus
}
HRESULT AddButtonConstraintPersist(ISearchCommandExt* pSrchCmd, LPCWSTR pszConstraint, HWND hwndButton)
{
BOOL bValue = SendMessage(hwndButton, BM_GETCHECK, 0, 0) == BST_CHECKED;
SHRegSetUSValue(TEXT("Software\\Microsoft\\Windows\\CurrentVersion\\Explorer"), pszConstraint,
REG_DWORD, &bValue, sizeof(bValue), SHREGSET_HKCU | SHREGSET_FORCE_HKCU);
VARIANT var = {0};
var.vt = VT_BOOL;
var.boolVal = bValue ? VARIANT_TRUE : 0;
return _AddConstraint(pSrchCmd, pszConstraint, &var);
}
STDMETHODIMP CAdvancedDlg::AddConstraints(ISearchCommandExt* pSrchCmd)
{
AddButtonConstraintPersist(pSrchCmd, L"SearchSystemDirs", GetDlgItem(IDC_USE_SYSTEMDIRS));
AddButtonConstraintPersist(pSrchCmd, L"SearchHidden", GetDlgItem(IDC_SEARCH_HIDDEN));
AddButtonConstraintPersist(pSrchCmd, L"IncludeSubFolders", GetDlgItem(IDC_USE_SUBFOLDERS));
AddButtonConstraintPersist(pSrchCmd, L"CaseSensitive", GetDlgItem(IDC_USE_CASE));
AddButtonConstraintPersist(pSrchCmd, L"SearchSlowFiles", GetDlgItem(IDC_USE_SLOW_FILES));
return S_OK;
}
// S_FALSE: constraint restored to UI. S_OK: subdialog should be opened.
// E_FAIL: constraint must be for some other subdlg.
STDMETHODIMP CAdvancedDlg::RestoreConstraint(const BSTR bstrName, const VARIANT* pValue)
{
if (IsConstraintName(L"IncludeSubFolders", bstrName))
{
ASSERT(VT_BOOL == pValue->vt || VT_I4 == pValue->vt);
CheckDlgButton(IDC_USE_SUBFOLDERS, pValue->lVal);
return S_FALSE; // this is a default. don't force open the subdialog.
}
if (IsConstraintName(L"CaseSensitive", bstrName))
{
ASSERT(VT_BOOL == pValue->vt || VT_I4 == pValue->vt);
CheckDlgButton(IDC_USE_CASE, pValue->lVal);
return pValue->lVal ? S_OK : S_FALSE;
}
if (IsConstraintName(L"SearchSlowFiles", bstrName))
{
ASSERT(VT_BOOL == pValue->vt || VT_I4 == pValue->vt);
CheckDlgButton(IDC_USE_SLOW_FILES, pValue->lVal);
return pValue->lVal ? S_OK : S_FALSE;
}
if (IsConstraintName(L"SearchSystemDirs", bstrName))
{
ASSERT(VT_BOOL == pValue->vt || VT_I4 == pValue->vt || VT_UI4 == pValue->vt);
CheckDlgButton(IDC_USE_SYSTEMDIRS, pValue->lVal);
return pValue->lVal ? S_OK : S_FALSE;
}
if (IsConstraintName(L"SearchHidden", bstrName))
{
ASSERT(VT_BOOL == pValue->vt || VT_I4 == pValue->vt || VT_UI4 == pValue->vt);
CheckDlgButton(IDC_SEARCH_HIDDEN, pValue->lVal);
return pValue->lVal ? S_OK : S_FALSE;
}
return E_FAIL;
}
void CheckDlgButtonPersist(HWND hdlg, UINT id, LPCTSTR pszOption, BOOL bDefault)
{
BOOL bValue = SHRegGetBoolUSValue(TEXT("Software\\Microsoft\\Windows\\CurrentVersion\\Explorer"), pszOption, FALSE, bDefault);
CheckDlgButton(hdlg, id, bValue);
}
void CAdvancedDlg::Clear()
{
CheckDlgButtonPersist(m_hWnd, IDC_USE_SYSTEMDIRS, L"SearchSystemDirs", IsOS(OS_ANYSERVER));
CheckDlgButtonPersist(m_hWnd, IDC_SEARCH_HIDDEN, L"SearchHidden", FALSE);
CheckDlgButtonPersist(m_hWnd, IDC_USE_SUBFOLDERS, L"IncludeSubFolders", TRUE);
CheckDlgButtonPersist(m_hWnd, IDC_USE_CASE, L"CaseSensitive", FALSE);
CheckDlgButtonPersist(m_hWnd, IDC_USE_SLOW_FILES, L"SearchSlowFiles", FALSE);
}
COptionsDlg::COptionsDlg(CFileSearchBand* pfsb)
: CSubDlg(pfsb),
_dlgDate(pfsb),
_dlgSize(pfsb),
_dlgType(pfsb),
_dlgAdvanced(pfsb)
{
// Verify that it initialized to 0's
ASSERT(0 == _nCIStatusText);
ZeroMemory(_subdlgs, sizeof(_subdlgs));
#define SUBDLG_ENTRY(idx, idCheck, dlg) \
{ _subdlgs[idx].nIDCheck = idCheck; _subdlgs[idx].pDlg = &dlg; }
SUBDLG_ENTRY(SUBDLG_DATE, IDC_USE_DATE, _dlgDate);
SUBDLG_ENTRY(SUBDLG_TYPE, IDC_USE_TYPE, _dlgType);
SUBDLG_ENTRY(SUBDLG_SIZE, IDC_USE_SIZE, _dlgSize);
SUBDLG_ENTRY(SUBDLG_ADVANCED, IDC_USE_ADVANCED, _dlgAdvanced);
}
LRESULT COptionsDlg::OnInitDialog(UINT uMsg, WPARAM wParam, LPARAM lParam, BOOL&)
{
_Attach(m_hWnd);
_dlgDate.SetBandDlg(_pBandDlg);
_dlgSize.SetBandDlg(_pBandDlg);
_dlgType.SetBandDlg(_pBandDlg);
_dlgAdvanced.SetBandDlg(_pBandDlg);
// Gather some metrics from the fresh dialog template...
CMetrics& metrics = _pfsb->GetMetrics();
RECT rc[3] = {0};
ASSERT(::IsWindow(GetDlgItem(IDC_USE_DATE)));
ASSERT(::IsWindow(GetDlgItem(IDC_USE_TYPE)));
ASSERT(::IsWindow(GetDlgItem(IDC_USE_ADVANCED)));
::GetWindowRect(GetDlgItem(IDC_USE_DATE), rc + 0);
::GetWindowRect(GetDlgItem(IDC_USE_TYPE), rc + 1);
::GetWindowRect(GetDlgItem(IDC_USE_ADVANCED), rc + 2);
for (int i = 0; i < ARRAYSIZE(rc); i++)
{
// MapWindowPoints is mirroring aware only if you pass two points
::MapWindowRect(NULL, m_hWnd, &rc[i]);
}
metrics.ExpandOrigin().y = rc[0].top;
metrics.CheckBoxRect() = rc[2];
OffsetRect(&metrics.CheckBoxRect(), -rc[0].left, -rc[0].top);
// Create subdialogs and collect native sizes.
if (_dlgDate.Create(m_hWnd))
_GetWindowSize(_dlgDate, &_subdlgs[SUBDLG_DATE].sizeDlg);
if (_dlgSize.Create(m_hWnd))
_GetWindowSize(_dlgSize, &_subdlgs[SUBDLG_SIZE].sizeDlg);
if (_dlgType.Create(m_hWnd))
_GetWindowSize(_dlgType, &_subdlgs[SUBDLG_TYPE].sizeDlg);
if (_dlgAdvanced.Create(m_hWnd))
_GetWindowSize(_dlgAdvanced, &_subdlgs[SUBDLG_ADVANCED].sizeDlg);
// Create index server link window
POINT pt = {0};
HWND hwndCI = _CreateLinkWindow(m_hWnd, IDC_INDEX_SERVER,
pt, IDS_FSEARCH_CI_DISABLED_LINK);
UpdateSearchCmdStateUI();
// Layout controls
LayoutControls();
return TRUE;
}
void COptionsDlg::OnWinIniChange()
{
CSubDlg::OnWinIniChange();
for (int i = 0; i < ARRAYSIZE(_subdlgs); i++)
_subdlgs[i].pDlg->OnWinIniChange();
}
BOOL _SaveCheck(HWND hwnd, UINT nIDCheck, HKEY hkey, LPCTSTR pszValue)
{
DWORD dwData = IsDlgButtonChecked(hwnd, nIDCheck);
return ERROR_SUCCESS == RegSetValueEx(hkey, pszValue, 0, REG_DWORD, (LPBYTE)&dwData, sizeof(dwData));
}
BOOL _LoadCheck(HWND hwnd, UINT nIDCheck, HKEY hkey, LPCTSTR pszValue)
{
DWORD dwData = IsDlgButtonChecked(hwnd, nIDCheck);
DWORD cbData = sizeof(dwData);
if (ERROR_SUCCESS == RegQueryValueEx(hkey, pszValue, 0, NULL, (LPBYTE)&dwData, &cbData))
{
CheckDlgButton(hwnd, nIDCheck, dwData);
return TRUE;
}
return FALSE;
}
void COptionsDlg::LoadSaveUIState(UINT nIDCtl, BOOL bSave)
{
}
LRESULT COptionsDlg::OnSize(UINT uMsg, WPARAM wParam, LPARAM lParam, BOOL&)
{
POINTS pts = MAKEPOINTS(lParam);
_PaintDlg(m_hWnd, _pfsb->GetMetrics());
LayoutControls(pts.x, pts.y);
return 0;
}
void COptionsDlg::LayoutControls(int cx, int cy)
{
if (cx < 0 || cy < 0)
{
RECT rc;
GetClientRect(&rc);
cx = RECTWIDTH(rc);
cy = RECTHEIGHT(rc);
}
HDWP hdwp = BeginDeferWindowPos(1 + (ARRAYSIZE(_subdlgs) * 2));
if (hdwp)
{
CMetrics& metrics = _pfsb->GetMetrics();
POINT ptOrigin = metrics.ExpandOrigin();
// For each checkbox and associated subdialog...
for (int i = 0; i < ARRAYSIZE(_subdlgs); i++)
{
// Calculate checkbox position
HWND hwndCheck = GetDlgItem(_subdlgs[i].nIDCheck);
ASSERT(hwndCheck);
SetRect(&_subdlgs[i].rcCheck,
ptOrigin.x, ptOrigin.y,
ptOrigin.x + RECTWIDTH(metrics.CheckBoxRect()),
ptOrigin.y + RECTHEIGHT(metrics.CheckBoxRect()));
// Calculate subdialog position
ULONG dwDlgFlags = SWP_NOACTIVATE;
if (IsDlgButtonChecked(_subdlgs[i].nIDCheck))
{
// position the checkbox's dialog immediately below.
SetRect(&_subdlgs[i].rcDlg,
_subdlgs[i].rcCheck.left, _subdlgs[i].rcCheck.bottom,
cx - 1, _subdlgs[i].rcCheck.bottom + _subdlgs[i].sizeDlg.cy);
dwDlgFlags |= SWP_SHOWWINDOW;
ptOrigin.y = _subdlgs[i].rcDlg.bottom + metrics.TightMarginY();
}
else
{
ptOrigin.y = _subdlgs[i].rcCheck.bottom + metrics.TightMarginY();
dwDlgFlags |= SWP_HIDEWINDOW;
}
// Reposition the pair
::DeferWindowPos(hdwp, _subdlgs[i].pDlg->Hwnd(), hwndCheck,
_subdlgs[i].rcDlg.left,
_subdlgs[i].rcDlg.top,
RECTWIDTH(_subdlgs[i].rcDlg),
RECTHEIGHT(_subdlgs[i].rcDlg),
dwDlgFlags);
::DeferWindowPos(hdwp, hwndCheck, NULL,
_subdlgs[i].rcCheck.left,
_subdlgs[i].rcCheck.top,
RECTWIDTH(_subdlgs[i].rcCheck),
RECTHEIGHT(_subdlgs[i].rcCheck),
SWP_NOZORDER|SWP_NOACTIVATE);
}
_LayoutLinkWindow(m_hWnd, metrics.CtlMarginX(), cx - metrics.CtlMarginX(), metrics.TightMarginY(),
ptOrigin.y, IDC_INDEX_SERVER);
EndDeferWindowPos(hdwp);
}
}
// Assigns focus to the options dialog. This cannot be done by
// simply setting focus to the options dialog, which is a child
// of another dialog; USER will simply assign focus to the parent dialog.
// So we need to explicitly set focus to our first child.
void COptionsDlg::TakeFocus()
{
for (HWND hwndCtl = GetWindow(GW_CHILD);
::IsWindow(hwndCtl);
hwndCtl = ::GetWindow(hwndCtl, GW_HWNDNEXT))
{
ULONG dwStyle = ::GetWindowLong(hwndCtl, GWL_STYLE);
if (dwStyle & WS_TABSTOP)
{
::SetFocus(hwndCtl);
break;
}
}
}
// Note that we do not care about returning results from this, as it will
// be started asynchronously.
void COptionsDlg::DoDelayedInit()
{
// have subdialogs do delayed initialization
for (int i = 0; i < ARRAYSIZE(_subdlgs); i++)
{
_subdlgs[i].pDlg->DoDelayedInit();
}
}
LONG COptionsDlg::QueryHeight(LONG cx /* proposed width */, LONG cy /* proposed height */)
{
HWND hwndBottommost = GetBottomItem();
RECT rcThis, rcBottommost;
// Retrieve the current height of the bottommost link window.
GetWindowRect(&rcThis);
::GetWindowRect(hwndBottommost, &rcBottommost);
::MapWindowRect(NULL, GetParent(), &rcThis);
::MapWindowRect(NULL, GetParent(), &rcBottommost);
// If, at the specified width, we compute a height for the bottommost
// linkwindow that is different from its current height (e.g, due to word wrap),
// we'll compute a new window rect that will
LONG cyBottommost = (LONG)::SendMessage(hwndBottommost, LWM_GETIDEALHEIGHT,
cx - (_pfsb->GetMetrics().CtlMarginX() * 2), 0);
if (cyBottommost > 0 && cyBottommost != RECTHEIGHT(rcBottommost))
rcThis.bottom = rcBottommost.top + cyBottommost + _pfsb->GetMetrics().TightMarginY();
return RECTHEIGHT(rcThis);
}
BOOL COptionsDlg::GetMinSize(SIZE *pSize)
{
pSize->cx = pSize->cy = 0;
HWND hwndBottom = GetBottomItem();
if (!::IsWindow(hwndBottom))
return FALSE;
RECT rcBottom;
::GetWindowRect(hwndBottom, &rcBottom);
::MapWindowRect(NULL, m_hWnd, &rcBottom);
pSize->cx = 0;
pSize->cy = rcBottom.bottom;
return TRUE;
}
HWND COptionsDlg::GetBottomItem()
{
HWND hwndBottom = GetDlgItem(IDC_INDEX_SERVER);
ASSERT(::IsWindow(hwndBottom))
return hwndBottom;
}
void COptionsDlg::UpdateSearchCmdStateUI(DISPID dispid)
{
UINT nStatusText;
BOOL fCiRunning, fCiIndexed, fCiPermission;
GetCIStatus(&fCiRunning, &fCiIndexed, &fCiPermission);
if (fCiRunning)
{
if (fCiPermission)
// we have permission to distinguish between ready and busy
nStatusText = fCiIndexed ? IDS_FSEARCH_CI_READY_LINK : IDS_FSEARCH_CI_BUSY_LINK;
else
// no permission to distinguish between ready and busy; we'll
// just say it's enabled.
nStatusText = IDS_FSEARCH_CI_ENABLED_LINK;
}
else
{
nStatusText = IDS_FSEARCH_CI_DISABLED_LINK;
}
TCHAR szCaption[MAX_PATH];
if (nStatusText != _nCIStatusText &&
EVAL(LoadString(HINST_THISDLL, nStatusText, szCaption, ARRAYSIZE(szCaption))))
{
SetDlgItemText(IDC_INDEX_SERVER, szCaption);
_nCIStatusText = nStatusText;
LayoutControls();
SizeToFit(FALSE);
}
}
STDMETHODIMP COptionsDlg::AddConstraints(ISearchCommandExt* pSrchCmd)
{
HRESULT hrRet = S_OK;
// have subdialogs add their constraints
for (int i = 0; i < ARRAYSIZE(_subdlgs); i++)
{
if (::IsWindowVisible(_subdlgs[i].pDlg->Hwnd()))
{
HRESULT hr = _subdlgs[i].pDlg->AddConstraints(pSrchCmd);
if (FAILED(hr))
hrRet = hr;
}
}
return hrRet;
}
STDMETHODIMP COptionsDlg::RestoreConstraint(const BSTR bstrName, const VARIANT* pValue)
{
// Try subordinate dialogs.
for (int i = 0; i < ARRAYSIZE(_subdlgs); i++)
{
HRESULT hr = _subdlgs[i].pDlg->RestoreConstraint(bstrName, pValue);
if (S_OK == hr) // open the dialog
{
CheckDlgButton(_subdlgs[i].nIDCheck, TRUE);
LayoutControls();
SizeToFit();
}
// if success, we're done.
if (SUCCEEDED(hr))
return hr;
// otherwise, try next subdialog.
}
return E_FAIL;
}
STDMETHODIMP COptionsDlg::TranslateAccelerator(MSG *pmsg)
{
if (S_OK == CSubDlg::TranslateAccelerator(pmsg))
return S_OK;
// Query subdialogs
if (_dlgDate.IsChild(pmsg->hwnd) &&
S_OK == _dlgDate.TranslateAccelerator(pmsg))
return S_OK;
if (_dlgType.IsChild(pmsg->hwnd) &&
S_OK == _dlgType.TranslateAccelerator(pmsg))
return S_OK;
if (_dlgSize.IsChild(pmsg->hwnd) &&
S_OK == _dlgSize.TranslateAccelerator(pmsg))
return S_OK;
if (_dlgAdvanced.IsChild(pmsg->hwnd) &&
S_OK == _dlgAdvanced.TranslateAccelerator(pmsg))
return S_OK;
return _pfsb->IsDlgMessage(Hwnd(), pmsg);
}
BOOL COptionsDlg::Validate()
{
// have subdialogs do validatation
for (int i = 0; i < ARRAYSIZE(_subdlgs); i++)
{
if (::IsWindowVisible(_subdlgs[i].pDlg->Hwnd()))
if (!_subdlgs[i].pDlg->Validate())
return FALSE;
}
return TRUE;
}
void COptionsDlg::Clear()
{
// have subdialogs clear themselves.
for (int i = 0; i < ARRAYSIZE(_subdlgs); i++)
{
_subdlgs[i].pDlg->Clear();
CheckDlgButton(_subdlgs[i].nIDCheck, FALSE);
}
LayoutControls();
SizeToFit();
}
LRESULT COptionsDlg::OnBtnClick(WORD nCode, WORD nID, HWND hwndCtl, BOOL&)
{
#ifdef DEBUG
// Is this a sub-dialog expansion/contraction?
BOOL bIsSubDlgBtn = FALSE;
for (int i = 0; i < ARRAYSIZE(_subdlgs) && !bIsSubDlgBtn; i++)
{
if (nID == _subdlgs[i].nIDCheck)
bIsSubDlgBtn = TRUE;
}
ASSERT(bIsSubDlgBtn);
#endif DEBUG
LoadSaveUIState(nID, TRUE); // persist it.
LayoutControls();
SizeToFit(!IsDlgButtonChecked(nID));
// don't need to scroll the band if we've expanded a subdialog,
// but we do if we've contracted one.
return 0;
}
void COptionsDlg::SizeToFit(BOOL bScrollBand)
{
SIZE size;
GetMinSize(&size);
size.cy += _pfsb->GetMetrics().TightMarginY();
SetWindowPos(NULL, 0, 0, size.cx, size.cy, SWP_NOZORDER|SWP_NOACTIVATE|SWP_NOMOVE);
ULONG dwLayoutFlags = BLF_ALL;
if (!bScrollBand)
dwLayoutFlags &= ~BLF_SCROLLWINDOW;
::SendMessage(GetParent(), WMU_UPDATELAYOUT, dwLayoutFlags, 0);
}
LRESULT COptionsDlg::OnIndexServerClick(int idCtl, NMHDR *pnmh, BOOL&)
{
BOOL fCiRunning, fCiIndexed, fCiPermission = FALSE;
HRESULT hr = GetCIStatus(&fCiRunning, &fCiIndexed, &fCiPermission);
if (SUCCEEDED(hr) && fCiPermission)
{
// CI is idle or not runnning. Show status dialog.
if (IDOK == CCISettingsDlg_DoModal(GetDlgItem(IDC_INDEX_SERVER)))
{
// reflect any state change in UI.
::PostMessage(GetParent(), WMU_STATECHANGE, 0, 0);
}
}
else
{
// No permission? display CI help.
_IndexServiceHelp(NULL);
}
return 0;
}
// CBandDlg impl
CBandDlg::CBandDlg(CFileSearchBand* pfsb)
: _pfsb(pfsb)
{
// Verify that it initialized to FALSE/NULL
ASSERT(NULL == _hwnd);
ASSERT(NULL == _hwndLastFocus);
VariantInit(&_varScope0);
VariantInit(&_varQueryFile0);
}
CBandDlg::~CBandDlg()
{
VariantClear(&_varScope0);
VariantClear(&_varQueryFile0);
}
STDMETHODIMP CBandDlg::TranslateAccelerator(MSG *pmsg)
{
if (WM_KEYDOWN == pmsg->message || WM_KEYUP == pmsg->message)
{
IAutoComplete2* pac2;
if (GetAutoCompleteObjectForWindow(pmsg->hwnd, &pac2))
{
if (S_OK == _TestAutoCompleteDropDownState(pac2, ACDD_VISIBLE))
{
TranslateMessage(pmsg);
DispatchMessage(pmsg);
pac2->Release();
return S_OK;
}
pac2->Release();
}
}
// Check for Ctrl+Nav Key:
if (_pfsb->IsKeyboardScroll(pmsg))
return S_OK;
return S_FALSE;
}
void CBandDlg::SetDefaultFocus()
{
HWND hwndFirst = GetFirstTabItem();
if (IsWindow(hwndFirst))
SetFocus(hwndFirst);
}
void CBandDlg::RememberFocus(HWND hwndFocus)
{
if (!IsWindow(hwndFocus))
{
_hwndLastFocus = NULL;
hwndFocus = GetFocus();
}
if (IsChild(_hwnd, hwndFocus))
_hwndLastFocus = hwndFocus;
}
BOOL CBandDlg::RestoreFocus()
{
if (IsWindow(_hwndLastFocus))
{
if (IsWindowVisible(_hwndLastFocus) && IsWindowEnabled(_hwndLastFocus))
{
SetFocus(_hwndLastFocus);
return TRUE;
}
}
else
_hwndLastFocus = NULL;
return FALSE;
}
LRESULT CBandDlg::OnChildSetFocusCmd(WORD, WORD, HWND hwndCtl, BOOL& bHandled)
{
_EnsureVisible(_hwnd, hwndCtl, _pfsb);
return 0;
}
LRESULT CBandDlg::OnChildSetFocusNotify(int, NMHDR *pnmh, BOOL&)
{
_EnsureVisible(_hwnd, pnmh->hwndFrom, _pfsb);
return 0;
}
LRESULT CBandDlg::OnChildKillFocusCmd(WORD, WORD, HWND hwndCtl, BOOL&)
{
_hwndLastFocus = hwndCtl;
return 0;
}
LRESULT CBandDlg::OnChildKillFocusNotify(int, NMHDR *pnmh, BOOL&)
{
_hwndLastFocus = pnmh->hwndFrom;
return 0;
}
LRESULT CBandDlg::OnComboExEndEdit(int, NMHDR *pnmh, BOOL&)
{
if (CBEN_ENDEDIT == pnmh->code)
{
if (CBENF_KILLFOCUS == ((NMCBEENDEDIT*)pnmh)->iWhy)
_hwndLastFocus = pnmh->hwndFrom;
}
return 0;
}
void CBandDlg::WndPosChanging(HWND hwndOC, LPWINDOWPOS pwp)
{
SIZE sizeMin;
if (0 == (pwp->flags & SWP_NOSIZE) && GetMinSize(hwndOC, &sizeMin))
{
if (pwp->cx < sizeMin.cx)
pwp->cx = sizeMin.cx;
if (pwp->cy < sizeMin.cy)
pwp->cy = sizeMin.cy;
}
}
LRESULT CBandDlg::OnSize(UINT, WPARAM wParam, LPARAM lParam, BOOL&)
{
POINTS pts = MAKEPOINTS(lParam);
LayoutControls(pts.x, pts.y);
return 0;
}
void CBandDlg::LayoutControls(int cx, int cy)
{
if (cx < 0 || cy < 0)
{
RECT rc;
GetClientRect(_hwnd, &rc);
cx = RECTWIDTH(rc);
cy = RECTHEIGHT(rc);
}
_LayoutCaption(GetIconID(), GetCaptionID(), GetCaptionDivID(), cx);
}
BOOL CBandDlg::GetIdealSize(HWND hwndOC, SIZE *psize) const
{
ASSERT(psize);
psize->cx = psize->cy = 0;
if (!IsWindow(Hwnd()))
return FALSE;
SIZE sizeMin;
if (GetMinSize(hwndOC, &sizeMin))
{
RECT rcClient;
::GetClientRect(hwndOC, &rcClient);
psize->cx = (RECTWIDTH(rcClient) < sizeMin.cx) ? sizeMin.cx : RECTWIDTH(rcClient);
psize->cy = sizeMin.cy;
return TRUE;
}
return FALSE;
}
LRESULT CBandDlg::OnPaint(UINT, WPARAM, LPARAM, BOOL&)
{
// Just going to call BeginPaint and EndPaint. All
// painting done in WM_ERASEBKGND handler to avoid flicker.
PAINTSTRUCT ps;
HDC hdc = BeginPaint(_hwnd, &ps);
if (hdc)
EndPaint(_hwnd, &ps);
return 0;
}
LRESULT CBandDlg::OnEraseBkgnd(UINT, WPARAM wParam, LPARAM, BOOL&)
{
ASSERT(::IsWindow(_hwnd)); // was _Attach() called, e.g. from WM_INITDIALOG?
_PaintDlg(_hwnd, _pfsb->GetMetrics(), (HDC)wParam);
ValidateRect(_hwnd, NULL);
return TRUE;
}
LRESULT CBandDlg::OnCtlColorStatic(UINT, WPARAM wParam, LPARAM lParam, BOOL&)
{
SetTextColor((HDC)wParam, _pfsb->GetMetrics().TextColor());
SetBkColor((HDC)wParam, _pfsb->GetMetrics().BkgndColor());
return (LRESULT)_pfsb->GetMetrics().BkgndBrush();
}
// Hack method to remove turds left after showing band toolbar.
// Methinks this is a USER issue. [scotthan]
void CBandDlg::RemoveToolbarTurds(int cyOffset)
{
RECT rcUpdate;
GetClientRect(_hwnd, &rcUpdate);
HWND hwndCtl = GetDlgItem(_hwnd, GetCaptionDivID());
if (hwndCtl)
{
RECT rc;
GetWindowRect(hwndCtl, &rc);
::MapWindowRect(NULL, _hwnd, &rc);
rcUpdate.bottom = rc.bottom;
OffsetRect(&rcUpdate, 0, cyOffset);
InvalidateRect(_hwnd, &rcUpdate, TRUE);
InvalidateRect(hwndCtl, NULL, TRUE);
UpdateWindow(hwndCtl);
}
hwndCtl = GetDlgItem(_hwnd, GetIconID());
if (hwndCtl)
{
InvalidateRect(hwndCtl, NULL, TRUE);
UpdateWindow(hwndCtl);
}
hwndCtl = GetDlgItem(_hwnd, GetCaptionID());
if (hwndCtl)
{
InvalidateRect(hwndCtl, NULL, TRUE);
UpdateWindow(hwndCtl);
}
UpdateWindow(_hwnd);
}
void CBandDlg::_BeautifyCaption(UINT nIDCaption, UINT nIDIcon, UINT nIDIconResource)
{
// Do some cosmetic and initialization stuff
HFONT hf = _pfsb->GetMetrics().BoldFont(_hwnd);
if (hf)
SendDlgItemMessage(_hwnd, nIDCaption, WM_SETFONT, (WPARAM)hf, 0);
if (nIDIcon && nIDIconResource)
{
HICON hiconCaption = _pfsb->GetMetrics().CaptionIcon(nIDIconResource);
if (hiconCaption)
SendDlgItemMessage(_hwnd, nIDIcon, STM_SETIMAGE, IMAGE_ICON, (LPARAM)hiconCaption);
}
}
void CBandDlg::_LayoutCaption(UINT nIDCaption, UINT nIDIcon, UINT nIDDiv, LONG cxDlg)
{
RECT rcIcon, rcCaption;
LONG cxMargin = _pfsb->GetMetrics().CtlMarginX();
GetWindowRect(GetDlgItem(_hwnd, nIDIcon), &rcIcon);
GetWindowRect(GetDlgItem(_hwnd, nIDCaption), &rcCaption);
::MapWindowRect(NULL, _hwnd, &rcIcon);
::MapWindowRect(NULL, _hwnd, &rcCaption);
int nTop = max(rcIcon.bottom, rcCaption.bottom) + _PixelsForDbu(_hwnd, 1, FALSE);
SetWindowPos(GetDlgItem(_hwnd, nIDDiv), GetDlgItem(_hwnd, nIDCaption),
cxMargin, nTop, cxDlg - (cxMargin * 2), 2, SWP_NOACTIVATE);
}
void CBandDlg::_LayoutSearchLinks(UINT nIDCaption, UINT nIDDiv, BOOL bShowDiv, LONG left, LONG right, LONG yMargin,
LONG& yStart, const int rgLinkIDs[], LONG cLinkIDs)
{
// Position divider
if (bShowDiv != 0)
{
RECT rcDiv;
SetRect(&rcDiv, left, yStart, right, yStart + 1);
SetWindowPos(GetDlgItem(_hwnd, nIDDiv), GetDlgItem(_hwnd, nIDCaption),
rcDiv.left, rcDiv.top, RECTWIDTH(rcDiv), RECTHEIGHT(rcDiv),
SWP_NOACTIVATE|SWP_SHOWWINDOW);
yStart += yMargin;
}
else
ShowWindow(GetDlgItem(_hwnd, nIDDiv), SW_HIDE);
// Position caption
RECT rcCaption;
GetWindowRect(GetDlgItem(_hwnd, nIDCaption), &rcCaption);
::MapWindowRect(NULL, _hwnd, &rcCaption);
OffsetRect(&rcCaption, left - rcCaption.left, yStart - rcCaption.top);
SetWindowPos(GetDlgItem(_hwnd, nIDCaption), NULL,
left, yStart, 0,0,
SWP_NOSIZE|SWP_NOZORDER|SWP_NOACTIVATE);
yStart += RECTHEIGHT(rcCaption) + yMargin;
// Position links
_LayoutLinkWindows(_hwnd, left, right, yMargin, yStart, rgLinkIDs, cLinkIDs);
}
LRESULT CBandDlg::OnEditChange(WORD, WORD, HWND, BOOL&)
{
_pfsb->SetDirty();
return 0;
}
LRESULT CBandDlg::OnSearchLink(int nID, LPNMHDR, BOOL&)
{
ASSERT(_pfsb);
_pfsb->StopSearch();
switch (nID)
{
case IDC_SEARCHLINK_FILES:
_pfsb->FindFilesOrFolders(FALSE, TRUE);
break;
case IDC_SEARCHLINK_COMPUTERS:
_pfsb->FindComputer(FALSE, TRUE);
break;
case IDC_SEARCHLINK_PRINTERS:
_pfsb->FindPrinter(FALSE, TRUE);
break;
case IDC_SEARCHLINK_PEOPLE:
_pfsb->FindPeople(FALSE, TRUE);
break;
case IDC_SEARCHLINK_INTERNET:
_pfsb->FindOnWeb(FALSE, TRUE);
break;
}
return 0;
}
// Invoked when a client calls IFileSearchBand::SetSearchParameters()
HRESULT CBandDlg::SetScope(IN VARIANT* pvarScope, BOOL bTrack)
{
HRESULT hr = S_OK;
VariantClear(&_varScope0);
// cache the scope
if (pvarScope)
hr = VariantCopy(&_varScope0, pvarScope);
return hr;
}
HRESULT CBandDlg::GetScope(OUT VARIANT* pvarScope)
{
// retrieve the scope
if (!pvarScope)
return E_INVALIDARG;
HRESULT hr = VariantCopy(pvarScope, &_varScope0);
return SUCCEEDED(hr) ? (VT_EMPTY == _varScope0.vt ? S_FALSE : S_OK) : hr;
}
HRESULT CBandDlg::SetQueryFile(IN VARIANT* pvarFile)
{
return VariantCopy(&_varQueryFile0, pvarFile);
}
HRESULT CBandDlg::GetQueryFile(OUT VARIANT* pvarFile)
{
// retrieve the filename of the query to restore.
if (!pvarFile)
return E_INVALIDARG;
VariantInit(pvarFile);
HRESULT hr = VariantCopy(pvarFile, &_varQueryFile0);
return SUCCEEDED(hr) ? (VT_EMPTY == _varQueryFile0.vt ? S_FALSE : S_OK) : hr;
}
// CFindFilesDlg impl
#define FSEARCHMAIN_TABFIRST IDC_FILESPEC
#define FSEARCHMAIN_TABLAST IDC_SEARCHLINK_INTERNET
#define FSEARCHMAIN_BOTTOMMOST IDC_SEARCHLINK_INTERNET // bottom-most control
#define FSEARCHMAIN_RIGHTMOST IDC_SEARCH_STOP // right-most control
#define UISTATETIMER 1
#define UISTATETIMER_DELAY 4000
CFindFilesDlg::CFindFilesDlg(CFileSearchBand* pfsb)
: CSearchCmdDlg(pfsb),
_dlgOptions(pfsb),
_iCurNamespace(CB_ERR),
_fTrackScope(TRACKSCOPE_SPECIFIC),
_dwWarningFlags(DFW_DEFAULT),
_dwRunOnceWarningFlags(DFW_DEFAULT)
{
// Since we use the zero initializer for COM objects, all variables should
// be initialized to NULL/FALSE/0
ASSERT(FALSE == _bScoped);
ASSERT(FALSE == _fDisplayOptions);
ASSERT(FALSE == _fNamespace);
ASSERT(FALSE == _fDebuted);
ASSERT(FALSE == _fBandFinishedDisplaying);
ASSERT(NULL == _pacGrepText);
ASSERT(NULL == _pmruGrepText);
ASSERT(NULL == _pacFileSpec);
ASSERT(NULL == _pmruFileSpec);
ASSERT(0 == *_szInitialPath);
ASSERT(0 == *_szInitialNames);
ASSERT(0 == *_szCurrentPath);
ASSERT(0 == *_szLocalDrives);
ASSERT(NULL == _pidlInitial);
}
CFindFilesDlg::~CFindFilesDlg()
{
ATOMICRELEASE(_pacGrepText);
ATOMICRELEASE(_pmruGrepText);
ATOMICRELEASE(_pacFileSpec);
ATOMICRELEASE(_pmruFileSpec);
ILFree(_pidlInitial);
}
// Scope to a default namespace.
BOOL CFindFilesDlg::SetDefaultScope()
{
// If we've already assigned a scope, bail early
if (_bScoped)
return TRUE;
// Try establiblishing the preassigned (_szInitialXXX) scope:
BOOL bScoped = _SetPreassignedScope();
if (!bScoped)
{
// Try setting scope to the current shell folder of the active view...
bScoped = _SetFolderScope();
if (!bScoped)
{
// set it to the hard-coded shell default folder
bScoped = _SetLocalDefaultScope();
}
}
return bScoped;
}
// Assignes the namespace control to the preassigned scope saved in
// _szInitialNames/_szInitialPath/_pidlInitial
BOOL CFindFilesDlg::_SetPreassignedScope()
{
BOOL bScoped = FALSE;
if (*_szInitialNames || *_szInitialPath || _pidlInitial)
bScoped = AssignNamespace(_szInitialPath, _pidlInitial, _szInitialNames, FALSE);
return bScoped;
}
STDAPI_(BOOL) IsFTPFolder(IShellFolder * psf);
// Scope to the namespace of the current shell folder view
BOOL CFindFilesDlg::_SetFolderScope()
{
BOOL bScoped = FALSE;
ASSERT(_pfsb->BandSite());
LPITEMIDLIST pidl;
if (SUCCEEDED(_GetCurrentFolderIDList(_pfsb->BandSite(), &pidl)))
{
// Get the display name/path. IF it is an FTP site, then we need to get the name
// as though it is for the address bar becasue when we call SHGetPathFromIDList,
// it returns "" for FTP sites.
IShellFolder *psf = NULL;
if (SUCCEEDED(SHBindToObject(NULL, IID_X_PPV_ARG(IShellFolder, pidl, &psf)))
&& IsFTPFolder(psf))
{
SHGetNameAndFlags(pidl, SHGDN_FORADDRESSBAR, _szInitialNames, ARRAYSIZE(_szInitialNames), NULL);
SHGetNameAndFlags(pidl, SHGDN_FORPARSING, _szInitialPath, ARRAYSIZE(_szInitialNames), NULL);
}
else
{
SHGetNameAndFlags(pidl, SHGDN_NORMAL, _szInitialNames, ARRAYSIZE(_szInitialNames), NULL);
SHGetPathFromIDList(pidl, _szInitialPath); // file system path only here!
}
if (psf)
{
psf->Release();
}
// Store the pidl for use later if we are starting it async
_pidlInitial = ILClone(pidl);
// if we're tracking the scope loosely...
if ((TRACKSCOPE_GENERAL == _fTrackScope) && _IsPathLocalHarddrive(_szInitialPath))
{
// scope to local default scope
*_szInitialNames = *_szInitialPath = 0;
bScoped = _SetLocalDefaultScope();
}
else if (_threadState.fComplete /* finished populating namespace combo */ &&
_szInitialPath[0])
{
bScoped = AssignNamespace(_szInitialPath, pidl, _szInitialNames, FALSE);
}
ILFree(pidl);
}
return bScoped;
}
// Scope to the hard-coded shell default namespace.
BOOL CFindFilesDlg::_SetLocalDefaultScope()
{
BOOL bScoped = FALSE;
// Initialize fallback initial namespace
// default to Local Hard Drives if possible
if (_szLocalDrives[0] &&
AssignNamespace(NULL, NULL, _szLocalDrives, FALSE))
{
bScoped = TRUE;
}
else
{
TCHAR szDesktopPath[MAX_PATH];
if (SUCCEEDED(SHGetFolderPath(NULL, CSIDL_DESKTOPDIRECTORY, NULL, SHGFP_TYPE_CURRENT, szDesktopPath)) &&
AssignNamespace(NULL, NULL, szDesktopPath, FALSE))
{
bScoped = TRUE;
}
}
// If we failed, this means that the namespace combo hasn't
// been populated yet.
// We just sit tight, cuz the populating thread will fall back on
// the LocalDefaultScope.
return bScoped;
}
// search **band** show/hide handler
void CFindFilesDlg::OnBandShow(BOOL fShow)
{
CSearchCmdDlg::OnBandShow(fShow);
if (fShow)
{
// Establish the first showing's band width
if (!_fDebuted && _pfsb->IsBandDebut())
{
_pfsb->SetDeskbandWidth(GetIdealDeskbandWidth());
_fDebuted = TRUE;
}
// If we're tracking the scope to the current folder shell view,
// update it now, as it may have changed.
if (_fTrackScope != TRACKSCOPE_NONE)
{
_bScoped = FALSE;
_SetFolderScope();
}
// restart our UI state timer
SetTimer(UISTATETIMER, UISTATETIMER_DELAY);
}
else
{
// we're being hidden so stop updating our state indicators.
KillTimer(UISTATETIMER);
}
}
// search band **dialog** show/hide handler
void CFindFilesDlg::OnBandDialogShow(BOOL fShow)
{
CSearchCmdDlg::OnBandDialogShow(fShow);
if (fShow)
{
// If we're tracking the scope to the current folder shell view,
// update it now, as it may have changed.
if (_fTrackScope != TRACKSCOPE_NONE)
{
_bScoped = FALSE;
_SetFolderScope();
}
}
}
// Explicit scoping method. This will be called if a client
// called IFileSearchBand::SetSearchParameters with a non-NULL scope.
HRESULT CFindFilesDlg::SetScope(IN VARIANT* pvarScope, BOOL bTrack)
{
HRESULT hr = CBandDlg::SetScope(pvarScope, bTrack);
if (S_OK != hr)
return hr;
LPITEMIDLIST pidlSearch = VariantToIDList(&_varScope0);
if (pidlSearch)
{
SHGetNameAndFlags(pidlSearch, SHGDN_FORPARSING, _szInitialPath, ARRAYSIZE(_szInitialPath), NULL);
SHGetNameAndFlags(pidlSearch, SHGDN_NORMAL, _szInitialNames, ARRAYSIZE(_szInitialNames), NULL);
ILFree(pidlSearch);
// Did we get one?
if (*_szInitialNames || *_szInitialPath)
{
if (_bScoped)
{
// If we've already scoped, update the namespace combo.
// Track if succeed and requested.
if (AssignNamespace(_szInitialPath, NULL, _szInitialNames, FALSE) && bTrack)
_fTrackScope = TRACKSCOPE_SPECIFIC;
}
else
{
// Not already scoped. We've assigned our initial namespace,
// let the namespace thread completion handler update
// the combo
if (bTrack)
_fTrackScope = TRACKSCOPE_SPECIFIC;
}
}
}
return S_OK;
}
LRESULT CFindFilesDlg::OnInitDialog(UINT uMsg, WPARAM wParam, LPARAM lParam, BOOL& bHandled)
{
_Attach(m_hWnd);
_dlgOptions.SetBandDlg(this);
// Register specialty window classes.
DivWindow_RegisterClass();
GroupButton_RegisterClass();
// Initialize some metrics
CMetrics& metrics = _pfsb->GetMetrics();
RECT rc;
_pfsb->GetMetrics().Init(m_hWnd);
// SHAutoComplete(::GetWindow(GetDlgItem(IDC_NAMESPACE), GW_CHILD), SHACF_FILESYS_DIRS);
::GetWindowRect(GetDlgItem(IDC_FILESPEC), &rc);
::MapWindowRect(NULL, m_hWnd, &rc);
metrics.ExpandOrigin().x = rc.left;
// Position start, stop buttons.
::GetWindowRect(GetDlgItem(IDC_SEARCH_START), &rc);
::MapWindowRect(NULL, m_hWnd, &rc);
int cxBtn = _GetResourceMetric(m_hWnd, IDS_FSEARCH_STARTSTOPWIDTH, TRUE);
if (cxBtn > 0)
{
rc.right = rc.left + cxBtn;
::SetWindowPos(GetDlgItem(IDC_SEARCH_START), NULL,
rc.left, rc.top, RECTWIDTH(rc), RECTHEIGHT(rc),
SWP_NOMOVE|SWP_NOZORDER|SWP_NOACTIVATE);
OffsetRect(&rc, cxBtn + _PixelsForDbu(m_hWnd, 12, TRUE), 0);
::SetWindowPos(GetDlgItem(IDC_SEARCH_STOP), NULL,
rc.left, rc.top, RECTWIDTH(rc), RECTHEIGHT(rc),
SWP_NOZORDER|SWP_NOACTIVATE);
}
// Create subdialogs and collect native sizes.
_dlgOptions.Create(m_hWnd);
ASSERT(::IsWindow(_dlgOptions));
// Load settings
LoadSaveUIState(0, FALSE);
// Show/Hide the "Search" Options subdialog
_dlgOptions.ShowWindow(_fDisplayOptions ? SW_SHOW : SW_HIDE);
// Create 'link' child controls
POINT pt;
pt.x = metrics.CtlMarginX();
pt.y = 0;
// Create 'Search Options' link and group button
_CreateLinkWindow(m_hWnd, IDC_SEARCHLINK_OPTIONS, pt,
IDS_FSEARCH_SEARCHLINK_OPTIONS, !_fDisplayOptions);
TCHAR szGroupBtn[128];
EVAL(LoadString(HINST_THISDLL, IDS_FSEARCH_GROUPBTN_OPTIONS,
szGroupBtn, ARRAYSIZE(szGroupBtn)));
HWND hwndGrpBtn = CreateWindowEx(0, GROUPBUTTON_CLASS, szGroupBtn,
WS_CHILD|WS_BORDER|WS_TABSTOP, pt.x, pt.y, 400, 18,
m_hWnd, (HMENU)IDC_GROUPBTN_OPTIONS, HINST_THISDLL, NULL);
if (::IsWindow(hwndGrpBtn))
{
::SendMessage(hwndGrpBtn, GBM_SETBUDDY,
(WPARAM)_dlgOptions.m_hWnd, (LPARAM)GBBF_HRESIZE|GBBF_VSLAVE);
::ShowWindow(GetDlgItem(IDC_GROUPBTN_OPTIONS), _fDisplayOptions ? SW_SHOW : SW_HIDE);
}
// Create cross-navigation links
_CreateSearchLinks(m_hWnd, pt, IDC_SEARCHLINK_FILES);
_CreateDivider(m_hWnd, IDC_FSEARCH_DIV1, pt, 2, GetDlgItem(IDC_FSEARCH_CAPTION));
_CreateDivider(m_hWnd, IDC_FSEARCH_DIV2, pt, 1, GetDlgItem(IDC_SEARCHLINK_CAPTION));
_CreateDivider(m_hWnd, IDC_FSEARCH_DIV3, pt, 1, GetDlgItem(IDC_SEARCHLINK_PEOPLE));
// Do some cosmetic and initialization stuff
OnWinIniChange();
_InitializeMru(GetDlgItem(IDC_FILESPEC), &_pacFileSpec,
TEXT("FilesNamedMRU"), &_pmruFileSpec);
_InitializeMru(GetDlgItem(IDC_GREPTEXT), &_pacGrepText,
TEXT("ContainingTextMRU"), &_pmruGrepText);
SendDlgItemMessage(IDC_FILESPEC, EM_LIMITTEXT, MAX_EDIT, 0);
SendDlgItemMessage(IDC_GREPTEXT, EM_LIMITTEXT, MAX_EDIT, 0);
SendDlgItemMessage(IDC_NAMESPACE, CBEM_SETEXTENDEDSTYLE,
CBES_EX_NOSIZELIMIT | CBES_EX_CASESENSITIVE,
CBES_EX_NOSIZELIMIT | CBES_EX_CASESENSITIVE);
SendDlgItemMessage(IDC_NAMESPACE, CBEM_SETIMAGELIST, 0, (LPARAM)GetSystemImageListSmallIcons());
SendDlgItemMessage(IDC_NAMESPACE, CBEM_SETEXSTYLE, 0, 0);
// Enable the cue banners for the edit boxes:
TCHAR szCaption[128];
LoadString(HINST_THISDLL, IDS_FIND_CUEBANNER_FILE, szCaption, ARRAYSIZE(szCaption));
SendDlgItemMessage(IDC_FILESPEC, EM_SETCUEBANNER, 0, (LPARAM) szCaption);
LoadString(HINST_THISDLL, IDS_FIND_CUEBANNER_GREP, szCaption, ARRAYSIZE(szCaption));
SendDlgItemMessage(IDC_GREPTEXT, EM_SETCUEBANNER, 0, (LPARAM) szCaption);
// Bias the input reader towards file names
SetModeBias(MODEBIASMODE_FILENAME);
// Launch thread to populate the namespaces combo.
_threadState.hwndCtl = GetDlgItem(IDC_NAMESPACE);
_threadState.pvParam = this;
_threadState.fComplete = FALSE;
_threadState.fCancel = FALSE;
if (SUCCEEDED(SAFECAST(_pfsb, IFileSearchBand*)->QueryInterface(IID_PPV_ARG(IUnknown, &_threadState.punkBand))))
{
if (!SHCreateThread(NamespaceThreadProc, &_threadState, CTF_COINIT, NULL))
{
ATOMICRELEASE(_threadState.punkBand);
}
}
// Layout our subdialogs and update state representation...
LayoutControls();
UpdateSearchCmdStateUI();
SetTimer(UISTATETIMER, UISTATETIMER_DELAY);
return TRUE; // Let the system set the focus
}
LRESULT CFindFilesDlg::OnEraseBkgnd(UINT uMsg, WPARAM wParam, LPARAM lParam, BOOL&)
{
// paint the background
_PaintDlg(m_hWnd, _pfsb->GetMetrics(), (HDC)wParam);
if (_fDisplayOptions)
// ensure that the group button is updated.
SendDlgItemMessage(IDC_GROUPBTN_OPTIONS, WM_NCPAINT, (WPARAM)1, 0);
// validate our work.
ValidateRect(NULL);
return TRUE;
}
void CFindFilesDlg::OnWinIniChange()
{
CBandDlg::OnWinIniChange();
// redisplay animated icon
HWND hwndIcon = GetDlgItem(IDC_FSEARCH_ICON);
Animate_Close(hwndIcon);
Animate_OpenEx(hwndIcon, HINST_THISDLL, MAKEINTRESOURCE(IDA_FINDFILE));
SendDlgItemMessage(IDC_NAMESPACE, CB_SETDROPPEDWIDTH,
_PixelsForDbu(m_hWnd, MIN_NAMESPACELIST_WIDTH, TRUE), 0);
_BeautifyCaption(IDC_FSEARCH_CAPTION);
_dlgOptions.OnWinIniChange();
}
LRESULT CFindFilesDlg::OnDestroy(UINT, WPARAM, LPARAM, BOOL& bHandled)
{
KillTimer(UISTATETIMER);
StopSearch();
if (_pSrchCmd)
{
DisconnectEvents();
IUnknown_SetSite(_pSrchCmd, NULL);
}
_threadState.fCancel = TRUE;
_fOnDestroy = TRUE;
bHandled = FALSE;
return 0;
}
BOOL CFindFilesDlg::Validate()
{
return _dlgOptions.Validate();
}
STDMETHODIMP CFindFilesDlg::AddConstraints(ISearchCommandExt *pSrchCmd)
{
HRESULT hr;
VARIANT var = {0};
TCHAR szPath[MAX_URL_STRING];
// If the user enters a path as a filename, it will recognize it as a path and replace
// the filename with just the file portion and the namespace with the path.
if (::GetDlgItemText(m_hWnd, IDC_FILESPEC, szPath, ARRAYSIZE(szPath)) > 0)
{
if (StrChr(szPath, TEXT('\\')) != NULL)
{
if (!_PathLooksLikeFilePattern(szPath) &&
(PathIsUNCServer(szPath) /* string test: \\server */||
_PathIsUNCServerShareOrSub(szPath) /* string test: \\server\share */ ||
PathIsDirectory(szPath)) /* this actually tests existence */)
{
::SetDlgItemText(m_hWnd, IDC_FILESPEC, TEXT("*.*"));
AssignNamespace(szPath, NULL, NULL, FALSE);
}
else
{
// just use the prefix for the file spec & the root for the location
TCHAR szRoot[MAX_URL_STRING];
lstrcpy(szRoot, szPath);
if (PathRemoveFileSpec(szRoot) && szRoot[0] != 0)
{
PathStripPath(szPath);
::SetDlgItemText(m_hWnd, IDC_FILESPEC, szPath);
AssignNamespace(szRoot, NULL, NULL, FALSE);
}
}
}
}
// If _ReconcileNamespace could not add an item to the combo box for
// the path entered, then it means that the path is likely invalid.
// Get the path and check it here.
IEnumIDList *penum;
hr = _GetTargetNamespace(&penum);
if (SUCCEEDED(hr))
{
var.vt = VT_UNKNOWN;
penum->QueryInterface(IID_PPV_ARG(IUnknown, &var.punkVal));
hr = _AddConstraint(pSrchCmd, L"LookIn", &var);
VariantClear(&var);
}
else
{
GetDlgItemText(IDC_NAMESPACE, szPath, ARRAYSIZE(szPath));
hr = _PathValidate(szPath, GetParent(), TRUE);
if (SUCCEEDED(hr))
{
if (SUCCEEDED(InitVariantFromStr(&var, szPath)))
{
hr = _AddConstraint(pSrchCmd, L"LookIn", &var);
VariantClear(&var);
}
}
else
{
// _PathValidate's SHPathPrepareForWrite may have already displayed error
if (HRESULT_FROM_WIN32(ERROR_CANCELLED) != hr)
{
TCHAR szMsg[MAX_URL_STRING];
if (_FmtError(IDS_FSEARCH_INVALIDFOLDER_FMT, szPath, szMsg, ARRAYSIZE(szMsg)))
ShellMessageBox(HINST_THISDLL, GetParent(), szMsg, NULL, MB_OK | MB_ICONASTERISK);
}
::SetFocus(GetDlgItem(IDC_NAMESPACE));
}
}
if (SUCCEEDED(hr))
{
// Add 'Files Named' constraint
if (S_OK == _GetWindowValue(m_hWnd, IDC_FILESPEC, &var))
{
hr = _AddConstraint(pSrchCmd, L"Named", &var);
if (SUCCEEDED(hr))
_AddMruStringFromWindow(_pmruFileSpec, GetDlgItem(IDC_FILESPEC));
VariantClear(&var);
}
// Add 'Containing Text' constraint
if (S_OK == _GetWindowValue(m_hWnd, IDC_GREPTEXT, &var))
{
VARIANT varQuery;
ULONG ulDialect;
BOOL fCiQuery = IsCiQuery(&var, &varQuery, &ulDialect);
if (fCiQuery)
{
hr = _AddConstraint(pSrchCmd, L"IndexedSearch", &varQuery);
if (SUCCEEDED(hr))
{
_AddMruStringFromWindow(_pmruGrepText, GetDlgItem(IDC_GREPTEXT));
VariantClear(&var);
var.vt = VT_UI4;
var.ulVal = ulDialect;
hr = _AddConstraint(pSrchCmd, L"QueryDialect", &var);
}
}
else
{
// add to 'containing text' constraint
hr = _AddConstraint(pSrchCmd, L"ContainingText", &var);
if (SUCCEEDED(hr))
_AddMruStringFromWindow(_pmruGrepText, GetDlgItem(IDC_GREPTEXT));
}
VariantClear(&varQuery);
VariantClear(&var);
}
// Warning flags
if (_dwRunOnceWarningFlags != DFW_DEFAULT)
{
// re-run the query w/ temporary warning bits.
var.ulVal = _dwRunOnceWarningFlags;
var.vt = VT_UI4;
//_dwRunOnceWarningFlags = DFW_DEFAULT; cannot reset it here in case of error, must preserve them
hr = _AddConstraint(pSrchCmd, L"WarningFlags", &var);
}
else if (_dwWarningFlags != DFW_DEFAULT)
{
var.ulVal = _dwWarningFlags;
var.vt = VT_UI4;
hr = _AddConstraint(pSrchCmd, L"WarningFlags", &var);
}
VariantClear(&var);
hr = _dlgOptions.AddConstraints(pSrchCmd);
}
return hr;
}
STDMETHODIMP CFindFilesDlg::RestoreConstraint(const BSTR bstrName, const VARIANT* pValue)
{
if (IsConstraintName(L"Named", bstrName))
{
_SetWindowValue(m_hWnd, IDC_FILESPEC, pValue);
return S_FALSE;
}
if (IsConstraintName(L"IndexedSearch", bstrName))
{
ASSERT(VT_BSTR == pValue->vt);
if (pValue->bstrVal)
{
int cch = lstrlenW(pValue->bstrVal) + 2;
LPWSTR pwszVal = new WCHAR[cch];
if (pwszVal)
{
*pwszVal = L'!';
StrCatW(pwszVal, pValue->bstrVal);
}
::SetDlgItemTextW(m_hWnd, IDC_GREPTEXT, pwszVal);
if (pwszVal)
delete [] pwszVal;
}
return S_FALSE;
}
if (IsConstraintName(L"ContainingText", bstrName))
{
_SetWindowValue(m_hWnd, IDC_GREPTEXT, pValue);
return S_FALSE;
}
HRESULT hr = _dlgOptions.RestoreConstraint(bstrName, pValue);
if (S_OK == hr) // opened a dialog
_ShowOptions(TRUE);
if (SUCCEEDED(hr))
return hr;
return E_FAIL;
}
void CFindFilesDlg::RestoreSearch()
{
DFConstraint* pdfc = NULL;
HRESULT hr;
BOOL bMore = TRUE;
ISearchCommandExt* pSrchCmd = GetSearchCmd();
if (NULL == pSrchCmd)
return;
CSearchCmdDlg::Clear();
// we'll anchor to any restored scope, or the default
_fTrackScope = TRACKSCOPE_GENERAL;
for (hr = pSrchCmd->GetNextConstraint(TRUE, &pdfc);
S_OK == hr && bMore;
hr = pSrchCmd->GetNextConstraint(FALSE, &pdfc))
{
BSTR bstrName = NULL;
if (S_OK == (hr = pdfc->get_Name(&bstrName)) && bstrName)
{
if (*bstrName == 0)
bMore = FALSE; // no more constraints.
else
{
VARIANT varValue = {0};
hr = pdfc->get_Value(&varValue);
if (S_OK == hr)
{
// If this is the 'lookin' value, cache the path.
if (IsConstraintName(L"LookIn", bstrName))
{
if (VT_BSTR == varValue.vt && varValue.bstrVal)
{
USES_CONVERSION;
// Assign path and clear display name (which we don't know or care about).
if (_bScoped)
AssignNamespace(W2T(varValue.bstrVal), NULL, NULL, FALSE);
else
{
lstrcpyn(_szInitialPath, W2T(varValue.bstrVal), ARRAYSIZE(_szInitialPath));
*_szInitialNames = 0;
}
}
}
else
RestoreConstraint(bstrName, &varValue);
VariantClear(&varValue);
}
}
SysFreeString(bstrName);
}
pdfc->Release();
}
LayoutControls();
_pfsb->UpdateLayout();
}
HRESULT FirstIDList(IEnumIDList *penum, LPITEMIDLIST *ppidl)
{
penum->Reset();
return penum->Next(1, ppidl, NULL);
}
HRESULT CFindFilesDlg::_GetTargetNamespace(IEnumIDList **ppenum)
{
*ppenum = NULL;
// We don't trust the comboex to handle the edit text properly so try to compensate...
TCHAR szText[MAX_PATH];
GetDlgItemText(IDC_NAMESPACE, szText, ARRAYSIZE(szText));
INT_PTR iCurSel = SendDlgItemMessage(IDC_NAMESPACE, CB_GETCURSEL, 0, 0);
if (CB_ERR != iCurSel)
{
TCHAR szItemName[MAX_PATH];
if (CB_ERR == SendDlgItemMessage(IDC_NAMESPACE, CB_GETLBTEXT, (WPARAM)iCurSel, (LPARAM)szItemName))
szItemName[0] = 0;
*ppenum = _GetItems(iCurSel);
if (*ppenum)
{
if (lstrcmp(szText, szItemName))
*ppenum = NULL; // combo edit/combo dropdown mismatch!
}
}
return *ppenum ? S_OK : E_FAIL;
}
void CFindFilesDlg::Clear()
{
CSearchCmdDlg::Clear();
// Clear edit fields
SetDlgItemText(IDC_FILESPEC, NULL);
SetDlgItemText(IDC_GREPTEXT, NULL);
_dlgOptions.Clear();
_pfsb->UpdateLayout(BLF_ALL);
}
void CFindFilesDlg::LoadSaveUIState(UINT nIDCtl, BOOL bSave)
{
if (0 == nIDCtl) // load/save all.
{
LoadSaveUIState(IDC_SEARCHLINK_OPTIONS, bSave);
LoadSaveUIState(LSUIS_WARNING, bSave);
}
HKEY hkey = _pfsb->GetBandRegKey(bSave);
if (hkey)
{
DWORD dwData;
DWORD cbData;
DWORD dwType;
LPCTSTR pszVal = NULL;
switch (nIDCtl)
{
case IDC_SEARCHLINK_OPTIONS:
pszVal = TEXT("UseSearchOptions");
dwData = _fDisplayOptions;
cbData = sizeof(dwData);
dwType = REG_DWORD;
break;
case LSUIS_WARNING:
pszVal = TEXT("Warnings");
dwData = _dwWarningFlags;
cbData = sizeof(_dwWarningFlags);
dwType = REG_DWORD;
break;
}
if (bSave)
RegSetValueEx(hkey, pszVal, 0, dwType, (LPBYTE)&dwData, cbData);
else
{
if (ERROR_SUCCESS == RegQueryValueEx(hkey, pszVal, 0, &dwType,
(LPBYTE)&dwData, &cbData))
{
switch (nIDCtl)
{
case IDC_SEARCHLINK_OPTIONS:
_fDisplayOptions = BOOLIFY(dwData);
break;
case LSUIS_WARNING:
_dwWarningFlags = dwData;
break;
}
}
}
RegCloseKey(hkey);
}
}
HWND CFindFilesDlg::GetFirstTabItem() const
{
return GetDlgItem(FSEARCHMAIN_TABFIRST);
}
HWND CFindFilesDlg::GetLastTabItem() const
{
return GetDlgItem(FSEARCHMAIN_TABLAST);
}
BOOL CFindFilesDlg::GetAutoCompleteObjectForWindow(HWND hwnd, IAutoComplete2** ppac2)
{
*ppac2 = NULL;
if (hwnd == GetDlgItem(IDC_FILESPEC))
*ppac2 = _pacFileSpec;
else if (hwnd == GetDlgItem(IDC_GREPTEXT))
*ppac2 = _pacGrepText;
if (*ppac2)
{
(*ppac2)->AddRef();
return TRUE;
}
return CBandDlg::GetAutoCompleteObjectForWindow(hwnd, ppac2);
}
void CFindFilesDlg::_ShowNamespaceEditImage(BOOL bShow)
{
SendDlgItemMessage(IDC_NAMESPACE, CBEM_SETEXTENDEDSTYLE, CBES_EX_NOEDITIMAGE, bShow ? 0 : CBES_EX_NOEDITIMAGE);
}
STDMETHODIMP CFindFilesDlg::TranslateAccelerator(MSG *pmsg)
{
// Check for Ctrl+Nav Key:
if (S_OK == CSearchCmdDlg::TranslateAccelerator(pmsg))
return S_OK;
// Check for VK_RETURN key.
if (WM_KEYDOWN == pmsg->message)
{
HWND hwndFocus = ::GetFocus();
if (hwndFocus == GetDlgItem(IDC_NAMESPACE) || ::IsChild(GetDlgItem(IDC_NAMESPACE), hwndFocus))
{
if (VK_RETURN == pmsg->wParam || VK_TAB == pmsg->wParam || VK_F6 == pmsg->wParam)
{
_UIReconcileNamespace();
}
else
{
// Hide edit image if this virtkey maps to a character,
if (MapVirtualKey((UINT)pmsg->wParam, 2) != 0 /* it's a char */)
_fNamespace = TRUE;
_ShowNamespaceEditImage(!_fNamespace);
}
}
}
if (_dlgOptions.IsChild(pmsg->hwnd) &&
S_OK == _dlgOptions.TranslateAccelerator(pmsg))
return S_OK;
// Handle it ourselves...
return _pfsb->IsDlgMessage(m_hWnd, pmsg);
}
BOOL CFindFilesDlg::GetMinSize(HWND hwndOC, SIZE *psize) const
{
CMetrics& metrics = _pfsb->GetMetrics();
RECT rc;
// Calculate minimum tracking width.
ASSERT(psize);
psize->cx = psize->cy = 0;
if (!::IsWindow(m_hWnd))
return FALSE;
// determine mininum width
HWND hwndLimit = GetDlgItem(FSEARCHMAIN_RIGHTMOST);
if (!::GetWindowRect(hwndLimit, &rc))
{
ASSERT(hwndLimit != NULL);
return FALSE;
}
::MapWindowRect(NULL, m_hWnd, &rc);
psize->cx = rc.right + metrics.CtlMarginX();
// determine mininum height
hwndLimit = GetDlgItem(FSEARCHMAIN_BOTTOMMOST);
if (!(::IsWindow(hwndLimit) && ::GetWindowRect(hwndLimit, &rc)))
return FALSE;
::MapWindowRect(NULL, m_hWnd, &rc);
psize->cy = rc.bottom + metrics.TightMarginY();
return TRUE;
}
int CFindFilesDlg::GetIdealDeskbandWidth() const
{
LONG cx0 = _GetResourceMetric(m_hWnd, IDS_FSEARCH_BANDWIDTH, TRUE);
ASSERT(cx0 >= 0);
return cx0 + (_pfsb->GetMetrics().CtlMarginX() * 2);
}
BOOL CFindFilesDlg::GetMinMaxInfo(HWND hwndOC, LPMINMAXINFO pmmi)
{
SIZE sizeMin;
if (GetMinSize(hwndOC, &sizeMin))
{
pmmi->ptMinTrackSize.x = sizeMin.cx;
pmmi->ptMinTrackSize.y = sizeMin.cy;
return TRUE;
}
return FALSE;
}
void CFindFilesDlg::LayoutControls(int cx, int cy)
{
if (cx < 0 || cy < 0)
{
RECT rcClient;
GetClientRect(&rcClient);
cx = RECTWIDTH(rcClient);
cy = RECTHEIGHT(rcClient);
}
CBandDlg::LayoutControls(cx, cy);
CMetrics& metrics = _pfsb->GetMetrics();
POINT ptOrigin = metrics.ExpandOrigin();
HDWP hdwp = BeginDeferWindowPos(6);
if (hdwp)
{
// Resize edit, combo immediate children
int i;
enum { ircFILESPEC,
ircGREPTEXT,
ircNAMESPACE,
ircSEARCHSTART,
ircOPTIONGRP,
ircOPTIONSDLG,
ircLINKCAPTION,
ircDIV2,
irc_count };
RECT rcCtls[irc_count];
::GetWindowRect(GetDlgItem(IDC_FILESPEC), &rcCtls[ircFILESPEC]);
::GetWindowRect(GetDlgItem(IDC_GREPTEXT), &rcCtls[ircGREPTEXT]);
::GetWindowRect(GetDlgItem(IDC_NAMESPACE), &rcCtls[ircNAMESPACE]);
::GetWindowRect(GetDlgItem(IDC_SEARCH_START), &rcCtls[ircSEARCHSTART]);
::GetWindowRect(GetDlgItem(IDC_GROUPBTN_OPTIONS), &rcCtls[ircOPTIONGRP]);
::GetWindowRect(GetDlgItem(IDC_SEARCHLINK_CAPTION), &rcCtls[ircLINKCAPTION]);
::GetWindowRect(GetDlgItem(IDC_FSEARCH_DIV2), &rcCtls[ircDIV2]);
SIZE sizeOptions;
_dlgOptions.GetWindowRect(&rcCtls[ircOPTIONSDLG]);
_dlgOptions.GetMinSize(&sizeOptions);
rcCtls[ircOPTIONSDLG].bottom = rcCtls[ircOPTIONSDLG].top + sizeOptions.cy;
for (i = 0; i < ARRAYSIZE(rcCtls); i++)
{
// MapWindowPoints is mirroring aware only if you pass two points
::MapWindowRect(NULL, m_hWnd, &rcCtls[i]);
}
// Position caption elements
_LayoutCaption(IDC_FSEARCH_CAPTION, IDC_FSEARCH_ICON, IDC_FSEARCH_DIV1, cx);
// Resize ctl widths
for (i = 0; i < irc_count; i++)
rcCtls[i].right = cx - metrics.CtlMarginX();
// Stretch the 'Named' combo:
::DeferWindowPos(hdwp, GetDlgItem(IDC_FILESPEC), NULL, 0, 0,
RECTWIDTH(*(rcCtls + ircFILESPEC)), RECTHEIGHT(*(rcCtls + ircFILESPEC)),
SWP_NOMOVE|SWP_NOZORDER|SWP_NOACTIVATE);
// Stretch the 'Containing Text' combo:
::DeferWindowPos(hdwp, GetDlgItem(IDC_GREPTEXT), NULL, 0, 0,
RECTWIDTH(*(rcCtls + ircGREPTEXT)), RECTHEIGHT(*(rcCtls + ircGREPTEXT)),
SWP_NOMOVE|SWP_NOZORDER|SWP_NOACTIVATE);
// Stretch the 'Look In' combo
::DeferWindowPos(hdwp, GetDlgItem(IDC_NAMESPACE), NULL, 0, 0,
RECTWIDTH(*(rcCtls + ircNAMESPACE)), RECTHEIGHT(*(rcCtls + ircNAMESPACE)),
SWP_NOMOVE|SWP_NOZORDER|SWP_NOACTIVATE);
// Arrange dynamically positioned controls.
ptOrigin.y = rcCtls[ircSEARCHSTART].bottom + metrics.LooseMarginY();
if (_fDisplayOptions)
{
OffsetRect(&rcCtls[ircOPTIONGRP], metrics.CtlMarginX() - rcCtls[ircOPTIONGRP].left,
ptOrigin.y - rcCtls[ircOPTIONGRP].top);
rcCtls[ircOPTIONSDLG].right = cx - metrics.CtlMarginX();
::SetWindowPos(GetDlgItem(IDC_GROUPBTN_OPTIONS), NULL,
rcCtls[ircOPTIONGRP].left, rcCtls[ircOPTIONGRP].top,
RECTWIDTH(rcCtls[ircOPTIONGRP]), RECTHEIGHT(rcCtls[ircOPTIONGRP]),
SWP_NOZORDER|SWP_NOACTIVATE);
::GetWindowRect(GetDlgItem(IDC_GROUPBTN_OPTIONS), &rcCtls[ircOPTIONGRP]);
::MapWindowRect(NULL, m_hWnd, &rcCtls[ircOPTIONGRP]);
ptOrigin.y = rcCtls[ircOPTIONGRP].bottom + metrics.TightMarginY();
}
else
{
// Position the 'Options' link
_LayoutLinkWindow(m_hWnd, metrics.CtlMarginX(), cx - metrics.CtlMarginX(), metrics.TightMarginY(),
ptOrigin.y, IDC_SEARCHLINK_OPTIONS);
}
ptOrigin.y += metrics.TightMarginY();
// Position the 'Search for Other Items' caption, divider and link windows
const int rgLinkIDs[] = {
IDC_SEARCHLINK_FILES,
IDC_SEARCHLINK_COMPUTERS,
IDC_SEARCHLINK_PRINTERS,
IDC_SEARCHLINK_PEOPLE,
-IDC_FSEARCH_DIV3,
IDC_SEARCHLINK_INTERNET,
};
_LayoutSearchLinks(IDC_SEARCHLINK_CAPTION, IDC_FSEARCH_DIV2, !_fDisplayOptions,
metrics.CtlMarginX(), cx - metrics.CtlMarginX(), metrics.TightMarginY(),
ptOrigin.y, rgLinkIDs, ARRAYSIZE(rgLinkIDs));
EndDeferWindowPos(hdwp);
}
}
LRESULT CFindFilesDlg::OnUpdateLayout(UINT, WPARAM wParam, LPARAM, BOOL&)
{
LayoutControls();
_pfsb->UpdateLayout((ULONG)wParam);
return 0;
}
LRESULT CFindFilesDlg::OnTimer(UINT, WPARAM wParam, LPARAM, BOOL&)
{
if (UISTATETIMER == wParam && IsWindowVisible())
UpdateSearchCmdStateUI();
return 0;
}
LRESULT CFindFilesDlg::OnOptions(int idCtl, NMHDR *pnmh, BOOL&)
{
_ShowOptions(!_fDisplayOptions);
LoadSaveUIState(IDC_SEARCHLINK_OPTIONS, TRUE);
if (_fDisplayOptions)
_dlgOptions.TakeFocus();
else
::SetFocus(GetDlgItem(IDC_SEARCHLINK_OPTIONS));
return 0;
}
void CFindFilesDlg::_ShowOptions(BOOL bShow)
{
_fDisplayOptions = bShow;
// don't need to scroll if we've expanded a subdialog,
// but we do if we've contracted one.
ULONG dwLayoutFlags = BLF_ALL;
if (_fDisplayOptions)
dwLayoutFlags &= ~BLF_SCROLLWINDOW;
LayoutControls();
_pfsb->UpdateLayout(dwLayoutFlags);
::ShowWindow(GetDlgItem(IDC_GROUPBTN_OPTIONS), _fDisplayOptions ? SW_SHOW : SW_HIDE);
::ShowWindow(GetDlgItem(IDC_SEARCHLINK_OPTIONS), !_fDisplayOptions ? SW_SHOW : SW_HIDE);
}
LRESULT CFindFilesDlg::OnQueryOptionsHeight(int idCtl, NMHDR *pnmh, BOOL&)
{
GBNQUERYBUDDYSIZE* pqbs = (GBNQUERYBUDDYSIZE*)pnmh;
pqbs->cy = _dlgOptions.QueryHeight(pqbs->cx, pqbs->cy);
return TRUE;
}
void CFindFilesDlg::UpdateSearchCmdStateUI(DISPID eventID)
{
if (_fOnDestroy)
return;
if (DISPID_SEARCHCOMMAND_COMPLETE == eventID
|| DISPID_SEARCHCOMMAND_ABORT == eventID)
_dwRunOnceWarningFlags = DFW_DEFAULT;
CSearchCmdDlg::UpdateSearchCmdStateUI(eventID);
_dlgOptions.UpdateSearchCmdStateUI(eventID);
}
BOOL CFindFilesDlg::OnSearchCmdError(HRESULT hr, LPCTSTR pszError)
{
if (SCEE_SCOPEMISMATCH == HRESULT_CODE(hr)
|| SCEE_INDEXNOTCOMPLETE == HRESULT_CODE(hr))
{
// Set up checkbox
BOOL fFlag = SCEE_SCOPEMISMATCH == HRESULT_CODE(hr)? DFW_IGNORE_CISCOPEMISMATCH :
DFW_IGNORE_INDEXNOTCOMPLETE ,
fNoWarn = (_dwWarningFlags & fFlag) != 0,
fNoWarnPrev = fNoWarn;
USHORT uDlgT = SCEE_SCOPEMISMATCH == HRESULT_CODE(hr)? DLG_FSEARCH_SCOPEMISMATCH :
DLG_FSEARCH_INDEXNOTCOMPLETE ;
int nRet = CSearchWarningDlg_DoModal(m_hWnd, uDlgT, &fNoWarn);
if (fNoWarn)
_dwWarningFlags |= fFlag;
else
_dwWarningFlags &= ~fFlag;
if (fNoWarnPrev != fNoWarn)
LoadSaveUIState(LSUIS_WARNING, TRUE);
if (IDOK == nRet)
{
_dwRunOnceWarningFlags |= _dwWarningFlags | fFlag ; // preserve the old run once flags...
// hack one, hack two... let's be USER!!! [scotthan]
PostMessage(WM_COMMAND, MAKEWPARAM(IDC_SEARCH_START, BN_CLICKED),
(LPARAM)GetDlgItem(IDC_SEARCH_START));
}
else
::SetFocus(GetDlgItem(IDC_NAMESPACE));
return TRUE;
}
return CSearchCmdDlg::OnSearchCmdError(hr, pszError);
}
LRESULT CFindFilesDlg::OnBtnClick(WORD nCode, WORD nID, HWND hwndCtl, BOOL&)
{
switch (nID)
{
case IDC_SEARCH_START:
if (_ShouldReconcileNamespace())
_UIReconcileNamespace(TRUE);
if (SUCCEEDED(StartSearch()))
{
EnableStartStopButton(hwndCtl, FALSE);
StartStopAnimation(TRUE);
}
break;
case IDC_SEARCH_STOP:
StopSearch();
break;
}
return 0;
}
void CFindFilesDlg::NavigateToResults(IWebBrowser2* pwb2)
{
BSTR bstrUrl = SysAllocString(L"::{e17d4fc0-5564-11d1-83f2-00a0c90dc849}");// CLSID_DocFindFolder
if (bstrUrl)
{
VARIANT varNil = {0};
pwb2->Navigate(bstrUrl, &varNil, &varNil, &varNil, &varNil);
SysFreeString(bstrUrl);
}
}
LRESULT CFindFilesDlg::OnStateChange(UINT, WPARAM, LPARAM, BOOL&)
{
UpdateSearchCmdStateUI();
return 0;
}
LRESULT CFindFilesDlg::OnNamespaceSelEndOk(WORD nCode, WORD nID, HWND hwndCtl, BOOL&)
{
LRESULT iSel = SendDlgItemMessage(IDC_NAMESPACE, CB_GETCURSEL, 0, 0);
if (iSel != CB_ERR)
{
IEnumIDList *penum = _GetItems(iSel);
if (NULL == penum)
_BrowseAndAssignNamespace(); // Was this the "Browse..." item
else
_iCurNamespace = iSel;
}
_pfsb->SetDirty();
return 0;
}
LRESULT CFindFilesDlg::OnNamespaceEditChange(WORD wID, WORD wCode, HWND hwndCtl, BOOL& bHandled)
{
return OnEditChange(wID, wCode, hwndCtl, bHandled);
}
// Handler for CBN_SELENDCANCEL, CBN_DROPDOWN, CBN_KILLFOCUS
LRESULT CFindFilesDlg::OnNamespaceReconcileCmd(WORD wID, WORD wCode, HWND hwndCtl, BOOL&)
{
if (_ShouldReconcileNamespace())
_UIReconcileNamespace(wCode != CBN_DROPDOWN);
return 0;
}
// Handler for WM_NOTIFY::CBEN_ENDEDIT
LRESULT CFindFilesDlg::OnNamespaceReconcileNotify(int idCtl, NMHDR *pnmh, BOOL& bHandled)
{
if (_ShouldReconcileNamespace())
{
// Post ourselves a message to reconcile the ad hoc namespace.
// Note: We need to do this because ComboBoxEx won't update his window text if he
// is waiting for his CBEN_ENDEDIT notification message to return.
PostMessage(WMU_NAMESPACERECONCILE, 0, 0);
}
bHandled = FALSE; // let base class have a crack as well.
return 0;
}
// WMU_NAMESPACERECONCILE handler
LRESULT CFindFilesDlg::OnNamespaceReconcileMsg(UINT, WPARAM, LPARAM, BOOL&)
{
if (_ShouldReconcileNamespace())
_UIReconcileNamespace(FALSE);
return 0;
}
// WMU_BANDFINISHEDDISPLAYING handler
// Note that we do not care about returning results from this, as it will
// be started asynchronously.
LRESULT CFindFilesDlg::OnBandFinishedDisplaying(UINT, WPARAM, LPARAM, BOOL&)
{
// Now that the search band has finished displaying, we will do the
// delayed initialization. Make sure we don't do it twice.
if (!_fBandFinishedDisplaying)
{
_fBandFinishedDisplaying = TRUE;
_dlgOptions.DoDelayedInit();
}
return 0;
}
BOOL CFindFilesDlg::_ShouldReconcileNamespace()
{
return _fNamespace || SendDlgItemMessage(IDC_NAMESPACE, CB_GETCURSEL, 0, 0) == CB_ERR;
}
// Invokes lower Namespace reconciliation helper, updates some UI and
// instance state data.
// this was added as a late RC 'safe' delta, and should have actually
// become part of _ReconcileNamespace() impl.
void CFindFilesDlg::_UIReconcileNamespace(BOOL bAsync)
{
LRESULT iSel = _ReconcileNamespace(bAsync);
if (iSel != CB_ERR)
_iCurNamespace = iSel;
_ShowNamespaceEditImage(TRUE);
_fNamespace = FALSE; // clear the ad hoc flag.
}
// Scans namespace combo for a matching namespace; if found, selects
// the namespace item, otherwise adds an adhoc item and selects it.
//
// Important: don't call this directly, call _UIReconcileNamespace()
// instead to ensure that instance state data is updated.
INT_PTR CFindFilesDlg::_ReconcileNamespace(OPTIONAL BOOL bAsync)
{
INT_PTR iSel = SendDlgItemMessage(IDC_NAMESPACE, CB_GETCURSEL, 0, 0);
if ((CB_ERR != iSel) && (NULL == _GetItems(iSel)))
{
// The user has selected the special Browse... item.
// Irreconcilable. Return CB_ERR
return CB_ERR;
}
// Don't know the namespace? Use current window text.
TCHAR szNamespace[MAX_URL_STRING];
if (0 == GetDlgItemText(IDC_NAMESPACE, szNamespace, ARRAYSIZE(szNamespace)))
return CB_ERR;
INT_PTR iFind = _FindNamespace(szNamespace, NULL);
// search display names
if (CB_ERR == iFind)
{
// search paths
TCHAR szTemp[MAX_URL_STRING];
StrCpy(szTemp, szNamespace);
_PathFixup(szNamespace, szTemp); // don't care if this fails, the path might be a path list
iFind = _FindNamespace(szNamespace, NULL);
}
// Not found in CB list? Add it if it's a valid path
if (CB_ERR == iFind)
{
iSel = _AddNamespace(szNamespace, NULL, szNamespace, TRUE);
}
else
{
// found in CB list? Select it.
if (bAsync)
{
// this was needed in cases of reconcile following kill focus
::PostMessage(GetDlgItem(IDC_NAMESPACE), CB_SETCURSEL, iFind, 0);
}
else
{
iSel = SendDlgItemMessage(IDC_NAMESPACE, CB_SETCURSEL, iFind, 0);
}
}
return iSel;
}
BOOL CFindFilesDlg::_PathFixup(LPTSTR pszDst, LPCTSTR pszSrc)
{
ASSERT(pszDst);
ASSERT(pszSrc);
TCHAR szSrc[MAX_PATH];
TCHAR szFull[MAX_PATH];
if (SHExpandEnvironmentStrings(pszSrc, szSrc, ARRAYSIZE(szSrc)) && *szSrc)
pszSrc = szSrc;
if (_IsPathList(pszSrc))
{
lstrcpy(pszDst, pszSrc);
return TRUE;
}
szFull[0] = 0;
BOOL bRelative = PathIsRelative(pszSrc);
BOOL bMissingDrive = bRelative ? FALSE : _IsFullPathMinusDriveLetter(pszSrc);
// bMissingDrive =,e.g. "\foo", "\foo\bar", etc. PathIsRelative() reports FALSE in this case.
if (bRelative || bMissingDrive)
{
ASSERT(_pfsb && _pfsb->BandSite());
LPITEMIDLIST pidl;
HRESULT hr = _GetCurrentFolderIDList(_pfsb->BandSite(), &pidl);
if (S_OK == hr)
{
TCHAR szCurDir[MAX_PATH];
// file system path only here!
if (SHGetPathFromIDList(pidl, szCurDir) &&
StrCmpI(szCurDir, _szCurrentPath))
{
lstrcpy(_szCurrentPath, szCurDir);
}
if (*_szCurrentPath)
{
if (bRelative)
{
if (PathCombine(szFull, _szCurrentPath, pszSrc))
pszSrc = szFull;
}
else if (bMissingDrive)
{
int iDrive = PathGetDriveNumber(_szCurrentPath);
if (-1 != iDrive)
{
TCHAR szRoot[MAX_PATH];
if (PathCombine(szFull, PathBuildRoot(szRoot, iDrive), pszSrc))
pszSrc = szFull;
}
}
}
ILFree(pidl);
}
}
return PathCanonicalize(pszDst, pszSrc);
}
LRESULT CFindFilesDlg::OnNamespaceDeleteItem(int idCtrl, NMHDR *pnmh, BOOL& bHandled)
{
PNMCOMBOBOXEX pnmce = (PNMCOMBOBOXEX)pnmh;
if (pnmce->ceItem.lParam)
{
IEnumIDList *penum = (IEnumIDList *)pnmce->ceItem.lParam;
penum->Release();
}
return 1;
}
DWORD CFindFilesDlg::NamespaceThreadProc(void* pv)
{
FSEARCHTHREADSTATE *pState = (FSEARCHTHREADSTATE *)pv;
CFindFilesDlg* pThis = (CFindFilesDlg*)pState->pvParam;
if (PopulateNamespaceCombo(pState->hwndCtl, AddNamespaceItemNotify, (LPARAM)pv) != E_ABORT)
{
::PostMessage(::GetParent(pState->hwndCtl), WMU_COMBOPOPULATIONCOMPLETE, (WPARAM)pState->hwndCtl, 0);
}
pState->fComplete = TRUE;
ATOMICRELEASE(pState->punkBand);
return 0;
}
#define CBX_CSIDL_LOCALDRIVES 0x04FF // arbitrarily out of range of other CSIDL_xxx values.
HRESULT CFindFilesDlg::AddNamespaceItemNotify(ULONG fAction, PCBXITEM pItem, LPARAM lParam)
{
FSEARCHTHREADSTATE *pState = (FSEARCHTHREADSTATE *)lParam;
if (fAction & CBXCB_ADDING && pState->fCancel)
return E_ABORT;
//
// Sets the string in the CFindFilesDlg as the display name.
// This string is then used to set the default item in the
// combo box.
//
if (fAction & CBXCB_ADDED && CBX_CSIDL_LOCALDRIVES == pItem->iID)
{
CFindFilesDlg* pffd = (CFindFilesDlg*)pState->pvParam;
lstrcpyn(pffd->_szLocalDrives, pItem->szText, ARRAYSIZE(pffd->_szLocalDrives));
}
return S_OK;
}
LRESULT CFindFilesDlg::OnComboPopulationComplete(UINT, WPARAM wParam, LPARAM, BOOL&)
{
_bScoped = SetDefaultScope();
return 0;
}
// bPassive TRUE -> assign only if no current selection
BOOL CFindFilesDlg::AssignNamespace(LPCTSTR pszPath, LPCITEMIDLIST pidl, LPCTSTR pszName, BOOL bPassive)
{
INT_PTR iSel = CB_ERR;
// If we don't yet have a current selection, establish it now.
if (!bPassive || CB_ERR == (iSel = SendDlgItemMessage(IDC_NAMESPACE, CB_GETCURSEL, 0, 0)))
{
iSel = _FindNamespace(pszPath, pidl);
// scan items by display name if we don't have pidl
// otherwise choosing x:\my pictures (in browse) would end up selecting
// my pictures folder and searching the wrong place
if (CB_ERR == iSel && !pidl && !pszPath && pszName && *pszName)
iSel = _FindNamespace(pszName, NULL);
// Is this a folder we already know about?
if (CB_ERR == iSel)
{
if (pidl || pszPath)
iSel = _AddNamespace(pszPath, pidl, pszName, TRUE);
if (iSel != CB_ERR)
_iCurNamespace = iSel;
}
else
{
// yes: select it
SendDlgItemMessage(IDC_NAMESPACE, CB_SETCURSEL, iSel, 0);
_iCurNamespace = iSel;
}
}
return CB_ERR != SendDlgItemMessage(IDC_NAMESPACE, CB_GETCURSEL, 0, 0);
}
HWND CFindFilesDlg::ShowHelp(HWND hwnd)
{
return ::HtmlHelp(hwnd, TEXT("find.chm"), HH_DISPLAY_TOPIC, 0);
}
// inserts something into the name space combo
INT_PTR CFindFilesDlg::_AddNamespace(LPCTSTR pszPath, LPCITEMIDLIST pidl, LPCTSTR pszName, BOOL bSelectItem)
{
IEnumIDList *penum = NULL;
if (pszPath)
{
CreateIEnumIDListPaths(pszPath, &penum);
}
else if (pidl)
{
CreateIEnumIDListOnIDLists(&pidl, 1, &penum);
}
CBXITEM item;
item.iItem = CB_ERR; // failure result here
if (penum)
{
LPITEMIDLIST pidlIcon;
if (S_OK == FirstIDList(penum, &pidlIcon))
{
if (NULL == pszName)
pszName = pszPath;
MakeCbxItem(&item, pszName, penum, pidlIcon, LISTINSERT_LAST, 1);
INT_PTR iSel = item.iItem;
if (SUCCEEDED(AddCbxItemToComboBox(GetDlgItem(IDC_NAMESPACE), &item, &iSel)))
{
penum = NULL; // don't release below
item.iItem = iSel;
if (bSelectItem)
SendDlgItemMessage(IDC_NAMESPACE, CB_SETCURSEL, iSel, 0);
}
else
{
item.iItem = CB_ERR;
}
ILFree(pidlIcon);
}
if (penum)
penum->Release(); // not inserted, free this
}
return item.iItem;
}
LPARAM CFindFilesDlg::_GetComboData(UINT id, INT_PTR idx)
{
if (CB_ERR == idx)
idx = SendDlgItemMessage(id, CB_GETCURSEL, 0, 0);
if (CB_ERR == idx)
return idx;
return (LPARAM)SendDlgItemMessage(id, CB_GETITEMDATA, idx, 0);
}
IEnumIDList *CFindFilesDlg::_GetItems(INT_PTR i)
{
IEnumIDList *penum = (IEnumIDList *)_GetComboData(IDC_NAMESPACE, i);
return (INVALID_HANDLE_VALUE != penum) ? penum : NULL;
}
BOOL MatchItem(IEnumIDList *penum, LPCTSTR pszPath, LPCITEMIDLIST pidl)
{
BOOL bMatch = FALSE;
// this is somewhat imprecise as we will match on the first IDList in the
// enumerator. but generally that is the desired behavior for the special
// items that include multiple implied items
LPITEMIDLIST pidlFirst;
if (S_OK == FirstIDList(penum, &pidlFirst))
{
bMatch = pidl && ILIsEqual(pidl, pidlFirst);
if (!bMatch && pszPath)
{
TCHAR szPath[MAX_PATH];
if (SUCCEEDED(SHGetNameAndFlags(pidlFirst, SHGDN_FORPARSING, szPath, ARRAYSIZE(szPath), NULL)))
{
bMatch = (0 == StrCmpI(pszPath, szPath));
}
}
ILFree(pidlFirst);
}
return bMatch;
}
// searches namespace comboboxex for the indicated item
// returns:
// index of item, CB_ERR (-1) if not found
INT_PTR CFindFilesDlg::_FindNamespace(LPCTSTR pszPath, LPCITEMIDLIST pidl)
{
for (INT_PTR i = 0, cnt = SendDlgItemMessage(IDC_NAMESPACE, CB_GETCOUNT, 0, 0); i < cnt; i++)
{
IEnumIDList *penum = _GetItems(i);
if (penum)
{
if (MatchItem(penum, pszPath, pidl))
return i;
}
}
// fall back to finding by display name in the combo
if (pszPath)
return SendDlgItemMessage(IDC_NAMESPACE, CB_FINDSTRINGEXACT, -1, (LPARAM)pszPath);
return CB_ERR;
}
// Invokes UI to select a namespace.
//
// Returns:
// S_OK if the user has selected a valid item and the pszNamespace contains
// a valid shell folder display name.
// E_ABORT if the user canceled his search
// E_FAIL if an error occurred
HRESULT CFindFilesDlg::_BrowseForNamespace(LPTSTR pszName, UINT cchName, LPITEMIDLIST *ppidlRet)
{
*pszName = 0;
TCHAR szTitle[128];
LoadString(HINST_THISDLL, IDS_SNS_BROWSERFORDIR_TITLE, szTitle, ARRAYSIZE(szTitle));
BROWSEINFO bi = {0};
bi.hwndOwner = m_hWnd;
bi.lpszTitle = szTitle;
bi.ulFlags = BIF_USENEWUI | BIF_EDITBOX; // | BIF_RETURNFSANCESTORS | BIF_RETURNONLYFSDIRS;
bi.lpfn = _BrowseCallback;
bi.lParam = (LPARAM)this;
HRESULT hr;
*ppidlRet = SHBrowseForFolder(&bi);
if (*ppidlRet)
{
SHGetNameAndFlags(*ppidlRet, SHGDN_NORMAL, pszName, cchName, NULL);
hr = S_OK;
}
else
{
hr = E_ABORT;
}
return hr;
}
// Invokes SHBrowserForFolder UI and assigns results.
void CFindFilesDlg::_BrowseAndAssignNamespace()
{
TCHAR szName[MAX_PATH];
LPITEMIDLIST pidl;
if (SUCCEEDED(_BrowseForNamespace(szName, ARRAYSIZE(szName), &pidl)))
{
AssignNamespace(NULL, pidl, szName, FALSE);
ILFree(pidl);
}
else
{
SendDlgItemMessage(IDC_NAMESPACE, CB_SETCURSEL, _iCurNamespace, 0);
}
}
BOOL CFindFilesDlg::_IsSearchableFolder(LPCITEMIDLIST pidlFolder)
{
return TRUE;
}
int CFindFilesDlg::_BrowseCallback(HWND hwnd, UINT msg, LPARAM lParam, LPARAM lpData)
{
CFindFilesDlg *pThis = (CFindFilesDlg *)lpData;
switch (msg)
{
case BFFM_INITIALIZED: // initializing: set default selection to drives if we can
{
LPITEMIDLIST pidlDefault = SHCloneSpecialIDList(NULL, CSIDL_DRIVES, TRUE);
if (pidlDefault)
{
if (!::SendMessage(hwnd, BFFM_SETSELECTION, FALSE, (LPARAM)pidlDefault)) // if we fail to default to drives, default to desktop
{
ILFree(pidlDefault);
pidlDefault = SHCloneSpecialIDList(NULL, CSIDL_DESKTOP, TRUE);
::SendMessage(hwnd, BFFM_SETSELECTION, FALSE, (LPARAM)pidlDefault);
}
ILFree(pidlDefault);
}
}
break;
case BFFM_SELCHANGED: // prevent non-searchable folder pidls from being selected.
{
BOOL bAllow = pThis->_IsSearchableFolder((LPCITEMIDLIST)lParam);
::SendMessage(hwnd, BFFM_ENABLEOK, 0, (LPARAM)bAllow);
}
break;
}
return 0;
}
class CSearchWarningDlg
{
private:
CSearchWarningDlg() : _hwnd(NULL), _bNoWarn(FALSE) {}
static BOOL_PTR WINAPI DlgProc(HWND, UINT, WPARAM, LPARAM);
HWND _hwnd;
BOOL _bNoWarn;
friend int CSearchWarningDlg_DoModal(HWND hwndParent, USHORT uDlgT, BOOL* pbNoWarn);
};
int CSearchWarningDlg_DoModal(HWND hwndParent, USHORT uDlgTemplate, BOOL* pbNoWarn)
{
ASSERT(pbNoWarn);
CSearchWarningDlg dlg;
dlg._bNoWarn = *pbNoWarn;
int nRet = (int)DialogBoxParam(HINST_THISDLL, MAKEINTRESOURCE(uDlgTemplate),
hwndParent, CSearchWarningDlg::DlgProc, (LPARAM)&dlg);
*pbNoWarn = dlg._bNoWarn;
return nRet;
}
BOOL_PTR WINAPI CSearchWarningDlg::DlgProc(HWND hwnd, UINT uMsg, WPARAM wParam, LPARAM lParam)
{
CSearchWarningDlg* pdlg = (CSearchWarningDlg*)GetWindowPtr(hwnd, GWLP_USERDATA);
if (WM_INITDIALOG == uMsg)
{
pdlg = (CSearchWarningDlg*)lParam;
pdlg->_hwnd = hwnd;
SetWindowPtr(hwnd, GWLP_USERDATA, pdlg);
CheckDlgButton(hwnd, IDC_NOSCOPEWARNING, pdlg->_bNoWarn);
MessageBeep(MB_ICONASTERISK);
return TRUE;
}
if (pdlg)
{
switch (uMsg)
{
case WM_COMMAND:
switch (GET_WM_COMMAND_ID(wParam, lParam))
{
case IDOK:
case IDCANCEL:
pdlg->_bNoWarn = IsDlgButtonChecked(hwnd, IDC_NOSCOPEWARNING);
EndDialog(hwnd, GET_WM_COMMAND_ID(wParam, lParam));
break;
}
return TRUE;
}
}
return FALSE;
}
class CCISettingsDlg
{
public:
CCISettingsDlg() : _hwnd(NULL), _fCiIndexed(FALSE), _fCiRunning(FALSE), _fCiPermission(FALSE), _hProcessMMC(INVALID_HANDLE_VALUE)
{
}
~CCISettingsDlg()
{
if (_hProcessMMC != INVALID_HANDLE_VALUE)
CloseHandle(_hProcessMMC);
}
static int DoModal(HWND hwndParent);
static HWND CreateModeless(HWND hwndParent);
protected:
BOOL OnInitDialog();
BOOL OnOK();
private:
static BOOL_PTR WINAPI DlgProc(HWND, UINT, WPARAM, LPARAM);
void ShowAdvanced();
HWND _hwnd;
BOOL _fCiIndexed,
_fCiRunning,
_fCiPermission;
HANDLE _hProcessMMC;
friend int CCISettingsDlg_DoModal(HWND hwndParent);
};
int CCISettingsDlg_DoModal(HWND hwndParent)
{
CCISettingsDlg dlg;
return (int)DialogBoxParam(HINST_THISDLL, MAKEINTRESOURCE(DLG_INDEXSERVER),
hwndParent, CCISettingsDlg::DlgProc, (LPARAM)&dlg);
}
BOOL_PTR WINAPI CCISettingsDlg::DlgProc(HWND hDlg, UINT nMsg, WPARAM wParam, LPARAM lParam)
{
CCISettingsDlg* pdlg = (CCISettingsDlg*)GetWindowPtr(hDlg, GWLP_USERDATA);
if (WM_INITDIALOG == nMsg)
{
pdlg = (CCISettingsDlg*)lParam;
pdlg->_hwnd = hDlg;
SetWindowPtr(hDlg, GWLP_USERDATA, pdlg);
return pdlg->OnInitDialog();
}
if (pdlg)
{
switch (nMsg)
{
case WM_NCDESTROY:
return TRUE;
case WM_COMMAND:
switch (GET_WM_COMMAND_ID(wParam, lParam))
{
case IDC_CI_ADVANCED:
pdlg->ShowAdvanced();
break;
case IDOK:
if (pdlg->OnOK())
EndDialog(hDlg, IDOK);
break;
case IDCANCEL:
EndDialog(hDlg, GET_WM_COMMAND_ID(wParam, lParam));
break;
case IDC_CI_HELP:
_IndexServiceHelp(hDlg);
break;
}
return TRUE;
}
}
return FALSE;
}
void CCISettingsDlg::ShowAdvanced()
{
// have we already spawned MMC?
if (_hProcessMMC != INVALID_HANDLE_VALUE)
{
if (WaitForSingleObject(_hProcessMMC, 0) != WAIT_OBJECT_0)
{
// MMC is still running, let user ATL+TAB or something but don't launch a second copy
return;
}
_hProcessMMC = INVALID_HANDLE_VALUE;
}
SHELLEXECUTEINFO sei = { sizeof(sei) };
sei.fMask = SEE_MASK_NOCLOSEPROCESS;
sei.nShow = SW_SHOWNORMAL;
sei.lpFile = TEXT("ciadv.msc");
sei.lpParameters = TEXT("computername=localmachine");
if (ShellExecuteEx(&sei))
{
_hProcessMMC = sei.hProcess;
}
}
BOOL CCISettingsDlg::OnInitDialog()
{
TCHAR szStatusFmt[128], szStatusText[MAX_PATH];
UINT nStatusText = IDS_FSEARCH_CI_DISABLED;
GetCIStatus(&_fCiRunning, &_fCiIndexed, &_fCiPermission);
if (_fCiRunning)
{
if (_fCiPermission)
// permission to distinguish between ready, busy.
nStatusText = _fCiIndexed ? IDS_FSEARCH_CI_READY : IDS_FSEARCH_CI_BUSY;
else
// no permission to distinguish between ready, busy; just say it's enabled.
nStatusText = IDS_FSEARCH_CI_ENABLED;
}
if (LoadString(HINST_THISDLL, IDS_FSEARCH_CI_STATUSFMT, szStatusFmt, ARRAYSIZE(szStatusFmt)))
{
if (LoadString(HINST_THISDLL, nStatusText, szStatusText, ARRAYSIZE(szStatusText)))
{
TCHAR szStatus[MAX_PATH];
wnsprintf(szStatus, ARRAYSIZE(szStatus), szStatusFmt, szStatusText);
SetDlgItemText(_hwnd, IDC_CI_STATUS, szStatus);
}
}
CheckDlgButton(_hwnd, IDC_ENABLE_CI, _fCiRunning);
CheckDlgButton(_hwnd, IDC_BLOWOFF_CI, !_fCiRunning);
EnableWindow(GetDlgItem(_hwnd, IDC_CI_PROMPT), _fCiPermission);
EnableWindow(GetDlgItem(_hwnd, IDC_ENABLE_CI), _fCiPermission);
EnableWindow(GetDlgItem(_hwnd, IDC_BLOWOFF_CI), _fCiPermission);
return TRUE;
}
BOOL CCISettingsDlg::OnOK()
{
StartStopCI(IsDlgButtonChecked(_hwnd, IDC_ENABLE_CI) ? TRUE : FALSE);
return TRUE;
}
#ifdef __PSEARCH_BANDDLG__
// CFindPrintersDlg impl
#define PSEARCHDLG_TABFIRST IDC_PSEARCH_NAME
#define PSEARCHDLG_TABLAST IDC_SEARCHLINK_INTERNET
#define PSEARCHDLG_RIGHTMOST IDC_SEARCH_START
#define PSEARCHDLG_BOTTOMMOST IDC_SEARCHLINK_INTERNET
CFindPrintersDlg::CFindPrintersDlg(CFileSearchBand* pfsb)
: CBandDlg(pfsb)
{
}
CFindPrintersDlg::~CFindPrintersDlg()
{
}
LRESULT CFindPrintersDlg::OnInitDialog(UINT, WPARAM, LPARAM, BOOL&)
{
_Attach(m_hWnd);
ASSERT(Hwnd());
CMetrics& metrics = _pfsb->GetMetrics();
_pfsb->GetMetrics().Init(m_hWnd);
POINT pt;
pt.x = metrics.CtlMarginX();
pt.y = 0;
_CreateSearchLinks(m_hWnd, pt, IDC_SEARCHLINK_PRINTERS);
_CreateDivider(m_hWnd, IDC_FSEARCH_DIV1, pt, 2, GetDlgItem(IDC_PSEARCH_CAPTION));
_CreateDivider(m_hWnd, IDC_FSEARCH_DIV2, pt, 1, GetDlgItem(IDC_SEARCHLINK_CAPTION));
_CreateDivider(m_hWnd, IDC_FSEARCH_DIV3, pt, 1, GetDlgItem(IDC_SEARCHLINK_PEOPLE));
OnWinIniChange();
LayoutControls(-1, -1);
return TRUE;
}
void CFindPrintersDlg::LayoutControls(int cx, int cy)
{
if (cx < 0 || cy < 0)
{
RECT rc;
GetClientRect(&rc);
cx = RECTWIDTH(rc);
cy = RECTHEIGHT(rc);
}
CBandDlg::LayoutControls(cx, cy);
CMetrics& metrics = _pfsb->GetMetrics();
const UINT nIDCtl[] = {
IDC_PSEARCH_NAME,
IDC_PSEARCH_LOCATION,
IDC_PSEARCH_MODEL,
};
RECT rcCtl[ARRAYSIZE(nIDCtl)];
// Stretch edit boxes to fit horz
for (int i = 0; i< ARRAYSIZE(nIDCtl); i++)
{
HWND hwndCtl = GetDlgItem(nIDCtl[i]);
if (hwndCtl && ::GetWindowRect(hwndCtl, &rcCtl[i]))
{
::MapWindowRect(NULL, Hwnd(), &rcCtl[i]);
rcCtl[i].right = cx - metrics.CtlMarginX();
::SetWindowPos(hwndCtl, NULL, 0, 0,
RECTWIDTH(*(rcCtl+i)), RECTHEIGHT(*(rcCtl+i)),
SWP_NOMOVE|SWP_NOZORDER|SWP_NOACTIVATE);
}
else
SetRectEmpty(rcCtl + i);
}
// Position the 'Search for Other Items' caption, divider and link windows
const int rgLinks[] = {
IDC_SEARCHLINK_FILES,
IDC_SEARCHLINK_COMPUTERS,
IDC_SEARCHLINK_PRINTERS,
IDC_SEARCHLINK_PEOPLE,
-IDC_FSEARCH_DIV3,
IDC_SEARCHLINK_INTERNET,
};
RECT rc;
::GetWindowRect(GetDlgItem(IDC_SEARCH_START), &rc);
::MapWindowRect(NULL, m_hWnd, &rc);
rc.bottom += metrics.LooseMarginY();
_LayoutSearchLinks(IDC_SEARCHLINK_CAPTION, IDC_FSEARCH_DIV2, TRUE,
metrics.CtlMarginX(), cx - metrics.CtlMarginX(), metrics.TightMarginY(),
rc.bottom, rgLinks, ARRAYSIZE(rgLinks));
}
BOOL CFindPrintersDlg::Validate()
{
return TRUE;
}
void CFindPrintersDlg::Clear()
{
SetDlgItemText(IDC_PSEARCH_NAME, NULL);
SetDlgItemText(IDC_PSEARCH_LOCATION, NULL);
SetDlgItemText(IDC_PSEARCH_MODEL, NULL);
}
BOOL CFindPrintersDlg::GetMinSize(HWND hwndOC, SIZE *pSize) const
{
RECT rcRightmost, rcBottommost;
HWND hwndRightmost = GetDlgItem(PSEARCHDLG_RIGHTMOST),
hwndBottommost= GetDlgItem(PSEARCHDLG_BOTTOMMOST);
ASSERT(::IsWindow(hwndRightmost));
ASSERT(::IsWindow(hwndBottommost));
::GetWindowRect(hwndRightmost, &rcRightmost);
::MapWindowRect(NULL, m_hWnd, &rcRightmost);
::GetWindowRect(hwndBottommost, &rcBottommost);
::MapWindowRect(NULL, m_hWnd, &rcBottommost);
pSize->cx = rcRightmost.right;
pSize->cy = rcBottommost.bottom + _pfsb->GetMetrics().TightMarginY();
return TRUE;
}
HWND CFindPrintersDlg::GetFirstTabItem() const
{
return GetDlgItem(PSEARCHDLG_TABFIRST);
}
HWND CFindPrintersDlg::GetLastTabItem() const
{
return GetDlgItem(PSEARCHDLG_TABLAST);
}
STDMETHODIMP CFindPrintersDlg::TranslateAccelerator(MSG *pmsg)
{
if (S_OK == CBandDlg::TranslateAccelerator(pmsg))
return S_OK;
// Handle it ourselves...
return _pfsb->IsDlgMessage(m_hWnd, pmsg);
}
void CFindPrintersDlg::OnWinIniChange()
{
_BeautifyCaption(IDC_PSEARCH_CAPTION, IDC_PSEARCH_ICON, IDI_PSEARCH);
}
LRESULT CFindPrintersDlg::OnSearchStartBtn(WORD nCode, WORD nID, HWND hwndCtl, BOOL&)
{
WCHAR wszName[MAX_PATH],
wszLocation[MAX_PATH],
wszModel[MAX_PATH];
::GetDlgItemTextW(m_hWnd, IDC_PSEARCH_NAME, wszName, ARRAYSIZE(wszName));
::GetDlgItemTextW(m_hWnd, IDC_PSEARCH_LOCATION, wszLocation, ARRAYSIZE(wszLocation));
::GetDlgItemTextW(m_hWnd, IDC_PSEARCH_MODEL, wszModel, ARRAYSIZE(wszModel));
ASSERT(_pfsb);
ASSERT(_pfsb->BandSite());
IShellDispatch2* psd2;
if (SUCCEEDED(CoCreateInstance(CLSID_Shell, NULL, CLSCTX_INPROC_SERVER,
IID_PPV_ARG(IShellDispatch2, &psd2))))
{
BSTR bstrName = *wszName ? SysAllocString(wszName) : NULL,
bstrLocation = *wszLocation ? SysAllocString(wszLocation) : NULL,
bstrModel = *wszModel ? SysAllocString(wszModel) : NULL;
if (FAILED(psd2->FindPrinter(bstrName, bstrLocation, bstrModel)))
{
SysFreeString(bstrName);
SysFreeString(bstrLocation);
SysFreeString(bstrModel);
}
psd2->Release();
}
return 0;
}
#endif __PSEARCH_BANDDLG__
// CFindComputersDlg impl
#define CSEARCHDLG_TABFIRST IDC_CSEARCH_NAME
#define CSEARCHDLG_TABLAST IDC_SEARCHLINK_INTERNET
#define CSEARCHDLG_RIGHTMOST IDC_SEARCH_STOP
#define CSEARCHDLG_BOTTOMMOST IDC_SEARCHLINK_INTERNET
CFindComputersDlg::CFindComputersDlg(CFileSearchBand* pfsb)
: CSearchCmdDlg(pfsb),
_pacComputerName(NULL),
_pmruComputerName(NULL)
{
}
CFindComputersDlg::~CFindComputersDlg()
{
ATOMICRELEASE(_pacComputerName);
ATOMICRELEASE(_pmruComputerName);
}
LRESULT CFindComputersDlg::OnInitDialog(UINT, WPARAM, LPARAM, BOOL&)
{
_Attach(m_hWnd);
ASSERT(Hwnd());
CMetrics& metrics = _pfsb->GetMetrics();
_pfsb->GetMetrics().Init(m_hWnd);
// Register specialty window classes.
DivWindow_RegisterClass();
POINT pt;
pt.x = metrics.CtlMarginX();
pt.y = 0;
_CreateSearchLinks(m_hWnd, pt, IDC_SEARCHLINK_COMPUTERS);
_CreateDivider(m_hWnd, IDC_FSEARCH_DIV1, pt, 2, GetDlgItem(IDC_CSEARCH_CAPTION));
_CreateDivider(m_hWnd, IDC_FSEARCH_DIV2, pt, 1, GetDlgItem(IDC_SEARCHLINK_CAPTION));
_CreateDivider(m_hWnd, IDC_FSEARCH_DIV3, pt, 1, GetDlgItem(IDC_SEARCHLINK_PEOPLE));
_InitializeMru(GetDlgItem(IDC_CSEARCH_NAME), &_pacComputerName,
TEXT("ComputerNameMRU"), &_pmruComputerName);
SendDlgItemMessage(IDC_CSEARCH_NAME, EM_LIMITTEXT, MAX_PATH, 0);
OnWinIniChange();
LayoutControls(-1, -1);
return TRUE;
}
LRESULT CFindComputersDlg::OnDestroy(UINT, WPARAM, LPARAM, BOOL& bHandled)
{
StopSearch();
if (_pSrchCmd)
{
DisconnectEvents();
IUnknown_SetSite(_pSrchCmd, NULL);
}
bHandled = FALSE;
_fOnDestroy = TRUE;
return 0;
}
void CFindComputersDlg::LayoutControls(int cx, int cy)
{
if (cx < 0 || cy < 0)
{
RECT rc;
GetClientRect(&rc);
cx = RECTWIDTH(rc);
cy = RECTHEIGHT(rc);
}
CBandDlg::LayoutControls(cx, cy);
const UINT nIDCtl[] = {
IDC_CSEARCH_NAME,
};
RECT rcCtl[ARRAYSIZE(nIDCtl)];
CMetrics& metrics = _pfsb->GetMetrics();
for (int i = 0; i< ARRAYSIZE(nIDCtl); i++)
{
HWND hwndCtl = GetDlgItem(nIDCtl[i]);
if (hwndCtl && ::GetWindowRect(hwndCtl, &rcCtl[i]))
{
::MapWindowRect(NULL, m_hWnd, &rcCtl[i]);
rcCtl[i].right = cx - metrics.CtlMarginX();
::SetWindowPos(hwndCtl, NULL, 0, 0,
RECTWIDTH(*(rcCtl+i)), RECTHEIGHT(*(rcCtl+i)),
SWP_NOMOVE|SWP_NOZORDER|SWP_NOACTIVATE);
}
else
SetRectEmpty(rcCtl + i);
}
// Position the 'Search for Other Items' caption, divider and link windows
const int rgLinks[] = {
IDC_SEARCHLINK_FILES,
IDC_SEARCHLINK_COMPUTERS,
IDC_SEARCHLINK_PRINTERS,
IDC_SEARCHLINK_PEOPLE,
-IDC_FSEARCH_DIV3,
IDC_SEARCHLINK_INTERNET,
};
RECT rc;
::GetWindowRect(GetDlgItem(IDC_SEARCH_START), &rc);
::MapWindowRect(NULL, m_hWnd, &rc);
rc.bottom += metrics.LooseMarginY();
_LayoutSearchLinks(IDC_SEARCHLINK_CAPTION, IDC_FSEARCH_DIV2, TRUE,
metrics.CtlMarginX(), cx - metrics.CtlMarginX(), metrics.TightMarginY(),
rc.bottom, rgLinks, ARRAYSIZE(rgLinks));
}
BOOL CFindComputersDlg::Validate()
{
return TRUE;
}
STDMETHODIMP CFindComputersDlg::AddConstraints(ISearchCommandExt* pSrchCmd)
{
HRESULT hr = E_FAIL;
TCHAR szName[MAX_PATH];
if (::GetDlgItemText(m_hWnd, IDC_CSEARCH_NAME, szName, MAX_PATH) <= 0)
{
lstrcpy(szName, TEXT("*"));
}
VARIANT var;
hr = InitVariantFromStr(&var, szName);
if (SUCCEEDED(hr))
{
hr = _AddConstraint(pSrchCmd, L"SearchFor", &var);
if (SUCCEEDED(hr))
_AddMruStringFromWindow(_pmruComputerName, GetDlgItem(IDC_CSEARCH_NAME));
VariantClear(&var);
}
return hr;
}
void CFindComputersDlg::UpdateStatusText()
{
CSearchCmdDlg::UpdateStatusText();
}
void CFindComputersDlg::RestoreSearch()
{
CSearchCmdDlg::RestoreSearch();
}
void CFindComputersDlg::Clear()
{
CSearchCmdDlg::Clear();
SetDlgItemText(IDC_CSEARCH_NAME, NULL);
}
BOOL CFindComputersDlg::GetMinSize(HWND hwndOC, SIZE *pSize) const
{
RECT rcRightmost, rcBottommost;
HWND hwndRightmost = GetDlgItem(CSEARCHDLG_RIGHTMOST),
hwndBottommost= GetDlgItem(CSEARCHDLG_BOTTOMMOST);
ASSERT(::IsWindow(hwndRightmost));
ASSERT(::IsWindow(hwndBottommost));
::GetWindowRect(hwndRightmost, &rcRightmost);
::MapWindowRect(NULL, m_hWnd, &rcRightmost);
::GetWindowRect(hwndBottommost, &rcBottommost);
::MapWindowRect(NULL, m_hWnd, &rcBottommost);
pSize->cx = rcRightmost.right;
pSize->cy = rcBottommost.bottom + _pfsb->GetMetrics().TightMarginY();
return TRUE;
}
void CFindComputersDlg::NavigateToResults(IWebBrowser2* pwb2)
{
BSTR bstrUrl = SysAllocString(L"::{1f4de370-d627-11d1-ba4f-00a0c91eedba}");// CLSID_ComputerFindFolder
if (bstrUrl)
{
VARIANT varNil = {0};
pwb2->Navigate(bstrUrl, &varNil, &varNil, &varNil, &varNil);
SysFreeString(bstrUrl);
}
}
HWND CFindComputersDlg::GetFirstTabItem() const
{
return GetDlgItem(CSEARCHDLG_TABFIRST);
}
HWND CFindComputersDlg::GetLastTabItem() const
{
return GetDlgItem(CSEARCHDLG_TABLAST);
}
BOOL CFindComputersDlg::GetAutoCompleteObjectForWindow(HWND hwnd, IAutoComplete2** ppac2)
{
if (hwnd == GetDlgItem(IDC_CSEARCH_NAME))
{
*ppac2 = _pacComputerName;
(*ppac2)->AddRef();
return TRUE;
}
return CBandDlg::GetAutoCompleteObjectForWindow(hwnd, ppac2);
}
STDMETHODIMP CFindComputersDlg::TranslateAccelerator(MSG *pmsg)
{
if (S_OK == CSearchCmdDlg::TranslateAccelerator(pmsg))
return S_OK;
// Handle it ourselves...
return _pfsb->IsDlgMessage(m_hWnd, pmsg);
}
void CFindComputersDlg::OnWinIniChange()
{
// redisplay animated icon
HWND hwndIcon = GetDlgItem(IDC_CSEARCH_ICON);
Animate_Close(hwndIcon);
Animate_OpenEx(hwndIcon, HINST_THISDLL, MAKEINTRESOURCE(IDA_FINDCOMP));
_BeautifyCaption(IDC_CSEARCH_CAPTION);
}
LRESULT CFindComputersDlg::OnSearchStartBtn(WORD nCode, WORD nID, HWND hwndCtl, BOOL&)
{
if (SUCCEEDED(StartSearch()))
{
EnableStartStopButton(hwndCtl, FALSE);
StartStopAnimation(TRUE);
}
return 0;
}
LRESULT CFindComputersDlg::OnSearchStopBtn(WORD nCode, WORD nID, HWND hwndCtl, BOOL&)
{
StopSearch();
return 0;
}
HWND CFindComputersDlg::ShowHelp(HWND hwnd)
{
return ::HtmlHelp(hwnd, TEXT("find.chm"), HH_DISPLAY_TOPIC, 0);
}
// CSearchCmdDlg object wrap and event sink
CSearchCmdDlg::CSearchCmdDlg(CFileSearchBand* pfsb)
: CBandDlg(pfsb),
_pSrchCmd(NULL),
_pcp(NULL),
_dwConnection(0)
{
ASSERT(pfsb);
}
CSearchCmdDlg::~CSearchCmdDlg()
{
DisconnectEvents();
if (_pSrchCmd)
{
_pSrchCmd->Release();
_pSrchCmd = NULL;
}
}
ISearchCommandExt* CSearchCmdDlg::GetSearchCmd()
{
if (_fOnDestroy)
return NULL;
ASSERT(_pfsb->BandSite() != NULL);
// Instantiate docfind command object
if (NULL == _pSrchCmd)
{
ASSERT(0 == _dwConnection);
if (SUCCEEDED(CoCreateInstance(CLSID_DocFindCommand, NULL, CLSCTX_INPROC_SERVER,
IID_PPV_ARG(ISearchCommandExt, &_pSrchCmd))))
{
// Assign search type.
_pSrchCmd->SearchFor(GetSearchType());
// cmd object needs site to get to browser
IUnknown_SetSite(_pSrchCmd, _pfsb->BandSite());
// Connect events.
ConnectToConnectionPoint(SAFECAST(this, DSearchCommandEvents*), DIID_DSearchCommandEvents,
TRUE, _pSrchCmd, &_dwConnection, &_pcp);
}
}
return _pSrchCmd;
}
HRESULT CSearchCmdDlg::DisconnectEvents()
{
HRESULT hr = S_FALSE;
if (_pcp)
{
_pcp->Unadvise(_dwConnection);
_pcp->Release();
_pcp = NULL;
_dwConnection = 0;
hr = S_OK;
}
return hr;
}
HRESULT CSearchCmdDlg::StartSearch()
{
HRESULT hr = E_INVALIDARG;
if (Validate()) // Validate input
{
ISearchCommandExt* pSrchCmd = GetSearchCmd();
if (pSrchCmd)
{
pSrchCmd->ClearResults(); // Clear off current results
hr = AddConstraints(pSrchCmd);
if (SUCCEEDED(hr))
hr = Execute(TRUE);
}
}
return hr;
}
void CSearchCmdDlg::StartStopAnimation(BOOL bStart)
{
HWND hwndAnimate = GetAnimation();
if (IsWindow(hwndAnimate))
{
if (bStart)
Animate_Play(hwndAnimate, 0, -1, -1);
else
Animate_Stop(hwndAnimate);
}
}
// WMU_RESTORESEARCH handler
LRESULT CSearchCmdDlg::OnRestoreSearch(UINT, WPARAM, LPARAM, BOOL&)
{
// We've posted ourselves this message in response to the event
// dispatch because we want to do our restoration on the
// band's primary thread rather than the OLE dispatch thread.
// To do the work on the dispatch thread results in a premature
// abort of the search restoration processing as the dispatch
// thread terminates.
RestoreSearch();
return 0;
}
void CSearchCmdDlg::Clear()
{
StopSearch();
ISearchCommandExt *pSrchCmd = GetSearchCmd();
if (pSrchCmd)
pSrchCmd->ClearResults();
}
HRESULT CSearchCmdDlg::Execute(BOOL bStart)
{
ASSERT(_pSrchCmd);
VARIANT varRecordsAffected = {0}, varParams = {0};
return _pSrchCmd->Execute(&varRecordsAffected, &varParams, bStart ? 1 : 0);
}
void CSearchCmdDlg::StopSearch()
{
if (SearchInProgress())
Execute(FALSE);
}
HRESULT CSearchCmdDlg::SetQueryFile(IN VARIANT* pvarFile)
{
HRESULT hr = CBandDlg::SetQueryFile(pvarFile);
if (S_OK == hr)
{
ISearchCommandExt* pSrchCmd = GetSearchCmd();
if (pSrchCmd)
hr = pSrchCmd->RestoreSavedSearch(pvarFile);
else
hr = E_FAIL;
}
return hr;
}
void CSearchCmdDlg::UpdateSearchCmdStateUI(DISPID eventID)
{
if (_fOnDestroy)
return;
BOOL bStopEvent = (DISPID_SEARCHCOMMAND_COMPLETE == eventID ||
DISPID_SEARCHCOMMAND_ERROR == eventID ||
DISPID_SEARCHCOMMAND_ABORT == eventID),
bStartEvent = DISPID_SEARCHCOMMAND_START == eventID;
HWND hwndStart = GetDlgItem(Hwnd(), IDC_SEARCH_START),
hwndStop = GetDlgItem(Hwnd(), IDC_SEARCH_STOP);
if (IsWindow(hwndStart))
{
EnableStartStopButton(hwndStart, !SearchInProgress());
if (bStopEvent && IsChild(Hwnd(), GetFocus()))
{
_pfsb->AutoActivate();
SetFocus(hwndStart);
}
}
if (IsWindow(hwndStop))
{
EnableStartStopButton(hwndStop, SearchInProgress());
if (bStartEvent)
{
_pfsb->AutoActivate();
SetFocus(hwndStop);
}
}
if (bStopEvent || !SearchInProgress())
StartStopAnimation(FALSE);
}
void CSearchCmdDlg::EnableStartStopButton(HWND hwndBtn, BOOL bEnable)
{
if (IsWindow(hwndBtn))
{
if (bEnable)
_ModifyWindowStyle(hwndBtn, BS_DEFPUSHBUTTON, 0);
else
_ModifyWindowStyle(hwndBtn, 0, BS_DEFPUSHBUTTON);
::EnableWindow(hwndBtn, bEnable);
}
}
// Extracts error information from ISearchCommandExt and
// propagate
BOOL CSearchCmdDlg::ProcessCmdError()
{
BOOL bRet = FALSE;
ISearchCommandExt* pSrchCmd = GetSearchCmd();
if (pSrchCmd)
{
HRESULT hr = S_OK;
BSTR bstrError = NULL;
USES_CONVERSION;
// request error information through ISearchCommandExt
if (SUCCEEDED(pSrchCmd->GetErrorInfo(&bstrError, (int *)&hr)))
// allow derivatives classes a crack at handling the error
bRet = OnSearchCmdError(hr, bstrError ? W2T(bstrError) : NULL);
}
return bRet;
}
BOOL CSearchCmdDlg::OnSearchCmdError(HRESULT hr, LPCTSTR pszError)
{
if (pszError)
{
ShellMessageBox(HINST_THISDLL, _pfsb->m_hWnd, pszError, NULL,
MB_OK | MB_ICONASTERISK);
return TRUE;
}
return FALSE;
}
void CSearchCmdDlg::UpdateStatusText()
{
if (_fOnDestroy)
return;
ASSERT(_pfsb && _pfsb->BandSite());
ISearchCommandExt* pSrchCmd = GetSearchCmd();
if (pSrchCmd)
{
BSTR bstrStatus;
if (SUCCEEDED(pSrchCmd->get_ProgressText(&bstrStatus)))
{
IWebBrowserApp* pwba;
if (SUCCEEDED(IUnknown_QueryServiceForWebBrowserApp(_pfsb->BandSite(), IID_PPV_ARG(IWebBrowserApp, &pwba))))
{
pwba->put_StatusText(bstrStatus);
pwba->Release();
}
if (bstrStatus)
SysFreeString(bstrStatus);
}
}
}
void CSearchCmdDlg::OnBandShow(BOOL bShow)
{
if (!bShow)
StopSearch() ;
}
STDMETHODIMP CSearchCmdDlg::TranslateAccelerator(MSG *pmsg)
{
if (S_OK == CBandDlg::TranslateAccelerator(pmsg))
return S_OK;
if (WM_KEYDOWN == pmsg->message &&
VK_ESCAPE == pmsg->wParam &&
SearchInProgress() &&
0 == (GetKeyState(VK_CONTROL) & 0x8000))
{
StopSearch();
}
return S_FALSE;
}
STDMETHODIMP CSearchCmdDlg::QueryInterface(REFIID riid, void** ppv)
{
static const QITAB qit[] = {
QITABENTMULTI(CSearchCmdDlg, IDispatch, DSearchCommandEvents),
QITABENTMULTI2(CSearchCmdDlg, DIID_DSearchCommandEvents, DSearchCommandEvents),
{ 0 },
};
return QISearch(this, qit, riid, ppv);
}
STDMETHODIMP_(ULONG) CSearchCmdDlg::AddRef()
{
return ((IFileSearchBand*)_pfsb)->AddRef();
}
STDMETHODIMP_(ULONG) CSearchCmdDlg::Release()
{
return ((IFileSearchBand*)_pfsb)->Release();
}
// IDispatch
STDMETHODIMP CSearchCmdDlg::Invoke(DISPID dispid, REFIID, LCID, WORD, DISPPARAMS*, VARIANT*, EXCEPINFO*, UINT*)
{
switch (dispid)
{
case DISPID_SEARCHCOMMAND_COMPLETE:
case DISPID_SEARCHCOMMAND_ABORT:
case DISPID_SEARCHCOMMAND_ERROR:
case DISPID_SEARCHCOMMAND_START:
_fSearchInProgress = (DISPID_SEARCHCOMMAND_START == dispid);
_fSearchAborted = (DISPID_SEARCHCOMMAND_ABORT == dispid);
UpdateSearchCmdStateUI(dispid);
if (DISPID_SEARCHCOMMAND_ERROR == dispid)
ProcessCmdError();
break;
case DISPID_SEARCHCOMMAND_PROGRESSTEXT:
UpdateStatusText();
break;
case DISPID_SEARCHCOMMAND_RESTORE:
PostMessage(Hwnd(), WMU_RESTORESEARCH, 0, 0);
// See comments in the CSearchCmdDlg::OnRestoreSearch message handler.
break;
}
return S_OK;
}
class CDivWindow
{
// All private members:
CDivWindow();
~CDivWindow();
static LRESULT WINAPI WndProc(HWND, UINT, WPARAM, LPARAM);
LRESULT EraseBkgnd(HDC hdc);
LRESULT WindowPosChanging(WINDOWPOS* pwp);
LRESULT SetHeight(LONG cy);
LRESULT SetBkColor(COLORREF rgb);
static ATOM _atom; // window class atom
HWND _hwnd;
LONG _cy; // enforced height.
COLORREF _rgbBkgnd; // background color
HBRUSH _hbrBkgnd; // background brush
friend void WINAPI DivWindow_RegisterClass();
};
void DivWindow_RegisterClass()
{
WNDCLASSEX wc = {0};
wc.cbSize = sizeof(wc);
wc.style = CS_GLOBALCLASS;
wc.lpfnWndProc = CDivWindow::WndProc;
wc.hInstance = HINST_THISDLL;
wc.hCursor = LoadCursor(NULL, IDC_ARROW);
wc.hbrBackground = (HBRUSH)(COLOR_BTNFACE+1);
wc.lpszClassName = DIVWINDOW_CLASS;
RegisterClassEx(&wc);
}
inline CDivWindow::CDivWindow() : _hwnd(NULL), _cy(1), _hbrBkgnd(NULL), _rgbBkgnd(COLOR_BTNFACE)
{
}
inline CDivWindow::~CDivWindow()
{
if (_hbrBkgnd)
DeleteObject(_hbrBkgnd);
}
LRESULT CDivWindow::EraseBkgnd(HDC hdc)
{
if (!_hbrBkgnd)
return DefWindowProc(_hwnd, WM_ERASEBKGND, (WPARAM)hdc, 0);
RECT rc;
GetClientRect(_hwnd, &rc);
FillRect(hdc, &rc, _hbrBkgnd);
return TRUE;
}
LRESULT CDivWindow::WindowPosChanging(WINDOWPOS* pwp)
{
// enforce height
if (0 == (pwp->flags & SWP_NOSIZE))
pwp->cy = _cy;
return 0;
}
LRESULT CDivWindow::SetHeight(LONG cy)
{
_cy = cy;
return TRUE;
}
LRESULT CDivWindow::SetBkColor(COLORREF rgb)
{
if (rgb != _rgbBkgnd)
{
_rgbBkgnd = rgb;
if (_hbrBkgnd)
DeleteObject(_hbrBkgnd);
_hbrBkgnd = CreateSolidBrush(_rgbBkgnd);
InvalidateRect(_hwnd, NULL, TRUE);
}
return TRUE;
}
LRESULT WINAPI CDivWindow::WndProc(HWND hwnd, UINT nMsg, WPARAM wParam, LPARAM lParam)
{
CDivWindow* pThis = (CDivWindow*)GetWindowLongPtr(hwnd, GWLP_USERDATA);
switch (nMsg)
{
case WM_ERASEBKGND:
return pThis->EraseBkgnd((HDC)wParam);
case WM_WINDOWPOSCHANGING:
return pThis->WindowPosChanging((WINDOWPOS*)lParam);
case WM_GETDLGCODE:
return DLGC_STATIC;
case DWM_SETHEIGHT:
return pThis->SetHeight((LONG)wParam);
case DWM_SETBKCOLOR:
return pThis->SetBkColor((COLORREF)wParam);
case WM_NCCREATE:
if (NULL == (pThis = new CDivWindow))
return FALSE;
pThis->_hwnd = hwnd;
SetWindowLongPtr(hwnd, GWLP_USERDATA, (LONG_PTR)pThis);
break;
case WM_NCDESTROY:
{
LRESULT lRet = DefWindowProc(hwnd, nMsg, wParam, lParam);
SetWindowPtr(hwnd, GWLP_USERDATA, 0);
pThis->_hwnd = NULL;
delete pThis;
return lRet;
}
}
return DefWindowProc(hwnd, nMsg, wParam, lParam);
}
// {C8F945CB-327A-4330-BB2F-C04122959488}
static const IID IID_IStringMru =
{ 0xc8f945cb, 0x327a, 0x4330, { 0xbb, 0x2f, 0xc0, 0x41, 0x22, 0x95, 0x94, 0x88 } };
// Creates and initializes a CStringMru instance
HRESULT CStringMru::CreateInstance(HKEY hKey, LPCTSTR szSubKey, LONG cMaxStrings, BOOL bCaseSensitive, REFIID riid, void ** ppv)
{
CStringMru* pmru = new CStringMru;
if (NULL == pmru)
return E_OUTOFMEMORY;
pmru->_hKeyRoot = hKey;
StrCpyN(pmru->_szSubKey, szSubKey, ARRAYSIZE(pmru->_szSubKey));
if (cMaxStrings > 0)
pmru->_cMax = cMaxStrings;
pmru->_bCaseSensitive = bCaseSensitive;
HRESULT hr = pmru->QueryInterface(riid, ppv);
pmru->Release();
return hr;
}
CStringMru::CStringMru() : _cRef(1), _hKeyRoot(NULL), _hKey(NULL),
_hdpaStrings(NULL), _cMax(25), _bCaseSensitive(TRUE), _iString(-1)
{
*_szSubKey = 0;
}
CStringMru::~CStringMru()
{
_Close();
_Clear();
}
// Opens string MRU store
HRESULT CStringMru::_Open()
{
if (_hKey)
return S_OK;
DWORD dwDisposition;
DWORD dwErr = RegCreateKeyEx(_hKeyRoot, _szSubKey, 0, NULL,
REG_OPTION_NON_VOLATILE, KEY_ALL_ACCESS,
NULL, &_hKey, &dwDisposition);
return HRESULT_FROM_WIN32(dwErr);
}
// Deletes string MRU store
void CStringMru::_Delete()
{
if (_hKey)
_Close();
SHDeleteKey(_hKeyRoot, _szSubKey);
}
// Reads string MRU store into memory
HRESULT CStringMru::_Read(OUT OPTIONAL LONG* pcRead)
{
HRESULT hr = E_FAIL;
if (pcRead)
*pcRead = 0;
if (SUCCEEDED((hr = _Open())))
{
_Clear(); // throw away existing cached strings
_hdpaStrings = DPA_Create(4); // allocate dynarray
if (NULL == _hdpaStrings)
{
hr = E_OUTOFMEMORY;
}
else
{
// step through string values in registry.
for (int iString = 0; iString < _cMax; iString++)
{
TCHAR szVal[16];
TCHAR szString[MAX_URL_STRING];
ULONG dwType, cbString = sizeof(szString);
wsprintf(szVal, TEXT("%03d"), iString);
DWORD dwErr = RegQueryValueEx(_hKey, szVal, 0, &dwType,
(LPBYTE)szString, &cbString);
if (dwErr == ERROR_SUCCESS && REG_SZ == dwType && *szString)
{
LPOLESTR pwszAdd;
if (SUCCEEDED(SHStrDup(szString, &pwszAdd)))
{
if (DPA_AppendPtr(_hdpaStrings, pwszAdd) == -1)
{
CoTaskMemFree(pwszAdd);
}
}
}
}
}
_Close();
if (pcRead && _hdpaStrings)
*pcRead = DPA_GetPtrCount(_hdpaStrings);
}
return hr;
}
// Writes string MRU store from memory
HRESULT CStringMru::_Write(OUT OPTIONAL LONG* pcWritten)
{
HRESULT hr = E_FAIL;
LONG cWritten = 0;
if (pcWritten)
*pcWritten = cWritten;
// Delete store and re-create.
_Delete();
if (NULL == _hdpaStrings)
return S_FALSE;
if (FAILED((hr = _Open())))
return hr;
ASSERT(DPA_GetPtrCount(_hdpaStrings) <= _cMax);
// step through string values in registry.
for (int iString = 0, cnt = DPA_GetPtrCount(_hdpaStrings);
iString < cnt; iString++)
{
TCHAR szVal[16];
TCHAR szString[MAX_URL_STRING];
wsprintf(szVal, TEXT("%03d"), iString);
LPOLESTR pwszWrite = (LPOLESTR)DPA_FastGetPtr(_hdpaStrings, iString);
SHUnicodeToTChar(pwszWrite, szString, ARRAYSIZE(szString));
DWORD dwErr = RegSetValueEx(_hKey, szVal, 0, REG_SZ,
(LPBYTE)szString, sizeof(szString));
if (ERROR_SUCCESS == dwErr)
cWritten++;
}
_Close();
if (pcWritten)
*pcWritten = cWritten;
return S_OK;
}
// Closes string MRU store
void CStringMru::_Close()
{
if (_hKey)
{
RegCloseKey(_hKey);
_hKey = NULL;
}
}
// Adds a string to the store
STDMETHODIMP CStringMru::Add(LPCOLESTR pwszAdd)
{
if (!(pwszAdd && *pwszAdd))
return E_INVALIDARG;
if (NULL == _hdpaStrings)
{
_hdpaStrings = DPA_Create(4);
if (NULL == _hdpaStrings)
return E_OUTOFMEMORY;
}
HRESULT hr = E_FAIL;
LONG iMatch = -1;
for (LONG i = 0, cnt = DPA_GetPtrCount(_hdpaStrings); i < cnt; i++)
{
LPOLESTR pwsz = (LPOLESTR)DPA_FastGetPtr(_hdpaStrings, i);
if (pwsz)
{
int nCompare = _bCaseSensitive ?
StrCmpW(pwszAdd, pwsz) : StrCmpIW(pwszAdd, pwsz);
if (0 == nCompare)
{
iMatch = i;
break;
}
}
}
if (-1 == iMatch)
{
// Create a copy and add it to the list.
LPOLESTR pwszCopy;
hr = SHStrDup(pwszAdd, &pwszCopy);
if (SUCCEEDED(hr))
{
int iNew = DPA_InsertPtr(_hdpaStrings, 0, pwszCopy);
if (iNew < 0)
{
CoTaskMemFree(pwszCopy);
hr = E_OUTOFMEMORY;
}
}
}
else
{
hr = _Promote(iMatch);
}
if (S_OK == hr)
{
// If we've grown too large, delete LRU string
int cStrings = DPA_GetPtrCount(_hdpaStrings);
while (cStrings > _cMax)
{
LPOLESTR pwsz = (LPOLESTR)DPA_DeletePtr(_hdpaStrings, cStrings - 1);
CoTaskMemFree(pwsz);
cStrings--;
}
hr = _Write();
}
return hr;
}
// Promotes a string to MRU
HRESULT CStringMru::_Promote(LONG iString)
{
if (0 == iString)
return S_OK;
LONG cnt = _hdpaStrings ? DPA_GetPtrCount(_hdpaStrings) : 0 ;
if (iString >= cnt)
return E_INVALIDARG;
LPOLESTR pwsz = (LPOLESTR)DPA_DeletePtr(_hdpaStrings, iString);
if (pwsz)
{
int iMru = DPA_InsertPtr(_hdpaStrings, 0, pwsz);
if (iMru < 0)
{
CoTaskMemFree(pwsz);
return E_OUTOFMEMORY;
}
else
{
ASSERT(0 == iMru);
return S_OK;
}
}
return E_FAIL;
}
// Clears string MRU memory cache
void CStringMru::_Clear()
{
if (_hdpaStrings)
{
for (int i = 0, cnt = DPA_GetPtrCount(_hdpaStrings); i < cnt; i++)
{
LPOLESTR pwsz = (LPOLESTR)DPA_FastGetPtr(_hdpaStrings, i);
CoTaskMemFree(pwsz);
}
DPA_Destroy(_hdpaStrings);
_hdpaStrings = NULL;
}
}
STDMETHODIMP_(ULONG) CStringMru::AddRef(void)
{
return InterlockedIncrement(&_cRef);
}
STDMETHODIMP_(ULONG) CStringMru::Release(void)
{
if (InterlockedDecrement(&_cRef))
return _cRef;
delete this;
return 0;
}
STDMETHODIMP CStringMru::QueryInterface(REFIID riid, void **ppv)
{
static const QITAB qit[] = {
QITABENT(CStringMru, IEnumString),
QITABENT(CStringMru, IStringMru),
{ 0 },
};
return QISearch(this, qit, riid, ppv);
}
// *** IEnumString ***
STDMETHODIMP CStringMru::Next(ULONG celt, LPOLESTR *rgelt, ULONG *pceltFetched)
{
ULONG cFetched = 0;
if (pceltFetched)
*pceltFetched = cFetched;
if (NULL == _hdpaStrings)
{
HRESULT hr = _Read();
if (FAILED(hr))
return hr;
}
for (int cnt = _hdpaStrings ? DPA_GetPtrCount(_hdpaStrings) : 0;
cFetched < celt && (_iString + 1) < cnt;)
{
_iString++;
LPOLESTR pwsz = (LPOLESTR)DPA_FastGetPtr(_hdpaStrings, _iString);
if (pwsz)
{
if (SUCCEEDED(SHStrDup(pwsz, &rgelt[cFetched])))
{
cFetched++;
}
}
}
if (pceltFetched)
*pceltFetched = cFetched;
return cFetched == celt ? S_OK : S_FALSE ;
}
STDMETHODIMP CStringMru::Skip(ULONG celt)
{
_iString += celt;
if (_iString >= _cMax)
_iString = _cMax - 1;
return S_OK;
}
STDMETHODIMP CStringMru::Reset(void)
{
_iString = -1;
return S_OK;
}
// Namespace selector combo methods
HRESULT _BuildDrivesList(UINT uiFilter, LPCTSTR pszEnd, LPTSTR pszString, DWORD cchSize)
{
TCHAR szDriveList[MAX_PATH]; // Needs to be 'Z'-'A' (26) * 3 + 1 = 79.
UINT nSlot = 0;
UINT cchSeparator = lstrlen(TEXT(";"));
UINT cchEnd = lstrlen(pszEnd);
for (int i = 0; i < 26; i++)
{
TCHAR szDrive[4];
UINT uiDriveType = GetDriveType(PathBuildRoot(szDrive, i));
UINT driveNum, dwRest;
if ((driveNum = PathGetDriveNumber(szDrive)) != -1) {
dwRest = SHRestricted(REST_NODRIVES);
if (dwRest & (1 << driveNum))
continue;
}
if ((1 != uiDriveType) && // Make sure it exists.
((-1 == uiFilter) ||
(uiFilter == uiDriveType)))
{
if (nSlot) // Do we need to add a separator before we add the next item?
{
StrCpy(szDriveList + nSlot, TEXT(";")); // Size guaranteed to not be a problem.
nSlot += cchSeparator;
}
szDriveList[nSlot++] = szDrive[0]; // terminate list.
StrCpy(szDriveList + nSlot, pszEnd); // Size guaranteed to not be a problem.
nSlot += cchEnd;
}
}
StrCpyN(pszString, szDriveList, cchSize); // Put back into the final location.
return S_OK;
}
HRESULT _MakeCSIDLCbxItem(UINT csidl, UINT csidl2, HWND hwndComboBoxEx, ADDCBXITEMCALLBACK pfn, LPARAM lParam)
{
LPCTSTR rgcsidl[2] = {MAKEINTRESOURCE(csidl), MAKEINTRESOURCE(csidl2)};
// note, CreateIEnumIDListOnCSIDLs checks SFGAO_NONENUMERATED so it filters
// out things we should not display
IEnumIDList *penum;
HRESULT hr = CreateIEnumIDListOnCSIDLs(NULL, rgcsidl, (-1 == csidl2 ? 1 : 2), &penum);
if (SUCCEEDED(hr))
{
LPITEMIDLIST pidl;
if (S_OK == FirstIDList(penum, &pidl))
{
TCHAR szName[MAX_PATH];
SHGetNameAndFlags(pidl, SHGDN_NORMAL, szName, ARRAYSIZE(szName), NULL);
CBXITEM item;
item.iID = csidl;
MakeCbxItem(&item, szName, penum, pidl, LISTINSERT_LAST, NO_ITEM_INDENT);
hr = AddCbxItemToComboBoxCallback(hwndComboBoxEx, &item, pfn, lParam);
if (SUCCEEDED(hr))
{
penum = NULL;
}
ILFree(pidl);
}
if (penum)
penum->Release();
}
return hr;
}
BOOL AppendItemToItemsArray(LPITEMIDLIST pidl, LPITEMIDLIST rgItems[], UINT sizeItems, UINT *pcItems)
{
BOOL bAdded = FALSE;
if (*pcItems < sizeItems)
{
DWORD dwFlags = SFGAO_NONENUMERATED;
if (SUCCEEDED(SHGetNameAndFlags(pidl, SHGDN_NORMAL, NULL, 0, &dwFlags)) &&
!(dwFlags & SFGAO_NONENUMERATED))
{
rgItems[(*pcItems)++] = pidl;
bAdded = TRUE;
pidl = NULL; // don't free below
}
}
ILFree(pidl); // will be NULL if added to array, ownership transfered
return bAdded;
}
BOOL AppendToItemsArray(LPCTSTR psz, LPITEMIDLIST rgItems[], UINT sizeItems, UINT *pcItems)
{
LPITEMIDLIST pidl;
if (IS_INTRESOURCE(psz))
{
SHGetFolderLocation(NULL, LOWORD((UINT_PTR)psz), NULL, 0, &pidl);
}
else
{
SHParseDisplayName(psz, NULL, &pidl, 0, NULL);
}
BOOL bAdded = FALSE;
if (pidl)
{
bAdded = AppendItemToItemsArray(pidl, rgItems, sizeItems, pcItems);
}
return bAdded;
}
// Create an item to put into the "look in" combo box for
// Local Hard Drives. Will search the following directories:
// 1. My Documents
// 2. The Desktop folder (not the root of all PIDLS)
// 3. My Pictures
// 4. My Music
// 5. Documents and Settings
// 6. The current directory
// 7. The recycle bin
// 8. All local drives.
#define MIR(x) MAKEINTRESOURCE(x)
HRESULT _MakeLocalHardDrivesCbxItem(HWND hwndComboBoxEx, ADDCBXITEMCALLBACK pfn, LPARAM lParam)
{
LPITEMIDLIST rgItems[32] = {0};
UINT cItems = 0;
AppendToItemsArray(MIR(CSIDL_PERSONAL), rgItems, ARRAYSIZE(rgItems), &cItems);
AppendToItemsArray(MIR(CSIDL_COMMON_DOCUMENTS | CSIDL_FLAG_NO_ALIAS), rgItems, ARRAYSIZE(rgItems), &cItems);
AppendToItemsArray(MIR(CSIDL_DESKTOPDIRECTORY | CSIDL_FLAG_NO_ALIAS), rgItems, ARRAYSIZE(rgItems), &cItems);
AppendToItemsArray(MIR(CSIDL_COMMON_DESKTOPDIRECTORY), rgItems, ARRAYSIZE(rgItems), &cItems);
AppendToItemsArray(MIR(CSIDL_MYPICTURES), rgItems, ARRAYSIZE(rgItems), &cItems);
AppendToItemsArray(MIR(CSIDL_MYMUSIC), rgItems, ARRAYSIZE(rgItems), &cItems);
AppendToItemsArray(MIR(CSIDL_MYVIDEO), rgItems, ARRAYSIZE(rgItems), &cItems);
TCHAR szPath[MAX_PATH];
DWORD cchPath = ARRAYSIZE(szPath);
if (GetProfilesDirectory(szPath, &cchPath))
{
AppendToItemsArray(szPath, rgItems, ARRAYSIZE(rgItems), &cItems);
}
AppendToItemsArray(MIR(CSIDL_BITBUCKET), rgItems, ARRAYSIZE(rgItems), &cItems);
TCHAR szDrives[128];
szDrives[0] = 0;
LPITEMIDLIST pidlIcon = NULL;
for (int i = 0; i < 26; i++)
{
TCHAR szDrive[4];
if (DRIVE_FIXED == GetDriveType(PathBuildRoot(szDrive, i)))
{
if (AppendToItemsArray(szDrive, rgItems, ARRAYSIZE(rgItems), &cItems))
{
// grab the pidl of the first time to use for the icon
if (pidlIcon == NULL)
SHParseDisplayName(szDrive, NULL, &pidlIcon, 0, NULL);
if (szDrives[0])
StrCatBuff(szDrives, TEXT(";"), ARRAYSIZE(szDrives));
szDrive[2] = 0; // remove the back slash
StrCatBuff(szDrives, szDrive, ARRAYSIZE(szDrives));
}
}
}
IEnumIDList *penum;
HRESULT hr = CreateIEnumIDListOnIDLists(rgItems, cItems, &penum);
if (SUCCEEDED(hr))
{
TCHAR szFmt[64];
LoadString(HINST_THISDLL, IDS_SNS_LOCALHARDDRIVES, szFmt, ARRAYSIZE(szFmt));
wnsprintf(szPath, ARRAYSIZE(szPath), szFmt, szDrives);
CBXITEM item;
MakeCbxItem(&item, szPath, penum, pidlIcon, LISTINSERT_LAST, ITEM_INDENT);
item.iID = CBX_CSIDL_LOCALDRIVES;
hr = AddCbxItemToComboBoxCallback(hwndComboBoxEx, &item, pfn, lParam);
if (FAILED(hr))
penum->Release();
}
ILFree(pidlIcon);
return hr;
}
typedef struct
{
HWND hwndComboBox;
ADDCBXITEMCALLBACK pfn;
LPARAM lParam;
} ENUMITEMPARAM;
HRESULT _PopulateDrivesCB(LPCITEMIDLIST pidl, void *pv)
{
ENUMITEMPARAM* peip = (ENUMITEMPARAM*)pv;
ULONG ulAttrs = SFGAO_FOLDER | SFGAO_FILESYSTEM | SFGAO_NONENUMERATED;
TCHAR szName[MAX_PATH];
HRESULT hr = SHGetNameAndFlags(pidl, SHGDN_NORMAL, szName, ARRAYSIZE(szName), &ulAttrs);
if (SUCCEEDED(hr))
{
if ((SFGAO_FOLDER | SFGAO_FILESYSTEM) == (ulAttrs & (SFGAO_FOLDER | SFGAO_FILESYSTEM | SFGAO_NONENUMERATED)))
{
IEnumIDList *penum;
hr = CreateIEnumIDListOnIDLists(&pidl, 1, &penum);
if (SUCCEEDED(hr))
{
CBXITEM item;
MakeCbxItem(&item, szName, penum, pidl, LISTINSERT_LAST, ITEM_INDENT);
item.iID = CSIDL_DRIVES;
hr = AddCbxItemToComboBoxCallback(peip->hwndComboBox, &item, peip->pfn, peip->lParam);
if (SUCCEEDED(hr))
{
penum = NULL;
}
else
{
penum->Release();
}
}
}
else
{
hr = S_FALSE;
}
}
return hr;
}
STDAPI PopulateNamespaceCombo(HWND hwndComboBoxEx, ADDCBXITEMCALLBACK pfn, LPARAM lParam)
{
::SendMessage(hwndComboBoxEx, CB_RESETCONTENT, 0, 0);
// CSIDL_DESKTOP - use just the file system locations, not the root of the whole
// name space here to avoid searching everything
HRESULT hr = _MakeCSIDLCbxItem(CSIDL_DESKTOPDIRECTORY | CSIDL_FLAG_NO_ALIAS,
CSIDL_COMMON_DESKTOPDIRECTORY | CSIDL_FLAG_NO_ALIAS, hwndComboBoxEx, pfn, lParam);
if (SUCCEEDED(hr))
hr = _MakeCSIDLCbxItem(CSIDL_PERSONAL, -1, hwndComboBoxEx, pfn, lParam);
if (SUCCEEDED(hr))
hr = _MakeCSIDLCbxItem(CSIDL_MYPICTURES, -1, hwndComboBoxEx, pfn, lParam);
if (SUCCEEDED(hr))
hr = _MakeCSIDLCbxItem(CSIDL_MYMUSIC, -1, hwndComboBoxEx, pfn, lParam);
if (SUCCEEDED(hr))
{
// My Computer and children
// If My Docs has been redirected to a remote share, we'll want to prepend its path
// to our My Computer path list; otherwise it'll be missed.
UINT csidl2 = -1;
TCHAR szPath[MAX_PATH];
if (SUCCEEDED(SHGetFolderPath(NULL, CSIDL_PERSONAL, NULL, SHGFP_TYPE_CURRENT, szPath)) &&
PathIsNetworkPath(szPath))
{
csidl2 = CSIDL_PERSONAL;
}
hr = _MakeCSIDLCbxItem(CSIDL_DRIVES, csidl2, hwndComboBoxEx, pfn, lParam);
if (SUCCEEDED(hr))
{
// Local hard drives (Which has heuristics to search best places first...)
hr = _MakeLocalHardDrivesCbxItem(hwndComboBoxEx, pfn, lParam);
if (SUCCEEDED(hr))
{
ENUMITEMPARAM eip = {0};
eip.hwndComboBox = hwndComboBoxEx;
eip.pfn = pfn;
eip.lParam = lParam;
hr = EnumSpecialItemIDs(CSIDL_DRIVES, SHCONTF_FOLDERS | SHCONTF_NONFOLDERS, _PopulateDrivesCB, &eip);
}
}
}
if (SUCCEEDED(hr))
{
// Browse...
CBXITEM item;
item.iID = -1;
TCHAR szDisplayName[MAX_PATH];
LoadString(HINST_THISDLL, IDS_SNS_BROWSER_FOR_DIR, szDisplayName, ARRAYSIZE(szDisplayName));
MakeCbxItem(&item, szDisplayName, NULL, NULL, LISTINSERT_LAST, NO_ITEM_NOICON_INDENT);
hr = AddCbxItemToComboBoxCallback(hwndComboBoxEx, &item, pfn, lParam);
}
return hr;
}
Reference in New Issue Copy Permalink