1380 lines
49 KiB
C++
1380 lines
49 KiB
C++
#include "priv.h"
|
|
#include "sccls.h"
|
|
#include "nscband.h"
|
|
#include "nsc.h"
|
|
#include "resource.h"
|
|
#include "dhuihand.h"
|
|
#include <varutil.h>
|
|
|
|
#include <mluisupp.h>
|
|
|
|
#define DM_HISTBAND 0x0000000
|
|
#define DM_GUIPAINS 0x40000000
|
|
|
|
#define REGKEY_HISTORY_VIEW TEXT("HistoryViewType")
|
|
#define REGKEY_DEFAULT_SIZE 0x10
|
|
|
|
#define VIEWTYPE_MAX 0x4 // A "guess" at how many viewtypes thare will be
|
|
#define VIEWTYPE_REALLOC 0x4 // How many to realloc at a time
|
|
|
|
// these are temporary
|
|
#define MENUID_SEARCH 0x4e4e
|
|
|
|
// Distance between history search go and stop buttons
|
|
#define HISTSRCH_BUTTONDIST 6
|
|
|
|
extern HINSTANCE g_hinst;
|
|
|
|
#define WM_SEARCH_STATE (WM_USER + 314)
|
|
|
|
class CHistBand : public CNSCBand,
|
|
public IShellFolderSearchableCallback
|
|
{
|
|
friend HRESULT CHistBand_CreateInstance(IUnknown *punkOuter,
|
|
IUnknown **ppunk, LPCOBJECTINFO poi);
|
|
public:
|
|
// *** IUnknown methods ***
|
|
STDMETHODIMP QueryInterface(REFIID riid, void **ppvObj);
|
|
STDMETHODIMP_(ULONG) AddRef (void) { return CNSCBand::AddRef(); };
|
|
STDMETHODIMP_(ULONG) Release(void) { return CNSCBand::Release(); };
|
|
|
|
// *** IOleCommandTarget methods ***
|
|
STDMETHODIMP Exec(const GUID *pguidCmdGroup,
|
|
DWORD nCmdID,
|
|
DWORD nCmdexecopt,
|
|
VARIANTARG *pvarargIn,
|
|
VARIANTARG *pvarargOut);
|
|
|
|
// *** IOleWindow methods ***
|
|
// (overriding CNSCBand implementation
|
|
STDMETHODIMP GetWindow(HWND *phwnd);
|
|
|
|
// *** IInputObject methods ***
|
|
// (overriding CNSCBand/CToolBand's implementation)
|
|
STDMETHODIMP TranslateAcceleratorIO(LPMSG lpMsg);
|
|
|
|
// *** IDockingWindow methods ***
|
|
STDMETHODIMP ShowDW(BOOL fShow);
|
|
|
|
// *** IShellFolderSearchableCallback methods ***
|
|
STDMETHODIMP RunBegin(DWORD dwReserved);
|
|
STDMETHODIMP RunEnd(DWORD dwReserved);
|
|
|
|
protected:
|
|
virtual void _AddButtons(BOOL fAdd);
|
|
virtual HRESULT _OnRegisterBand(IOleCommandTarget *poctProxy);
|
|
virtual BOOL _ShouldNavigateToPidl(LPCITEMIDLIST pidl, ULONG ulAttrib);
|
|
virtual HRESULT _NavigateRightPane(IShellBrowser *psb, LPCITEMIDLIST pidl);
|
|
|
|
~CHistBand();
|
|
|
|
HRESULT _InitViewPopup();
|
|
HRESULT _DoViewPopup(int x, int y);
|
|
HRESULT _ViewPopupSelect(UINT idCmd);
|
|
|
|
#ifdef SPLIT_HISTORY_VIEW_BUTTON
|
|
UINT _NextMenuItem();
|
|
#endif
|
|
|
|
HRESULT _ChangePidl(LPITEMIDLIST);
|
|
HRESULT _SelectPidl(LPCITEMIDLIST pidlSelect, BOOL fCreate,
|
|
LPCITEMIDLIST pidlViewType = NULL,
|
|
BOOL fReinsert = FALSE);
|
|
|
|
virtual HRESULT _InitializeNsc();
|
|
LPITEMIDLIST _GetCurrentSelectPidl(IOleCommandTarget *poctProxy = NULL);
|
|
HRESULT _SetRegistryPersistView(int iMenuID);
|
|
int _GetRegistryPersistView();
|
|
LPCITEMIDLIST _MenuIDToPIDL(UINT uMenuID);
|
|
int _PIDLToMenuID(LPITEMIDLIST pidl);
|
|
IShellFolderViewType* _GetViewTypeInfo();
|
|
HRESULT _GetHistoryViews();
|
|
HRESULT _FreeViewInfo();
|
|
|
|
void _ResizeChildWindows(LONG width, LONG height, BOOL fRepaint);
|
|
HRESULT _DoSearchUIStuff();
|
|
HRESULT _ExecuteSearch(LPTSTR pszSearchString);
|
|
HRESULT _ClearSearch();
|
|
IShellFolderSearchable *_EnsureSearch();
|
|
static LRESULT CALLBACK s_EditWndSubclassProc(HWND hwnd, UINT uMsg, WPARAM wParam, LPARAM lParam);
|
|
static LRESULT CALLBACK s_WndProc(HWND hWnd, UINT msg, WPARAM wParam, LPARAM lParam);
|
|
static BOOL_PTR CALLBACK s_HistSearchDlgProc(HWND hwndDlg, UINT uMsg, WPARAM wParam, LPARAM lParam);
|
|
|
|
BOOL _fStrsAdded; // Strings from resource have been added as buttons on the toolbar
|
|
LONG_PTR _lStrOffset;
|
|
|
|
HMENU _hViewMenu; // an instance var so we can cache it
|
|
UINT _uViewCheckedItem; // which menuitem in the View menu is checked?
|
|
|
|
LPITEMIDLIST *_ppidlViewTypes;
|
|
LPTSTR *_ppszStrViewNames;
|
|
UINT _nViews;
|
|
int _iMaxMenuID;
|
|
|
|
HWND _hwndNSC;
|
|
HWND _hwndSearchDlg;
|
|
LONG _lSearchDlgHeight;
|
|
LPITEMIDLIST _pidlSearch; // current search
|
|
IShellFolderSearchable *_psfSearch;
|
|
|
|
LPITEMIDLIST _pidlHistory; // cache the history pidl from SHGetHistoryPIDL
|
|
IShellFolder *_psfHistory; // cache the history shell folder
|
|
IShellFolderViewType *_psfvtCache; // view type information
|
|
|
|
LPITEMIDLIST _pidlLastSelect;
|
|
};
|
|
|
|
CHistBand::~CHistBand()
|
|
{
|
|
DestroyMenu(_hViewMenu);
|
|
if (_pidlLastSelect)
|
|
ILFree(_pidlLastSelect);
|
|
if (_pidlHistory)
|
|
ILFree(_pidlHistory);
|
|
if (_psfHistory)
|
|
_psfHistory->Release();
|
|
if (_psfvtCache)
|
|
_psfvtCache->Release();
|
|
|
|
_ClearSearch(); // Frees _pidlSearch
|
|
if (_psfSearch)
|
|
_psfSearch->Release();
|
|
|
|
_FreeViewInfo();
|
|
}
|
|
|
|
HRESULT CHistBand::QueryInterface(REFIID riid, void **ppvObj)
|
|
{
|
|
static const QITAB qit[] = {
|
|
QITABENT(CHistBand, IShellFolderSearchableCallback), // IID_IShellFolderSearchableCallback
|
|
{ 0 },
|
|
};
|
|
HRESULT hr = QISearch(this, qit, riid, ppvObj);
|
|
if (FAILED(hr))
|
|
hr = CNSCBand::QueryInterface(riid, ppvObj);
|
|
return hr;
|
|
}
|
|
|
|
// *** IOleCommandTarget methods ***
|
|
HRESULT CHistBand::Exec(const GUID *pguidCmdGroup, DWORD nCmdID,
|
|
DWORD nCmdexecopt, VARIANTARG *pvarargIn, VARIANTARG *pvarargOut)
|
|
{
|
|
HRESULT hRes = S_OK;
|
|
if (pguidCmdGroup)
|
|
{
|
|
if (IsEqualGUID(CLSID_HistBand, *pguidCmdGroup))
|
|
{
|
|
switch(nCmdID)
|
|
{
|
|
case FCIDM_HISTBAND_VIEW:
|
|
if (pvarargIn && (pvarargIn->vt == VT_I4))
|
|
{
|
|
#ifdef SPLIT_HISTORY_VIEW_BUTTON
|
|
if (nCmdexecopt == OLECMDEXECOPT_PROMPTUSER)
|
|
hRes = _DoViewPopup(GET_X_LPARAM(pvarargIn->lVal), GET_Y_LPARAM(pvarargIn->lVal));
|
|
else
|
|
hRes = _ViewPopupSelect(_NextMenuItem());
|
|
#else
|
|
ASSERT(nCmdexecopt == OLECMDEXECOPT_PROMPTUSER);
|
|
hRes = _DoViewPopup(GET_X_LPARAM(pvarargIn->lVal), GET_Y_LPARAM(pvarargIn->lVal));
|
|
#endif
|
|
}
|
|
else
|
|
ASSERT(0);
|
|
break;
|
|
|
|
case FCIDM_HISTBAND_SEARCH:
|
|
_ViewPopupSelect(MENUID_SEARCH);
|
|
break;
|
|
}
|
|
}
|
|
else if ((IsEqualGUID(CGID_Explorer, *pguidCmdGroup)))
|
|
{
|
|
switch (nCmdID)
|
|
{
|
|
case SBCMDID_SELECTHISTPIDL:
|
|
#ifdef ANNOYING_HISTORY_AUTOSELECT
|
|
if (_uViewCheckedItem != MENUID_SEARCH)
|
|
{
|
|
LPCITEMIDLIST pidlSelect = VariantToIDList(pvarargIn);
|
|
|
|
// Get the current view information
|
|
LPCITEMIDLIST pidlView = _MenuIDToPIDL(_uViewCheckedItem);
|
|
DWORD dwViewFlags = SFVTFLAG_NOTIFY_CREATE;
|
|
IShellFolderViewType* psfvtInfo = _GetViewTypeInfo();
|
|
|
|
if (psfvtInfo)
|
|
{
|
|
// query for view type properties -- this will tell us how to
|
|
// select the item...
|
|
hRes = psfvtInfo->GetViewTypeProperties(pidlView,
|
|
&dwViewFlags);
|
|
psfvtInfo->Release();
|
|
}
|
|
if (SUCCEEDED(hRes))
|
|
{
|
|
hRes = _SelectPidl(pidlSelect, dwViewFlags & SFVTFLAG_NOTIFY_CREATE,
|
|
pidlView, dwViewFlags & SFVTFLAG_NOTIFY_RESORT);
|
|
}
|
|
ILFree(pidlSelect);
|
|
}
|
|
else //eat it, so that nsc doesn't get it
|
|
hRes = S_OK;
|
|
#endif //ANNOYING_HISTORY_AUTOSELECT
|
|
hRes = S_OK;
|
|
break;
|
|
|
|
case SBCMDID_FILEDELETE:
|
|
hRes = _InvokeCommandOnItem(TEXT("delete"));
|
|
break;
|
|
}
|
|
}
|
|
else
|
|
hRes = CNSCBand::Exec(pguidCmdGroup, nCmdID, nCmdexecopt, pvarargIn, pvarargOut);
|
|
}
|
|
else
|
|
hRes = CNSCBand::Exec(pguidCmdGroup, nCmdID, nCmdexecopt, pvarargIn, pvarargOut);
|
|
return hRes;
|
|
}
|
|
|
|
// *** IInputObject methods ***
|
|
HRESULT CHistBand::TranslateAcceleratorIO(LPMSG pmsg)
|
|
{
|
|
#ifdef DEBUG
|
|
if (pmsg->message == WM_KEYDOWN)
|
|
TraceMsg(DM_GUIPAINS, "CHistBand -- TranslateAcceleratorIO called and _hwndSearchDlg is %x", _hwndSearchDlg);
|
|
#endif
|
|
|
|
HWND hwndFocus = GetFocus();
|
|
|
|
// Translate accelerator messages for dialog
|
|
if ( (_hwndSearchDlg) && (hwndFocus != _hwndNSC) && (!hwndFocus || !IsChild(_hwndNSC, hwndFocus)) )
|
|
{
|
|
if (pmsg->message == WM_KEYDOWN)
|
|
{
|
|
if (IsVK_TABCycler(pmsg))
|
|
{
|
|
BOOL fBackwards = (GetAsyncKeyState(VK_SHIFT) < 0);
|
|
HWND hwndCur = pmsg->hwnd;
|
|
if (GetParent(pmsg->hwnd) != _hwndSearchDlg)
|
|
hwndCur = NULL;
|
|
|
|
HWND hwndNext = GetNextDlgTabItem(_hwndSearchDlg, hwndCur, fBackwards);
|
|
|
|
// Get the First dialog item in this searching order
|
|
HWND hwndFirst;
|
|
if (!fBackwards) {
|
|
hwndFirst = GetNextDlgTabItem(_hwndSearchDlg, NULL, FALSE);
|
|
}
|
|
else
|
|
// passing NULL for the 2nd parameter returned NULL with ERROR_SUCCESS,
|
|
// so this is a workaround
|
|
hwndFirst = GetNextDlgTabItem(_hwndSearchDlg,
|
|
GetNextDlgTabItem(_hwndSearchDlg,
|
|
NULL, FALSE), TRUE);
|
|
|
|
// If the next dialog tabstop is the first dialog tabstop, then
|
|
// let someone else get focus
|
|
if ((!hwndCur) || (hwndNext != hwndFirst))
|
|
{
|
|
SetFocus(hwndNext);
|
|
return S_OK;
|
|
}
|
|
else if (!fBackwards) {
|
|
SetFocus(_hwndNSC);
|
|
return S_OK;
|
|
}
|
|
}
|
|
else if ( (pmsg->wParam == VK_RETURN) )
|
|
SendMessage(_hwndSearchDlg, WM_COMMAND, MAKELONG(GetDlgCtrlID(pmsg->hwnd), 0), 0L);
|
|
}
|
|
// The History Search Edit Box is activated
|
|
if (pmsg->hwnd == GetDlgItem(_hwndSearchDlg, IDC_EDITHISTSEARCH)) {
|
|
// If the user pressed tab within the dialog
|
|
return EditBox_TranslateAcceleratorST(pmsg);
|
|
}
|
|
}
|
|
return CNSCBand::TranslateAcceleratorIO(pmsg);
|
|
}
|
|
|
|
// sends appropriate resize messages to our children windows
|
|
void CHistBand::_ResizeChildWindows(LONG width, LONG height, BOOL fRepaint)
|
|
{
|
|
if (_hwndNSC)
|
|
{
|
|
int y1 = _hwndSearchDlg ? _lSearchDlgHeight : 0;
|
|
int y2 = _hwndSearchDlg ? height - _lSearchDlgHeight : height;
|
|
|
|
MoveWindow(_hwndNSC, 0, y1, width, y2, fRepaint);
|
|
}
|
|
|
|
if (_hwndSearchDlg)
|
|
{
|
|
MoveWindow(_hwndSearchDlg, 0, 0, width, _lSearchDlgHeight, fRepaint);
|
|
}
|
|
}
|
|
|
|
HRESULT CHistBand::_DoSearchUIStuff()
|
|
{
|
|
HRESULT hr;
|
|
|
|
// host the search dialog inside my window:
|
|
_hwndSearchDlg = CreateDialogParam(MLGetHinst(), MAKEINTRESOURCE(DLG_HISTSEARCH2),
|
|
_hwnd, s_HistSearchDlgProc, reinterpret_cast<LPARAM>(this));
|
|
|
|
if (_hwndSearchDlg)
|
|
{
|
|
RECT rcSelf;
|
|
GetClientRect(_hwnd, &rcSelf);
|
|
|
|
RECT rcDlg;
|
|
GetClientRect(_hwndSearchDlg, &rcDlg);
|
|
|
|
_lSearchDlgHeight = rcDlg.bottom;
|
|
|
|
_ResizeChildWindows(rcSelf.right, rcSelf.bottom, TRUE);
|
|
ShowWindow(_hwndSearchDlg, SW_SHOWDEFAULT);
|
|
|
|
hr = S_OK;
|
|
}
|
|
else
|
|
{
|
|
hr = E_FAIL;
|
|
}
|
|
|
|
return hr;
|
|
}
|
|
|
|
// WndProc for main window to go in rebar
|
|
LRESULT CALLBACK CHistBand::s_WndProc(HWND hWnd, UINT msg, WPARAM wParam, LPARAM lParam)
|
|
{
|
|
CHistBand* phb = reinterpret_cast<CHistBand *>(GetWindowLongPtr(hWnd, GWLP_USERDATA));
|
|
|
|
switch (msg)
|
|
{
|
|
case WM_SETFOCUS:
|
|
{
|
|
TraceMsg(DM_GUIPAINS, "Histband Parent -- SETFOCUS");
|
|
// The only way this should be called is via a RB_CYCLEFOCUS->...->UIActivateIO->SetFocus
|
|
// therefore, we can assume that we're being tabbed into or something with equally good.
|
|
// If we tab into the outer dummy window, transfer the focus to
|
|
// our appropriate child:
|
|
BOOL fBackwards = (GetAsyncKeyState(VK_SHIFT) < 0);
|
|
if (phb->_hwndSearchDlg) {
|
|
// Select either the first or the last item in the dialog depending on
|
|
// whether we're shifting in or shifting out
|
|
SetFocus(GetNextDlgTabItem(phb->_hwndSearchDlg, (NULL), fBackwards));
|
|
}
|
|
else {
|
|
TraceMsg(DM_GUIPAINS, "NSC is being given focus!");
|
|
SetFocus(phb->_hwndNSC);
|
|
}
|
|
}
|
|
return 0;
|
|
case WM_CREATE:
|
|
SetWindowLongPtr(hWnd, GWLP_USERDATA,
|
|
(reinterpret_cast<LONG_PTR>((reinterpret_cast<CREATESTRUCT *>(lParam))->lpCreateParams)));
|
|
return 0;
|
|
case WM_SIZE:
|
|
if (phb)
|
|
phb->_ResizeChildWindows(LOWORD(lParam), HIWORD(lParam), TRUE);
|
|
return 0;
|
|
case WM_NCDESTROY:
|
|
//make sure the search object gets freed when the view/window is destroyed, because it holds a ref to us
|
|
phb->_ClearSearch();
|
|
break;
|
|
|
|
case WM_NOTIFY:
|
|
{
|
|
if (phb) {
|
|
// We proxy the notification messages to our own parent who thinks that we
|
|
// are the namespace control
|
|
LPNMHDR pnmh = (LPNMHDR)lParam;
|
|
|
|
// Notification message coming from NSC
|
|
if (pnmh->hwndFrom == phb->_hwndNSC)
|
|
return SendMessage(phb->_hwndParent, msg, wParam, lParam);
|
|
}
|
|
} // INTENTIONAL FALLTHROUGH
|
|
}
|
|
return DefWindowProc(hWnd, msg, wParam, lParam);
|
|
}
|
|
|
|
// *** IOleWindow methods ***
|
|
HRESULT CHistBand::GetWindow(HWND *phwnd)
|
|
{
|
|
if (!_hwnd)
|
|
{
|
|
// we want to wrap a window around the namespace control so
|
|
// that we can add siblings later
|
|
|
|
// Get our parent's dimensions
|
|
RECT rcParent;
|
|
GetClientRect(_hwndParent, &rcParent);
|
|
|
|
static LPTSTR pszClassName = TEXT("History Pane");
|
|
|
|
WNDCLASSEX wndclass = { 0 };
|
|
wndclass.cbSize = sizeof(wndclass);
|
|
wndclass.style = CS_PARENTDC | CS_HREDRAW | CS_VREDRAW;
|
|
wndclass.lpfnWndProc = s_WndProc;
|
|
wndclass.hInstance = g_hinst;
|
|
wndclass.hCursor = LoadCursor(NULL, IDC_ARROW);
|
|
wndclass.lpszClassName = pszClassName;
|
|
|
|
RegisterClassEx(&wndclass);
|
|
|
|
_hwnd = CreateWindow(pszClassName, TEXT("History Window"),
|
|
WS_CHILD | WS_TABSTOP,
|
|
0, 0, rcParent.right, rcParent.bottom,
|
|
_hwndParent, NULL, g_hinst, (LPVOID)this);
|
|
}
|
|
|
|
if (_hwnd) // Host NSC
|
|
_pns->CreateTree(_hwnd, _GetTVStyle(), &_hwndNSC);
|
|
|
|
return CToolBand::GetWindow(phwnd);
|
|
}
|
|
|
|
// *** IDockingWindow methods ***
|
|
HRESULT CHistBand::ShowDW(BOOL fShow)
|
|
{
|
|
HRESULT hr = CNSCBand::ShowDW(fShow);
|
|
_AddButtons(fShow);
|
|
return hr;
|
|
}
|
|
|
|
static const TBBUTTON c_tbHistory[] =
|
|
{
|
|
{ I_IMAGENONE, FCIDM_HISTBAND_VIEW, TBSTATE_ENABLED, BTNS_AUTOSIZE | BTNS_WHOLEDROPDOWN | BTNS_SHOWTEXT, {0,0}, 0, 0 },
|
|
{ 2, FCIDM_HISTBAND_SEARCH, TBSTATE_ENABLED, BTNS_AUTOSIZE | BTNS_SHOWTEXT, {0,0}, 0, 1 },
|
|
};
|
|
|
|
// Adds buttons from the above table to the Explorer
|
|
void CHistBand::_AddButtons(BOOL fAdd)
|
|
{
|
|
// don't add button if we have no menu
|
|
if (!_hViewMenu)
|
|
return;
|
|
|
|
IExplorerToolbar* piet;
|
|
|
|
if (SUCCEEDED(_punkSite->QueryInterface(IID_IExplorerToolbar, (void**)&piet)))
|
|
{
|
|
if (fAdd)
|
|
{
|
|
piet->SetCommandTarget((IUnknown*)SAFECAST(this, IOleCommandTarget*), &CLSID_HistBand, 0);
|
|
|
|
if (!_fStrsAdded)
|
|
{
|
|
piet->AddString(&CLSID_HistBand, MLGetHinst(), IDS_HIST_BAR_LABELS, &_lStrOffset);
|
|
_fStrsAdded = TRUE;
|
|
}
|
|
|
|
_EnsureImageListsLoaded();
|
|
piet->SetImageList(&CLSID_HistBand, _himlNormal, _himlHot, NULL);
|
|
|
|
TBBUTTON tbHistory[ARRAYSIZE(c_tbHistory)];
|
|
memcpy(tbHistory, c_tbHistory, SIZEOF(TBBUTTON) * ARRAYSIZE(c_tbHistory));
|
|
for (int i = 0; i < ARRAYSIZE(c_tbHistory); i++)
|
|
tbHistory[i].iString += (long) _lStrOffset;
|
|
|
|
piet->AddButtons(&CLSID_HistBand, ARRAYSIZE(tbHistory), tbHistory);
|
|
}
|
|
else
|
|
piet->SetCommandTarget(NULL, NULL, 0);
|
|
|
|
piet->Release();
|
|
}
|
|
}
|
|
|
|
// *** IShellFolderSearchableCallback methods ***
|
|
// enable and disable cancel buttons
|
|
HRESULT CHistBand::RunBegin(DWORD dwReserved)
|
|
{
|
|
HRESULT hr = E_FAIL;
|
|
if (_hwndSearchDlg)
|
|
{
|
|
SendMessage(_hwndSearchDlg, WM_SEARCH_STATE, (WPARAM)TRUE, NULL);
|
|
hr = S_OK;
|
|
}
|
|
return hr;
|
|
}
|
|
|
|
HRESULT CHistBand::RunEnd(DWORD dwReserved)
|
|
{
|
|
HRESULT hr = E_FAIL;
|
|
if (_hwndSearchDlg)
|
|
{
|
|
SendMessage(_hwndSearchDlg, WM_SEARCH_STATE, (WPARAM)FALSE, NULL);
|
|
hr = S_OK;
|
|
}
|
|
return hr;
|
|
}
|
|
|
|
// A utility function used in the WM_SIZE handling below...
|
|
inline HWND _GetHwndAndRect(HWND hwndDlg, int item, BOOL fClient, RECT &rc) {
|
|
HWND hwnd = GetDlgItem(hwndDlg, item);
|
|
if (fClient)
|
|
GetClientRect(hwnd, &rc);
|
|
else {
|
|
GetWindowRect(hwnd, &rc);
|
|
MapWindowPoints(NULL, hwndDlg, ((LPPOINT)&rc), 2);
|
|
}
|
|
return hwnd;
|
|
}
|
|
|
|
LRESULT CALLBACK CHistBand::s_EditWndSubclassProc(HWND hwnd, UINT uMsg, WPARAM wParam, LPARAM lParam)
|
|
{
|
|
switch(uMsg) {
|
|
case WM_KEYDOWN:
|
|
if ((GetAsyncKeyState(VK_CONTROL) < 0) &&
|
|
(wParam == TEXT('U'))) {
|
|
uMsg = WM_SETTEXT;
|
|
wParam = 0;
|
|
lParam = ((LPARAM)(LPCTSTR)TEXT(""));
|
|
}
|
|
break;
|
|
|
|
case WM_CHAR:
|
|
if (wParam == VK_RETURN) {
|
|
PostMessage(GetParent(hwnd), WM_COMMAND, MAKELONG(IDB_HISTSRCH_GO, 0), 0L);
|
|
return 0L;
|
|
}
|
|
break;
|
|
}
|
|
return CallWindowProc((WNDPROC)(GetWindowLongPtr(hwnd, GWLP_USERDATA)), hwnd, uMsg, wParam, lParam);
|
|
}
|
|
|
|
|
|
// Please see note at top of file for explanation...
|
|
INT_PTR CALLBACK CHistBand::s_HistSearchDlgProc(HWND hwndDlg, UINT uMsg, WPARAM wParam, LPARAM lParam)
|
|
{
|
|
switch(uMsg) {
|
|
case WM_PAINT:
|
|
{
|
|
// paint a little separator bar on the bottom
|
|
PAINTSTRUCT ps;
|
|
RECT rcSelf;
|
|
HDC hdc = BeginPaint(hwndDlg, &ps);
|
|
GetClientRect(hwndDlg, &rcSelf);
|
|
RECT rcFill = { 0, rcSelf.bottom - 2, rcSelf.right, rcSelf.bottom };
|
|
FillRect(hdc, &rcFill, GetSysColorBrush(COLOR_BTNFACE));
|
|
EndPaint(hwndDlg, &ps);
|
|
break;
|
|
}
|
|
|
|
// Supply child controls with correct bkgd color
|
|
case WM_CTLCOLORSTATIC:
|
|
if ((HWND)lParam == GetDlgItem(hwndDlg, IDD_HISTSRCH_ANIMATION)) {
|
|
SetBkColor((HDC)wParam, GetSysColor(COLOR_WINDOW));
|
|
return (INT_PTR) GetSysColorBrush(COLOR_WINDOW);
|
|
}
|
|
else {
|
|
SetBkMode((HDC)wParam, TRANSPARENT);
|
|
return (INT_PTR) GetSysColorBrush(COLOR_WINDOW);
|
|
}
|
|
case WM_CTLCOLORDLG:
|
|
//SetBkColor((HDC)HIWORD(lParam), GetSysColor(COLOR_WINDOW));
|
|
return (INT_PTR) GetSysColorBrush(COLOR_WINDOW);
|
|
case WM_INITDIALOG: {
|
|
HWND hwndEdit = GetDlgItem(hwndDlg, IDC_EDITHISTSEARCH);
|
|
WNDPROC pfnOldEditProc = (WNDPROC)(GetWindowLongPtr(hwndEdit, GWLP_WNDPROC));
|
|
|
|
// subclass the editbox
|
|
SetWindowLongPtr(hwndEdit, GWLP_USERDATA, (LPARAM)pfnOldEditProc);
|
|
SetWindowLongPtr(hwndEdit, GWLP_WNDPROC, (LPARAM)s_EditWndSubclassProc);
|
|
|
|
SetWindowLongPtr(hwndDlg, DWLP_USER, lParam);
|
|
Animate_Open(GetDlgItem(hwndDlg, IDD_HISTSRCH_ANIMATION),
|
|
MAKEINTRESOURCE(IDA_HISTSEARCHAVI));
|
|
|
|
// limit the edit control to MAX_PATH-1 characters
|
|
Edit_LimitText(hwndEdit, MAX_PATH-1);
|
|
|
|
break;
|
|
}
|
|
case WM_DESTROY:
|
|
Animate_Close(GetDlgItem(hwndDlg, IDD_HISTSRCH_ANIMATION));
|
|
break;
|
|
case WM_SIZE: {
|
|
if (wParam == SIZE_RESTORED) {
|
|
UINT uWidth = LOWORD(lParam);
|
|
UINT uHeight = HIWORD(lParam);
|
|
|
|
RECT rcAnimSize, rcCancel, rcSearch, rcEdit, rcStatic;
|
|
HWND hwndAnim = _GetHwndAndRect(hwndDlg, IDD_HISTSRCH_ANIMATION, TRUE, rcAnimSize);
|
|
HWND hwndCancel = _GetHwndAndRect(hwndDlg, IDCANCEL, FALSE, rcCancel);
|
|
HWND hwndSearch = _GetHwndAndRect(hwndDlg, IDB_HISTSRCH_GO, FALSE, rcSearch);
|
|
HWND hwndEdit = _GetHwndAndRect(hwndDlg, IDC_EDITHISTSEARCH, FALSE, rcEdit);
|
|
|
|
// calculate the minimum tolerable width
|
|
UINT uMinWidth = ((rcCancel.right - rcCancel.left) +
|
|
(rcSearch.right - rcSearch.left) + HISTSRCH_BUTTONDIST +
|
|
rcEdit.left +
|
|
rcAnimSize.right + 1);
|
|
|
|
if (uWidth < uMinWidth)
|
|
uWidth = uMinWidth;
|
|
|
|
HDWP hdwp = BeginDeferWindowPos(5);
|
|
|
|
if (hdwp)
|
|
{
|
|
// align the animation box with the upper-right corner
|
|
DeferWindowPos(hdwp, hwndAnim, HWND_TOP, uWidth - rcAnimSize.right, 0,
|
|
rcAnimSize.right, rcAnimSize.bottom, SWP_NOZORDER);
|
|
|
|
// stretch the textbox as wide as possible
|
|
UINT uNewTextWidth = uWidth - rcAnimSize.right - 1 - rcEdit.left;
|
|
DeferWindowPos(hdwp, hwndEdit, HWND_TOP, rcEdit.left, rcEdit.top, uNewTextWidth,
|
|
rcEdit.bottom - rcEdit.top, SWP_NOZORDER);
|
|
|
|
// static text should not be longer than edit textbox
|
|
HWND hwndStatic = _GetHwndAndRect(hwndDlg, IDC_HISTSRCH_STATIC, FALSE, rcStatic);
|
|
DeferWindowPos(hdwp, hwndStatic, HWND_TOP, rcEdit.left, rcStatic.top, uNewTextWidth,
|
|
rcStatic.bottom - rcStatic.top, SWP_NOZORDER);
|
|
|
|
// align the cancel button with the right of the edit box
|
|
UINT uCancelLeft = uWidth - rcAnimSize.right - 1 - (rcCancel.right - rcCancel.left);
|
|
DeferWindowPos(hdwp, hwndCancel, HWND_TOP, uCancelLeft, rcCancel.top,
|
|
rcCancel.right - rcCancel.left, rcCancel.bottom - rcCancel.top, SWP_NOZORDER);
|
|
|
|
// align the search button so that it ends six pixels (HISTSRCH_BUTTONDIST)
|
|
// to the left of the cancel button
|
|
DeferWindowPos(hdwp, hwndSearch, HWND_TOP,
|
|
uCancelLeft - HISTSRCH_BUTTONDIST - (rcSearch.right - rcSearch.left),
|
|
rcSearch.top, rcSearch.right - rcSearch.left, rcSearch.bottom - rcSearch.top, SWP_NOZORDER);
|
|
|
|
EndDeferWindowPos(hdwp);
|
|
}
|
|
}
|
|
else
|
|
return FALSE;
|
|
break;
|
|
}
|
|
case WM_COMMAND:
|
|
{
|
|
CHistBand *phb = reinterpret_cast<CHistBand *>(GetWindowLongPtr(hwndDlg, DWLP_USER));
|
|
|
|
switch (LOWORD(wParam))
|
|
{
|
|
case IDC_EDITHISTSEARCH:
|
|
switch (HIWORD(wParam))
|
|
{
|
|
case EN_SETFOCUS:
|
|
// This guy allows us to intercept TranslateAccelerator messages
|
|
// like backspace. This is the same as calling UIActivateIO(TRUE), but
|
|
// doesn't cause an infinite setfocus loop in Win95
|
|
IUnknown_OnFocusChangeIS(phb->_punkSite, SAFECAST(phb, IInputObject*), TRUE);
|
|
SetFocus((HWND)lParam);
|
|
break;
|
|
case EN_CHANGE:
|
|
// Enable 'Go Fish' button iff there is text in the edit box
|
|
EnableWindow(GetDlgItem(hwndDlg, IDB_HISTSRCH_GO),
|
|
(bool) SendDlgItemMessage(hwndDlg, IDC_EDITHISTSEARCH, EM_LINELENGTH, 0, 0));
|
|
break;
|
|
}
|
|
break;
|
|
case IDB_HISTSRCH_GO:
|
|
{
|
|
TCHAR szSearchString[MAX_PATH];
|
|
if (GetDlgItemText(hwndDlg, IDC_EDITHISTSEARCH, szSearchString, ARRAYSIZE(szSearchString)))
|
|
{
|
|
IServiceProvider *pServiceProvider;
|
|
|
|
HRESULT hr = IUnknown_QueryService(phb->_punkSite,
|
|
SID_SProxyBrowser,
|
|
IID_IServiceProvider,
|
|
(void **)&pServiceProvider);
|
|
|
|
if (SUCCEEDED(hr))
|
|
{
|
|
IWebBrowser2 *pWebBrowser2;
|
|
hr = pServiceProvider->QueryService(SID_SWebBrowserApp,
|
|
IID_IWebBrowser2,
|
|
(void **)&pWebBrowser2);
|
|
if (SUCCEEDED(hr))
|
|
{
|
|
::PutFindText(pWebBrowser2, szSearchString);
|
|
pWebBrowser2->Release();
|
|
}
|
|
|
|
pServiceProvider->Release();
|
|
}
|
|
|
|
phb->_ExecuteSearch(szSearchString);
|
|
}
|
|
}
|
|
break;
|
|
case IDCANCEL:
|
|
{
|
|
if (phb->_EnsureSearch())
|
|
{
|
|
phb->_psfSearch->CancelAsyncSearch(phb->_pidlSearch, NULL);
|
|
}
|
|
break;
|
|
}
|
|
default:
|
|
return FALSE;
|
|
}
|
|
}
|
|
return FALSE;
|
|
|
|
case WM_SEARCH_STATE:
|
|
{
|
|
BOOL fStart = (BOOL)wParam;
|
|
if (fStart)
|
|
Animate_Play(GetDlgItem(hwndDlg, IDD_HISTSRCH_ANIMATION), 0, -1, -1);
|
|
else {
|
|
HWND hwndAnim = GetDlgItem(hwndDlg, IDD_HISTSRCH_ANIMATION);
|
|
Animate_Stop(hwndAnim);
|
|
Animate_Seek(hwndAnim, 0); // reset the animation
|
|
|
|
//HACK for IE5 ship
|
|
//if there's only one item found in history search, the item doesn't display
|
|
//because someone (comctl32?) set redraw to false.
|
|
//so, manually force it to true when the search stops
|
|
CHistBand *phb = reinterpret_cast<CHistBand *>(GetWindowLongPtr(hwndDlg, DWLP_USER));
|
|
if (phb)
|
|
SendMessage(phb->_hwndNSC, WM_SETREDRAW, TRUE, 0);
|
|
}
|
|
HWND hwndFocus = GetFocus();
|
|
|
|
EnableWindow(GetDlgItem(hwndDlg, IDC_EDITHISTSEARCH), !fStart);
|
|
EnableWindow(GetDlgItem(hwndDlg, IDB_HISTSRCH_GO), !fStart);
|
|
EnableWindow(GetDlgItem(hwndDlg, IDCANCEL), fStart);
|
|
|
|
//make sure the focus goes to the right place
|
|
if ((NULL != hwndFocus) && (hwndFocus == GetDlgItem(hwndDlg, IDC_EDITHISTSEARCH) ||
|
|
(hwndFocus == GetDlgItem(hwndDlg, IDCANCEL))))
|
|
SetFocus(GetDlgItem(hwndDlg, fStart ? IDCANCEL : IDC_EDITHISTSEARCH));
|
|
break;
|
|
}
|
|
|
|
default:
|
|
return FALSE;
|
|
}
|
|
return TRUE;
|
|
}
|
|
|
|
IShellFolderSearchable *CHistBand::_EnsureSearch() {
|
|
ASSERT(_psfHistory);
|
|
if (!_pidlSearch) {
|
|
_psfHistory->QueryInterface(IID_IShellFolderSearchable,
|
|
(LPVOID *)&_psfSearch);
|
|
}
|
|
return _psfSearch;
|
|
}
|
|
|
|
HRESULT CHistBand::_ClearSearch() {
|
|
HRESULT hr = S_FALSE;
|
|
|
|
if (_pidlSearch) {
|
|
if (_EnsureSearch())
|
|
{
|
|
EVAL(SUCCEEDED(_psfSearch->CancelAsyncSearch(_pidlSearch, NULL)));
|
|
hr = _psfSearch->InvalidateSearch(_pidlSearch, NULL);
|
|
}
|
|
ILFree(_pidlSearch);
|
|
_pidlSearch = NULL;
|
|
}
|
|
return hr;
|
|
}
|
|
|
|
HRESULT CHistBand::_ExecuteSearch(LPTSTR pszSearchString)
|
|
{
|
|
HRESULT hr = E_FAIL;
|
|
|
|
if (_EnsureSearch())
|
|
{
|
|
_ClearSearch();
|
|
hr = _psfSearch->FindString(pszSearchString,
|
|
NULL,
|
|
reinterpret_cast<IUnknown *>
|
|
(static_cast<IShellFolderSearchableCallback *>
|
|
(this)),
|
|
&_pidlSearch);
|
|
if (SUCCEEDED(hr))
|
|
{
|
|
_ChangePidl(ILCombine(_pidlHistory, _pidlSearch));
|
|
}
|
|
}
|
|
return hr;
|
|
}
|
|
|
|
#ifdef SPLIT_HISTORY_VIEW_BUTTON
|
|
UINT CHistBand::_NextMenuItem() {
|
|
if (_uViewCheckedItem + 1 > _nViews)
|
|
return 1;
|
|
else
|
|
return _uViewCheckedItem + 1;
|
|
}
|
|
#endif
|
|
|
|
HRESULT CHistBand::_ViewPopupSelect(UINT idCmd)
|
|
{
|
|
HRESULT hr = E_FAIL;
|
|
|
|
if (idCmd == MENUID_SEARCH)
|
|
{
|
|
if (_uViewCheckedItem != MENUID_SEARCH)
|
|
{
|
|
// display the dialog box
|
|
if (SUCCEEDED(hr = _DoSearchUIStuff()))
|
|
{
|
|
_ChangePidl((LPITEMIDLIST)INVALID_HANDLE_VALUE); // blank out NSC
|
|
_uViewCheckedItem = MENUID_SEARCH;
|
|
CheckMenuRadioItem(_hViewMenu, 1, _iMaxMenuID, _uViewCheckedItem, MF_BYCOMMAND);
|
|
}
|
|
}
|
|
if (_hwndSearchDlg)
|
|
SetFocus(GetDlgItem(_hwndSearchDlg, IDC_EDITHISTSEARCH));
|
|
}
|
|
else
|
|
{
|
|
LPCITEMIDLIST pidlNewSelect = _MenuIDToPIDL(idCmd);
|
|
if (pidlNewSelect) {
|
|
if (ILIsEmpty(pidlNewSelect))
|
|
hr = _ChangePidl(ILClone(_pidlHistory));
|
|
else
|
|
hr = _ChangePidl(ILCombine(_pidlHistory, pidlNewSelect));
|
|
|
|
if (SUCCEEDED(hr))
|
|
hr = _SelectPidl(NULL, TRUE, pidlNewSelect);
|
|
|
|
// deleted "&& _uViewCheckedItem >= 0" from test below
|
|
// because UINTs are by definition always >= 0
|
|
if (SUCCEEDED(hr))
|
|
{
|
|
// get rid of search dialog -- its no longer needed
|
|
if (_hwndSearchDlg) {
|
|
EndDialog(_hwndSearchDlg, 0);
|
|
DestroyWindow(_hwndSearchDlg);
|
|
_hwndSearchDlg = NULL;
|
|
// invalidate the previous search and prepare for the next
|
|
_ClearSearch();
|
|
RECT rcSelf;
|
|
GetClientRect(_hwnd, &rcSelf);
|
|
_ResizeChildWindows(rcSelf.right, rcSelf.bottom, TRUE);
|
|
}
|
|
|
|
_uViewCheckedItem = idCmd;
|
|
CheckMenuRadioItem(_hViewMenu, 1, _iMaxMenuID,
|
|
_uViewCheckedItem, MF_BYCOMMAND);
|
|
// write out the new selection to registry
|
|
EVAL(SUCCEEDED(_SetRegistryPersistView(_uViewCheckedItem)));
|
|
hr = S_OK;
|
|
}
|
|
}
|
|
}
|
|
return hr;
|
|
}
|
|
|
|
HRESULT CHistBand::_DoViewPopup(int x, int y)
|
|
{
|
|
if (!_hViewMenu) return E_FAIL;
|
|
|
|
HRESULT hr = E_FAIL;
|
|
|
|
UINT idCmd = TrackPopupMenu(_hViewMenu, TPM_RETURNCMD, x, y, 0, _hwnd, NULL);
|
|
// Currently, re-selecting the menu item will cause the item to be refreshed
|
|
// This makes sense to me, but it can be prevented by
|
|
// testing idCmd != _uViewCheckedItem
|
|
if ( (idCmd > 0) )
|
|
{
|
|
return _ViewPopupSelect(idCmd);
|
|
}
|
|
else
|
|
hr = S_FALSE;
|
|
|
|
return hr;
|
|
}
|
|
|
|
// Change the current select NSC pidl
|
|
// WARNING: The pidl passed in will be assimilated by us...
|
|
// We will deallocate it.
|
|
HRESULT CHistBand::_ChangePidl(LPITEMIDLIST pidl)
|
|
{
|
|
if (_pidl)
|
|
ILFree(_pidl);
|
|
|
|
_pidl = pidl;
|
|
if ((LPITEMIDLIST)INVALID_HANDLE_VALUE == pidl)
|
|
_pidl = NULL;
|
|
_pns->Initialize(pidl, (SHCONTF_FOLDERS | SHCONTF_NONFOLDERS), (NSS_DROPTARGET | NSS_BROWSERSELECT));
|
|
return S_OK;
|
|
}
|
|
|
|
// _SelectPidl - Have NSC change the current selected pidl
|
|
//
|
|
// passing NULL for pidlSelect will select the current select pidl
|
|
HRESULT CHistBand::_SelectPidl(LPCITEMIDLIST pidlSelect, // <-Standard Hist-type pidl to select
|
|
BOOL fCreate, // <-create NSC item if not there?
|
|
LPCITEMIDLIST pidlView,/*=NULL*/ // <-special history view type or NULL
|
|
BOOL fReinsert /*=0*/) // <-reinsert pidl into NSC and re-sort
|
|
{
|
|
HRESULT hRes = S_OK;
|
|
BOOL fFreePidlSelect = FALSE;
|
|
|
|
if ( (!pidlSelect) &&
|
|
((pidlSelect = _GetCurrentSelectPidl())) )
|
|
fFreePidlSelect = TRUE;
|
|
|
|
if (pidlSelect) {
|
|
LPITEMIDLIST pidlNewSelect = NULL;
|
|
|
|
// cache the last selected pidl
|
|
if (_pidlLastSelect != pidlSelect) {
|
|
if (_pidlLastSelect)
|
|
ILFree(_pidlLastSelect);
|
|
_pidlLastSelect = ILClone(pidlSelect);
|
|
}
|
|
|
|
if (pidlView && !ILIsEmpty(pidlView)) {
|
|
IShellFolderViewType *psfvtInfo = _GetViewTypeInfo();
|
|
|
|
if (psfvtInfo) {
|
|
LPITEMIDLIST pidlFromRoot = ILFindChild(_pidlHistory,
|
|
pidlSelect);
|
|
if (pidlFromRoot && !ILIsEmpty(pidlFromRoot))
|
|
{
|
|
LPITEMIDLIST pidlNewFromRoot;
|
|
if (SUCCEEDED(psfvtInfo->TranslateViewPidl(pidlFromRoot, pidlView,
|
|
&pidlNewFromRoot)))
|
|
{
|
|
if (pidlNewFromRoot) {
|
|
pidlNewSelect = ILCombine(_pidlHistory, pidlNewFromRoot);
|
|
if (pidlNewSelect) {
|
|
_pns->SetSelectedItem(pidlNewSelect, fCreate, fReinsert, 0);
|
|
ILFree(pidlNewSelect);
|
|
}
|
|
ILFree(pidlNewFromRoot);
|
|
}
|
|
}
|
|
}
|
|
psfvtInfo->Release();
|
|
}
|
|
}
|
|
else
|
|
_pns->SetSelectedItem(pidlSelect, fCreate, fReinsert, 0);
|
|
|
|
if (fFreePidlSelect)
|
|
ILFree(const_cast<LPITEMIDLIST>(pidlSelect));
|
|
}
|
|
return hRes;
|
|
}
|
|
|
|
HRESULT CHistBand::_SetRegistryPersistView(int iMenuID)
|
|
{
|
|
LPCITEMIDLIST pidlReg = _MenuIDToPIDL(iMenuID);
|
|
|
|
if (!pidlReg)
|
|
return E_FAIL;
|
|
|
|
LONG lRet = (SHRegSetUSValue(REGSTR_PATH_MAIN, REGKEY_HISTORY_VIEW,
|
|
REG_BINARY, (LPVOID)pidlReg, ILGetSize(pidlReg),
|
|
SHREGSET_HKCU | SHREGSET_FORCE_HKCU));
|
|
return HRESULT_FROM_WIN32(lRet);
|
|
}
|
|
|
|
// Get the default view from the registry as a menu item
|
|
int CHistBand::_GetRegistryPersistView()
|
|
{
|
|
int iRegMenu = -1;
|
|
DWORD dwType = REG_BINARY;
|
|
|
|
ITEMIDLIST pidlDefault = { 0 };
|
|
|
|
// make a preliminary call to find out the size of the data
|
|
DWORD cbData = 0;
|
|
LONG error = SHRegGetUSValue(REGSTR_PATH_MAIN, REGKEY_HISTORY_VIEW, &dwType,
|
|
NULL, &cbData, FALSE, &pidlDefault,
|
|
sizeof(pidlDefault));
|
|
if (cbData)
|
|
{
|
|
LPITEMIDLIST pidlReg = ((LPITEMIDLIST)SHAlloc(cbData));
|
|
|
|
if (pidlReg)
|
|
{
|
|
error = SHRegGetUSValue(REGSTR_PATH_MAIN, REGKEY_HISTORY_VIEW, &dwType,
|
|
(LPVOID)pidlReg, &cbData, FALSE, &pidlDefault,
|
|
sizeof(pidlDefault));
|
|
|
|
if (error == ERROR_SUCCESS)
|
|
iRegMenu = _PIDLToMenuID(pidlReg);
|
|
|
|
SHFree(pidlReg);
|
|
}
|
|
}
|
|
|
|
return iRegMenu;
|
|
}
|
|
|
|
LPCITEMIDLIST CHistBand::_MenuIDToPIDL(UINT uMenuID)
|
|
{
|
|
ASSERT(_ppidlViewTypes);
|
|
if ((uMenuID > 0) && (uMenuID <= _nViews))
|
|
return _ppidlViewTypes[uMenuID - 1];
|
|
return NULL;
|
|
}
|
|
|
|
int CHistBand::_PIDLToMenuID(LPITEMIDLIST pidl)
|
|
{
|
|
ASSERT(_psfHistory && _ppidlViewTypes);
|
|
|
|
int iMenuID = -1;
|
|
|
|
// handle the empty pidl, which designates the
|
|
// default view, separately
|
|
if (ILIsEmpty(pidl))
|
|
iMenuID = 1;
|
|
else
|
|
{
|
|
for (UINT u = 0; u < _nViews; ++u)
|
|
{
|
|
if (_psfHistory->CompareIDs(0, pidl, _ppidlViewTypes[u]) == 0)
|
|
iMenuID = u + 1;
|
|
}
|
|
}
|
|
return iMenuID;
|
|
}
|
|
|
|
// remember to release return value
|
|
IShellFolderViewType* CHistBand::_GetViewTypeInfo()
|
|
{
|
|
IShellFolderViewType* psfvRet = NULL;
|
|
|
|
if (_psfvtCache)
|
|
{
|
|
_psfvtCache->AddRef();
|
|
psfvRet = _psfvtCache;
|
|
}
|
|
else if (_psfHistory)
|
|
{
|
|
// QI For the views
|
|
// We set the pointer because of a bad QI somewhere...
|
|
if (SUCCEEDED(_psfHistory->QueryInterface(IID_IShellFolderViewType,
|
|
((void**)&psfvRet))))
|
|
{
|
|
_psfvtCache = psfvRet;
|
|
psfvRet->AddRef(); // one released in destructor, another by caller
|
|
}
|
|
else
|
|
psfvRet = NULL;
|
|
}
|
|
return psfvRet;
|
|
}
|
|
|
|
HRESULT CHistBand::_FreeViewInfo()
|
|
{
|
|
if (_ppidlViewTypes)
|
|
{
|
|
// the first pidl in this list is NULL, the default view
|
|
for (UINT u = 0; u < _nViews; ++u)
|
|
if (EVAL(_ppidlViewTypes[u]))
|
|
ILFree(_ppidlViewTypes[u]);
|
|
LocalFree(_ppidlViewTypes);
|
|
_ppidlViewTypes = NULL;
|
|
}
|
|
if (_ppszStrViewNames)
|
|
{
|
|
for (UINT u = 0; u < _nViews; ++u)
|
|
if (EVAL(_ppszStrViewNames[u]))
|
|
CoTaskMemFree(_ppszStrViewNames[u]);
|
|
LocalFree(_ppszStrViewNames);
|
|
_ppszStrViewNames = NULL;
|
|
}
|
|
return S_OK;
|
|
}
|
|
|
|
// Load the popup menu (if there are views to be had)
|
|
HRESULT CHistBand::_InitViewPopup()
|
|
{
|
|
HRESULT hRes = E_FAIL;
|
|
|
|
_iMaxMenuID = 0;
|
|
|
|
if (SUCCEEDED((hRes = _GetHistoryViews())))
|
|
{
|
|
if ((_hViewMenu = CreatePopupMenu()))
|
|
{
|
|
// the IDCMD for the view menu will always be
|
|
// one more than the index into the view tables
|
|
for (UINT u = 0; u < _nViews; ++u)
|
|
{
|
|
int iMenuID = _PIDLToMenuID(_ppidlViewTypes[u]);
|
|
if (iMenuID >= 0)
|
|
AppendMenu(_hViewMenu, MF_STRING, iMenuID,
|
|
_ppszStrViewNames[u]);
|
|
if (iMenuID > _iMaxMenuID)
|
|
_iMaxMenuID = iMenuID;
|
|
}
|
|
|
|
// retrieve the persisted view information
|
|
// and check the corresponding menu item
|
|
int iSelectMenuID = _GetRegistryPersistView();
|
|
if (iSelectMenuID < 0 || ((UINT)iSelectMenuID) > _nViews)
|
|
iSelectMenuID = 1; //bogus menuid
|
|
_uViewCheckedItem = iSelectMenuID;
|
|
CheckMenuRadioItem(_hViewMenu, 1, _nViews, _uViewCheckedItem, MF_BYCOMMAND);
|
|
}
|
|
}
|
|
|
|
#ifdef HISTORY_VIEWSEARCHMENU
|
|
// if this is a searchable shell folder, then add the search menu item
|
|
if (_EnsureSearch())
|
|
{
|
|
hRes = S_OK;
|
|
|
|
// only add separator if there is a menu already!
|
|
if (!_hViewMenu)
|
|
_hViewMenu = CreatePopupMenu();
|
|
else
|
|
AppendMenu(_hViewMenu, MF_SEPARATOR, 0, NULL);
|
|
|
|
if (_hViewMenu)
|
|
{
|
|
TCHAR szSearchMenuText[MAX_PATH];
|
|
LoadString(MLGetHinst(), IDS_SEARCH_MENUOPT,
|
|
szSearchMenuText, ARRAYSIZE(szSearchMenuText));
|
|
AppendMenu(_hViewMenu, MF_STRING, MENUID_SEARCH, szSearchMenuText);
|
|
_iMaxMenuID = MENUID_SEARCH;
|
|
}
|
|
else
|
|
hRes = E_FAIL;
|
|
}
|
|
#endif
|
|
return hRes;
|
|
}
|
|
|
|
// This guy calls the enumerator
|
|
HRESULT CHistBand::_GetHistoryViews()
|
|
{
|
|
ASSERT(_psfHistory);
|
|
HRESULT hRes = E_FAIL;
|
|
|
|
UINT cbViews; // how many views are allocated
|
|
|
|
ASSERT(VIEWTYPE_MAX > 0);
|
|
|
|
EVAL(SUCCEEDED(_FreeViewInfo()));
|
|
|
|
IShellFolderViewType *psfViewType = _GetViewTypeInfo();
|
|
|
|
if (psfViewType)
|
|
{
|
|
// allocate buffers to store the view information
|
|
_ppidlViewTypes = ((LPITEMIDLIST *)LocalAlloc(LPTR, VIEWTYPE_MAX * sizeof(LPITEMIDLIST)));
|
|
if (_ppidlViewTypes) {
|
|
_ppszStrViewNames = ((LPTSTR *)LocalAlloc(LPTR, VIEWTYPE_MAX * sizeof(LPTSTR)));
|
|
if (_ppszStrViewNames) {
|
|
IEnumIDList *penum = NULL;
|
|
cbViews = VIEWTYPE_MAX;
|
|
_nViews = 1;
|
|
// get the default view information
|
|
_ppidlViewTypes[0] = IEILCreate(sizeof(ITEMIDLIST));
|
|
if (_ppidlViewTypes[0] &&
|
|
SUCCEEDED((hRes = psfViewType->GetDefaultViewName(0, &(_ppszStrViewNames[0])))))
|
|
{
|
|
// empty pidl will be the default
|
|
ASSERT(ILIsEmpty(_ppidlViewTypes[0]));
|
|
// get the iterator for the other views
|
|
if (SUCCEEDED((hRes = psfViewType->EnumViews(0, &penum)))) {
|
|
ULONG cFetched = 0;
|
|
// iterate to get other view information
|
|
while(SUCCEEDED(hRes) &&
|
|
SUCCEEDED(penum->Next(1, &(_ppidlViewTypes[_nViews]), &cFetched)) &&
|
|
cFetched)
|
|
{
|
|
// get the name of this view
|
|
if (SUCCEEDED(DisplayNameOfAsOLESTR(_psfHistory, _ppidlViewTypes[_nViews], 0, &(_ppszStrViewNames[_nViews]))))
|
|
{
|
|
// prepare for next iteration by reallocating the buffer if necessary
|
|
if (_nViews > cbViews - 1)
|
|
{
|
|
LPITEMIDLIST *ppidlViewTypes = ((LPITEMIDLIST *)LocalReAlloc(_ppidlViewTypes,
|
|
(cbViews + VIEWTYPE_REALLOC) * sizeof(LPITEMIDLIST),
|
|
LMEM_MOVEABLE | LMEM_ZEROINIT));
|
|
if (ppidlViewTypes)
|
|
{
|
|
_ppidlViewTypes = ppidlViewTypes;
|
|
LPTSTR * ppszStrViewNames = ((LPTSTR *)LocalReAlloc(_ppszStrViewNames,
|
|
(cbViews + VIEWTYPE_REALLOC) * sizeof(LPTSTR),
|
|
LMEM_MOVEABLE | LMEM_ZEROINIT));
|
|
if (ppszStrViewNames)
|
|
{
|
|
_ppszStrViewNames = ppszStrViewNames;
|
|
cbViews += VIEWTYPE_REALLOC;
|
|
}
|
|
else
|
|
{
|
|
hRes = E_OUTOFMEMORY;
|
|
break;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
hRes = E_OUTOFMEMORY;
|
|
break;
|
|
}
|
|
}
|
|
++_nViews;
|
|
}
|
|
}
|
|
penum->Release();
|
|
}
|
|
}
|
|
}
|
|
}
|
|
psfViewType->Release();
|
|
}
|
|
return hRes;
|
|
}
|
|
|
|
HRESULT CHistBand_CreateInstance(IUnknown *punkOuter, IUnknown **ppunk, LPCOBJECTINFO poi)
|
|
{
|
|
// aggregation checking is handled in class factory
|
|
CHistBand * phb = new CHistBand();
|
|
|
|
if (!phb)
|
|
return E_OUTOFMEMORY;
|
|
|
|
ASSERT(phb->_pidlHistory == NULL &&
|
|
phb->_pidlLastSelect == NULL &&
|
|
phb->_pidl == NULL &&
|
|
phb->_psfvtCache == NULL);
|
|
|
|
|
|
if (SUCCEEDED(SHGetHistoryPIDL(&(phb->_pidlHistory))) &&
|
|
SUCCEEDED(IEBindToObject(phb->_pidlHistory,
|
|
&(phb->_psfHistory))))
|
|
{
|
|
HRESULT hResLocal = E_FAIL;
|
|
|
|
// if we can get different views, then init with the persisted
|
|
// view type, otherwise, init with the top-level history type
|
|
if (SUCCEEDED(phb->_InitViewPopup())) {
|
|
LPCITEMIDLIST pidlInit = phb->_MenuIDToPIDL(phb->_uViewCheckedItem);
|
|
if (pidlInit) {
|
|
LPITEMIDLIST pidlFullInit = ILCombine(phb->_pidlHistory, pidlInit);
|
|
if (pidlFullInit) {
|
|
hResLocal = phb->_Init(pidlFullInit);
|
|
ILFree(pidlFullInit);
|
|
}
|
|
}
|
|
}
|
|
else
|
|
hResLocal = phb->_Init(phb->_pidlHistory);
|
|
|
|
// From old favband code: // if (SUCCEEDED(phb->_Init((LPCITEMIDLIST)CSIDL_FAVORITES)))
|
|
if (SUCCEEDED(hResLocal))
|
|
{
|
|
phb->_pns = CNscTree_CreateInstance();
|
|
if (phb->_pns)
|
|
{
|
|
ASSERT(poi);
|
|
phb->_poi = poi;
|
|
// if you change this cast, fix up CChannelBand_CreateInstance
|
|
*ppunk = SAFECAST(phb, IDeskBand *);
|
|
|
|
IUnknown_SetSite(phb->_pns, *ppunk);
|
|
phb->_SetNscMode(MODE_HISTORY);
|
|
return S_OK;
|
|
}
|
|
}
|
|
}
|
|
|
|
phb->Release();
|
|
|
|
return E_FAIL;
|
|
}
|
|
|
|
// Ask the powers that be which pidl is selected...
|
|
LPITEMIDLIST CHistBand::_GetCurrentSelectPidl(IOleCommandTarget *poctProxy/* = NULL*/)
|
|
{
|
|
LPITEMIDLIST pidlRet = NULL;
|
|
VARIANT var;
|
|
BOOL fReleaseProxy = FALSE;
|
|
VariantInit(&var);
|
|
var.vt = VT_EMPTY;
|
|
|
|
if (poctProxy == NULL)
|
|
{
|
|
IBrowserService *pswProxy;
|
|
if (SUCCEEDED(QueryService(SID_SProxyBrowser, IID_PPV_ARG(IBrowserService, &pswProxy))))
|
|
{
|
|
ASSERT(pswProxy);
|
|
if (FAILED(pswProxy->QueryInterface(IID_PPV_ARG(IOleCommandTarget, &poctProxy))))
|
|
{
|
|
pswProxy->Release();
|
|
return NULL;
|
|
}
|
|
else
|
|
fReleaseProxy = TRUE;
|
|
|
|
pswProxy->Release();
|
|
}
|
|
}
|
|
|
|
// Inquire the current select pidl
|
|
if ((SUCCEEDED(poctProxy->Exec(&CGID_Explorer, SBCMDID_GETHISTPIDL,
|
|
OLECMDEXECOPT_PROMPTUSER, NULL, &var))) &&
|
|
(var.vt != VT_EMPTY))
|
|
{
|
|
pidlRet = VariantToIDList(&var);
|
|
VariantClearLazy(&var);
|
|
}
|
|
if (fReleaseProxy)
|
|
poctProxy->Release();
|
|
return pidlRet;
|
|
}
|
|
|
|
// gets called by CNSCBand::ShowDW every time history band is shown
|
|
HRESULT CHistBand::_OnRegisterBand(IOleCommandTarget *poctProxy)
|
|
{
|
|
HRESULT hRes = E_FAIL;
|
|
if (_uViewCheckedItem != MENUID_SEARCH)
|
|
{
|
|
LPITEMIDLIST pidlSelect = _GetCurrentSelectPidl(poctProxy);
|
|
if (pidlSelect)
|
|
{
|
|
_SelectPidl(pidlSelect, TRUE);
|
|
ILFree(pidlSelect);
|
|
hRes = S_OK;
|
|
}
|
|
}
|
|
return hRes;
|
|
}
|
|
|
|
HRESULT CHistBand::_InitializeNsc()
|
|
{
|
|
return _pns->Initialize(_pidl, SHCONTF_FOLDERS | SHCONTF_NONFOLDERS, NSS_NOHISTSELECT | NSS_DROPTARGET | NSS_BROWSERSELECT);
|
|
}
|
|
|
|
BOOL CHistBand::_ShouldNavigateToPidl(LPCITEMIDLIST pidl, ULONG ulAttrib)
|
|
{
|
|
return !(ulAttrib & SFGAO_FOLDER);
|
|
}
|
|
|
|
HRESULT CHistBand::_NavigateRightPane(IShellBrowser *psb, LPCITEMIDLIST pidl)
|
|
{
|
|
HRESULT hr = psb->BrowseObject(pidl, SBSP_SAMEBROWSER | SBSP_NOAUTOSELECT);
|
|
if (SUCCEEDED(hr))
|
|
{
|
|
IOleCommandTarget *poctProxy;
|
|
if (SUCCEEDED(QueryService(SID_SProxyBrowser, IID_PPV_ARG(IOleCommandTarget, &poctProxy))))
|
|
{
|
|
VARIANTARG var;
|
|
|
|
InitVariantFromIDList(&var, pidl);
|
|
poctProxy->Exec(&CGID_Explorer, SBCMDID_SELECTHISTPIDL, OLECMDEXECOPT_PROMPTUSER, &var, NULL);
|
|
VariantClear(&var);
|
|
poctProxy->Release();
|
|
}
|
|
UEMFireEvent(&UEMIID_BROWSER, UEME_INSTRBROWSER, UEMF_INSTRUMENT, UIBW_NAVIGATE, UIBL_NAVHIST);
|
|
}
|
|
return hr;
|
|
}
|
|
|