able/windows-nt
1
0
Fork 0
Code Issues Pull requests Projects Releases Wiki Activity
windows-nt/Source/XPSP1/NT/shell/browseui/commonsb.cpp

1889 lines
58 KiB
C++
Raw Normal View History

Add source files
2020-09-26 03:20:57 -05:00
#include "priv.h"
#include "sccls.h"
#include "resource.h"
#include "commonsb.h"
#include "dockbar.h" // for DRAG_MOVE etc.
#include "mluisupp.h"
#define DM_HTTPEQUIV TF_SHDNAVIGATE
#define DM_NAV TF_SHDNAVIGATE
#define DM_ZONE TF_SHDNAVIGATE
#define DM_IEDDE DM_TRACE
#define DM_CANCELMODE 0
#define DM_UIWINDOW 0
#define DM_ENABLEMODELESS TF_SHDNAVIGATE
#define DM_EXPLORERMENU 0
#define DM_BACKFORWARD 0
#define DM_PROTOCOL 0
#define DM_ITBAR 0
#define DM_STARTUP 0
#define DM_AUTOLIFE 0
#define DM_PALETTE 0
#define DM_PERSIST 0 // trace IPS::Load, ::Save, etc.
#define DM_VIEWSTREAM DM_TRACE
#define DM_FOCUS 0
#define DM_FOCUS2 0 // like DM_FOCUS, but verbose
#define DM_ACCELERATOR 0
#define TF_PERF TF_CUSTOM2
#define DM_MISC DM_TRACE // misc/tmp stuff
PZONEICONNAMECACHE g_pZoneIconNameCache = NULL;
DWORD g_dwZoneCount = 0;
//*** create, ctor/init/dtor, QI/AddRef/Release {
// So CDesktopBrowser can access us...
HRESULT CCommonBrowser_CreateInstance(IUnknown* punkOuter, IUnknown** ppunk, LPCOBJECTINFO poi)
{
CCommonBrowser *pcb = new CCommonBrowser(punkOuter);
if (pcb)
{
*ppunk = pcb->_GetInner();
return S_OK;
}
*ppunk = NULL;
return E_OUTOFMEMORY;
}
CCommonBrowser::CCommonBrowser(IUnknown* punkAgg) :
CAggregatedUnknown(punkAgg)
{
// cache "out" pointers
_QueryOuterInterface(IID_PPV_ARG(IBrowserService2, &_pbsOuter));
// warning: can't call SUPER/_psbInner until _Initialize has been called
// (since that's what does the aggregation)
}
HRESULT CCommonBrowser::_Initialize(HWND hwnd, IUnknown *pauto)
{
// I hope we have an IBrowserService2 to talk to.
if (!_pbsOuter)
{
return E_FAIL;
}
IUnknown* punk;
HRESULT hr = CoCreateInstance(CLSID_CBaseBrowser, SAFECAST(this, IShellBrowser*), CLSCTX_INPROC_SERVER, IID_PPV_ARG(IUnknown, &punk));
if (SUCCEEDED(hr))
{
hr = SetInner(punk); // paired w/ Release in outer (TBS::Release)
if (EVAL(SUCCEEDED(hr)))
{
hr = _pbsInner->_Initialize(hwnd, pauto);
}
}
EVAL(FDSA_Initialize(sizeof(TOOLBARITEM), ITB_CGROW, &_fdsaTBar, _aTBar, ITB_CSTATIC));
return hr;
}
CCommonBrowser::~CCommonBrowser()
{
// First, release outer interfaces, since the
// outer object is in the process of destroying itself.
RELEASEOUTERINTERFACE(_pbsOuter);
RELEASEOUTERINTERFACE(_pbsOuter3);
// Second, release the inner guy so it knows to clean up
// Note: this should come third, but the inner guy's cached
// outer interfaces are already dead (they point to our
// aggregator) and we don't have the compiler to fix up
// the vtables for us...
// (I have no idea what that comment means -raymondc)
RELEASEINNERINTERFACE(_GetOuter(), _pbsInner);
RELEASEINNERINTERFACE(_GetOuter(), _pbsInner3);
RELEASEINNERINTERFACE(_GetOuter(), _psbInner);
RELEASEINNERINTERFACE(_GetOuter(), _pdtInner);
RELEASEINNERINTERFACE(_GetOuter(), _pspInner);
RELEASEINNERINTERFACE(_GetOuter(), _pctInner);
RELEASEINNERINTERFACE(_GetOuter(), _piosInner); // FEATURE: split: nuke this
// _punkInner goes last because it is the one that really destroys
// the inner.
ATOMICRELEASE(_punkInner); // paired w/ CCI aggregation
// Last, clean up our stuff. Better make sure
// none of the below use any of the above vtables...
_CloseAndReleaseToolbars(FALSE);
SetAcceleratorMenu(NULL);
FDSA_Destroy(&_fdsaTBar);
}
HRESULT CCommonBrowser::v_InternalQueryInterface(REFIID riid, void **ppvObj)
{
static const QITAB qit[] = {
// perf: last tuned 980728
QITABENT(CCommonBrowser, IServiceProvider), // IID_IServiceProvider
QITABENT(CCommonBrowser, IOleCommandTarget), // IID_IOleCommandTarget
QITABENTMULTI(CCommonBrowser, IBrowserService, IBrowserService3), // IID_IBrowserService
QITABENTMULTI(CCommonBrowser, IBrowserService2, IBrowserService3), // IID_IBrowserService2
QITABENT(CCommonBrowser, IBrowserService3), // IID_IBrowserService3
QITABENT(CCommonBrowser, IShellBrowser), // IID_IShellBrowser
QITABENT(CCommonBrowser, IShellBrowserService), // IID_IShellBrowserService
QITABENTMULTI(CCommonBrowser, IOleWindow, IShellBrowser), // rare IID_IOleWindow
QITABENT(CCommonBrowser, IDockingWindowSite), // rare IID_IDockingWindowSite
QITABENT(CCommonBrowser, IDockingWindowFrame), // rare IID_IDockingWindowFrame
QITABENT(CCommonBrowser, IInputObjectSite), // rare IID_IInputObjectSite
QITABENT(CCommonBrowser, IDropTarget), // rare IID_IDropTarget
{ 0 },
};
HRESULT hr = QISearch(this, qit, riid, ppvObj);
if (FAILED(hr))
{
if (_punkInner)
{
return _punkInner->QueryInterface(riid, ppvObj);
}
}
return hr;
}
//
// Accept punk as our inner (contained) object to which we forward a lot of
// things we don't want to deal with.
//
// Warning! The refcount on the punk is *transferred* to us through this
// method. This is contrary to OLE convention.
//
HRESULT CCommonBrowser::SetInner(IUnknown* punk)
{
HRESULT hres;
//
// It's okay to shove the interesting things directly into
// our members, because if any of them go wrong, we fail
// the _Initialize and our destructor will release them all.
#define INNERCACHE(iid, p) do { \
hres = SHQueryInnerInterface(_GetOuter(), punk, iid, (void **)&p); \
if (!EVAL(SUCCEEDED(hres))) return E_FAIL; \
} while (0)
// Do not AddRef; the caller is tranferring the ref to us
_punkInner = punk;
INNERCACHE(IID_IBrowserService2, _pbsInner);
INNERCACHE(IID_IBrowserService3, _pbsInner3);
INNERCACHE(IID_IShellBrowser, _psbInner);
INNERCACHE(IID_IDropTarget, _pdtInner);
INNERCACHE(IID_IServiceProvider, _pspInner);
INNERCACHE(IID_IOleCommandTarget, _pctInner);
INNERCACHE(IID_IInputObjectSite, _piosInner);
#undef INNERCACHE
_pbsInner->GetBaseBrowserData(&_pbbd);
if (!EVAL(_pbbd))
return E_FAIL; // o.w. zillions-o-GPFs on _pbbd->foo
return S_OK;
}
// }
// {
#define CALL_INNER(_result, _function, _arglist, _args) \
_result CCommonBrowser:: _function _arglist { return _pbsInner-> _function _args ; }
#define CALL_INNER_HRESULT(_function, _arglist, _args) CALL_INNER(HRESULT, _function, _arglist, _args)
// *** IBrowserService2 specific methods ***
CALL_INNER_HRESULT(GetParentSite, ( IOleInPlaceSite** ppipsite), ( ppipsite));
CALL_INNER_HRESULT(SetTitle, (IShellView* psv, LPCWSTR pszName), (psv, pszName));
CALL_INNER_HRESULT(GetTitle, (IShellView* psv, LPWSTR pszName, DWORD cchName), (psv, pszName, cchName));
CALL_INNER_HRESULT(GetOleObject, ( IOleObject** ppobjv), ( ppobjv));
// think about this one.. I'm not sure we want to expose this -- Chee
// NOTE:: Yep soon we should have interface instead.
// My impression is that we won't document this whole interface???
CALL_INNER_HRESULT(GetTravelLog, (ITravelLog** pptl), (pptl));
CALL_INNER_HRESULT(ShowControlWindow, (UINT id, BOOL fShow), (id, fShow));
CALL_INNER_HRESULT(IsControlWindowShown, (UINT id, BOOL *pfShown), (id, pfShown));
CALL_INNER_HRESULT(IEGetDisplayName, (LPCITEMIDLIST pidl, LPWSTR pwszName, UINT uFlags), (pidl, pwszName, uFlags));
CALL_INNER_HRESULT(IEParseDisplayName, (UINT uiCP, LPCWSTR pwszPath, LPITEMIDLIST * ppidlOut), (uiCP, pwszPath, ppidlOut));
CALL_INNER_HRESULT(DisplayParseError, (HRESULT hres, LPCWSTR pwszPath), (hres, pwszPath));
CALL_INNER_HRESULT(NavigateToPidl, (LPCITEMIDLIST pidl, DWORD grfHLNF), (pidl, grfHLNF));
CALL_INNER_HRESULT(SetNavigateState, (BNSTATE bnstate), (bnstate));
CALL_INNER_HRESULT(GetNavigateState, (BNSTATE *pbnstate), (pbnstate));
CALL_INNER_HRESULT(NotifyRedirect, ( IShellView* psv, LPCITEMIDLIST pidl, BOOL *pfDidBrowse), ( psv, pidl, pfDidBrowse));
CALL_INNER_HRESULT(UpdateWindowList, (), ());
CALL_INNER_HRESULT(UpdateBackForwardState, (), ());
CALL_INNER_HRESULT(SetFlags, (DWORD dwFlags, DWORD dwFlagMask), (dwFlags, dwFlagMask));
CALL_INNER_HRESULT(GetFlags, (DWORD *pdwFlags), (pdwFlags));
// Tells if it can navigate now or not.
CALL_INNER_HRESULT(CanNavigateNow, (), ());
CALL_INNER_HRESULT(GetPidl, (LPITEMIDLIST *ppidl), (ppidl));
CALL_INNER_HRESULT(SetReferrer, (LPITEMIDLIST pidl), (pidl));
CALL_INNER(DWORD, GetBrowserIndex ,(), ());
CALL_INNER_HRESULT(GetBrowserByIndex, (DWORD dwID, IUnknown **ppunk), (dwID, ppunk));
CALL_INNER_HRESULT(GetHistoryObject, (IOleObject **ppole, IStream **pstm, IBindCtx **ppbc), (ppole, pstm, ppbc));
CALL_INNER_HRESULT(SetHistoryObject, (IOleObject *pole, BOOL fIsLocalAnchor), (pole, fIsLocalAnchor));
CALL_INNER_HRESULT(CacheOLEServer, (IOleObject *pole), (pole));
CALL_INNER_HRESULT(GetSetCodePage, (VARIANT* pvarIn, VARIANT* pvarOut), (pvarIn, pvarOut));
CALL_INNER_HRESULT(OnHttpEquiv, (IShellView* psv, BOOL fDone, VARIANT* pvarargIn, VARIANT* pvarargOut), (psv, fDone, pvarargIn, pvarargOut));
CALL_INNER_HRESULT(GetPalette, ( HPALETTE * hpal), ( hpal));
CALL_INNER_HRESULT(RegisterWindow, (BOOL fUnregister, int swc), (fUnregister, swc));
CALL_INNER(LRESULT, WndProcBS ,(HWND hwnd, UINT uMsg, WPARAM wParam, LPARAM lParam), (hwnd, uMsg, wParam, lParam));
CALL_INNER_HRESULT(OnSize, (WPARAM wParam), (wParam));
CALL_INNER_HRESULT(OnCreate, (LPCREATESTRUCT pcs), (pcs));
CALL_INNER(LRESULT, OnCommand, (WPARAM wParam, LPARAM lParam), (wParam, lParam));
CALL_INNER_HRESULT(OnDestroy, (), ());
CALL_INNER(LRESULT, OnNotify, (NMHDR * pnm), (pnm));
CALL_INNER_HRESULT(OnSetFocus, (), ());
CALL_INNER_HRESULT(GetBaseBrowserData,(LPCBASEBROWSERDATA* ppbd), (ppbd));
CALL_INNER(LPBASEBROWSERDATA, PutBaseBrowserData,(), ());
CALL_INNER_HRESULT(CreateViewWindow, (IShellView* psvNew, IShellView* psvOld, LPRECT prcView, HWND* phwnd), (psvNew, psvOld, prcView, phwnd));;
CALL_INNER_HRESULT(SetTopBrowser, (), ());
CALL_INNER_HRESULT(OnFrameWindowActivateBS, (BOOL fActive), (fActive));
CALL_INNER_HRESULT(ReleaseShellView, (), ());
CALL_INNER_HRESULT(ActivatePendingView, (), ());
CALL_INNER_HRESULT(InitializeDownloadManager, (), ());
CALL_INNER_HRESULT(InitializeTransitionSite, (), ());
CALL_INNER_HRESULT(Offline, (int iCmd), (iCmd));
CALL_INNER_HRESULT(AllowViewResize, (BOOL f), (f));
CALL_INNER_HRESULT(SetActivateState, (UINT u), (u));
CALL_INNER_HRESULT(UpdateSecureLockIcon, (int eSecureLock), (eSecureLock));
CALL_INNER_HRESULT(CreateBrowserPropSheetExt, (REFIID riid, void **ppvOut), (riid, ppvOut));
CALL_INNER_HRESULT(SetAsDefFolderSettings,(), ());
CALL_INNER_HRESULT(GetViewRect,(RECT* prc), (prc));
CALL_INNER_HRESULT(GetViewWindow,(HWND * phwnd), (phwnd));
CALL_INNER_HRESULT(InitializeTravelLog,(ITravelLog* ptl, DWORD dw), (ptl, dw));
CALL_INNER_HRESULT(_UIActivateView, (UINT uState), (uState));
CALL_INNER_HRESULT(_UpdateViewRectSize,(), ());
CALL_INNER_HRESULT(_GetEffectiveClientArea, (LPRECT prcBorder, HMONITOR hmon), (prcBorder, hmon));
CALL_INNER_HRESULT(_ResizeView,(), ());
// BEGIN REVIEW: review names and need of each.
//
// this first set could be basebrowser only members. no one overrides
CALL_INNER_HRESULT(_CancelPendingNavigationAsync, (), ());
CALL_INNER_HRESULT(_MaySaveChanges, (), ());
CALL_INNER_HRESULT(_PauseOrResumeView, (BOOL fPaused), (fPaused));
CALL_INNER_HRESULT(_DisableModeless, (), ());
// rethink these... are all of these necessary?
CALL_INNER_HRESULT(_NavigateToPidl, (LPCITEMIDLIST pidl, DWORD grfHLNF, DWORD dwFlags), (pidl, grfHLNF, dwFlags));
CALL_INNER_HRESULT(_TryShell2Rename, (IShellView* psv, LPCITEMIDLIST pidlNew), (psv, pidlNew));
CALL_INNER_HRESULT(_SwitchActivationNow, () , ());
CALL_INNER_HRESULT(_CancelPendingView, (), ());
//END REVIEW:
// overridden by cdesktopbrowser
CALL_INNER(IStream*, v_GetViewStream, (LPCITEMIDLIST pidl, DWORD grfMode, LPCWSTR pwszName), (pidl, grfMode, pwszName));
#undef CALL_INNER
#undef CALL_INNER_HRESULT
// }
// {
#define CALL_INNER(_result, _function, _arglist, _args) \
_result CCommonBrowser:: _function _arglist { return _pbsInner3-> _function _args ; }
#define CALL_INNER_HRESULT(_function, _arglist, _args) CALL_INNER(HRESULT, _function, _arglist, _args)
CALL_INNER_HRESULT(_PositionViewWindow, (HWND hwnd, LPRECT prc), (hwnd, prc));
#undef CALL_INNER
#undef CALL_INNER_HRESULT
// }
// {
#define CALL_INNER(_result, _function, _arglist, _args) \
_result CCommonBrowser:: _function _arglist { return _psbInner-> _function _args ; }
#define CALL_INNER_HRESULT(_function, _arglist, _args) CALL_INNER(HRESULT, _function, _arglist, _args)
// IShellBrowser (same as IOleInPlaceFrame)
// IOleWindow
CALL_INNER_HRESULT(GetWindow, (HWND * lphwnd), (lphwnd));
CALL_INNER_HRESULT(ContextSensitiveHelp, (BOOL fEnterMode), (fEnterMode));
CALL_INNER_HRESULT(InsertMenusSB, (HMENU hmenuShared, LPOLEMENUGROUPWIDTHS lpMenuWidths), (hmenuShared, lpMenuWidths));
CALL_INNER_HRESULT(SetMenuSB, (HMENU hmenuShared, HOLEMENU holemenu, HWND hwnd), (hmenuShared, holemenu, hwnd));
CALL_INNER_HRESULT(RemoveMenusSB, (HMENU hmenuShared), (hmenuShared));
CALL_INNER_HRESULT(SetStatusTextSB, (LPCOLESTR lpszStatusText), (lpszStatusText));
CALL_INNER_HRESULT(EnableModelessSB, (BOOL fEnable), (fEnable));
CALL_INNER_HRESULT(BrowseObject, (LPCITEMIDLIST pidl, UINT wFlags), (pidl, wFlags));
CALL_INNER_HRESULT(GetControlWindow, (UINT id, HWND * lphwnd), (id, lphwnd));
CALL_INNER_HRESULT(SendControlMsg, (UINT id, UINT uMsg, WPARAM wParam, LPARAM lParam, LRESULT *pret), (id, uMsg, wParam, lParam, pret));
CALL_INNER_HRESULT(QueryActiveShellView, (struct IShellView ** ppshv), (ppshv));
CALL_INNER_HRESULT(OnViewWindowActive, (struct IShellView * ppshv), (ppshv));
CALL_INNER_HRESULT(SetToolbarItems, (LPTBBUTTON lpButtons, UINT nButtons, UINT uFlags), (lpButtons, nButtons, uFlags));
#undef CALL_INNER
#undef CALL_INNER_HRESULT
// }
// {
#define CALL_INNER(_result, _function, _arglist, _args) \
_result CCommonBrowser:: _function _arglist { return _pdtInner-> _function _args ; }
#define CALL_INNER_HRESULT(_function, _arglist, _args) CALL_INNER(HRESULT, _function, _arglist, _args)
// *** IDropTarget ***
CALL_INNER_HRESULT(DragEnter, (IDataObject *pdtobj, DWORD grfKeyState, POINTL pt, DWORD *pdwEffect), (pdtobj, grfKeyState, pt, pdwEffect));
CALL_INNER_HRESULT(DragOver, (DWORD grfKeyState, POINTL pt, DWORD *pdwEffect), (grfKeyState, pt, pdwEffect));
CALL_INNER_HRESULT(DragLeave, (void), ());
CALL_INNER_HRESULT(Drop, (IDataObject *pdtobj, DWORD grfKeyState, POINTL pt, DWORD *pdwEffect), (pdtobj, grfKeyState, pt, pdwEffect));
#undef CALL_INNER
#undef CALL_INNER_HRESULT
// }
// {
#define CALL_INNER(_result, _function, _arglist, _args) \
_result CCommonBrowser:: _function _arglist { return _pspInner-> _function _args ; }
#define CALL_INNER_HRESULT(_function, _arglist, _args) CALL_INNER(HRESULT, _function, _arglist, _args)
// IServiceProvider
CALL_INNER_HRESULT(QueryService, (REFGUID guidService, REFIID riid, void **ppvObj), (guidService, riid, ppvObj));
#undef CALL_INNER
#undef CALL_INNER_HRESULT
// }
// {
#define CALL_INNER(_result, _function, _arglist, _args) \
_result CCommonBrowser:: _function _arglist { return _pctInner-> _function _args ; }
#define CALL_INNER_HRESULT(_function, _arglist, _args) CALL_INNER(HRESULT, _function, _arglist, _args)
// IOleCommandTarget
CALL_INNER_HRESULT(QueryStatus, (const GUID *pguidCmdGroup, ULONG cCmds, OLECMD rgCmds[], OLECMDTEXT *pcmdtext), (pguidCmdGroup, cCmds, rgCmds, pcmdtext));
#undef CALL_INNER
#undef CALL_INNER_HRESULT
// }
HRESULT CCommonBrowser::Exec(const GUID *pguidCmdGroup, DWORD nCmdID, DWORD nCmdexecopt, VARIANTARG *pvarargIn, VARIANTARG *pvarargOut)
{
if (pguidCmdGroup && IsEqualGUID(CGID_Explorer, *pguidCmdGroup))
{
if (nCmdID == SBCMDID_CACHEINETZONEICON)
{
if (!pvarargIn || pvarargIn->vt != VT_BOOL || !pvarargOut)
return ERROR_INVALID_PARAMETER;
pvarargOut->vt = VT_UI4;
ENTERCRITICAL;
pvarargOut->ulVal = _CacheZonesIconsAndNames(pvarargIn->boolVal);
LEAVECRITICAL;
return S_OK;
}
}
return _pctInner->Exec(pguidCmdGroup, nCmdID, nCmdexecopt, pvarargIn, pvarargOut);
}
// {
#define CALL_INNER(_result, _function, _arglist, _args) \
_result CCommonBrowser:: _function _arglist { return _piosInner-> _function _args ; }
#define CALL_INNER_HRESULT(_function, _arglist, _args) CALL_INNER(HRESULT, _function, _arglist, _args)
#undef CALL_INNER
#undef CALL_INNER_HRESULT
// }
HRESULT CCommonBrowser::TranslateAcceleratorSB(LPMSG lpmsg, WORD wID)
{
HRESULT hres = S_FALSE;
TraceMsg(0, "ief TR CCommonBrowser::TranslateAcceleratorSB called");
if (!_CanHandleAcceleratorNow())
{
TraceMsg(0, "Ignoring TranslateAccelerator, not active");
return S_FALSE;
}
// If we're NOT top level, assume virtual TranslateAcceleratorSB
// handles this request. (See CVOCBrowser.)
// CDefView may call this before it passes it down to extended view
if (_hacc && ::TranslateAcceleratorWrap(_pbbd->_hwnd, _hacc, lpmsg))
{
TraceMsg(DM_ACCELERATOR, "CSB::TranslateAcceleratorSB TA(_hacc) ate %x,%x",
lpmsg->message, lpmsg->wParam);
// We don't want to eat this escape because some controls on the
// page rely on ESC getting dispatched. Besides, dispatching it won't
// hurt us...
if (lpmsg->wParam != VK_ESCAPE)
hres = S_OK;
}
return hres;
}
//////////////////////////////////////////////////////////////////////////////////
//
// Code to get the ViewStateStream of the "Explorer" OCX
//
//////////////////////////////////////////////////////////////////////////////////
HRESULT CCommonBrowser::GetViewStateStream(DWORD grfMode, IStream **ppstm)
{
// NOTE: We can't use _pidlCur or _pidlPending here. Both are NULL
// when we goto a new directory. _pidlPending is initialized later in
// _CreateNewShellView. So, we use for which the NewShellView is created.
LPCITEMIDLIST pidl = _pbbd->_pidlNewShellView;
if (!pidl)
pidl = _pbbd->_pidlPending;
if (!pidl)
pidl = _pbbd->_pidlCur;
*ppstm = _pbsOuter->v_GetViewStream(pidl, grfMode, L"ViewView2");
// If getting the new one (for read) failed, try the old one.
if ((grfMode == STGM_READ) && (!*ppstm || SHIsEmptyStream(*ppstm)))
{
if (*ppstm)
(*ppstm)->Release();
*ppstm = _pbsOuter->v_GetViewStream(pidl, grfMode, L"ViewView");
TraceMsg(DM_VIEWSTREAM, "CBB::GetViewStateStream tried old stream (%x)", *ppstm);
}
return *ppstm ? S_OK : E_OUTOFMEMORY;
}
//
// Returns the border rectangle for the shell view.
//
HRESULT CCommonBrowser::_GetViewBorderRect(RECT* prc)
{
_pbsOuter->_GetEffectiveClientArea(prc, NULL); // FEATURE: hmon?
//
// Extract the border taken by all "frame" toolbars
//
for (int i=0; i < _GetToolbarCount(); i++)
{
TOOLBARITEM *ptbi = _GetToolbarItem(i);
prc->left += ptbi->rcBorderTool.left;
prc->top += ptbi->rcBorderTool.top;
prc->right -= ptbi->rcBorderTool.right;
prc->bottom -= ptbi->rcBorderTool.bottom;
}
return S_OK;
}
// NOTE: these toolbar functions are still part of CBaseBrowser2
// so they keep working. right now they are in IBrowserService2 and
// forwarded down.
void CCommonBrowser::_ReleaseToolbarItem(int itb, BOOL fClose)
{
// grab it and NULL it out to eliminate race condition.
// (actually, there's still a v. small window btwn the 2 statements).
//
// e.g. if you close a WebBar and then quickly shutdown windows,
// the close destroys the window etc. but then the shutdown code
// does _SaveToolbars which tries to do ->Save on that destroyed guy.
//
// note however that this now means that the entry is marked
// 'free' so someone else might grab it out from under us and start
// trashing it.
TOOLBARITEM *ptbi = _GetToolbarItem(itb);
IDockingWindow *ptbTmp = ptbi->ptbar;
ptbi->ptbar = NULL;
if (fClose)
{
ptbTmp->CloseDW(0);
}
IUnknown_SetSite(ptbTmp, NULL);
// Check for NULL for BoundsChecker with Pageheap enabled functionality.
if ( ptbi->pwszItem )
{
LocalFree(ptbi->pwszItem);
ptbi->pwszItem = NULL;
}
ptbTmp->Release();
}
//*** CBB::_AllocToolbarItem -- find/create free slot in _aTBar toolbar array
// ENTRY/EXIT
// hres [out] S_OK|itb on success; o.w. E_FAIL
// _aTBar [inout] possibly grown
int CCommonBrowser::_AllocToolbarItem()
{
TOOLBARITEM *ptbi;
// try to recycle a dead one
int iCount = FDSA_GetItemCount(&_fdsaTBar);
for (int itb = 0; itb < iCount; ++itb)
{
ptbi = (LPTOOLBARITEM)FDSA_GetItemPtr(&_fdsaTBar, itb, TOOLBARITEM);
ASSERT(ptbi != NULL);
if (ptbi && ptbi->ptbar == NULL)
{
ASSERT(itb < ITB_MAX);
return itb;
}
}
// no luck recycling, create a new one
static TOOLBARITEM tbiTmp /*=0*/;
int i = FDSA_AppendItem(&_fdsaTBar, &tbiTmp);
if (i == -1)
{
TraceMsg(DM_WARNING, "cbb._ati: ret=-1");
return -1; // warning: same as ITB_VIEW (!)
}
ASSERT(i == itb);
#ifdef DEBUG
{
ptbi = (LPTOOLBARITEM) FDSA_GetItemPtr(&_fdsaTBar, itb, TOOLBARITEM);
ASSERT(ptbi != NULL);
for (int j = 0; j < sizeof(*ptbi); ++j)
ASSERT(*(((char *)ptbi) + j) == 0);
}
#endif
ASSERT(i < ITB_MAX);
return i;
}
HRESULT CCommonBrowser::_CloseAndReleaseToolbars(BOOL fClose)
{
for (int itb = 0; itb < _GetToolbarCount(); itb++)
{
TOOLBARITEM *ptbi = _GetToolbarItem(itb);
if (ptbi->ptbar)
{
_ReleaseToolbarItem(itb, fClose);
}
}
return S_OK;
}
//
// Implementation of CBaseBrowser2::ShowToolbar
//
// Make toolbar visible or not and update our conception of whether it
// should be shown
//
// Returns: S_OK, if successfully done.
// E_INVALIDARG, duh.
//
HRESULT CCommonBrowser::ShowToolbar(IUnknown* punkSrc, BOOL fShow)
{
UINT itb = _FindTBar(punkSrc);
if (itb == (UINT)-1)
{
return E_INVALIDARG;
}
TOOLBARITEM *ptbi = _GetToolbarItem(itb);
// The _FindTBar function should assure us that ptbi->ptbar is non-NULL.
ASSERT(ptbi->ptbar);
ptbi->ptbar->ShowDW(fShow);
ptbi->fShow = fShow;
return S_OK;
}
//*** IDockingWindowFrame::* {
//
// Implementation of IDockingWindowFrame::AddToolbar
//
// Add the specified toolbar (as punkSrc) to this toolbar site and
// make it visible.
//
// Returns: S_OK, if successfully done.
// E_FAIL, if failed (exceeded maximum).
// E_NOINTERFACE, the toolbar does not support an approriate interface.
//
HRESULT CCommonBrowser::AddToolbar(IUnknown* punk, LPCWSTR pszItem, DWORD dwAddFlags)
{
HRESULT hr = E_FAIL;
int itb = _AllocToolbarItem(); // Find the first empty spot.
if (itb != -1)
{
TOOLBARITEM *ptbi = _GetToolbarItem(itb);
ASSERT(ptbi != NULL);
ASSERT(ptbi->ptbar == NULL);
hr = punk->QueryInterface(IID_PPV_ARG(IDockingWindow, &ptbi->ptbar));
if (SUCCEEDED(hr))
{
if (pszItem)
{
ptbi->pwszItem = StrDupW(pszItem);
if (NULL == ptbi->pwszItem)
{
hr = E_OUTOFMEMORY;
ATOMICRELEASE(ptbi->ptbar);
return hr;
}
}
ptbi->fShow = (! (dwAddFlags & DWFAF_HIDDEN)); // shown
IUnknown_SetSite(ptbi->ptbar, SAFECAST(this, IShellBrowser*));
ptbi->ptbar->ShowDW(ptbi->fShow);
}
else
{
// ERROR: all toolbars should implement IDockingWindow
// call tjgreen if this rips
ASSERT(0);
}
}
return hr;
}
//
// Implementation of IDockingWindowFrame::RemoveToolbar
//
HRESULT CCommonBrowser::RemoveToolbar(IUnknown* punkSrc, DWORD dwRemoveFlags)
{
UINT itb = _FindTBar(punkSrc);
if (itb == (UINT)-1)
{
return E_INVALIDARG;
}
_ReleaseToolbarItem(itb, TRUE);
// Clear the rect and resize the inner ones (including the view).
// note the semi-hoaky post-release partying on rcBorderTool
SetRect(&_GetToolbarItem(itb)->rcBorderTool, 0, 0, 0, 0);
_pbsOuter->_ResizeNextBorder(itb + 1);
return S_OK;
}
//
// Implementation of IDockingWindowFrame::FindToolbar
//
HRESULT CCommonBrowser::FindToolbar(LPCWSTR pwszItem, REFIID riid, void **ppvObj)
{
HRESULT hr = E_INVALIDARG;
*ppvObj = NULL;
if (pwszItem)
{
hr = S_FALSE;
for (int itb = 0; itb < _GetToolbarCount(); itb++)
{
TOOLBARITEM *ptbi = _GetToolbarItem(itb);
if (ptbi->pwszItem && StrCmpIW(ptbi->pwszItem, pwszItem)==0)
{
if (ptbi->ptbar)
{
hr = ptbi->ptbar->QueryInterface(riid, ppvObj);
}
else
{
TraceMsg(TF_WARNING, "ptbi->ptbar is NULL in FindToolbar");
hr = E_FAIL;
}
break;
}
}
}
return hr;
}
// }
UINT CCommonBrowser::_FindTBar(IUnknown* punkSrc)
{
#ifdef DEBUG
static long nQuick = 0;
static long nSlow = 0;
#endif
ASSERT(punkSrc);
// Quick check without QI
TOOLBARITEM *ptbi;
for (int i=0; i < _GetToolbarCount(); i++)
{
ptbi = _GetToolbarItem(i);
if (punkSrc==ptbi->ptbar)
{
#ifdef DEBUG
// I wonder if we ever hit this case...
InterlockedIncrement(&nQuick);
TraceMsg(TF_PERF, "_FindTBar QUICK=%d SLOW=%d", nQuick, nSlow);
#endif
return i;
}
}
// If failed, do the real COM object identity check.
for (i=0; i < _GetToolbarCount(); i++)
{
ptbi = _GetToolbarItem(i);
if (ptbi->ptbar)
{
if (SHIsSameObject(ptbi->ptbar, punkSrc))
{
#ifdef DEBUG
InterlockedIncrement(&nSlow);
TraceMsg(TF_PERF, "_FindTBar QUICK=%d SLOW=%d", nQuick, nSlow);
#endif
return i;
}
}
}
return (UINT)-1;
}
HRESULT CCommonBrowser::v_ShowHideChildWindows(BOOL fChildOnly)
{
for (UINT itb = 0; itb < (UINT)_GetToolbarCount(); itb++)
{
TOOLBARITEM *ptbi = _GetToolbarItem(itb);
if (ptbi->ptbar)
{
ptbi->ptbar->ShowDW(ptbi->fShow);
}
}
if (!fChildOnly)
{
_pbsInner->v_ShowHideChildWindows(fChildOnly);
}
return S_OK;
}
//*** _Load/_SaveToolbars {
#ifdef DEBUG
extern unsigned long DbStreamTell(IStream *pstm);
#else
#define DbStreamTell(pstm) ((ULONG) 0)
#endif
const static DWORD c_BBSVersion = 0x00000011; // Increment when the stream is changed.
#define MAX_ITEMID 128 // enough for item id
HRESULT CCommonBrowser::_SaveToolbars(IStream* pstm)
{
HRESULT hres = S_OK;
DWORD count = 0;
TraceMsg(DM_PERSIST, "cbb.stb enter(this=%x pstm=%x) tell()=%x", this, pstm, DbStreamTell(pstm));
if (pstm==NULL)
{
for (UINT itb = 0; itb < (UINT)_GetToolbarCount(); itb++)
{
TOOLBARITEM *ptbi = _GetToolbarItem(itb);
if (ptbi->ptbar)
{
IPersistStream* ppstm;
HRESULT hresT = ptbi->ptbar->QueryInterface(IID_PPV_ARG(IPersistStream, &ppstm));
if (SUCCEEDED(hresT))
{
ppstm->Release();
count++;
}
}
}
TraceMsg(DM_PERSIST, "cbb.stb leave count=%d", count);
return (count>0) ? S_OK : S_FALSE;
}
ULARGE_INTEGER liStart;
pstm->Write(&c_BBSVersion, sizeof(c_BBSVersion), NULL);
// Remember the current location, where we writes count.
pstm->Seek(c_li0, STREAM_SEEK_CUR, &liStart);
TraceMsg(DM_PERSIST, "cbb.stb seek(count)=%x", liStart.LowPart);
hres = pstm->Write(&count, sizeof(count), NULL);
if (hres==S_OK)
{
for (UINT itb = 0; itb < (UINT)_GetToolbarCount(); itb++)
{
TOOLBARITEM *ptbi = _GetToolbarItem(itb);
if (ptbi->ptbar)
{
IPersistStream* ppstm;
HRESULT hresT = ptbi->ptbar->QueryInterface(IID_PPV_ARG(IPersistStream, &ppstm));
if (SUCCEEDED(hresT))
{
DWORD cchName = 0;
if (ptbi->pwszItem &&
(cchName=lstrlenW(ptbi->pwszItem)) &&
cchName < MAX_ITEMID)
{
TraceMsg(DM_PERSIST, "cbb.stb pwszItem=<%ls>", ptbi->pwszItem);
pstm->Write(&cchName, sizeof(cchName), NULL);
pstm->Write(ptbi->pwszItem, cchName*sizeof(WCHAR), NULL);
}
else
{
TraceMsg(DM_PERSIST, "cbb.stb lstrlenW(pwszItem)=%d", cchName);
pstm->Write(&cchName, sizeof(cchName), NULL);
}
TraceMsg(DM_PERSIST, "cbb.stb enter OleSaveToStream tell()=%x", DbStreamTell(pstm));
hres = OleSaveToStream(ppstm, pstm);
TraceMsg(DM_PERSIST, "cbb.stb leave OleSaveToStream tell()=%x", DbStreamTell(pstm));
ppstm->Release();
if (FAILED(hres))
{
break;
}
count++;
}
}
}
// Remember the end
ULARGE_INTEGER liEnd;
pstm->Seek(c_li0, STREAM_SEEK_CUR, &liEnd);
TraceMsg(DM_PERSIST, "cbb.stb seek(end save)=%x", DbStreamTell(pstm));
// Seek back to the original location
TraceMsg(DM_PERSIST, "cbb.stb fix count=%d", count);
LARGE_INTEGER liT;
liT.HighPart = 0;
liT.LowPart = liStart.LowPart;
pstm->Seek(liT, STREAM_SEEK_SET, NULL);
hres = pstm->Write(&count, sizeof(count), NULL);
// Seek forward to the end
liT.LowPart = liEnd.LowPart;
pstm->Seek(liT, STREAM_SEEK_SET, NULL);
TraceMsg(DM_PERSIST, "cbb.stb seek(end restore)=%x", DbStreamTell(pstm));
}
TraceMsg(DM_PERSIST, "cbb.stb leave tell()=%x", DbStreamTell(pstm));
return hres;
}
HRESULT IUnknown_GetClientDB(IUnknown *punk, IUnknown **ppdbc)
{
*ppdbc = NULL;
IDeskBar *pdb;
HRESULT hr = punk->QueryInterface(IID_PPV_ARG(IDeskBar, &pdb));
if (SUCCEEDED(hr))
{
hr = pdb->GetClient(ppdbc);
pdb->Release();
}
return hr;
}
HRESULT CCommonBrowser::_LoadToolbars(IStream* pstm)
{
DWORD dwVersion;
TraceMsg(DM_PERSIST, "cbb.ltb enter(this=%x pstm=%x) tell()=%x", this, pstm, DbStreamTell(pstm));
HRESULT hres = pstm->Read(&dwVersion, sizeof(dwVersion), NULL);
if (hres == S_OK && dwVersion == c_BBSVersion)
{
DWORD count;
hres = pstm->Read(&count, sizeof(count), NULL);
if (hres == S_OK)
{
for (UINT i=0; i<count && SUCCEEDED(hres); i++)
{
DWORD cchName = 0;
hres = pstm->Read(&cchName, sizeof(cchName), NULL);
if (hres == S_OK)
{
WCHAR wszName[MAX_ITEMID];
wszName[0] = 0;
// if cchName >= ARRAYSIZE(wszName) then we're misaligned in the stream!
if (cchName && cchName<ARRAYSIZE(wszName))
{
hres = pstm->Read(wszName, cchName*sizeof(WCHAR), NULL);
}
TraceMsg(DM_PERSIST, "cbb.ltb name=<%ls>", wszName);
if (hres==S_OK)
{
IDockingWindow* pstb;
TraceMsg(DM_PERSIST, "cbb.ltb enter OleLoadFromStream tell()=%x", DbStreamTell(pstm));
hres = OleLoadFromStream(pstm, IID_PPV_ARG(IDockingWindow, &pstb));
TraceMsg(DM_PERSIST, "cbb.ltb leave OleLoadFromStream tell()=%x", DbStreamTell(pstm));
if (SUCCEEDED(hres))
{
IUnknown *pDbc = NULL;
// nt5:216944: turn off size negotiation during
// load. o.w. persisted size gets nuked.
IUnknown_GetClientDB(pstb, &pDbc);
if (pDbc)
DBC_ExecDrag(pDbc, DRAG_MOVE);
hres = AddToolbar(pstb, wszName[0] ? wszName : NULL, NULL);
if (pDbc)
{
DBC_ExecDrag(pDbc, 0);
pDbc->Release();
}
pstb->Release();
}
}
}
}
}
}
else
{
hres = E_FAIL;
}
TraceMsg(DM_PERSIST, "cbb.ltb leave tell()=%x", DbStreamTell(pstm));
return hres;
}
// }
// *** IDockingWindowSite methods ***
HRESULT CCommonBrowser::_GetBorderDWHelper(IUnknown* punkSrc, LPRECT prcBorder, BOOL bUseHmonitor)
{
UINT itb = _FindTBar(punkSrc);
if (itb == (UINT)-1)
{
RIPMSG(0, "GetBorderDW: invalid punkSrc");
return E_INVALIDARG;
}
else if (!prcBorder)
{
RIPMSG(0, "GetBorderDW: invalid prcBorder");
return E_INVALIDARG;
}
TOOLBARITEM *ptbThis = _GetToolbarItem(itb);
if (bUseHmonitor && ptbThis && ptbThis->hMon)
{
_pbsOuter->_GetEffectiveClientArea(prcBorder, ptbThis->hMon);
}
else
{
_pbsOuter->_GetEffectiveClientArea(prcBorder, NULL);
}
//
// Subtract border area taken by "outer toolbars"
//
for (UINT i = 0; i < itb; i++)
{
TOOLBARITEM *ptbi = _GetToolbarItem(i);
if (!bUseHmonitor || (ptbThis && (ptbi->hMon == ptbThis->hMon)))
{
prcBorder->left += ptbi->rcBorderTool.left;
prcBorder->top += ptbi->rcBorderTool.top;
prcBorder->right -= ptbi->rcBorderTool.right;
prcBorder->bottom -= ptbi->rcBorderTool.bottom;
}
}
return S_OK;
}
//
// This is an implementation of IDockingWindowSite::GetBorderDW.
//
// This function returns a bounding rectangle for the specified toolbar
// (by punkSrc). It gets the effective client area, then subtract border
// area taken by "outer" toolbars.
//
HRESULT CCommonBrowser::GetBorderDW(IUnknown* punkSrc, LPRECT prcBorder)
{
return _GetBorderDWHelper(punkSrc, prcBorder, FALSE);
}
HRESULT CCommonBrowser::RequestBorderSpaceDW(IUnknown* punkSrc, LPCBORDERWIDTHS pbw)
{
RIP(IS_VALID_READ_PTR(pbw, BORDERWIDTHS));
return S_OK;
}
HRESULT CCommonBrowser::SetBorderSpaceDW(IUnknown* punkSrc, LPCBORDERWIDTHS pbw)
{
UINT itb = _FindTBar(punkSrc);
if (itb == (UINT)-1)
{
RIPMSG(0, "GetBorderDW: invalid punkSrc");
return E_INVALIDARG;
}
_GetToolbarItem(itb)->rcBorderTool = *pbw;
_pbsOuter->_ResizeNextBorder(itb + 1);
return S_OK;
}
HRESULT CCommonBrowser::_ResizeNextBorderHelper(UINT itb, BOOL bUseHmonitor)
{
//
// Starting with itb, look for the next toolbar on the same
// monitor (if we care about the monitor).
//
IDockingWindow* ptbarNext = NULL;
if ((int) itb < _GetToolbarCount())
{
TOOLBARITEM *ptbThis = _GetToolbarItem(itb);
for (int i = itb; i < _GetToolbarCount(); i++)
{
TOOLBARITEM *ptbi = _GetToolbarItem(i);
if (ptbi->ptbar && (!bUseHmonitor || (ptbi->hMon == ptbThis->hMon)))
{
//
// Found it, we're done
//
ptbarNext = ptbi->ptbar;
break;
}
}
}
if (ptbarNext)
{
//
// Get the toolbar's docking window rect and resize the
// border to that.
//
RECT rc;
GetBorderDW(ptbarNext, &rc);
ptbarNext->ResizeBorderDW(&rc, (IShellBrowser*)this, TRUE);
}
else
{
//
// We didn't find a toolbar, so we must be at the end
// of the list. Finish up by resizing the view.
//
_pbsOuter->_ResizeView();
}
return S_OK;
}
HRESULT CCommonBrowser::_ResizeNextBorder(UINT itb)
{
_ResizeNextBorderHelper(itb, FALSE);
return S_OK;
}
//
// Hack alert!
//
// IE grabs the focus via _FixToolbarFocus when it shouldn't. For example if a
// java app in a seperate window contains an edit control and the address bar
// had focus before the java app. In this scenario the first time a user types
// in the edit control IE grabs back the focus. IE bug#59007.
//
// To prevent IE from incorrectly grabbing the focus this fuction checks that
// top level parent of the toolbar is the same as the top level parent of the
// window that has focus.
//
BOOL CCommonBrowser::_TBWindowHasFocus(UINT itb)
{
ASSERT(itb < ITB_MAX);
BOOL fRet = TRUE;
HWND hwndFocus = GetFocus();
while (GetWindowLong(hwndFocus, GWL_STYLE) & WS_CHILD)
hwndFocus = GetParent(hwndFocus);
if (hwndFocus)
{
TOOLBARITEM *pti = _GetToolbarItem(itb);
if (pti && pti->ptbar)
{
HWND hwndTB;
if (SUCCEEDED(pti->ptbar->GetWindow(&hwndTB)) && hwndTB)
{
fRet = (S_OK == SHIsChildOrSelf(hwndFocus, hwndTB));
}
}
}
return fRet;
}
void DestroyZoneIconNameCache(void)
{
if (g_pZoneIconNameCache)
{
PZONEICONNAMECACHE pzinc = g_pZoneIconNameCache;
for (DWORD i = 0; i < g_dwZoneCount; i++)
{
if (pzinc->hiconZones)
DestroyIcon((HICON)pzinc->hiconZones);
pzinc++;
}
LocalFree(g_pZoneIconNameCache);
g_pZoneIconNameCache = NULL;
g_dwZoneCount = 0;
}
}
DWORD CCommonBrowser::_CacheZonesIconsAndNames(BOOL fRefresh)
{
ASSERTCRITICAL;
if (g_pZoneIconNameCache) // If we've already cached the zones, just return the zone count unless we want to refresh cache
{
if (fRefresh)
{
DestroyZoneIconNameCache();
}
else
return(g_dwZoneCount);
}
// Create ZoneManager
if (!_pizm)
CoCreateInstance(CLSID_InternetZoneManager, NULL, CLSCTX_INPROC_SERVER, IID_PPV_ARG(IInternetZoneManager, &_pizm));
if (_pizm)
{
DWORD dwZoneEnum;
if (SUCCEEDED(_pizm->CreateZoneEnumerator(&dwZoneEnum, &g_dwZoneCount, 0)))
{
if ((g_pZoneIconNameCache = (PZONEICONNAMECACHE)LocalAlloc(LPTR, g_dwZoneCount * sizeof(ZONEICONNAMECACHE))) == NULL)
{
g_dwZoneCount = 0;
return 0;
}
for (int nIndex=0; (DWORD)nIndex < g_dwZoneCount; nIndex++)
{
DWORD dwZone;
ZONEATTRIBUTES za = {sizeof(ZONEATTRIBUTES)};
_pizm->GetZoneAt(dwZoneEnum, nIndex, &dwZone);
// get the zone attributes for this zone
_pizm->GetZoneAttributes(dwZone, &za);
StrCpyW(g_pZoneIconNameCache[nIndex].szZonesName, za.szDisplayName);
StrCpyW(g_pZoneIconNameCache[nIndex].szIconPath, za.szIconPath);
g_pZoneIconNameCache[nIndex].hiconZones = 0; // Load the hIcon on demand
}
_pizm->DestroyZoneEnumerator(dwZoneEnum);
}
}
return g_dwZoneCount;
}
// zero's out pIcon & pszName on failure
BOOL CCommonBrowser::_GetCachedZoneIconAndName(DWORD lZone, HICON *pIcon, LPTSTR pszName, DWORD cch)
{
BOOL bRet = FALSE;
*pIcon = NULL;
pszName[0] = 0;
ENTERCRITICAL;
if (lZone < _CacheZonesIconsAndNames(FALSE))
{
ZONEICONNAMECACHE *pzinc = &g_pZoneIconNameCache[lZone];
// if we haven't yet cached the icon for this zone, extract it now
// REVIEW: worth pulling the extraction outside the critsec?
if (!pzinc->hiconZones)
{
// Zone icons are in two formats.
// wininet.dll#1200 where 1200 is the res id.
// or foo.ico directly pointing to an icon file.
// search for the '#'
// # is a valid filename character
LPWSTR pwsz = StrChrW(pzinc->szIconPath, TEXTW('#'));
WORD iIcon = 0;
if (pwsz)
{
// if we found it, then we have the foo.dll#00001200 format
pwsz[0] = TEXTW('\0');
iIcon = (WORD)StrToIntW(pwsz+1);
ExtractIconExW(pzinc->szIconPath,(UINT)(-1*iIcon), NULL, &pzinc->hiconZones, 1);
}
else
pzinc->hiconZones = (HICON)ExtractAssociatedIconExW(HINST_THISDLL, pzinc->szIconPath, (LPWORD)&iIcon, &iIcon);
// If mirrored system, mirror icon so that it get unmirrored again when displayed
if (IS_BIDI_LOCALIZED_SYSTEM())
{
MirrorIcon(&pzinc->hiconZones, NULL);
}
}
*pIcon = CopyIcon(pzinc->hiconZones);
StrCpyNW(pszName, pzinc->szZonesName, cch);
bRet = TRUE;
}
LEAVECRITICAL;
return bRet;
}
BOOL _QITest(IUnknown* punk, REFIID riid);
BOOL CCommonBrowser::_ShouldTranslateAccelerator(MSG* pmsg)
{
//
// We should only translate an acclerator if
//
// (a) the window is the frame or a child of the frame
// or a child of a defview window (NT5 Bug # 357186).
// (need to check this because you can have, for
// example, a toplevel java applet window running
// on our thread)
//
// and
//
// (b) it's on our thread (need to check this because
// old-style OLE controls on a web page can run
// on the desktop thread)
//
BOOL fTranslate = FALSE;
fTranslate = (SHIsChildOrSelf(_pbbd->_hwnd, pmsg->hwnd) == S_OK);
if (!fTranslate)
{
HWND hwnd = NULL;
if (_pbbd->_psv && (_QITest(SAFECAST(_pbbd->_psv, IUnknown*), IID_CDefView))
&& SUCCEEDED(_pbbd->_psv->GetWindow(&hwnd)))
{
fTranslate = (SHIsChildOrSelf(hwnd, pmsg->hwnd) == S_OK);
}
}
if (fTranslate)
{
DWORD dwThread = GetWindowThreadProcessId(_pbbd->_hwnd, NULL);
HWND hwndMsg = pmsg->hwnd;
while (GetWindowLong(hwndMsg, GWL_STYLE) & WS_CHILD)
{
hwndMsg = GetParent(hwndMsg);
}
DWORD dwMsgThread = hwndMsg ? GetWindowThreadProcessId(hwndMsg, NULL) : 0;
if (dwThread == dwMsgThread)
{
return TRUE;
}
}
return FALSE;
}
HRESULT CCommonBrowser::v_MayTranslateAccelerator(MSG* pmsg)
{
if (!(WM_KEYFIRST <= pmsg->message && pmsg->message <= WM_KEYLAST))
return S_FALSE;
BOOL fToolbarHasFocus = _HasToolbarFocus();
if (fToolbarHasFocus)
{
ASSERT(_get_itbLastFocus() < (UINT)_GetToolbarCount());
// toolbar has focus -- give it first chance to translate
//
// Notes:
// Notice that we don't give a chance to translate its accelerators
// to other toolbars. This is by-design right now. We might want to
// change it later, but it will be tricky to do it right.
//
if (IUnknown_TranslateAcceleratorIO(_GetToolbarItem(_get_itbLastFocus())->ptbar, pmsg) == S_OK)
return(S_OK);
}
else
{
UINT itbLastFocus = _get_itbLastFocus();
if (itbLastFocus != ITB_VIEW && _TBWindowHasFocus(itbLastFocus))
{
// view got focus back, update cache
_FixToolbarFocus();
}
// view has focus -- give it first chance to translate
// View doesn't necessarily have focus. Added a check.
//
if (_pbbd->_psv) // If we have a shell view
{
HWND hwnd;
// Note: Not everyone supports GetWindow (go figure)
// In which case, we try the GetFocus() window.
if (FAILED(_pbbd->_psv->GetWindow(&hwnd)))
{
hwnd = GetFocus();
}
// check if view or its child has focus
// before it checked for browser or a child but if user
// clicked on Show Desktop in quick launch
// defview is deparented from the desktop and this call
// fails which prevents tabbing to Active Desktop
// (done in CDefView::TranslateAccelerator
if (SHIsChildOrSelf(hwnd, pmsg->hwnd) == S_OK)
{
if (_pbbd->_psv->TranslateAccelerator(pmsg) == S_OK) // and the shell view translated the message
{
return S_OK;
}
}
}
}
// Then, handle our own accelerators (with special code for TAB key).
if (_ShouldTranslateAccelerator(pmsg))
{
if (IsVK_TABCycler(pmsg))
return _CycleFocus(pmsg);
BOOL fFwdItbar = FALSE;
// FEATURE: Why not just include F4 and Alt-D in ACCEL_MERGE,
// which gets localized?
if (pmsg->message == WM_KEYDOWN && pmsg->wParam == VK_F4)
{
fFwdItbar = TRUE;
}
if (pmsg->message == WM_SYSCHAR)
{
static CHAR szAccel[2] = "\0";
CHAR szChar [2] = "\0";
if ('\0' == szAccel[0])
MLLoadStringA(IDS_ADDRBAND_ACCELLERATOR, szAccel, ARRAYSIZE(szAccel));
szChar[0] = (CHAR)pmsg->wParam;
if (lstrcmpiA(szChar,szAccel) == 0)
{
fFwdItbar = TRUE;
}
}
if (fFwdItbar)
{
IDockingWindow *ptbar = _GetToolbarItem(ITB_ITBAR)->ptbar;
if (IUnknown_TranslateAcceleratorIO(ptbar, pmsg) == S_OK)
return S_OK;
}
if (TranslateAcceleratorSB(pmsg, 0) == S_OK)
return S_OK;
}
// If a toolbar has focus, we ask the view last.
if (fToolbarHasFocus)
{
if (_pbbd->_psv && _pbbd->_psv->TranslateAccelerator(pmsg) == S_OK)
return S_OK;
}
return S_FALSE;
}
HRESULT CCommonBrowser::_CycleFocus(LPMSG lpMsg)
{
UINT citb = 1;
if (GetKeyState(VK_SHIFT) < 0)
{
// go backward
citb = (UINT)-1;
}
UINT itbCur = _get_itbLastFocus();
//
// Find the next visible toolbar and set the focus to it. Otherwise,
// set the focus to the view window.
//
HWND hwndFocusNext;
TOOLBARITEM *ptbi;
if (_pbsOuter->v_MayGetNextToolbarFocus(lpMsg, itbCur, citb, &ptbi, &hwndFocusNext) == S_OK)
{
// Found a toolbar to take focus, nothing more to do.
// FEATURE: do we (or caller) need to do SetStatusTextSB?
// It looks like no one is doing it right now.
return S_OK;
}
if (!(hwndFocusNext && IsWindowVisible(hwndFocusNext)))
{
// Didn't find anyone. Set focus on the view.
hwndFocusNext = _pbbd->_hwndView;
}
_SetFocus(ptbi, hwndFocusNext, lpMsg);
return S_OK;
}
//*** _MayUIActTAB -- attempt TAB-activation of IOleWindow/IInputObject
// ENTRY/EXIT
// powEtc IOleWindow/IInputObject pair.
// lpMsg msg causing activation (may be NULL) (typically TAB)
// fShowing currently showing?
// phwnd [OUT] hwnd for object
// hr [RET] UIActivateIO result, plus E_FAIL
// DESCRIPTION
// when TABing we only want to activate certain guys, viz. those who are
// currently showing, visible, and willing to accept activation.
HRESULT _MayUIActTAB(IOleWindow *pow, LPMSG lpMsg, BOOL fShowing, HWND *phwnd)
{
HRESULT hr = E_FAIL;
HWND hwnd = 0;
if (pow && fShowing)
{
hr = pow->GetWindow(&hwnd);
if (IsWindowVisible(hwnd))
hr = IUnknown_UIActivateIO(pow, TRUE, lpMsg);
}
if (phwnd)
*phwnd = hwnd;
return hr;
}
//*** v_MayGetNextToolbarFocus -- get next in TAB order (and maybe SetFocus)
// ENTRY/EXIT
// hres E_FAIL for no candidate, S_FALSE for candidate, S_OK for 100% done
// (S_OK only used by derived class for now)
HRESULT CCommonBrowser::v_MayGetNextToolbarFocus(LPMSG lpMsg,
UINT itbCur, int citb,
TOOLBARITEM ** pptbi, HWND * phwnd)
{
HWND hwnd = 0;
TOOLBARITEM *ptbi = NULL;
if (itbCur == ITB_VIEW)
{
ASSERT(citb == 1 || citb == -1);
if (citb == 1)
itbCur = 0;
else
itbCur = _GetToolbarCount() - 1;
}
else
{
itbCur += citb;
}
// (semi-tricky: loop on an unsigned so get 0..n or n..0 w/ single loop)
for (UINT i = itbCur; i < (UINT)_GetToolbarCount(); i += citb)
{
ptbi = _GetToolbarItem(i);
// NOTE: _MayUIActTAB checks ptbi->ptbar for NULL
if (_MayUIActTAB(ptbi->ptbar, lpMsg, ptbi->fShow, &hwnd) == S_OK)
{
*pptbi = ptbi;
*phwnd = hwnd;
return S_FALSE;
}
}
*pptbi = NULL;
*phwnd = 0;
return E_FAIL;
}
BOOL _QITest(IUnknown* punk, REFIID riid)
{
ASSERT(punk);
BOOL fRet = FALSE;
if (SUCCEEDED(punk->QueryInterface(riid, (void**)&punk)))
{
punk->Release();
fRet = TRUE;
}
return fRet;
}
__inline BOOL _IsV4DefView(IShellView* psv)
{
if (GetUIVersion() < 5)
return _QITest(SAFECAST(psv, IUnknown*), IID_CDefView);
return FALSE;
}
__inline BOOL _IsOldView(IShellView* psv)
{
//
// Current CDocObjectView and v4 and greater CDefView
// implement IShellView2
//
return (FALSE == _QITest(SAFECAST(psv, IUnknown*), IID_IShellView2));
}
HRESULT CCommonBrowser::_SetFocus(TOOLBARITEM *ptbi, HWND hwnd, LPMSG lpMsg)
{
// Clear the upper layer of status text
SetStatusTextSB(NULL);
if (hwnd == _pbbd->_hwndView)
{
if (_pbbd->_psv)
{
BOOL fTranslate = TRUE, fActivate = TRUE;
if (!lpMsg)
{
// NULL message, so nothing to translate
fTranslate = FALSE;
}
else if (_IsV4DefView(_pbbd->_psv) || _IsOldView(_pbbd->_psv))
{
// These views expect only to be UI-activated
fTranslate = FALSE;
}
else if (IsVK_CtlTABCycler(lpMsg))
{
// Don't let trident translate ctl-tab. Since it's always
// UI-active, it will reject focus.
fTranslate = FALSE;
}
else
{
// Normal case - do not activate the view. TranslateAccelerator will do the right thing.
fActivate = FALSE;
}
if (fActivate)
_UIActivateView(SVUIA_ACTIVATE_FOCUS);
if (fTranslate)
_pbbd->_psv->TranslateAccelerator(lpMsg);
}
else
{
// IE3 compat (we used to do for all hwnd's)
SetFocus(hwnd);
}
// Update our cache
_OnFocusChange(ITB_VIEW);
}
return S_OK;
}
HRESULT CCommonBrowser::_FindActiveTarget(REFIID riid, void **ppvOut)
{
HRESULT hres = E_FAIL;
*ppvOut = NULL;
BOOL fToolbarHasFocus = _HasToolbarFocus();
if (fToolbarHasFocus)
{
hres = _GetToolbarItem(_get_itbLastFocus())->ptbar->QueryInterface(riid, ppvOut);
}
else if (_pbbd->_psv)
{
if (_get_itbLastFocus() != ITB_VIEW)
{
// view got focus back, update cache
_FixToolbarFocus();
}
if (_pbbd->_psv != NULL)
{
hres = _pbbd->_psv->QueryInterface(riid, ppvOut);
}
}
return hres;
}
BOOL CCommonBrowser::_HasToolbarFocus(void)
{
UINT uLast = _get_itbLastFocus();
if (uLast < ITB_MAX)
{
TOOLBARITEM *ptbi = _GetToolbarItem(uLast);
if (ptbi)
{
// NOTE: IUnknown_HasFocusIO checks ptbi->ptbar for NULL
return (IUnknown_HasFocusIO(ptbi->ptbar) == S_OK);
}
}
return FALSE;
}
//*** _FixToolbarFocus -- fake a UIActivate from the view
// NOTES
// The view never goes 'truly' non-UIActive so we never get notified when
// it goes 'truly' UIActive. we fake it here by mucking w/ our cache.
//
HRESULT CCommonBrowser::_FixToolbarFocus(void)
{
_OnFocusChange(ITB_VIEW); // ... and update cache
_UIActivateView(SVUIA_ACTIVATE_FOCUS); // steal the focus
return S_OK;
}
HRESULT CCommonBrowser::_OnFocusChange(UINT itb)
{
UINT itbPrevFocus = _get_itbLastFocus();
if (itbPrevFocus != itb)
{
//
// If the view is losing the focus (within the explorer),
// we should let it know. We should update _itbLastFocus before
// calling UIActivate, because it will call our InsertMenu back.
//
_put_itbLastFocus(itb);
if (itbPrevFocus == ITB_VIEW)
{
// DocHost will ignore this (since deactivating the view is taboo).
// ShellView will respect it (so menu merge works).
_UIActivateView(SVUIA_ACTIVATE_NOFOCUS);
}
else
{
IDockingWindow *ptb;
// FEATURE: uh-oh not sure what we do if NULL
// we do get NULL the 1st time we click on the SearchBand
ptb = _GetToolbarItem(itbPrevFocus)->ptbar;
IUnknown_UIActivateIO(ptb, FALSE, NULL);
}
}
return S_OK;
}
HRESULT CCommonBrowser::OnFocusChangeIS(IUnknown* punkSrc, BOOL fSetFocus)
{
UINT itb = _FindTBar(punkSrc);
if (itb == ITB_VIEW)
{
return E_INVALIDARG;
}
//
// Note that we keep track of which toolbar got the focus last.
// We can't reliably monitor the kill focus event because OLE's
// window procedure hook (for merged menu dispatching code) changes
// focus around.
//
if (fSetFocus)
{
_OnFocusChange(itb);
// Then, notify it to the shellview.
if (_pbbd->_pctView)
{
_pbbd->_pctView->Exec(NULL, OLECMDID_ONTOOLBARACTIVATED, OLECMDEXECOPT_DONTPROMPTUSER, NULL, NULL);
}
}
else if (itb == _get_itbLastFocus())
{
//
// The toolbar which currently has focus is giving it up.
// Move focus to the view when this happens.
//
_FixToolbarFocus();
}
return S_OK;
}
//*** toolbar/view broadcast {
//*** _ExecChildren -- broadcast Exec to view and toolbars
// NOTES
// we might do *both* punkBar and fBroadcast if we want to send stuff
// to both the view and to all toolbars, e.g. 'stop' or 'refresh'.
//
// NOTE: n.b. the tray isn't a real toolbar, so it won't get called (sigh...).
HRESULT CCommonBrowser::_ExecChildren(IUnknown *punkBar, BOOL fBroadcast, const GUID *pguidCmdGroup,
DWORD nCmdID, DWORD nCmdexecopt,
VARIANTARG *pvarargIn, VARIANTARG *pvarargOut)
{
// 1st, send to specified guy (if requested)
if (punkBar != NULL)
{
// send to specified guy
_pbsInner->_ExecChildren(punkBar, FALSE, pguidCmdGroup, nCmdID, nCmdexecopt, pvarargIn, pvarargOut);
}
// 2nd, broadcast to all (if requested)
if (fBroadcast)
{
for (int itb = 0; itb<_GetToolbarCount(); itb++)
{
TOOLBARITEM *ptbi = _GetToolbarItem(itb);
// NOTE: IUnknown_Exec checks ptbi->ptbar for NULL
IUnknown_Exec(ptbi->ptbar, pguidCmdGroup, nCmdID, nCmdexecopt, pvarargIn, pvarargOut);
}
}
return S_OK;
}
HRESULT CCommonBrowser::_SendChildren(HWND hwndBar, BOOL fBroadcast, UINT uMsg, WPARAM wParam, LPARAM lParam)
{
// 1st, send to specified guy (if requested)
if (hwndBar != NULL)
{
// send to specified guy
_pbsInner->_SendChildren(hwndBar, FALSE, uMsg, wParam, lParam);
}
// 2nd, broadcast to all (if requested)
if (fBroadcast)
{
for (int itb = 0; itb < _GetToolbarCount(); itb++)
{
HWND hwndToolbar;
TOOLBARITEM *ptbi = _GetToolbarItem(itb);
if (ptbi->ptbar && SUCCEEDED(ptbi->ptbar->GetWindow(&hwndToolbar)))
SendMessage(hwndToolbar, uMsg, wParam, lParam);
}
}
return S_OK;
}
LRESULT CCommonBrowser::ForwardViewMsg(UINT uMsg, WPARAM wParam, LPARAM lParam)
{
return _pbbd->_hwndView ? SendMessage(_pbbd->_hwndView, uMsg, wParam, lParam) : 0;
}
// }
TOOLBARITEM *CCommonBrowser::_GetToolbarItem(int itb)
{
ASSERT(itb != ITB_VIEW);
ASSERT(itb < ITB_MAX);
// ==0 for semi-bogus CBB::_OnFocusChange code
ASSERT(itb < FDSA_GetItemCount(&_fdsaTBar) || itb == 0);
TOOLBARITEM *ptbi = FDSA_GetItemPtr(&_fdsaTBar, itb, TOOLBARITEM);
ASSERT(ptbi != NULL);
return ptbi;
}
HRESULT CCommonBrowser::SetAcceleratorMenu(HACCEL hacc)
{
if (hacc != _hacc)
{
if (_hacc)
{
DestroyAcceleratorTable(_hacc);
}
_hacc = hacc;
}
return S_OK;
}
HRESULT _ConvertPathToPidl(IBrowserService2 *pbs, HWND hwnd, LPCTSTR pszPath, LPITEMIDLIST * ppidl)
{
HRESULT hres = E_FAIL;
WCHAR wszCmdLine[MAX_URL_STRING]; // must be with pszPath
TCHAR szParsedUrl[MAX_URL_STRING] = {'\0'};
TCHAR szFixedUrl[MAX_URL_STRING];
DWORD dwUrlLen = ARRAYSIZE(szParsedUrl);
LPCTSTR pUrlToUse = pszPath;
// Copy the command line into a temporary buffer
// so we can remove the surrounding quotes (if
// they exist)
StrCpyN(szFixedUrl, pszPath, ARRAYSIZE(szFixedUrl));
PathUnquoteSpaces(szFixedUrl);
if (ParseURLFromOutsideSource(szFixedUrl, szParsedUrl, &dwUrlLen, NULL))
pUrlToUse = szParsedUrl;
SHTCharToUnicode(pUrlToUse, wszCmdLine, ARRAYSIZE(wszCmdLine));
hres = pbs->IEParseDisplayName(CP_ACP, wszCmdLine, ppidl);
pbs->DisplayParseError(hres, wszCmdLine);
return hres;
}
Reference in a new issue Copy permalink