mirror of https://github.com/tongzx/nt5src
You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
4062 lines
125 KiB
4062 lines
125 KiB
#include "priv.h"
|
|
|
|
#include "sccls.h"
|
|
#include "comcat.h"
|
|
#include "dvocx.h"
|
|
#include <hliface.h>
|
|
#include "shlguid.h"
|
|
#include "shvocx.h"
|
|
#include "winlist.h"
|
|
#include <mshtml.h>
|
|
#include "stdenum.h"
|
|
#include "iface.h"
|
|
#include "resource.h"
|
|
#include "msiehost.h"
|
|
|
|
#include <mluisupp.h>
|
|
|
|
#define SUPERCLASS CShellOcx
|
|
|
|
#define MIN_HEIGHT 80 // minimum height of a ShellFolderViewOC
|
|
#define MIN_WIDTH 80 // minimum width of a ShellFolderViewOC.
|
|
#define DEF_WIDTH 300 // default width when we cannot get sizing information
|
|
#define DEF_HEIGHT 150 // default height when we cannot get sizing information
|
|
|
|
#define IPSMSG(psz) TraceMsg(TF_SHDCONTROL, "shv IPS::%s called", (psz))
|
|
#define IPSMSG2(psz, hres) TraceMsg(TF_SHDCONTROL, "shv IPS::%s %x", (psz), hres)
|
|
#define IPSMSG3(psz, hres, x, y) TraceMsg(TF_SHDCONTROL,"shv IPS::%s %x %d (%d)", (psz), hres, x, y)
|
|
#define IOOMSG(psz) TraceMsg(TF_SHDCONTROL, "shv IOO::%s called", (psz))
|
|
#define IOOMSG2(psz, i) TraceMsg(TF_SHDCONTROL, "shv IOO::%s called with (%d)", (psz), i)
|
|
#define IOOMSG3(psz, i, j) TraceMsg(TF_SHDCONTROL, "shv IOO::%s called with (%d, %d)", (psz), i, j)
|
|
#define IVOMSG(psz) TraceMsg(TF_SHDCONTROL, "shv IVO::%s called", (psz))
|
|
#define IVOMSG2(psz, i) TraceMsg(TF_SHDCONTROL, "shv IVO::%s called with (%d)", (psz), i)
|
|
#define IVOMSG3(psz, i, j) TraceMsg(TF_SHDCONTROL, "shv IVO::%s called with (%d, %d)", (psz), i, j)
|
|
#define PROPMSG(psz) TraceMsg(TF_SHDCONTROL, "shv %s", (psz))
|
|
#define PROPMSG2(psz, pstr) TraceMsg(TF_SHDCONTROL, "shv %s with [%s]", (psz), pstr)
|
|
#define PROPMSG3(psz, hex) TraceMsg(TF_SHDCONTROL, "shv %s with 0x%x", (psz), hex)
|
|
#define PRIVMSG(psz) TraceMsg(TF_SHDCONTROL, "shv %s", (psz))
|
|
#define CVOCBMSG(psz) TraceMsg(TF_SHDCONTROL, "shv CWebBrowserSB::%s", (psz))
|
|
#define IOIPAMSG(psz) TraceMsg(TF_SHDCONTROL, "shv IOIPA::%s", (psz));
|
|
|
|
#define ABS(i) (((i) < 0) ? -(i) : (i))
|
|
|
|
#define BOOL_TO_VARIANTBOOL(b) ((b) ? VARIANT_TRUE : VARIANT_FALSE)
|
|
#define VARIANTBOOL_TO_BOOL(vb) ((vb == VARIANT_FALSE) ? FALSE : TRUE)
|
|
|
|
// sizing messages are annoying, but occasionally useful:
|
|
#define DM_FORSEARCHBAND 0
|
|
|
|
static const OLEVERB c_averbsSV[] = {
|
|
{ 0, (LPWSTR)MAKEINTRESOURCE(IDS_VERB_EDIT), 0, OLEVERBATTRIB_ONCONTAINERMENU },
|
|
{ 0, NULL, 0, 0 }
|
|
};
|
|
static const OLEVERB c_averbsDesignSV[] = {
|
|
{ 0, NULL, 0, 0 }
|
|
};
|
|
|
|
#define HMODULE_NOTLOADED ((HMODULE)-1)
|
|
|
|
HRESULT TargetQueryService(IUnknown *punk, REFIID riid, void **ppvObj);
|
|
|
|
/*
|
|
* CMsgFilter - implementation of IMessageFilter
|
|
*
|
|
* Used to reject RPC-reentrant calls while inside AOL
|
|
*
|
|
*/
|
|
class CMsgFilter : public IMessageFilter {
|
|
public:
|
|
// *** IUnknown methods ***
|
|
STDMETHODIMP QueryInterface(REFIID riid, void ** ppvObj)
|
|
{
|
|
// This interface doesn't get QI'ed.
|
|
ASSERT(FALSE);
|
|
return E_NOINTERFACE;
|
|
};
|
|
virtual ULONG __stdcall AddRef(void) { return ++_cRef; };
|
|
virtual ULONG __stdcall Release(void) { ASSERT(_cRef > 0);
|
|
_cRef--;
|
|
if (_cRef > 0)
|
|
return _cRef;
|
|
|
|
delete this;
|
|
return 0;
|
|
};
|
|
|
|
// *** IMessageFilter specific methods ***
|
|
virtual DWORD __stdcall HandleInComingCall(
|
|
IN DWORD dwCallType,
|
|
IN HTASK htaskCaller,
|
|
IN DWORD dwTickCount,
|
|
IN LPINTERFACEINFO lpInterfaceInfo)
|
|
{
|
|
#ifdef DEBUG
|
|
WCHAR wszIID[39];
|
|
|
|
StringFromGUID2( lpInterfaceInfo->iid, wszIID, ARRAYSIZE(wszIID) );
|
|
|
|
TraceMsg(TF_SHDCONTROL, "shvMF HandleIncomingCall: calltype=%lx, pUnk=%lx, IID=%ws, wMethod=%hu",
|
|
dwCallType,
|
|
lpInterfaceInfo->pUnk,
|
|
wszIID,
|
|
lpInterfaceInfo->wMethod);
|
|
#endif
|
|
|
|
//
|
|
// The following statement guards against RPC-reentrancy by checking if
|
|
// the calltype is TOPLEVEL_CALLPENDING, which means that a call has arrived with a new
|
|
// logical threadid and that the object is currently waiting for a reply from a previous
|
|
// outgoing call. It's this type of call that has proven troublesome in the past with AOL.
|
|
//
|
|
// 2-Dec-97: AOL QFE: We need to allow resizing requests to pass through the message filter.
|
|
// These appear as IOleObject::SetExtent. Check the IID for IOleObject, and the
|
|
// wMethod for 17 (SetExtent is the 17th method in the vtable, Zero-based).
|
|
//
|
|
const int SetExtent = 17;
|
|
|
|
if ( ( dwCallType == CALLTYPE_TOPLEVEL_CALLPENDING )
|
|
&& !(IsEqualIID(lpInterfaceInfo->iid, IID_IOleObject) && lpInterfaceInfo->wMethod == SetExtent) )
|
|
{
|
|
#ifdef DEBUG
|
|
TraceMsg(TF_SHDCONTROL, "shvMF rejected call: calltype=%lx, pUnk=%lx, IID=%ws, wMethod=%hu",
|
|
dwCallType,
|
|
lpInterfaceInfo->pUnk,
|
|
wszIID,
|
|
lpInterfaceInfo->wMethod);
|
|
#endif
|
|
return SERVERCALL_RETRYLATER;
|
|
}
|
|
|
|
if (_lpMFOld)
|
|
{
|
|
HRESULT hr = _lpMFOld->HandleInComingCall(dwCallType, htaskCaller, dwTickCount, lpInterfaceInfo);
|
|
TraceMsg(TF_SHDCONTROL, "shvMF HIC Previous MF returned %x", hr);
|
|
return hr;
|
|
}
|
|
else
|
|
{
|
|
TraceMsg(TF_SHDCONTROL, "shvMF HIC returning SERVERCALL_ISHANDLED.");
|
|
return SERVERCALL_ISHANDLED;
|
|
}
|
|
};
|
|
|
|
virtual DWORD __stdcall RetryRejectedCall(
|
|
IN HTASK htaskCallee,
|
|
IN DWORD dwTickCount,
|
|
IN DWORD dwRejectType)
|
|
{
|
|
TraceMsg(TF_SHDCONTROL, "shv MF RetryRejectedCall htaskCallee=%x, dwTickCount=%x, dwRejectType=%x",
|
|
htaskCallee,
|
|
dwTickCount,
|
|
dwRejectType);
|
|
|
|
if (_lpMFOld)
|
|
{
|
|
HRESULT hr = _lpMFOld->RetryRejectedCall(htaskCallee, dwTickCount, dwRejectType);
|
|
TraceMsg(TF_SHDCONTROL, "shvMF RRC returned %x", hr);
|
|
return hr;
|
|
}
|
|
else
|
|
{
|
|
TraceMsg(TF_SHDCONTROL, "shvMF RRC returning 0xffffffff");
|
|
return 0xffffffff;
|
|
}
|
|
};
|
|
|
|
virtual DWORD __stdcall MessagePending(
|
|
IN HTASK htaskCallee,
|
|
IN DWORD dwTickCount,
|
|
IN DWORD dwPendingType)
|
|
{
|
|
TraceMsg(TF_SHDCONTROL, "shv MF MessagePending htaskCallee=%x, dwTickCount=%x, dwPendingType=%x",
|
|
htaskCallee,
|
|
dwTickCount,
|
|
dwPendingType);
|
|
|
|
if (_lpMFOld)
|
|
{
|
|
HRESULT hr = _lpMFOld->MessagePending(htaskCallee, dwTickCount, dwPendingType);
|
|
TraceMsg(TF_SHDCONTROL, "shvMF RRC returned %x", hr);
|
|
return hr;
|
|
}
|
|
else
|
|
{
|
|
TraceMsg(TF_SHDCONTROL, "shvMF MP returning PENDINGMSG_WAITDEFPROCESS");
|
|
return PENDINGMSG_WAITDEFPROCESS;
|
|
}
|
|
};
|
|
|
|
CMsgFilter() : _cRef(1)
|
|
{
|
|
ASSERT(_lpMFOld == NULL);
|
|
};
|
|
|
|
BOOL Initialize()
|
|
{
|
|
BOOL bResult = CoRegisterMessageFilter((LPMESSAGEFILTER)this, &_lpMFOld) != S_FALSE;
|
|
TraceMsg(TF_SHDCONTROL, "shv Previous message filter is %lx", _lpMFOld);
|
|
return bResult;
|
|
};
|
|
|
|
void UnInitialize()
|
|
{
|
|
TraceMsg(TF_SHDCONTROL, "shv MF Uninitializing, previous message filter = %x", _lpMFOld);
|
|
CoRegisterMessageFilter(_lpMFOld, NULL);
|
|
|
|
// we shouldn't ever get called again, but after 30 minutes
|
|
// of automation driving we once hit a function call above
|
|
// and we dereferenced this old pointer and page faulted.
|
|
|
|
ATOMICRELEASE(_lpMFOld);
|
|
};
|
|
|
|
protected:
|
|
int _cRef;
|
|
LPMESSAGEFILTER _lpMFOld;
|
|
};
|
|
|
|
|
|
CWebBrowserOC::CWebBrowserOC(IUnknown* punkOuter, LPCOBJECTINFO poi) :
|
|
SUPERCLASS(punkOuter, poi, c_averbsSV, c_averbsDesignSV)
|
|
{
|
|
TraceMsg(TF_SHDLIFE, "ctor CWebBrowserOC %x", this);
|
|
|
|
// flag special so we only try to load browseui once
|
|
_hBrowseUI = HMODULE_NOTLOADED;
|
|
}
|
|
|
|
BOOL CWebBrowserOC::_InitializeOC(IUnknown *punkOuter)
|
|
{
|
|
// we used a zero-init memory allocator, so everything else is NULL.
|
|
// check to be sure:
|
|
ASSERT(!_fInit);
|
|
|
|
// By default, we're visible. Everything else can default to FALSE.
|
|
//
|
|
_fVisible = 1;
|
|
|
|
// CShellOcx holds the default event source which is DIID_DWebBrowserEvents2
|
|
m_cpWB1Events.SetOwner(_GetInner(), &DIID_DWebBrowserEvents);
|
|
|
|
// some stuff we want to set up now. we're a WebBrowser, so create the
|
|
// IShellBrowser now. We need an aggregated automation object before
|
|
// we do that.
|
|
CIEFrameAuto_CreateInstance(SAFECAST(this, IOleControl*), &_pauto);
|
|
if (_pauto)
|
|
{
|
|
// Cache some interfaces of CIEFrameAuto.
|
|
//
|
|
// Since we aggregate CIEFrameAuto, this will increase our refcount.
|
|
// We cannot release this interface and expect it to work, so we
|
|
// call release on ourself to remove the refcount cycle.
|
|
//
|
|
// Since we ourselves may be aggregated and we always want to get
|
|
// CIEFrameAuto's interface and not our aggregator's, we delay
|
|
// setting up punkOuter until below.
|
|
//
|
|
_pauto->QueryInterface(IID_PPV_ARG(IWebBrowser2, &_pautoWB2));
|
|
ASSERT(_pautoWB2);
|
|
Release();
|
|
|
|
_pauto->QueryInterface(IID_PPV_ARG(IExpDispSupport, &_pautoEDS));
|
|
ASSERT(_pautoEDS);
|
|
Release();
|
|
}
|
|
|
|
// Now set up our aggregator's punkOuter
|
|
if (punkOuter)
|
|
{
|
|
CAggregatedUnknown::_SetOuter(punkOuter);
|
|
}
|
|
|
|
// postpone initialization of stuff that may be persisted
|
|
// until InitNew is called.
|
|
|
|
// Were we successful? (we don't have to free this
|
|
// here on failure, cuz we'll free them on delete)
|
|
return (NULL!=_pauto);
|
|
}
|
|
|
|
CWebBrowserOC::~CWebBrowserOC()
|
|
{
|
|
TraceMsg(TF_SHDLIFE, "dtor CWebBrowserOC %x", this);
|
|
|
|
ASSERT(!_fDidRegisterAsBrowser);
|
|
_UnregisterWindow(); // Last Chance - should have been done in InplaceDeactivate
|
|
|
|
if (_psb) {
|
|
ATOMICRELEASET(_psb, CWebBrowserSB);
|
|
}
|
|
|
|
ATOMICRELEASE(_plinkA);
|
|
|
|
// We need to release these cached interface pointers.
|
|
//
|
|
// Since we cached them before setting up our outer-aggregation,
|
|
// we need to un-outer-aggregate ourself first.
|
|
//
|
|
// Since we aggregate CIEFrameAuto (where these come from) we need
|
|
// to AddRef ourself before releasing. Fortunately, this is done for us
|
|
// by CAggregatedUnknown::Release (it bumps _cRef to 1000).
|
|
//
|
|
CAggregatedUnknown::_SetOuter(CAggregatedUnknown::_GetInner());
|
|
ATOMICRELEASE(_pautoWB2);
|
|
ATOMICRELEASE(_pautoEDS);
|
|
|
|
ATOMICRELEASE(_pauto);
|
|
|
|
if (_hmemSB) {
|
|
GlobalFree(_hmemSB);
|
|
_hmemSB = NULL;
|
|
}
|
|
|
|
if (_hBrowseUI != 0 && _hBrowseUI != HMODULE_NOTLOADED)
|
|
FreeLibrary(_hBrowseUI);
|
|
}
|
|
|
|
|
|
|
|
IStream *CWebBrowserSB::v_GetViewStream(LPCITEMIDLIST pidl, DWORD grfMode, LPCWSTR pwszName)
|
|
{
|
|
TCHAR szName[MAX_PATH];
|
|
SHUnicodeToTChar(pwszName, szName, ARRAYSIZE(szName));
|
|
return GetViewStream(pidl, grfMode, szName, REGSTR_PATH_EXPLORER TEXT("\\OCXStreamMRU"), TEXT("OCXStreams"));
|
|
}
|
|
|
|
void CWebBrowserOC::_InitDefault()
|
|
{
|
|
if (_fInit)
|
|
{
|
|
IPSMSG(TEXT("_InitDefault already initialized"));
|
|
return;
|
|
}
|
|
_fInit = TRUE;
|
|
|
|
// Different versions of the control get different defaults.
|
|
if (_pObjectInfo->lVersion == VERSION_1)
|
|
{
|
|
// AOL 3.0 compatibility: register as a browser window on InPlaceActivate
|
|
_fShouldRegisterAsBrowser = TRUE;
|
|
}
|
|
else
|
|
{
|
|
// we use a zero-init memory allocator, so everything else is NULL.
|
|
ASSERT(FALSE == _fShouldRegisterAsBrowser);
|
|
}
|
|
|
|
_size.cx = DEF_WIDTH;
|
|
_size.cy = DEF_HEIGHT;
|
|
_sizeHIM = _size;
|
|
PixelsToMetric(&_sizeHIM);
|
|
|
|
_fs.ViewMode = FVM_ICON;
|
|
_fs.fFlags = FWF_AUTOARRANGE | FWF_NOCLIENTEDGE;
|
|
|
|
}
|
|
|
|
void CWebBrowserOC::_RegisterWindow()
|
|
{
|
|
if (!_fDidRegisterAsBrowser && _pipsite && _fShouldRegisterAsBrowser)
|
|
{
|
|
ITargetFrame2 *ptgf;
|
|
HRESULT hr;
|
|
|
|
if (SUCCEEDED(QueryInterface(IID_PPV_ARG(ITargetFrame2, &ptgf))))
|
|
{
|
|
IUnknown *pUnkParent;
|
|
|
|
hr = ptgf->GetParentFrame(&pUnkParent);
|
|
if (SUCCEEDED(hr) && pUnkParent != NULL)
|
|
{
|
|
pUnkParent->Release();
|
|
}
|
|
else
|
|
{
|
|
IShellWindows* psw = WinList_GetShellWindows(TRUE);
|
|
if (psw)
|
|
{
|
|
IDispatch* pid;
|
|
|
|
if (SUCCEEDED(ptgf->QueryInterface(IID_PPV_ARG(IDispatch, &pid))))
|
|
{
|
|
psw->Register(pid, PtrToLong(_hwnd), SWC_3RDPARTY, &_cbCookie);
|
|
_fDidRegisterAsBrowser = 1;
|
|
pid->Release();
|
|
}
|
|
psw->Release();
|
|
}
|
|
}
|
|
ptgf->Release();
|
|
}
|
|
}
|
|
}
|
|
|
|
void CWebBrowserOC::_UnregisterWindow()
|
|
{
|
|
if (_fDidRegisterAsBrowser)
|
|
{
|
|
IShellWindows* psw = NULL;
|
|
|
|
psw = WinList_GetShellWindows(TRUE);
|
|
if (psw)
|
|
{
|
|
psw->Revoke(_cbCookie);
|
|
_fDidRegisterAsBrowser = 0;
|
|
psw->Release();
|
|
}
|
|
}
|
|
}
|
|
|
|
HRESULT CWebBrowserOC::Draw(
|
|
DWORD dwDrawAspect,
|
|
LONG lindex,
|
|
void *pvAspect,
|
|
DVTARGETDEVICE *ptd,
|
|
HDC hdcTargetDev,
|
|
HDC hdcDraw,
|
|
LPCRECTL lprcBounds,
|
|
LPCRECTL lprcWBounds,
|
|
BOOL ( __stdcall *pfnContinue )(ULONG_PTR dwContinue),
|
|
ULONG_PTR dwContinue)
|
|
{
|
|
IS_INITIALIZED;
|
|
|
|
HRESULT hres;
|
|
|
|
IVOMSG3(TEXT("Draw called"), lprcBounds->top, lprcBounds->bottom);
|
|
IViewObject *pvo;
|
|
if (_psb && _psb->GetShellView() &&
|
|
SUCCEEDED(_psb->GetShellView()->QueryInterface(IID_PPV_ARG(IViewObject, &pvo))))
|
|
{
|
|
hres = pvo->Draw(dwDrawAspect, lindex, pvAspect, ptd, hdcTargetDev, hdcDraw,
|
|
lprcBounds, lprcWBounds, pfnContinue, dwContinue);
|
|
pvo->Release();
|
|
if (SUCCEEDED(hres))
|
|
return hres;
|
|
}
|
|
|
|
// If we don't have a shell view, or if it couldn't draw, then we draw ourselves.
|
|
// (if we're in design mode).
|
|
//
|
|
if (_IsDesignMode())
|
|
{
|
|
FillRect(hdcDraw, (RECT*) lprcBounds, (HBRUSH)GetStockObject(BLACK_BRUSH));
|
|
|
|
SIZE size = { ABS( lprcBounds->right - lprcBounds->left ),
|
|
ABS( lprcBounds->bottom - lprcBounds->top ) };
|
|
|
|
HBITMAP hImage;
|
|
HDC hdcTmp = CreateCompatibleDC( hdcDraw );
|
|
HMODULE hBrowseUI;
|
|
|
|
hBrowseUI = _GetBrowseUI();
|
|
if ( hBrowseUI )
|
|
hImage = LoadBitmap( hBrowseUI, MAKEINTRESOURCE( IDB_IEBRAND ));
|
|
else
|
|
hImage = NULL;
|
|
|
|
// hdcDraw may be a metafile, in which case the CreateCompatibleDC call will fail.
|
|
//
|
|
if ( !hdcTmp )
|
|
{
|
|
hdcTmp = CreateCompatibleDC( hdcTargetDev ); // Okay if hdcTargetDev == NULL
|
|
}
|
|
|
|
if (hdcTmp)
|
|
{
|
|
if ( hImage )
|
|
{
|
|
BITMAP bm;
|
|
POINT ptOriginDest; // origin of destination
|
|
SIZE sizeDest;
|
|
POINT ptOriginSrc = { 0, 0 };
|
|
SIZE sizeSrc;
|
|
|
|
GetObject( hImage, sizeof( bm ), &bm );
|
|
|
|
HGDIOBJ hPrev = SelectObject( hdcTmp, hImage );
|
|
|
|
// Yes, this looks wrong, but it's right. We only want the first frame
|
|
// of the brand bitmap, and the frames are stacked vertically.
|
|
//
|
|
sizeSrc.cx = sizeSrc.cy = bm.bmWidth;
|
|
|
|
// This code centers the bitmap while preserving its aspect ratio.
|
|
//
|
|
if ( size.cx > size.cy )
|
|
{
|
|
// if destination is wider than tall,
|
|
//
|
|
ptOriginDest.x = lprcBounds->left + size.cx/2 - size.cy/2;
|
|
ptOriginDest.y = lprcBounds->top;
|
|
sizeDest.cx = size.cy;
|
|
sizeDest.cy = lprcBounds->bottom - lprcBounds->top >= 0 ? size.cy : -size.cy;
|
|
}
|
|
else
|
|
{
|
|
// else destination is taller than wide
|
|
//
|
|
ptOriginDest.x = lprcBounds->left;
|
|
ptOriginDest.y = lprcBounds->bottom - lprcBounds->top >= 0
|
|
? ( lprcBounds->top + size.cy/2 - size.cx/2 )
|
|
: -( lprcBounds->top + size.cy/2 - size.cx/2 );
|
|
sizeDest.cx = size.cx;
|
|
sizeDest.cy = lprcBounds->bottom - lprcBounds->top >= 0 ? size.cx : -size.cx;
|
|
}
|
|
|
|
StretchBlt( hdcDraw,
|
|
ptOriginDest.x, ptOriginDest.y,
|
|
sizeDest.cx, sizeDest.cy,
|
|
hdcTmp,
|
|
ptOriginSrc.x, ptOriginSrc.y,
|
|
sizeSrc.cx, sizeSrc.cy,
|
|
SRCCOPY );
|
|
|
|
SelectObject( hdcTmp, hPrev );
|
|
DeleteObject( hImage );
|
|
}
|
|
|
|
DeleteDC( hdcTmp );
|
|
}
|
|
|
|
return S_OK;
|
|
}
|
|
|
|
return SUPERCLASS::Draw(dwDrawAspect, lindex, pvAspect, ptd, hdcTargetDev, hdcDraw,
|
|
lprcBounds, lprcWBounds, pfnContinue, dwContinue);
|
|
}
|
|
|
|
HRESULT CWebBrowserOC::GetColorSet(DWORD dwAspect, LONG lindex,
|
|
void *pvAspect, DVTARGETDEVICE *ptd, HDC hicTargetDev,
|
|
LOGPALETTE **ppColorSet)
|
|
{
|
|
IViewObject *pvo;
|
|
|
|
if (_psb && _psb->GetShellView() &&
|
|
SUCCEEDED(_psb->GetShellView()->QueryInterface(IID_PPV_ARG(IViewObject, &pvo))))
|
|
{
|
|
HRESULT hres = pvo->GetColorSet(dwAspect, lindex, pvAspect, ptd,
|
|
hicTargetDev, ppColorSet);
|
|
|
|
pvo->Release();
|
|
|
|
if (SUCCEEDED(hres))
|
|
return hres;
|
|
}
|
|
|
|
return SUPERCLASS::GetColorSet(dwAspect, lindex, pvAspect, ptd,
|
|
hicTargetDev, ppColorSet);
|
|
}
|
|
|
|
HRESULT CWebBrowserOC::SetExtent(DWORD dwDrawAspect, SIZEL *psizel)
|
|
{
|
|
HRESULT hr = SUPERCLASS::SetExtent(dwDrawAspect, psizel);
|
|
if ( FAILED( hr ))
|
|
{
|
|
return hr;
|
|
}
|
|
|
|
//
|
|
// If oc < inplace then forward SetExtent through to docobject.
|
|
// If docobject is already inplace active, SetExtent is meaningless.
|
|
//
|
|
|
|
if (_nActivate < OC_INPLACEACTIVE)
|
|
{
|
|
IPrivateOleObject * pPrivOle = NULL;
|
|
if ( _psb && _psb->GetShellView() &&
|
|
SUCCEEDED(_psb->GetShellView()->QueryInterface(IID_PPV_ARG(IPrivateOleObject, &pPrivOle))))
|
|
{
|
|
// we have an ole object, delegate downwards...
|
|
hr = pPrivOle->SetExtent( dwDrawAspect, psizel );
|
|
pPrivOle->Release();
|
|
}
|
|
|
|
_dwDrawAspect = dwDrawAspect;
|
|
// the size is already cached in _sizeHIM in our base class by the SUPERCLASS::SetExtent()
|
|
}
|
|
|
|
return hr;
|
|
}
|
|
|
|
|
|
|
|
// Called after the client site has been set so we can process
|
|
// stuff in the correct order
|
|
//
|
|
void CWebBrowserOC::_OnSetClientSite()
|
|
{
|
|
// Until we have a client site we can't determine toplevelness.
|
|
//
|
|
if (_pcli)
|
|
{
|
|
BOOL fFoundBrowserService = FALSE;
|
|
IBrowserService *pbsTop;
|
|
|
|
if (SUCCEEDED(IUnknown_QueryService(_pcli, SID_STopLevelBrowser, IID_PPV_ARG(IBrowserService, &pbsTop))))
|
|
{
|
|
fFoundBrowserService = TRUE;
|
|
pbsTop->Release();
|
|
}
|
|
|
|
// if nobody above us supports IBrowserService, we must be toplevel.
|
|
if (!fFoundBrowserService)
|
|
_fTopLevel = TRUE;
|
|
|
|
|
|
// If we haven't created CWebBrowserSB, do so now.
|
|
// We do this before our superclass OnSetClientSite
|
|
// because shembed will create the window which
|
|
// requires _psb's existence.
|
|
//
|
|
// NOTE: We do this here instead of _Initialize because
|
|
// CBaseBrowser will QI us for interfaces during this call.
|
|
// If we're in the middle of our CreateInstance function
|
|
// and we've been aggregated, we pass the QI to _punkAgg
|
|
// who faults because we haven't returned from CoCreateInstance.
|
|
//
|
|
// NOTE: We now destroy our window on SetClientSite(NULL)
|
|
// which frees ths _psb, so we should create this every time.
|
|
//
|
|
if (!_psb)
|
|
{
|
|
// Give _psb our inner unknown so we never get interfaces
|
|
// from whoever may aggregate us. _GetInner gives us
|
|
// first crack at QueryInterface so we get the correct
|
|
// IWebBrowser implementation.
|
|
//
|
|
_psb = new CWebBrowserSB(CAggregatedUnknown::_GetInner(), this);
|
|
|
|
// if we don't get _psb we're totally hosed...
|
|
//
|
|
if (_psb)
|
|
{
|
|
_psb->_fldBase._fld._fs = _fs;
|
|
// tell _psb if it's top-level or not
|
|
//
|
|
if (_fTopLevel)
|
|
{
|
|
_psb->SetTopBrowser();
|
|
}
|
|
|
|
// CBaseBrowser assumes SVUIA_ACTIVATE_FOCUS, tell it what we really are
|
|
//
|
|
ASSERT(OC_DEACTIVE == _nActivate); // we shouldn't be activated yet
|
|
_psb->_UIActivateView(SVUIA_DEACTIVATE);
|
|
}
|
|
else
|
|
{
|
|
TraceMsg(TF_WARNING, "Couldn't create _psb. We are hosed!");
|
|
// don't let the window get created by our superclass,
|
|
// as we can't do anything anyway...
|
|
//
|
|
return;
|
|
}
|
|
}
|
|
}
|
|
else
|
|
{
|
|
// Tell our aggregatee that their cached window is invalid
|
|
//
|
|
IEFrameAuto * piefa;
|
|
if (EVAL(SUCCEEDED(_pauto->QueryInterface(IID_PPV_ARG(IEFrameAuto, &piefa)))))
|
|
{
|
|
piefa->SetOwnerHwnd(NULL);
|
|
piefa->Release();
|
|
}
|
|
|
|
if (_lpMF)
|
|
{
|
|
IMessageFilter* lpMF = _lpMF;
|
|
_lpMF = NULL;
|
|
((CMsgFilter *)lpMF)->UnInitialize();
|
|
EVAL(lpMF->Release() == 0);
|
|
}
|
|
|
|
// Decrement the browser session count
|
|
//
|
|
if (_fIncrementedSessionCount)
|
|
{
|
|
SetQueryNetSessionCount(SESSION_DECREMENT);
|
|
_fIncrementedSessionCount = FALSE; // In case this instance is reused.
|
|
}
|
|
}
|
|
|
|
SUPERCLASS::_OnSetClientSite();
|
|
|
|
if (_pcli)
|
|
{
|
|
VARIANT_BOOL fAmbient = VARIANT_FALSE;
|
|
HWND hwndParent = NULL;
|
|
// We init the local properties using ambients if available
|
|
// If this fails, fAmbient will be left at VARIANT_FALSE which is what we need for the next
|
|
// statement.
|
|
//
|
|
if (SUPERCLASS::_GetAmbientProperty(DISPID_AMBIENT_OFFLINEIFNOTCONNECTED, VT_BOOL, &fAmbient))
|
|
{
|
|
put_Offline(fAmbient);
|
|
}
|
|
|
|
// If top-level and not offline, increment the browser session count.
|
|
//
|
|
if (_fTopLevel && !fAmbient)
|
|
{
|
|
SetQueryNetSessionCount(SESSION_INCREMENT_NODEFAULTBROWSERCHECK);
|
|
_fIncrementedSessionCount = TRUE;
|
|
}
|
|
|
|
if (SUPERCLASS::_GetAmbientProperty(DISPID_AMBIENT_SILENT, VT_BOOL, &fAmbient))
|
|
{
|
|
put_Silent(fAmbient);
|
|
}
|
|
|
|
// After the parent window has been set, check to see if it is on the same thread as us.
|
|
// If not, we have a cross-thread container and we need a message filter.
|
|
//
|
|
if ( _fTopLevel // If we're top level
|
|
&& _hwnd // and we have an hwnd (we should)
|
|
&& (hwndParent = GetParent( _hwnd ) ) // and we have a parent window
|
|
// and the parent window is on a different thread
|
|
&& GetWindowThreadProcessId( _hwnd, NULL ) != GetWindowThreadProcessId( hwndParent, NULL ))
|
|
{
|
|
if (!_lpMF)
|
|
{
|
|
/*
|
|
* Create a message filter here to reject RPC-reentrant calls.
|
|
*/
|
|
_lpMF = new CMsgFilter();
|
|
|
|
if (_lpMF && !(((CMsgFilter *)_lpMF)->Initialize()))
|
|
{
|
|
ATOMICRELEASE(_lpMF);
|
|
}
|
|
TraceMsg(TF_SHDCONTROL, "shv Registering message filter (%lx) for RPC-reentrancy", _lpMF);
|
|
}
|
|
}
|
|
|
|
|
|
// if we have a pending navigation from IPS::Load, do it now.
|
|
//
|
|
if (_fNavigateOnSetClientSite && _plinkA && _psb)
|
|
{
|
|
//
|
|
// We hit this code if this OC is IPersistStream::Loaded before
|
|
// the client site is set.
|
|
//
|
|
LPITEMIDLIST pidl;
|
|
if (SUCCEEDED(_plinkA->GetIDList(&pidl)) && pidl)
|
|
{
|
|
_BrowseObject(pidl);
|
|
ILFree(pidl);
|
|
}
|
|
|
|
_fNavigateOnSetClientSite = FALSE;
|
|
}
|
|
}
|
|
|
|
}
|
|
|
|
STDAPI CWebBrowserOC_CreateInstance(IUnknown* punkOuter, IUnknown** ppunk, LPCOBJECTINFO poi)
|
|
{
|
|
HRESULT hres;
|
|
|
|
hres = E_OUTOFMEMORY;
|
|
CWebBrowserOC* psvo = new CWebBrowserOC(NULL, poi);
|
|
if (psvo)
|
|
{
|
|
if (!psvo->_InitializeOC(punkOuter))
|
|
{
|
|
psvo->Release();
|
|
}
|
|
else
|
|
{
|
|
*ppunk = psvo->_GetInner();
|
|
hres = S_OK;
|
|
}
|
|
}
|
|
return hres;
|
|
}
|
|
|
|
|
|
LRESULT CWebBrowserOC::_OnPaintPrint(HDC hdcPrint)
|
|
{
|
|
PAINTSTRUCT ps;
|
|
HDC hdc = hdcPrint ? hdcPrint : BeginPaint(_hwnd, &ps);
|
|
RECT rc;
|
|
GetClientRect(_hwnd, &rc);
|
|
DrawEdge(hdc, &rc, EDGE_SUNKEN, BF_ADJUST|BF_RECT|BF_SOFT);
|
|
DrawText(hdc, hdcPrint ? TEXT("Print") : TEXT("Paint"),
|
|
-1, &rc, DT_CENTER | DT_VCENTER | DT_SINGLELINE);
|
|
if (!hdcPrint)
|
|
{
|
|
EndPaint(_hwnd, &ps);
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
HRESULT CWebBrowserOC::_BrowseObject(LPCITEMIDLIST pidlBrowseTo)
|
|
{
|
|
if (_psb)
|
|
return _psb->BrowseObject(pidlBrowseTo, SBSP_SAMEBROWSER | SBSP_ABSOLUTE);
|
|
|
|
// if no _psb at this point, container did not
|
|
// honor OLEMISC_SETCLIENTSITEFIRST bit, so silently
|
|
// fail instead of trying to make this work
|
|
ASSERT(FALSE);
|
|
return E_FAIL;
|
|
}
|
|
|
|
LRESULT CWebBrowserOC::_OnCreate(LPCREATESTRUCT lpcs)
|
|
{
|
|
LRESULT lres;
|
|
|
|
if (_psb)
|
|
{
|
|
ASSERT(_hwnd);
|
|
_psb->_SetWindow(_hwnd);
|
|
|
|
lres = _psb->OnCreate(NULL);
|
|
}
|
|
else
|
|
{
|
|
lres = (LRESULT)-1;
|
|
}
|
|
|
|
//
|
|
// If IPersistStream::Load has stored away a block of stream for
|
|
// toolbars, this is the time to use it.
|
|
//
|
|
if (_hmemSB)
|
|
{
|
|
#if 0
|
|
// only do the load if we're successfully creating the window
|
|
if (lres != -1)
|
|
{
|
|
IStream* pstm;
|
|
HRESULT hresT = ::CreateStreamOnHGlobal(_hmemSB, FALSE, &pstm);
|
|
if (SUCCEEDED(hresT))
|
|
{
|
|
_psb->_LoadToolbars(pstm);
|
|
pstm->Release();
|
|
}
|
|
}
|
|
#endif
|
|
GlobalFree(_hmemSB);
|
|
_hmemSB = NULL;
|
|
}
|
|
|
|
return lres;
|
|
}
|
|
|
|
//
|
|
// This is a virtual function defined in CShellEmbedding class, which
|
|
// is called when all but WM_NCCREATE and WM_NCDESTROY messages are
|
|
// dispatched to the our "Shell Embedding" window. It's important
|
|
// to remember that we pass this window handle to the constructor of
|
|
// CWebBrowserSB (which calls the constructor of CBaseBrowser).
|
|
// That's why we forward all messages to _psb->WndProcBS. (SatoNa)
|
|
//
|
|
LRESULT CWebBrowserOC::v_WndProc(HWND hwnd, UINT uMsg, WPARAM wParam, LPARAM lParam)
|
|
{
|
|
LRESULT lres = 0L;
|
|
|
|
if (WM_CREATE == uMsg)
|
|
{
|
|
// We need first crack at this message before
|
|
// forwarding it along to _psb (which we do
|
|
// in this _OnCreate call)
|
|
return _OnCreate((LPCREATESTRUCT)lParam);
|
|
}
|
|
|
|
// only let _psb look at it if the message is not reserved for us
|
|
if (!IsInRange(uMsg, CWM_RESERVEDFORWEBBROWSER_FIRST, CWM_RESERVEDFORWEBBROWSER_LAST))
|
|
{
|
|
BOOL fDontForward = FALSE;
|
|
|
|
// destroy bottom up for these
|
|
switch (uMsg)
|
|
{
|
|
case WM_DESTROY:
|
|
case WM_CLOSE:
|
|
SUPERCLASS::v_WndProc(hwnd, uMsg, wParam, lParam);
|
|
fDontForward = TRUE;
|
|
break;
|
|
}
|
|
|
|
//
|
|
// This AssertMsg will help debugging IE v4.1 bug 12931.
|
|
//
|
|
// Comment out assert now that we don't create _psb at constructor time. (?)
|
|
//AssertMsg((BOOL)_psb, "WBOC::v_WndProc _psb==NULL! uMsg=%x", uMsg);
|
|
|
|
if (_psb)
|
|
{
|
|
lres = _psb->WndProcBS(hwnd, uMsg, wParam, lParam);
|
|
|
|
// Due to aggregation of IEFrameAuto, _psb is holding references
|
|
// to us, so we need to break the cycle.
|
|
// _psb may have been freed above. Double check it.
|
|
//
|
|
if (uMsg == WM_DESTROY && _psb)
|
|
{
|
|
_psb->ReleaseShellView();
|
|
_psb->ReleaseShellExplorer();
|
|
ATOMICRELEASET(_psb, CWebBrowserSB);
|
|
}
|
|
}
|
|
if (uMsg >= WM_USER || fDontForward)
|
|
{
|
|
return lres;
|
|
}
|
|
}
|
|
|
|
switch(uMsg)
|
|
{
|
|
/* these are handled by CBaseBrowser only */
|
|
case WM_NOTIFY:
|
|
return lres;
|
|
|
|
case WM_SETCURSOR:
|
|
if (lres) {
|
|
return lres;
|
|
}
|
|
goto DoDefault;
|
|
|
|
DoDefault:
|
|
default:
|
|
return SUPERCLASS::v_WndProc(hwnd, uMsg, wParam, lParam);
|
|
}
|
|
|
|
return 0L;
|
|
}
|
|
|
|
HRESULT CWebBrowserOC::Close(DWORD dwSaveOption)
|
|
{
|
|
if (_psb)
|
|
{
|
|
_psb->_CancelPendingNavigation();
|
|
}
|
|
|
|
if (_pauto)
|
|
{
|
|
IWebBrowserPriv * pWBPriv;
|
|
|
|
HRESULT hr = _pauto->QueryInterface(IID_IWebBrowserPriv, (void**)&pWBPriv);
|
|
if (SUCCEEDED(hr))
|
|
{
|
|
pWBPriv->OnClose();
|
|
pWBPriv->Release();
|
|
}
|
|
}
|
|
|
|
return SUPERCLASS::Close(dwSaveOption);
|
|
}
|
|
|
|
HRESULT CWebBrowserOC::SetHostNames(LPCOLESTR szContainerApp, LPCOLESTR szContainerObj)
|
|
{
|
|
IOOMSG(TEXT("SetHostNames"));
|
|
|
|
// We are not interested in host name
|
|
// ...well ... maybe a little. this turns out to be the best place to
|
|
// do an apphack for VC 5.0. VC 5.0 has a bug where it calls Release()
|
|
// one too many times. the only good way to detect being hosted in the
|
|
// offending container is to check the szContainerApp in SetHostNames!
|
|
// ...chrisfra 8/14/97, bug 30428
|
|
// NOTE: Mike Colee of VC verified their bug and will put a Raid bug in
|
|
// their database including how to signal that a new version works by
|
|
// changing szContainerApp string.
|
|
if (_fTopLevel && szContainerApp && !StrCmpW(szContainerApp, L"DevIV Package"))
|
|
{
|
|
AddRef();
|
|
}
|
|
return SUPERCLASS::SetHostNames(szContainerApp, szContainerObj);
|
|
}
|
|
|
|
HRESULT CWebBrowserOC::DoVerb(
|
|
LONG iVerb,
|
|
LPMSG lpmsg,
|
|
IOleClientSite *pActiveSite,
|
|
LONG lindex,
|
|
HWND hwndParent,
|
|
LPCRECT lprcPosRect)
|
|
{
|
|
IS_INITIALIZED;
|
|
|
|
_pmsgDoVerb = lpmsg;
|
|
|
|
HRESULT hr = SUPERCLASS::DoVerb(iVerb, lpmsg, pActiveSite, lindex, hwndParent, lprcPosRect);
|
|
|
|
_pmsgDoVerb = NULL;
|
|
|
|
return hr;
|
|
}
|
|
|
|
// *** IPersistStreamInit ***
|
|
|
|
// in order to have upgrade and downgrade compatibility in stream formats
|
|
// we can't have any size assumptions in this code. Extra data streamed
|
|
// after our PersistSVOCX structure must be referenced by a dwOffX offset
|
|
// so the downgrade case knows where to start reading from.
|
|
//
|
|
// since we always write out a stream that's downward compatible, we don't
|
|
// need to folow the "source compatible" rule of: reading an old stream
|
|
// with an old CLSID WebBrowser implies that when we save, we need to
|
|
// save using the old stream format.
|
|
//
|
|
typedef struct _PersistSVOCX
|
|
{
|
|
struct _tagIE30 {
|
|
DWORD cbSize;
|
|
SIZE sizeObject; // IE3 saves as PIXELS, IE4 saves as HIMETRIC
|
|
FOLDERSETTINGS fs;
|
|
long lAutoSize; // IE3, no longer used
|
|
DWORD fColorsSet; // IE3, no longer used
|
|
COLORREF clrBack; // IE3, no longer used
|
|
COLORREF clrFore; // IE3, no longer used
|
|
DWORD dwOffPersistLink;
|
|
long lAutoSizePercentage; // IE3, no longer used
|
|
} ie30;
|
|
struct _tagIE40 {
|
|
DWORD dwExtra;
|
|
BOOL bRestoreView;
|
|
SHELLVIEWID vid;
|
|
DWORD fFlags;
|
|
DWORD dwVersion;
|
|
} ie40;
|
|
} PersistSVOCX;
|
|
|
|
//
|
|
// Flags for dwExtra. Having a flag indicate that we have some extra
|
|
// streamed data after this structure + persisted link.
|
|
//
|
|
// NOTE: All data stored this way (instead of storing an offset to
|
|
// the data, such as dwOffPersistLink) will be lost on downgrade
|
|
// cases and cases where we have to emulate old stream formats.
|
|
//
|
|
#define SVO_EXTRA_TOOLBARS 0x00000001
|
|
|
|
// Random flags we need to persist
|
|
#define SVO_FLAGS_OFFLINE 0x00000001
|
|
#define SVO_FLAGS_SILENT 0x00000002
|
|
#define SVO_FLAGS_REGISTERASBROWSER 0x00000004
|
|
#define SVO_FLAGS_REGISTERASDROPTGT 0x00000008
|
|
|
|
#define SVO_VERSION 0 // increment for upgrade changes when size doesn't change
|
|
|
|
HRESULT CWebBrowserOC::Load(IStream *pstm)
|
|
{
|
|
IPSMSG(TEXT("Load"));
|
|
// Load _size
|
|
ULONG cbRead;
|
|
PersistSVOCX sPersist;
|
|
HRESULT hres, hresNavigate = E_FAIL;
|
|
DWORD dwExtra = 0;
|
|
|
|
// It is illegal to call Load or InitNew more than once
|
|
if (_fInit)
|
|
{
|
|
TraceMsg(TF_SHDCONTROL, "shv IPersistStream::Load called when ALREADY INITIALIZED!");
|
|
ASSERT(FALSE);
|
|
return E_FAIL;
|
|
}
|
|
|
|
// we need an IShellLink to read into
|
|
if (_plinkA == NULL)
|
|
{
|
|
hres = CoCreateInstance(CLSID_ShellLink, NULL, CLSCTX_INPROC_SERVER, IID_PPV_ARG(IShellLinkA, &_plinkA));
|
|
if (FAILED(hres))
|
|
return hres;
|
|
}
|
|
|
|
// remember our starting location
|
|
ULARGE_INTEGER liStart;
|
|
//ULARGE_INTEGER liEnd;
|
|
LARGE_INTEGER liMove;
|
|
liMove.LowPart = liMove.HighPart = 0;
|
|
hres = pstm->Seek(liMove, STREAM_SEEK_CUR, &liStart);
|
|
if (FAILED(hres))
|
|
{
|
|
return hres;
|
|
}
|
|
|
|
// Zero initialize our struct
|
|
ZeroMemory(&sPersist, SIZEOF(sPersist));
|
|
|
|
hres = pstm->Read(&sPersist, SIZEOF(DWORD), &cbRead);
|
|
if (SUCCEEDED(hres))
|
|
{
|
|
// Validate the data
|
|
if (cbRead != SIZEOF(DWORD) ||
|
|
sPersist.ie30.cbSize < SIZEOF(sPersist.ie30))
|
|
{
|
|
TraceMsg(DM_ERROR, "Someone is asking us to read the wrong thing.");
|
|
hres = E_FAIL;
|
|
}
|
|
else
|
|
{
|
|
DWORD cbSizeToRead = sPersist.ie30.cbSize;
|
|
if (cbSizeToRead > SIZEOF(sPersist))
|
|
{
|
|
// must be a newer struct, only read what we know (ie, don't trash the stack!)
|
|
cbSizeToRead = SIZEOF(sPersist);
|
|
}
|
|
cbSizeToRead -= SIZEOF(DWORD); // remove what we've already read
|
|
hres = pstm->Read(&sPersist.ie30.sizeObject, cbSizeToRead, &cbRead);
|
|
if (SUCCEEDED(hres))
|
|
{
|
|
if (cbRead != cbSizeToRead)
|
|
{
|
|
hres = E_FAIL;
|
|
}
|
|
else
|
|
{
|
|
// read ie30 data
|
|
//
|
|
if (EVAL(sPersist.ie30.cbSize >= SIZEOF(sPersist.ie30)))
|
|
{
|
|
_size = sPersist.ie30.sizeObject;
|
|
_fs = sPersist.ie30.fs;
|
|
|
|
// IE3 saved size in pixels IE4 saves size in HIM already
|
|
//
|
|
_sizeHIM = _size;
|
|
if (sPersist.ie30.cbSize == SIZEOF(sPersist.ie30) ||
|
|
sPersist.ie30.cbSize == SIZEOF(sPersist) - SIZEOF(sPersist.ie40.dwVersion)) // handle upgrade
|
|
{
|
|
// Size is in pixels. Adjust _sizeHIM to Hi Metric.
|
|
PixelsToMetric(&_sizeHIM);
|
|
}
|
|
else
|
|
{
|
|
// Size is in Hi Metric. Adjust _size to Pixels.
|
|
MetricToPixels(&_size);
|
|
}
|
|
|
|
if (_psb) // if no _psb then container ignored OLEMISC_SETCLIENTSITEFIRST
|
|
_psb->_fldBase._fld._fs = _fs;
|
|
|
|
// Load _plinkA
|
|
IPersistStream* ppstm;
|
|
hres = _plinkA->QueryInterface(IID_PPV_ARG(IPersistStream, &ppstm));
|
|
if (SUCCEEDED(hres))
|
|
{
|
|
ASSERT(sPersist.ie30.dwOffPersistLink >= sPersist.ie30.cbSize);
|
|
liMove.LowPart = liStart.LowPart + sPersist.ie30.dwOffPersistLink;
|
|
|
|
hres = pstm->Seek(liMove, STREAM_SEEK_SET, NULL);
|
|
if (SUCCEEDED(hres))
|
|
{
|
|
hres = ppstm->Load(pstm);
|
|
if (SUCCEEDED(hres))
|
|
{
|
|
// We always save link info last,
|
|
// so remember where we are in the stream.
|
|
// Since we don't have more dwOff variables
|
|
// currently, don't bother remebering this...
|
|
//hres = pstm->Seek(liMove, STREAM_SEEK_CUR, &liEnd);
|
|
//if (SUCCEEDED(hres))
|
|
_fInit = TRUE;
|
|
|
|
// in case the target moved invoke link tracking (ignore errors)
|
|
_plinkA->Resolve(_hwnd, SLR_NO_UI);
|
|
|
|
// If we already have the client site,
|
|
// navigate now. Otherwise, navigate
|
|
// when the client site is set.
|
|
if (_pcli)
|
|
{
|
|
LPITEMIDLIST pidl;
|
|
if (SUCCEEDED(_plinkA->GetIDList(&pidl)) && pidl)
|
|
{
|
|
ASSERT(FALSE == _psb->_fAsyncNavigate);
|
|
_psb->_fAsyncNavigate = TRUE;
|
|
hresNavigate = _BrowseObject(pidl);
|
|
_psb->_fAsyncNavigate = FALSE;
|
|
ILFree(pidl);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
_fNavigateOnSetClientSite = TRUE;
|
|
}
|
|
}
|
|
}
|
|
|
|
ppstm->Release();
|
|
}
|
|
} // read ie30 data
|
|
|
|
|
|
// temp upgrade hack for older struct
|
|
if (sPersist.ie30.cbSize == SIZEOF(sPersist) - SIZEOF(sPersist.ie40.dwVersion))
|
|
{
|
|
// dwVersion field is already correct, update cbSize
|
|
// to pass below size check
|
|
sPersist.ie30.cbSize = SIZEOF(sPersist);
|
|
}
|
|
|
|
// read ie40 data
|
|
if (SUCCEEDED(hres) &&
|
|
sPersist.ie30.cbSize >= SIZEOF(sPersist))
|
|
{
|
|
if (_psb) // if no _psb then container ignored OLEMISC_SETCLIENTSITEFIRST
|
|
{
|
|
if (sPersist.ie40.bRestoreView)
|
|
{
|
|
_psb->_fldBase._fld._vidRestore = sPersist.ie40.vid;
|
|
// since we read the ie40 data, this is a cache hit
|
|
_psb->_fldBase._fld._dwViewPriority = VIEW_PRIORITY_CACHEHIT;
|
|
}
|
|
}
|
|
|
|
// We let ambients take precedence over what we have persisted
|
|
VARIANT_BOOL fAmbient;
|
|
if (SUPERCLASS::_GetAmbientProperty(DISPID_AMBIENT_OFFLINEIFNOTCONNECTED, VT_BOOL, &fAmbient))
|
|
{
|
|
put_Offline(fAmbient);
|
|
}
|
|
else
|
|
{
|
|
put_Offline((sPersist.ie40.fFlags & SVO_FLAGS_OFFLINE) ? -1 : FALSE);
|
|
}
|
|
if (SUPERCLASS::_GetAmbientProperty(DISPID_AMBIENT_SILENT, VT_BOOL, &fAmbient))
|
|
{
|
|
put_Silent(fAmbient);
|
|
}
|
|
else
|
|
{
|
|
put_Silent((sPersist.ie40.fFlags & SVO_FLAGS_SILENT) ? -1 : FALSE);
|
|
}
|
|
|
|
|
|
put_RegisterAsDropTarget(BOOL_TO_VARIANTBOOL(sPersist.ie40.fFlags & SVO_FLAGS_REGISTERASDROPTGT));
|
|
|
|
_fShouldRegisterAsBrowser = (sPersist.ie40.fFlags & SVO_FLAGS_REGISTERASBROWSER) ? TRUE : FALSE;
|
|
|
|
// remember this for later
|
|
dwExtra = sPersist.ie40.dwExtra;
|
|
}
|
|
else
|
|
{
|
|
// if CLSID_WebBrowser_V1 reads an old stream format,
|
|
// it means that we must write out an old stream format later
|
|
// remember this...
|
|
if (_pObjectInfo->lVersion == VERSION_1)
|
|
{
|
|
_fEmulateOldStream = TRUE;
|
|
}
|
|
} // read ie40 data
|
|
}
|
|
|
|
// if we read all the data then make sure we're at
|
|
// the end of the stream
|
|
if (SUCCEEDED(hres) && _fInit)
|
|
{
|
|
//liMove.LowPart = liEnd.LowPart;
|
|
//hres = pstm->Seek(liMove, STREAM_SEEK_SET, NULL);
|
|
|
|
// now we can read in extra streamed data if we have it
|
|
if (dwExtra & SVO_EXTRA_TOOLBARS)
|
|
{
|
|
DWORD dwTotal;
|
|
hres = pstm->Read(&dwTotal, SIZEOF(dwTotal), NULL);
|
|
if (SUCCEEDED(hres))
|
|
{
|
|
ASSERT(dwTotal >= SIZEOF(dwTotal));
|
|
dwTotal -= SIZEOF(dwTotal);
|
|
|
|
if (_hmemSB)
|
|
{
|
|
GlobalFree(_hmemSB);
|
|
}
|
|
|
|
_hmemSB = GlobalAlloc(GPTR, dwTotal);
|
|
if (_hmemSB)
|
|
{
|
|
hres = pstm->Read((BYTE*)_hmemSB, dwTotal, NULL);
|
|
}
|
|
else
|
|
{
|
|
hres = E_OUTOFMEMORY;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
_OnLoaded(FAILED(hresNavigate));
|
|
|
|
if (SUCCEEDED(hres))
|
|
hres = S_OK; // convert S_FALSE to S_OK
|
|
|
|
return hres;
|
|
}
|
|
|
|
HRESULT CWebBrowserOC_SavePersistData(IStream *pstm, SIZE* psizeObj,
|
|
FOLDERSETTINGS* pfs, IShellLinkA* plinkA, SHELLVIEWID* pvid,
|
|
BOOL fOffline, BOOL fSilent, BOOL fRegisterAsBrowser, BOOL fRegisterAsDropTarget,
|
|
BOOL fEmulateOldStream, DWORD *pdwExtra)
|
|
{
|
|
ULONG cbWritten;
|
|
PersistSVOCX sPersist;
|
|
HRESULT hres;
|
|
|
|
// This means that this instance of CWebBrowserOC was created using
|
|
// the ie30 CLSID and we were persisted from an old format stream.
|
|
// Under this scenario, we have to write out a stream format that
|
|
// can be read by the old ie30 object.
|
|
if (fEmulateOldStream && pdwExtra)
|
|
{
|
|
// The only data we stream out that can't be read back in by
|
|
// the old ie30 webbrowser is the dwExtra data.
|
|
*pdwExtra = 0;
|
|
}
|
|
|
|
|
|
ZeroMemory(&sPersist, SIZEOF(sPersist));
|
|
|
|
sPersist.ie30.cbSize = fEmulateOldStream ? SIZEOF(sPersist.ie30) : SIZEOF(sPersist);
|
|
sPersist.ie30.sizeObject = *psizeObj;
|
|
sPersist.ie30.fs = *pfs;
|
|
sPersist.ie30.dwOffPersistLink = SIZEOF(sPersist);
|
|
if (pvid)
|
|
{
|
|
sPersist.ie40.bRestoreView = TRUE;
|
|
sPersist.ie40.vid = *pvid;
|
|
}
|
|
sPersist.ie40.dwExtra = pdwExtra ? *pdwExtra : 0;
|
|
if (fOffline)
|
|
sPersist.ie40.fFlags |= SVO_FLAGS_OFFLINE;
|
|
if (fSilent)
|
|
sPersist.ie40.fFlags |= SVO_FLAGS_SILENT;
|
|
if (fRegisterAsBrowser)
|
|
sPersist.ie40.fFlags |= SVO_FLAGS_REGISTERASBROWSER;
|
|
if (fRegisterAsDropTarget)
|
|
sPersist.ie40.fFlags |= SVO_FLAGS_REGISTERASDROPTGT;
|
|
sPersist.ie40.dwVersion = SVO_VERSION;
|
|
|
|
hres = pstm->Write(&sPersist, SIZEOF(sPersist), &cbWritten);
|
|
IPSMSG3(TEXT("Save 1st Write(&_size) returned"), hres, cbWritten, sizeof(*psizeObj));
|
|
if (SUCCEEDED(hres))
|
|
{
|
|
// Save plinkA
|
|
ASSERT(plinkA);
|
|
IPersistStream* ppstm;
|
|
hres = plinkA->QueryInterface(IID_PPV_ARG(IPersistStream, &ppstm));
|
|
if (SUCCEEDED(hres))
|
|
{
|
|
hres = ppstm->Save(pstm, TRUE);
|
|
IPSMSG2(TEXT("Save plink->Save() returned"), hres);
|
|
|
|
ppstm->Release();
|
|
}
|
|
}
|
|
|
|
return hres;
|
|
}
|
|
|
|
BOOL CWebBrowserOC::_GetViewInfo(SHELLVIEWID* pvid)
|
|
{
|
|
BOOL bGotView = FALSE;
|
|
|
|
if (_psb)
|
|
{
|
|
if (_psb->GetShellView())
|
|
{
|
|
_psb->GetShellView()->GetCurrentInfo(&_fs);
|
|
}
|
|
else
|
|
{
|
|
_fs = _psb->_fldBase._fld._fs;
|
|
}
|
|
bGotView = FileCabinet_GetDefaultViewID2(&_psb->_fldBase, pvid);
|
|
}
|
|
|
|
return bGotView;
|
|
}
|
|
|
|
HRESULT CWebBrowserOC::Save(IStream *pstm, BOOL fClearDirty)
|
|
{
|
|
HRESULT hres;
|
|
LPITEMIDLIST pidl;
|
|
SHELLVIEWID vid;
|
|
BOOL bGotView;
|
|
VARIANT_BOOL fOffline, fSilent, fRegDT;
|
|
|
|
IPSMSG(TEXT("Save"));
|
|
IS_INITIALIZED;
|
|
|
|
pidl = NULL;
|
|
if (_psb)
|
|
pidl = _psb->_bbd._pidlCur;
|
|
|
|
// we need an IShellLink to save with
|
|
if (_plinkA == NULL)
|
|
{
|
|
hres = CoCreateInstance(CLSID_ShellLink, NULL, CLSCTX_INPROC_SERVER, IID_PPV_ARG(IShellLinkA, &_plinkA));
|
|
if (FAILED(hres))
|
|
return hres;
|
|
}
|
|
_plinkA->SetIDList(pidl);
|
|
|
|
bGotView = _GetViewInfo(&vid);
|
|
|
|
DWORD dwExtra = 0;
|
|
#if 0
|
|
if (_psb && _psb->_SaveToolbars(NULL)==S_OK) {
|
|
dwExtra |= SVO_EXTRA_TOOLBARS;
|
|
}
|
|
#endif
|
|
|
|
get_Offline(&fOffline);
|
|
get_Silent(&fSilent);
|
|
get_RegisterAsDropTarget(&fRegDT);
|
|
|
|
hres = CWebBrowserOC_SavePersistData(pstm, _fEmulateOldStream ? &_size : &_sizeHIM, &_fs, _plinkA,
|
|
(bGotView ? &vid : NULL),
|
|
fOffline, fSilent, _fShouldRegisterAsBrowser, fRegDT,
|
|
_fEmulateOldStream, &dwExtra);
|
|
|
|
ASSERT(!(dwExtra & SVO_EXTRA_TOOLBARS));
|
|
#if 0
|
|
if (SUCCEEDED(hres) && (dwExtra & SVO_EXTRA_TOOLBARS))
|
|
{
|
|
// Remember the current location.
|
|
ULARGE_INTEGER liStart;
|
|
pstm->Seek(c_li0, STREAM_SEEK_CUR, &liStart);
|
|
|
|
// Write the dummy size.
|
|
DWORD dwTotal = 0;
|
|
hres = pstm->Write(&dwTotal, SIZEOF(dwTotal), NULL);
|
|
if (SUCCEEDED(hres)) {
|
|
if (_psb)
|
|
hres = _psb->_SaveToolbars(pstm);
|
|
|
|
// Remember the end
|
|
ULARGE_INTEGER liEnd;
|
|
pstm->Seek(c_li0, STREAM_SEEK_CUR, &liEnd);
|
|
|
|
// Seek back to the original location
|
|
LARGE_INTEGER liT;
|
|
liT.HighPart = 0;
|
|
liT.LowPart = liStart.LowPart;
|
|
pstm->Seek(liT, STREAM_SEEK_SET, NULL);
|
|
|
|
// Get the real dwTotal and write it
|
|
dwTotal = liEnd.LowPart - liStart.LowPart;
|
|
hres = pstm->Write(&dwTotal, SIZEOF(dwTotal), NULL);
|
|
|
|
// Seek forward to the end
|
|
liT.LowPart = liEnd.LowPart;
|
|
pstm->Seek(liT, STREAM_SEEK_SET, NULL);
|
|
}
|
|
}
|
|
#endif
|
|
|
|
if (fClearDirty)
|
|
{
|
|
_fDirty = FALSE;
|
|
}
|
|
|
|
return hres;
|
|
}
|
|
|
|
void CWebBrowserOC::_OnLoaded(BOOL fUpdateBrowserReadyState)
|
|
{
|
|
IEFrameAuto * piefa;
|
|
if (SUCCEEDED(_pauto->QueryInterface(IID_PPV_ARG(IEFrameAuto, &piefa))))
|
|
{
|
|
piefa->put_DefaultReadyState(READYSTATE_COMPLETE, fUpdateBrowserReadyState);
|
|
piefa->Release();
|
|
}
|
|
}
|
|
|
|
HRESULT CWebBrowserOC::InitNew(void)
|
|
{
|
|
IPSMSG(TEXT("InitNew"));
|
|
|
|
_InitDefault();
|
|
|
|
// On the InitNew case, we do want to update the browser's ready state
|
|
_OnLoaded(TRUE);
|
|
|
|
return NOERROR;
|
|
}
|
|
|
|
// IPersistPropertyBag
|
|
|
|
static const struct {
|
|
LPOLESTR pName;
|
|
UINT flag;
|
|
} g_boolprops[] = {
|
|
{L"AutoArrange", FWF_AUTOARRANGE},
|
|
{L"NoClientEdge", FWF_NOCLIENTEDGE},
|
|
{L"AlignLeft", FWF_ALIGNLEFT},
|
|
{L"NoWebView", FWF_NOWEBVIEW},
|
|
{L"HideFileNames", FWF_HIDEFILENAMES},
|
|
{L"SingleClick", FWF_SINGLECLICKACTIVATE},
|
|
{L"SingleSelection", FWF_SINGLESEL},
|
|
{L"NoFolders", FWF_NOSUBFOLDERS},
|
|
{L"Transparent", FWF_TRANSPARENT},
|
|
};
|
|
|
|
HRESULT CWebBrowserOC::Load(IPropertyBag *pBag, IErrorLog *pErrorLog)
|
|
{
|
|
BOOL fOffline = FALSE;
|
|
BOOL fSilent = FALSE;
|
|
BOOL fRegisterAsBrowser = FALSE;
|
|
BOOL fRegisterAsDropTgt = FALSE;
|
|
BOOL fUpdateBrowserReadyState = TRUE;
|
|
VARIANT_BOOL fAmbient;
|
|
|
|
// It is illegal to call ::Load or ::InitNew more than once
|
|
if (_fInit)
|
|
{
|
|
TraceMsg(TF_SHDCONTROL, "shv IPersistPropertyBag::Load called when ALREADY INITIALIZED!");
|
|
ASSERT(FALSE);
|
|
return E_FAIL;
|
|
}
|
|
|
|
_InitDefault();
|
|
|
|
// grab all our DWORD-sized (VT_UI4) properties
|
|
struct {
|
|
LPOLESTR pName;
|
|
DWORD* pdw;
|
|
} rgLoadProps[] = {
|
|
{L"Height", (DWORD *)&_size.cy},
|
|
{L"Width", (DWORD *)&_size.cx},
|
|
{L"ViewMode", (DWORD *)&_fs.ViewMode},
|
|
{L"Offline", (DWORD *)&fOffline},
|
|
{L"Silent", (DWORD *)&fSilent},
|
|
{L"RegisterAsBrowser", (DWORD *)&fRegisterAsBrowser},
|
|
{L"RegisterAsDropTarget", (DWORD *)&fRegisterAsDropTgt}
|
|
};
|
|
|
|
for (int i = 0; i < ARRAYSIZE(rgLoadProps); i++)
|
|
{
|
|
SHPropertyBag_ReadDWORD(pBag, rgLoadProps[i].pName, rgLoadProps[i].pdw);
|
|
}
|
|
|
|
// We let ambients take precedence over what we have persisted
|
|
if (SUPERCLASS::_GetAmbientProperty(DISPID_AMBIENT_OFFLINEIFNOTCONNECTED, VT_BOOL, &fAmbient))
|
|
{
|
|
put_Offline(fAmbient);
|
|
}
|
|
else
|
|
{
|
|
put_Offline(BOOL_TO_VARIANTBOOL(fOffline));
|
|
}
|
|
|
|
if (SUPERCLASS::_GetAmbientProperty(DISPID_AMBIENT_SILENT, VT_BOOL, &fAmbient))
|
|
{
|
|
put_Silent(fAmbient);
|
|
}
|
|
else
|
|
{
|
|
put_Silent(BOOL_TO_VARIANTBOOL(fSilent));
|
|
}
|
|
|
|
// If You use fOffline or fSilent after this, you will have to re-init them according
|
|
// to the returned values of fAmbient in the if statements above
|
|
|
|
put_RegisterAsDropTarget(BOOL_TO_VARIANTBOOL(fRegisterAsDropTgt));
|
|
|
|
_fShouldRegisterAsBrowser = VARIANTBOOL_TO_BOOL(fRegisterAsBrowser);
|
|
|
|
// IE3 saved PIXEL size, IE4 saves HIMETRIC size
|
|
DWORD lVal;
|
|
HRESULT hr = SHPropertyBag_ReadDWORD(pBag, L"ExtentX", &lVal);
|
|
if (SUCCEEDED(hr))
|
|
{
|
|
_sizeHIM.cx = lVal;
|
|
hr = SHPropertyBag_ReadDWORD(pBag, L"ExtentY", &lVal);
|
|
if (SUCCEEDED(hr))
|
|
{
|
|
_sizeHIM.cy = lVal;
|
|
}
|
|
}
|
|
|
|
if (FAILED(hr))
|
|
{
|
|
// convert IE3 info to HIMETRIC
|
|
_sizeHIM = _size;
|
|
PixelsToMetric(&_sizeHIM);
|
|
}
|
|
|
|
hr = S_OK;
|
|
|
|
for (i = 0; i < ARRAYSIZE(g_boolprops); i++)
|
|
{
|
|
if (SHPropertyBag_ReadBOOLDefRet(pBag, g_boolprops[i].pName, FALSE))
|
|
_fs.fFlags |= g_boolprops[i].flag;
|
|
else
|
|
_fs.fFlags &= ~g_boolprops[i].flag;
|
|
}
|
|
|
|
// grab special properties
|
|
|
|
if (_psb) // if no _psb then container ignored OLEMISC_SETCLIENTSITEFIRST
|
|
{
|
|
if (SUCCEEDED(SHPropertyBag_ReadGUID(pBag, L"ViewID", &_psb->_fldBase._fld._vidRestore)))
|
|
{
|
|
// we sucessfully read the ViewID, so this is a cache hit
|
|
_psb->_fldBase._fld._dwViewPriority = VIEW_PRIORITY_CACHEHIT;
|
|
}
|
|
|
|
_psb->_fldBase._fld._fs = _fs;
|
|
|
|
BSTR bstrVal;
|
|
if (SUCCEEDED(SHPropertyBag_ReadBSTR(pBag, L"Location", &bstrVal)))
|
|
{
|
|
ASSERT(FALSE == _psb->_fAsyncNavigate);
|
|
|
|
hr = WrapSpecialUrl(&bstrVal);
|
|
if (SUCCEEDED(hr))
|
|
{
|
|
_psb->_fAsyncNavigate = TRUE;
|
|
|
|
if (FAILED(Navigate(bstrVal, NULL, NULL, NULL, NULL)))
|
|
{
|
|
TraceMsg(TF_SHDCONTROL, "Load PropertyBag Navigate FAILED!");
|
|
}
|
|
else
|
|
{
|
|
// Navigate is successful (at least initially), let it update ReadyState
|
|
//
|
|
fUpdateBrowserReadyState = FALSE;
|
|
}
|
|
_psb->_fAsyncNavigate = FALSE;
|
|
}
|
|
SysFreeString(bstrVal);
|
|
}
|
|
}
|
|
|
|
_OnLoaded(fUpdateBrowserReadyState);
|
|
|
|
return hr;
|
|
}
|
|
HRESULT CWebBrowserOC::Save(IPropertyBag *pBag, BOOL fClearDirty, BOOL fSaveAllProperties)
|
|
{
|
|
IS_INITIALIZED;
|
|
|
|
HRESULT hres;
|
|
VARIANT var;
|
|
int i;
|
|
SHELLVIEWID vid;
|
|
BOOL bGotView = FALSE;
|
|
|
|
VARIANT_BOOL f;
|
|
BOOL fOffline;
|
|
BOOL fSilent;
|
|
BOOL fRegisterAsDropTgt;
|
|
BOOL fRegisterAsBrowser;
|
|
|
|
get_Offline(&f);
|
|
fOffline = f ? TRUE : FALSE;
|
|
get_Silent(&f);
|
|
fSilent = f ? TRUE : FALSE;
|
|
get_RegisterAsDropTarget(&f);
|
|
fRegisterAsDropTgt = f ? TRUE : FALSE;
|
|
fRegisterAsBrowser = _fShouldRegisterAsBrowser ? TRUE : FALSE;
|
|
|
|
// our state may have changed
|
|
bGotView = _GetViewInfo(&vid);
|
|
|
|
// save all our DWORD-sized properties
|
|
struct {
|
|
LPOLESTR pName;
|
|
DWORD* pdw;
|
|
} rgLoadProps[] = {
|
|
{L"ExtentX", (DWORD *)&_sizeHIM.cx},
|
|
{L"ExtentY", (DWORD *)&_sizeHIM.cy},
|
|
{L"ViewMode", (DWORD *)&_fs.ViewMode},
|
|
{L"Offline", (DWORD *)&fOffline},
|
|
{L"Silent", (DWORD *)&fSilent},
|
|
{L"RegisterAsBrowser", (DWORD *)&fRegisterAsBrowser},
|
|
{L"RegisterAsDropTarget", (DWORD *)&fRegisterAsDropTgt},
|
|
|
|
// IE3 OC stuff here
|
|
{L"Height", (DWORD *)&_size.cy},
|
|
{L"Width", (DWORD *)&_size.cx}
|
|
};
|
|
VariantInit(&var);
|
|
var.vt = VT_I4; // VB doesn't understand VT_UI4! (pBag->Write succeeds,
|
|
// but it doesn't write anything! The load then fails!)
|
|
int nCount = ARRAYSIZE(rgLoadProps);
|
|
if (_pObjectInfo->lVersion != VERSION_1)
|
|
nCount -= 2;
|
|
|
|
for (i = 0; i < nCount; i++)
|
|
{
|
|
var.lVal = *rgLoadProps[i].pdw;
|
|
hres = pBag->Write(rgLoadProps[i].pName, &var);
|
|
if (FAILED(hres))
|
|
{
|
|
TraceMsg(TF_SHDCONTROL, "Save PropertyBag could not save %ws for DWORD", rgLoadProps[i].pName);
|
|
return hres;
|
|
}
|
|
}
|
|
|
|
// save all our _fs.fFlags (VT_BOOL) flags
|
|
var.vt = VT_BOOL;
|
|
for (i = 0; i < ARRAYSIZE(g_boolprops); i++)
|
|
{
|
|
var.boolVal = BOOL_TO_VARIANTBOOL(_fs.fFlags & g_boolprops[i].flag);
|
|
hres = pBag->Write(g_boolprops[i].pName, &var);
|
|
if (FAILED(hres))
|
|
{
|
|
TraceMsg(TF_SHDCONTROL, "Load PropertyBag did not save %ws for BOOL", g_boolprops[i].pName);
|
|
}
|
|
}
|
|
|
|
// save special properties
|
|
|
|
if (bGotView)
|
|
{
|
|
SHPropertyBag_WriteGUID(pBag, L"ViewID", &(GUID)vid);
|
|
}
|
|
|
|
var.vt = VT_BSTR;
|
|
if (SUCCEEDED(get_LocationURL(&var.bstrVal)))
|
|
{
|
|
hres = pBag->Write(L"Location", &var);
|
|
|
|
VariantClear(&var);
|
|
|
|
if (FAILED(hres))
|
|
{
|
|
TraceMsg(TF_SHDCONTROL, "Save PropertyBag could not save Location");
|
|
return hres;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
var.vt = VT_EMPTY;
|
|
TraceMsg(TF_SHDCONTROL, "Save PropertyBag get_Location FAILED!");
|
|
}
|
|
|
|
return NOERROR;
|
|
}
|
|
|
|
|
|
// IPersistString
|
|
|
|
STDMETHODIMP CWebBrowserOC::Initialize(LPCWSTR pwszInit)
|
|
{
|
|
HRESULT hr = E_OUTOFMEMORY;
|
|
BSTR bstr = SysAllocString(pwszInit);
|
|
if (bstr)
|
|
{
|
|
hr = Navigate(bstr, NULL, NULL, NULL, NULL);
|
|
SysFreeString(bstr);
|
|
}
|
|
return hr;
|
|
}
|
|
|
|
|
|
#define THISCLASS CWebBrowserOC
|
|
HRESULT CWebBrowserOC::v_InternalQueryInterface(REFIID riid, void ** ppvObj)
|
|
{
|
|
static const QITAB qit[] = {
|
|
QITABENT(THISCLASS, IWebBrowser2),
|
|
QITABENTMULTI(THISCLASS, IDispatch, IWebBrowser2), // VBA QI's IDispatch and assumes it gets the "default" automation interface, which is IWebBrowser2
|
|
QITABENTMULTI(THISCLASS, IWebBrowser, IWebBrowser2),
|
|
QITABENTMULTI(THISCLASS, IWebBrowserApp, IWebBrowser2),
|
|
QITABENT(THISCLASS, IPersistString),
|
|
QITABENT(THISCLASS, IOleCommandTarget),
|
|
QITABENT(THISCLASS, IObjectSafety),
|
|
QITABENT(THISCLASS, ITargetEmbedding),
|
|
QITABENT(THISCLASS, IExpDispSupport),
|
|
QITABENT(THISCLASS, IExpDispSupportOC),
|
|
QITABENT(THISCLASS, IPersistHistory),
|
|
QITABENT(THISCLASS, IPersistStorage),
|
|
{ 0 },
|
|
};
|
|
HRESULT hres = QISearch(this, qit, riid, ppvObj);
|
|
if (FAILED(hres))
|
|
{
|
|
hres = SUPERCLASS::v_InternalQueryInterface(riid, ppvObj);
|
|
|
|
// we want to expose our aggregated CIEFrameAuto's interfaces
|
|
// in addition to ours.
|
|
if (FAILED(hres))
|
|
{
|
|
hres = _pauto->QueryInterface(riid, ppvObj);
|
|
}
|
|
}
|
|
|
|
return hres;
|
|
}
|
|
|
|
// *** IOleInPlaceActiveObject ***
|
|
HRESULT CWebBrowserOC::OnFrameWindowActivate(BOOL fActivate)
|
|
{
|
|
if (_psb)
|
|
_psb->OnFrameWindowActivateBS(fActivate);
|
|
|
|
return S_OK;
|
|
}
|
|
|
|
HRESULT CWebBrowserOC::TranslateAccelerator(LPMSG lpMsg)
|
|
{
|
|
if (_psb)
|
|
{
|
|
// FEATURE REVIEW: what wID should we really pass? Is 0 ok?
|
|
if (S_OK == _psb->_TranslateAccelerator(lpMsg, 0, DIRECTION_FORWARD_TO_CHILD))
|
|
return S_OK;
|
|
}
|
|
else
|
|
{
|
|
IOIPAMSG(TEXT("TranslateAccelerator cannot forward to _psb"));
|
|
}
|
|
|
|
// SUPERCLASS has no accelerators
|
|
return S_FALSE;
|
|
}
|
|
|
|
HRESULT CWebBrowserOC::EnableModeless(BOOL fEnable)
|
|
{
|
|
SUPERCLASS::EnableModeless(fEnable);
|
|
if (_psb)
|
|
{
|
|
return _psb->_EnableModeless(fEnable, DIRECTION_FORWARD_TO_CHILD);
|
|
}
|
|
else
|
|
{
|
|
IOIPAMSG(TEXT("EnableModeless cannot forward to _psb"));
|
|
return S_OK;
|
|
}
|
|
}
|
|
|
|
|
|
HRESULT CWebBrowserOC::_OnActivateChange(IOleClientSite* pActiveSite, UINT uState)
|
|
{
|
|
HRESULT hres = SUPERCLASS::_OnActivateChange(pActiveSite, uState);
|
|
|
|
if (SUCCEEDED(hres))
|
|
{
|
|
UINT uViewState;
|
|
|
|
switch (uState)
|
|
{
|
|
case OC_DEACTIVE: uViewState = SVUIA_DEACTIVATE; break;
|
|
case OC_INPLACEACTIVE: uViewState = SVUIA_INPLACEACTIVATE; break;
|
|
case OC_UIACTIVE: uViewState = SVUIA_ACTIVATE_FOCUS; break;
|
|
default: ASSERT(FALSE); return E_INVALIDARG;
|
|
}
|
|
|
|
if (_psb)
|
|
_psb->_UIActivateView(uViewState);
|
|
}
|
|
else
|
|
{
|
|
TraceMsg(TF_SHDCONTROL, "shv _OnActivateChange failed, _psb=0x%x", _psb);
|
|
}
|
|
|
|
return hres;
|
|
}
|
|
|
|
void CWebBrowserOC::_OnInPlaceActivate(void)
|
|
{
|
|
HWND hwnd = NULL;
|
|
|
|
SUPERCLASS::_OnInPlaceActivate();
|
|
|
|
_RegisterWindow();
|
|
|
|
if (_pipsite)
|
|
{
|
|
|
|
// we have to hold on to the target frame until we deactivate,
|
|
// because the psbFrame will delete this thing when it shuts down
|
|
// *before* we are actually deactivated, leaking the unadvise
|
|
// in ieframeauto.
|
|
ASSERT(NULL==_pTargetFramePriv);
|
|
if (SUCCEEDED(IUnknown_QueryService(_pipsite, IID_ITargetFrame2, IID_PPV_ARG(ITargetFramePriv, &_pTargetFramePriv))))
|
|
{
|
|
_pTargetFramePriv->OnChildFrameActivate(SAFECAST(this, IConnectionPointContainer* ));
|
|
}
|
|
|
|
ASSERT(NULL==_pctContainer);
|
|
if (FAILED(_pipsite->QueryInterface(IID_PPV_ARG(IOleCommandTarget, &_pctContainer))))
|
|
{
|
|
// NT 305187 discover.exe crash on exit when _pcli is NULL
|
|
if (_pcli)
|
|
{
|
|
// APPCOMPAT: It should be on IOleInPlaceSite,
|
|
// but MSHTML currently has it on IOleContainer.
|
|
IOleContainer *pCont;
|
|
if (SUCCEEDED(_pcli->GetContainer(&pCont)))
|
|
{
|
|
pCont->QueryInterface(IID_PPV_ARG(IOleCommandTarget, &_pctContainer));
|
|
pCont->Release();
|
|
}
|
|
}
|
|
}
|
|
|
|
if (_pipframe && SUCCEEDED(_pipframe->GetWindow(&hwnd)))
|
|
{
|
|
// Check to see if our inplace frame is VB5. If so, we have to hack around
|
|
// _pipframe->EnableModeless calls
|
|
//
|
|
const TCHAR VBM_THUNDER[] = TEXT("Thunder");
|
|
TCHAR strBuf[VB_CLASSNAME_LENGTH];
|
|
|
|
// Check to see if the inplace frame we just called is VB5's forms engine.
|
|
//
|
|
memset(strBuf, 0, ARRAYSIZE(strBuf)); // Clear the buffer
|
|
GetClassName(hwnd, strBuf, (VB_CLASSNAME_LENGTH - 1)); // Get the class name of the window.
|
|
if (StrCmpN(strBuf, VBM_THUNDER, (sizeof(VBM_THUNDER)/sizeof(TCHAR))-1) == 0) // Is the first part "Thunder"?
|
|
{
|
|
_fHostedInVB5 = TRUE;
|
|
}
|
|
}
|
|
|
|
{
|
|
//
|
|
// App compat: Check for imagineer technical
|
|
//
|
|
|
|
const WCHAR STR_IMAGINEER[] = L"imagine.exe";
|
|
WCHAR szBuff[MAX_PATH];
|
|
|
|
if (GetModuleFileName(NULL, szBuff, ARRAYSIZE(szBuff)))
|
|
{
|
|
LPWSTR pszFile = PathFindFileName(szBuff);
|
|
|
|
if (pszFile)
|
|
{
|
|
_fHostedInImagineer = (0 == StrNCmpI(pszFile, STR_IMAGINEER,
|
|
ARRAYSIZE(STR_IMAGINEER) - 1));
|
|
}
|
|
}
|
|
}
|
|
}
|
|
else
|
|
{
|
|
IOIPAMSG(TEXT("_OnInPlaceActivate doesn't have pipsite!"));
|
|
}
|
|
}
|
|
|
|
void CWebBrowserOC::_OnInPlaceDeactivate(void)
|
|
{
|
|
_UnregisterWindow();
|
|
|
|
if (_pTargetFramePriv)
|
|
{
|
|
_pTargetFramePriv->OnChildFrameDeactivate(SAFECAST(this, IConnectionPointContainer*));
|
|
ATOMICRELEASE(_pTargetFramePriv);
|
|
}
|
|
|
|
ATOMICRELEASE(_pctContainer);
|
|
|
|
SUPERCLASS::_OnInPlaceDeactivate();
|
|
}
|
|
|
|
|
|
/*
|
|
** Ambient properties we care about
|
|
*/
|
|
|
|
// We forward IOleControl calls to the docobj.
|
|
// This helper function returns the docobj's IOleControl interface.
|
|
//
|
|
// NOTE: we may want to fail this when the WebBrowserOC was created
|
|
// using IE3's classid just to be safe...
|
|
//
|
|
IOleControl* GetForwardingIOC(IWebBrowser* pwb)
|
|
{
|
|
IOleControl* poc = NULL;
|
|
IDispatch* pdisp;
|
|
|
|
if (SUCCEEDED(pwb->get_Document(&pdisp)))
|
|
{
|
|
pdisp->QueryInterface(IID_PPV_ARG(IOleControl, &poc));
|
|
|
|
pdisp->Release();
|
|
}
|
|
|
|
return poc;
|
|
}
|
|
STDMETHODIMP CWebBrowserOC::GetControlInfo(LPCONTROLINFO pCI)
|
|
{
|
|
HRESULT hres = E_NOTIMPL;
|
|
|
|
// REVIEW: What if we return some docobjects CONTROLINFO here and
|
|
// we navigate somewhere else. Do we have to know when this
|
|
// happens and tell our container that the CONTROLINFO has
|
|
// changed??
|
|
|
|
IOleControl* poc = GetForwardingIOC(_pautoWB2);
|
|
if (poc)
|
|
{
|
|
hres = poc->GetControlInfo(pCI);
|
|
poc->Release();
|
|
}
|
|
|
|
return hres;
|
|
}
|
|
STDMETHODIMP CWebBrowserOC::OnMnemonic(LPMSG pMsg)
|
|
{
|
|
HRESULT hres = E_NOTIMPL;
|
|
|
|
IOleControl* poc = GetForwardingIOC(_pautoWB2);
|
|
if (poc)
|
|
{
|
|
hres = poc->OnMnemonic(pMsg);
|
|
poc->Release();
|
|
}
|
|
|
|
return hres;
|
|
}
|
|
HRESULT __stdcall CWebBrowserOC::OnAmbientPropertyChange(DISPID dispid)
|
|
{
|
|
IS_INITIALIZED;
|
|
|
|
// First let our base class know about the change
|
|
//
|
|
SUPERCLASS::OnAmbientPropertyChange(dispid);
|
|
|
|
// Forward ambient property changes down to the docobject
|
|
// if it is something other than offline or silent
|
|
// for offline and silent, we call the methods to set
|
|
// the properties so that we remember it and these
|
|
// methods forward downwards on their own and so we we
|
|
// end up forwarding twice.
|
|
|
|
if((dispid == DISPID_AMBIENT_OFFLINEIFNOTCONNECTED) || (dispid == DISPID_AMBIENT_SILENT))
|
|
{
|
|
VARIANT_BOOL fAmbient;
|
|
if (SUPERCLASS::_GetAmbientProperty(dispid, VT_BOOL, &fAmbient))
|
|
{
|
|
if (dispid == DISPID_AMBIENT_OFFLINEIFNOTCONNECTED)
|
|
{
|
|
put_Offline(fAmbient);
|
|
}
|
|
else if(dispid == DISPID_AMBIENT_SILENT)
|
|
{
|
|
put_Silent(fAmbient);
|
|
}
|
|
}
|
|
// return ; // BharatS 01/20/97
|
|
// APPCOMPAT --- This could be avoided if the forwarding
|
|
// from simply calling put_offline worked fine but it does not
|
|
// and so the second forwarding can be removed when that is fixed
|
|
|
|
|
|
}
|
|
IOleControl* poc = GetForwardingIOC(_pautoWB2);
|
|
if (poc)
|
|
{
|
|
poc->OnAmbientPropertyChange(dispid);
|
|
poc->Release();
|
|
}
|
|
|
|
return S_OK;
|
|
}
|
|
STDMETHODIMP CWebBrowserOC::FreezeEvents(BOOL bFreeze)
|
|
{
|
|
// First let our base class know about the change
|
|
//
|
|
SUPERCLASS::FreezeEvents(bFreeze);
|
|
|
|
// Forward this down to the docobject
|
|
//
|
|
IOleControl* poc = GetForwardingIOC(_pautoWB2);
|
|
|
|
// delegate only if the freezeevents count is balanced when
|
|
// you receive a FALSE. There may be FALSE calls coming in,
|
|
// before we get a chance to delegate the pending freezeevents calls
|
|
// TRUE is always delegated.
|
|
if (poc && (bFreeze || (_cPendingFreezeEvents == 0)))
|
|
{
|
|
poc->FreezeEvents(bFreeze);
|
|
}
|
|
else
|
|
{
|
|
// keeping a total number of FreezeEvents(TRUE) calls
|
|
// that we have to make up for.
|
|
if ( bFreeze )
|
|
{
|
|
_cPendingFreezeEvents++;
|
|
}
|
|
else
|
|
{
|
|
// Don't let this go negative, otherwise we'll send 4 billion FreezeEvents(TRUE)
|
|
// to the DocObject in CWebBrowserOC::_OnSetShellView. (QFE [alanau])(ferhane)
|
|
if (EVAL(_cPendingFreezeEvents > 0))
|
|
{
|
|
_cPendingFreezeEvents --;
|
|
}
|
|
}
|
|
}
|
|
|
|
if (poc)
|
|
poc->Release();
|
|
|
|
return S_OK;
|
|
}
|
|
|
|
// CWebBrowserSB just started viewing psvNew - do our OC stuff now
|
|
//
|
|
void CWebBrowserOC::_OnSetShellView(IShellView* psvNew)
|
|
{
|
|
_fDirty = TRUE;
|
|
// NOTE: Document, Type, LocationName, LocationURL, Busy just changed...
|
|
// PropertyChanged(DISPID_LOCATION);
|
|
// NOTE: that is the job of the CBaseBrowser to tell us really.
|
|
// ideally we would not put this here at all (or in _OnReleaseShellV...
|
|
_SendAdvise(OBJECTCODE_DATACHANGED); // implies OBJECTCODE_VIEWCHANGED
|
|
|
|
// we might have received FreezeEvents(TRUE) calls from the container
|
|
// and if the document was not ready, we might not have had a chance
|
|
// to pass them down the stream. This is the time to make up for it.
|
|
|
|
if (_cPendingFreezeEvents > 0)
|
|
{
|
|
IOleControl* poc = GetForwardingIOC(_pautoWB2);
|
|
|
|
if (poc)
|
|
{
|
|
for ( ; _cPendingFreezeEvents > 0; _cPendingFreezeEvents-- )
|
|
{
|
|
// Forward this down to the docobject
|
|
poc->FreezeEvents(TRUE);
|
|
}
|
|
|
|
poc->Release();
|
|
}
|
|
}
|
|
}
|
|
|
|
// CWebBrowserSB is releasing the currently viewed IShellView
|
|
void CWebBrowserOC::_OnReleaseShellView()
|
|
{
|
|
}
|
|
|
|
|
|
// *** IOleCommandTarget
|
|
//
|
|
// our version simply forwards to the object below our CWebBrowserSB
|
|
//
|
|
HRESULT CWebBrowserOC::QueryStatus(const GUID *pguidCmdGroup, ULONG cCmds, OLECMD rgCmds[], OLECMDTEXT *pcmdtext)
|
|
{
|
|
if (_psb && _psb->_bbd._pctView)
|
|
return _psb->_bbd._pctView->QueryStatus(pguidCmdGroup, cCmds, rgCmds, pcmdtext);
|
|
|
|
return OLECMDERR_E_UNKNOWNGROUP;
|
|
}
|
|
HRESULT CWebBrowserOC::Exec(const GUID *pguidCmdGroup, DWORD nCmdID, DWORD nCmdexecopt, VARIANTARG *pvarargIn, VARIANTARG *pvarargOut)
|
|
{
|
|
HRESULT hr = OLECMDERR_E_UNKNOWNGROUP;
|
|
if (_psb)
|
|
{
|
|
if (pguidCmdGroup==NULL)
|
|
{
|
|
switch(nCmdID)
|
|
{
|
|
case OLECMDID_STOP:
|
|
{
|
|
LPITEMIDLIST pidlIntended = (_psb->_bbd._pidlPending) ? ILClone(_psb->_bbd._pidlPending) : NULL;
|
|
_psb->_CancelPendingNavigation();
|
|
|
|
// We've just canceled the pending navigation. We may not have a current page! The following
|
|
// accomplishes two goals:
|
|
//
|
|
// 1. Gives the user some information about the frame that couldn't navigate.
|
|
// 2. Allows the browser to reach READYSTATE_COMPLETE
|
|
//
|
|
if (!_psb->_bbd._pidlCur)
|
|
{
|
|
// We display the navcancl.htm page in most cases.
|
|
// However, we won't display it if the call has
|
|
// explicitly specified that we shouldn't.
|
|
//
|
|
if ( !pvarargIn
|
|
|| V_VT(pvarargIn) != VT_BOOL
|
|
|| V_BOOL(pvarargIn) == VARIANT_TRUE)
|
|
{
|
|
TCHAR szResURL[MAX_URL_STRING];
|
|
|
|
hr = MLBuildResURLWrap(TEXT("shdoclc.dll"),
|
|
HINST_THISDLL,
|
|
ML_CROSSCODEPAGE,
|
|
TEXT("navcancl.htm"),
|
|
szResURL,
|
|
ARRAYSIZE(szResURL),
|
|
TEXT("shdocvw.dll"));
|
|
if (SUCCEEDED(hr))
|
|
{
|
|
_psb->_ShowBlankPage(szResURL, pidlIntended);
|
|
}
|
|
}
|
|
}
|
|
|
|
if(pidlIntended)
|
|
ILFree(pidlIntended);
|
|
break; // Note that we need to fall through.
|
|
}
|
|
|
|
case OLECMDID_ENABLE_INTERACTION:
|
|
if (pvarargIn && pvarargIn->vt == VT_I4)
|
|
{
|
|
_psb->_fPausedByParent = BOOLIFY(pvarargIn->lVal);
|
|
}
|
|
break; // Note that we need to fall through.
|
|
}
|
|
|
|
hr = S_OK;
|
|
// WARNING: fall through to forward down
|
|
}
|
|
if (_psb->_bbd._pctView)
|
|
hr = _psb->_bbd._pctView->Exec(pguidCmdGroup, nCmdID, nCmdexecopt, pvarargIn, pvarargOut);
|
|
}
|
|
return hr;
|
|
}
|
|
|
|
//
|
|
// We hit this code if the normal IOleCommandTarget chain is broken (such as
|
|
// browser band in the browser bar). In this case, we get the command target
|
|
// to the top level browser and send OLECMDID_SETDOWNLOADSTATE to it.
|
|
//
|
|
// Returns:
|
|
// S_OK If we found the top level browser and it processed it.
|
|
// hresRet Otherwise
|
|
//
|
|
HRESULT CWebBrowserOC::_SetDownloadState(HRESULT hresRet, DWORD nCmdexecopt, VARIANTARG *pvarargIn)
|
|
{
|
|
ASSERT(hresRet == OLECMDERR_E_UNKNOWNGROUP || hresRet == OLECMDERR_E_NOTSUPPORTED);
|
|
|
|
IOleCommandTarget* pcmdtTop;
|
|
if (_psb && SUCCEEDED(_psb->_QueryServiceParent(SID_STopLevelBrowser, IID_PPV_ARG(IOleCommandTarget, &pcmdtTop))))
|
|
{
|
|
ASSERT(pcmdtTop != _psb);
|
|
VARIANTARG var;
|
|
if (pvarargIn && pvarargIn->lVal)
|
|
{
|
|
ASSERT(pvarargIn->vt == VT_I4 || pvarargIn->vt == VT_BOOL || pvarargIn->vt == VT_UNKNOWN);
|
|
//
|
|
// Notice that we pass the pointer to this OC so that the top
|
|
// level browser can keep track of it. This is a new behavior
|
|
// which is different from IE 3.0.
|
|
//
|
|
var.vt = VT_UNKNOWN;
|
|
var.punkVal = SAFECAST(this, IOleCommandTarget*);
|
|
}
|
|
else
|
|
{
|
|
var.vt = VT_BOOL;
|
|
var.lVal = FALSE;
|
|
}
|
|
HRESULT hresT = pcmdtTop->Exec(NULL, OLECMDID_SETDOWNLOADSTATE, nCmdexecopt, &var, NULL);
|
|
|
|
TraceMsg(DM_FORSEARCHBAND, "WBOC::_SetDownloadState pcmdTop->Exec returned %x", hresT);
|
|
|
|
if (SUCCEEDED(hresT))
|
|
{
|
|
hresRet = S_OK;
|
|
}
|
|
pcmdtTop->Release();
|
|
}
|
|
else
|
|
{
|
|
TraceMsg(DM_FORSEARCHBAND, "WBOC::_SetDownloadState can't find the top guy");
|
|
}
|
|
|
|
return hresRet;
|
|
}
|
|
|
|
#if 0 // not sure if this is correct, waiting for reply from OLEPSS alias
|
|
// VB is not happy if we fail a property get, so when an IDispatch
|
|
// is not safe we return an instance of this dummy IDispatch
|
|
class CDispatchDummy : public IDispatch
|
|
{
|
|
public:
|
|
CDispatchDummy() { m_cRef=1; DllAddRef(); };
|
|
~CDispatchDummy() { DllRelease(); };
|
|
|
|
// IUnknown methods
|
|
STDMETHOD(QueryInterface(REFIID riid, void ** ppvObj);
|
|
STDMETHOD_(ULONG, AddRef)(THIS);
|
|
STDMETHOD_(ULONG, Release)(THIS);
|
|
|
|
// IDispatch methods
|
|
STDMETHOD(GetTypeInfoCount) (unsigned int *pctinfo)
|
|
{ return E_FAIL; };
|
|
STDMETHOD(GetTypeInfo) (unsigned int itinfo, LCID lcid, ITypeInfo **pptinfo)
|
|
{ return E_FAIL; };
|
|
STDMETHODIMP GetIDsOfNames(REFIID riid, OLECHAR **rgszNames, unsigned int cNames, LCID lcid, DISPID * rgdispid)
|
|
{ return E_FAIL; };
|
|
STDMETHODIMP Invoke(DISPID dispidMember, REFIID iid, LCID lcid, WORD wFlags, DISPPARAMS * pdispparams,VARIANT * pvarResult,EXCEPINFO * pexcepinfo,UINT * puArgErr)
|
|
{ return E_FAIL; };
|
|
|
|
protected:
|
|
ULONG m_cRef;
|
|
};
|
|
|
|
HRESULT CDispatchDummy::QueryInterface(REFIID riid, void ** ppvObj)
|
|
{
|
|
if (IsEqualIID(riid, IID_IDispatch) ||
|
|
IsEqualIID(riid, IID_IUnknown))
|
|
{
|
|
AddRef();
|
|
*ppvObj = SAFECAST(this, IDispatch*);
|
|
return S_OK;
|
|
}
|
|
|
|
return E_NOINTERFACE;
|
|
}
|
|
ULONG CDispatchDummy::AddRef(THIS)
|
|
{
|
|
return ++m_cRef;
|
|
}
|
|
ULONG CDispatchDummy::Release(THIS)
|
|
{
|
|
if (--m_cRef==0)
|
|
{
|
|
delete this;
|
|
return 0;
|
|
}
|
|
return m_cRef;
|
|
}
|
|
|
|
HRESULT CreateDummyDispatch(IDispatch** ppDisp)
|
|
{
|
|
HRESULT hres = E_OUTOFMEMORY;
|
|
|
|
CDispatchDummy* pdisp = new(CDispatchDummy);
|
|
if (pdisp)
|
|
{
|
|
hres = pdisp->QueryInterface(IID_PPV_ARG(IDispatch, ppDisp));
|
|
pdisp->Release();
|
|
}
|
|
|
|
return hres;
|
|
}
|
|
#endif
|
|
|
|
|
|
#ifdef FEATURE_FRAMES
|
|
|
|
// *** ITargetEmedding ***
|
|
|
|
HRESULT CWebBrowserOC::GetTargetFrame(ITargetFrame **ppTargetFrame)
|
|
{
|
|
if (_psb)
|
|
{
|
|
return _psb->QueryServiceItsOwn(IID_ITargetFrame2, IID_PPV_ARG(ITargetFrame, ppTargetFrame));
|
|
}
|
|
else
|
|
{
|
|
*ppTargetFrame = NULL;
|
|
return E_FAIL;
|
|
}
|
|
}
|
|
|
|
#endif
|
|
|
|
// *** CImpIConnectionPoint override ***
|
|
CConnectionPoint* CWebBrowserOC::_FindCConnectionPointNoRef(BOOL fdisp, REFIID iid)
|
|
{
|
|
CConnectionPoint *pccp;
|
|
|
|
// Warning: Some apps (MSDN for one) passes in IID_IDispatch and
|
|
// expect the ole events. So we need to be careful on which one we return.
|
|
//
|
|
if (fdisp && IsEqualIID(iid, IID_IDispatch))
|
|
{
|
|
if (_pObjectInfo->lVersion == VERSION_1)
|
|
pccp = &m_cpWB1Events;
|
|
else
|
|
pccp = &m_cpEvents;
|
|
}
|
|
|
|
else if (IsEqualIID(iid, DIID_DWebBrowserEvents2))
|
|
{
|
|
pccp = &m_cpEvents;
|
|
}
|
|
else if (IsEqualIID(iid, DIID_DWebBrowserEvents))
|
|
{
|
|
pccp = &m_cpWB1Events;
|
|
}
|
|
else if (IsEqualIID(iid, IID_IPropertyNotifySink))
|
|
{
|
|
pccp = &m_cpPropNotify;
|
|
}
|
|
else
|
|
{
|
|
pccp = NULL;
|
|
}
|
|
|
|
return pccp;
|
|
}
|
|
|
|
STDMETHODIMP CWebBrowserOC::EnumConnectionPoints(LPENUMCONNECTIONPOINTS * ppEnum)
|
|
{
|
|
return CreateInstance_IEnumConnectionPoints(ppEnum, 3,
|
|
m_cpEvents.CastToIConnectionPoint(),
|
|
m_cpWB1Events.CastToIConnectionPoint(),
|
|
m_cpPropNotify.CastToIConnectionPoint());
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
** Properties and Methods we implement
|
|
*/
|
|
|
|
// Invoke perf
|
|
//
|
|
HRESULT CWebBrowserOC::Invoke(DISPID dispidMember, REFIID riid, LCID lcid, WORD wFlags, DISPPARAMS * pdispparams, VARIANT * pvarResult, EXCEPINFO * pexcepinfo, UINT * puArgErr)
|
|
{
|
|
HRESULT hres = S_OK;
|
|
|
|
// we should probably check that riid is IID_NULL...
|
|
|
|
_fInsideInvokeCall = TRUE; // we're inside an invoke
|
|
|
|
switch (dispidMember)
|
|
{
|
|
// handle ReadyState immediately for performance (avoid oleaut a tad longer)...
|
|
case DISPID_READYSTATE:
|
|
ASSERT(pdispparams && pdispparams->cArgs==0);
|
|
if (EVAL(pvarResult) && (wFlags & DISPATCH_PROPERTYGET))
|
|
{
|
|
ZeroMemory(pvarResult, SIZEOF(*pvarResult));
|
|
pvarResult->vt = VT_I4;
|
|
hres = get_ReadyState((READYSTATE*)(&pvarResult->lVal));
|
|
goto Cleanup;
|
|
}
|
|
break; // let the below invoke call give us the proper error value
|
|
|
|
// forward these two down to our embedded object so that
|
|
// Trident can handle cross-frame security correctly
|
|
case DISPID_SECURITYCTX:
|
|
case DISPID_SECURITYDOMAIN:
|
|
{
|
|
IDispatch* pdisp;
|
|
if (SUCCEEDED(_pautoWB2->get_Document(&pdisp)))
|
|
{
|
|
hres = pdisp->Invoke(dispidMember, riid, lcid, wFlags, pdispparams, pvarResult, pexcepinfo, puArgErr);
|
|
pdisp->Release();
|
|
goto Cleanup;
|
|
}
|
|
|
|
break;
|
|
}
|
|
|
|
default:
|
|
// handle the default after the switch.
|
|
break;
|
|
}
|
|
|
|
hres = CShellOcx::Invoke(dispidMember, riid, lcid, wFlags, pdispparams, pvarResult, pexcepinfo, puArgErr);
|
|
|
|
Cleanup:
|
|
|
|
_fInsideInvokeCall = FALSE; // We are leaving the invoke
|
|
|
|
return hres;
|
|
}
|
|
|
|
|
|
// IObjectSafety override so script can't talk to us from an unsafe zone
|
|
HRESULT CWebBrowserOC::SetInterfaceSafetyOptions(REFIID riid, DWORD dwOptionSetMask, DWORD dwEnabledOptions)
|
|
{
|
|
HRESULT hr = CObjectSafety::SetInterfaceSafetyOptions(riid, dwOptionSetMask, dwEnabledOptions);
|
|
|
|
// If we are hosted in IEXPLORER.EXE or EXPLORER.EXE (eventually this should be the default, but we need longer app-compat simmer time)
|
|
// And we can get a URL from our parent
|
|
// And the policy for that URL is "disable WebOC script access" (default for internet zone)
|
|
if (GetModuleHandle(TEXT("EXPLORER.EXE")) || GetModuleHandle(TEXT("IEXPLORE.EXE")))
|
|
{
|
|
IHTMLDocument2 *pHtmlDoc;
|
|
if (SUCCEEDED(GetHTMLDoc2(_pcli, &pHtmlDoc))) // if the parent isn't trident, then we must be client-side code hosting weboc directly - no need to bail
|
|
{
|
|
BSTR bstrURL;
|
|
if (SUCCEEDED(pHtmlDoc->get_URL(&bstrURL)))
|
|
{
|
|
DWORD dwPolicy = 0;
|
|
DWORD dwContext = 0;
|
|
|
|
ZoneCheckUrlEx(bstrURL, &dwPolicy, sizeof(dwPolicy), &dwContext, sizeof(dwContext),
|
|
URLACTION_ACTIVEX_NO_WEBOC_SCRIPT, 0, NULL);
|
|
|
|
if (GetUrlPolicyPermissions(dwPolicy) != URLPOLICY_ALLOW)
|
|
{
|
|
// Then we don't support script access - override whatever we were told above.
|
|
hr = E_ACCESSDENIED;
|
|
}
|
|
|
|
SysFreeString(bstrURL);
|
|
}
|
|
pHtmlDoc->Release();
|
|
}
|
|
}
|
|
|
|
return hr;
|
|
}
|
|
|
|
|
|
//
|
|
// Wrap around iedisp
|
|
//
|
|
|
|
#define WRAP_WB2(fn, args, nargs) \
|
|
HRESULT CWebBrowserOC :: fn args { return _pautoWB2-> fn nargs; }
|
|
#define WRAP_WB2_DESIGN(fn, args, nargs) \
|
|
HRESULT CWebBrowserOC :: fn args { if (_IsDesignMode()) return E_FAIL; else return _pautoWB2-> fn nargs; }
|
|
|
|
// IWebBrowser methods
|
|
//
|
|
WRAP_WB2_DESIGN(GoBack, (), ())
|
|
WRAP_WB2_DESIGN(GoForward, (), ())
|
|
WRAP_WB2_DESIGN(GoHome, (), ())
|
|
WRAP_WB2_DESIGN(GoSearch, (), ())
|
|
WRAP_WB2_DESIGN(Refresh, (), ())
|
|
WRAP_WB2_DESIGN(Refresh2, (VARIANT * Level), (Level))
|
|
WRAP_WB2_DESIGN(Stop, (), ())
|
|
WRAP_WB2(get_Type, (BSTR * pbstrType), (pbstrType))
|
|
WRAP_WB2(get_LocationName, (BSTR * pbstrLocationName), (pbstrLocationName))
|
|
WRAP_WB2(get_LocationURL, (BSTR * pbstrLocationURL), (pbstrLocationURL))
|
|
WRAP_WB2(get_Busy, (VARIANT_BOOL * pBool), (pBool))
|
|
|
|
HRESULT CWebBrowserOC::Navigate(BSTR URL,
|
|
VARIANT * Flags,
|
|
VARIANT * TargetFrameName,
|
|
VARIANT * PostData,
|
|
VARIANT * Headers)
|
|
{
|
|
HRESULT hr = S_OK;
|
|
|
|
if (_dwSafetyOptions)
|
|
{
|
|
hr = WrapSpecialUrl(&URL);
|
|
if (SUCCEEDED(hr))
|
|
{
|
|
if (!AccessAllowedToNamedFrame(TargetFrameName))
|
|
hr = E_ACCESSDENIED;
|
|
else
|
|
hr = _pautoWB2->Navigate(URL, Flags, TargetFrameName, PostData, Headers);
|
|
}
|
|
}
|
|
else
|
|
hr = _pautoWB2->Navigate(URL, Flags, TargetFrameName, PostData, Headers);
|
|
|
|
return hr;
|
|
}
|
|
|
|
HRESULT CWebBrowserOC::get_Application(IDispatch **ppDisp)
|
|
{
|
|
PROPMSG(TEXT("get_Application"));
|
|
return QueryInterface(IID_PPV_ARG(IDispatch, ppDisp));
|
|
}
|
|
|
|
HRESULT CWebBrowserOC::get_Parent(IDispatch **ppDisp)
|
|
{
|
|
HRESULT hres = E_FAIL;
|
|
PROPMSG(TEXT("get_Parent"));
|
|
|
|
if (ppDisp)
|
|
*ppDisp = NULL;
|
|
|
|
if (_pcli)
|
|
{
|
|
IOleContainer* pContainer;
|
|
|
|
hres = _pcli->GetContainer(&pContainer);
|
|
if (SUCCEEDED(hres))
|
|
{
|
|
hres = pContainer->QueryInterface(IID_PPV_ARG(IDispatch, ppDisp));
|
|
|
|
if (SUCCEEDED(hres) && _dwSafetyOptions)
|
|
hres = MakeSafeForScripting((IUnknown**)ppDisp);
|
|
|
|
pContainer->Release();
|
|
}
|
|
else
|
|
{
|
|
PROPMSG(TEXT("get_Parent couldn't find the container!"));
|
|
}
|
|
}
|
|
else
|
|
{
|
|
PROPMSG(TEXT("get_Parent does not have _pcli!"));
|
|
}
|
|
|
|
// if there was an error *ppDisop is NULL, and so VB realizes
|
|
// this is a "nothing" dispatch -- returning failure causes
|
|
// error boxes to appear. ugh.
|
|
|
|
return S_OK;
|
|
}
|
|
HRESULT CWebBrowserOC::get_Container(IDispatch **ppDisp)
|
|
{
|
|
// Container property is "same as parent" unless there is no parent.
|
|
// Since we always have a parent, let get_Parent handle this.
|
|
PROPMSG(TEXT("get_Containter passing off to get_Parent"));
|
|
return get_Parent(ppDisp);
|
|
}
|
|
HRESULT CWebBrowserOC::get_Document(IDispatch **ppDisp)
|
|
{
|
|
HRESULT hres = _pautoWB2->get_Document(ppDisp);
|
|
|
|
if (FAILED(hres) && ppDisp)
|
|
{
|
|
*ppDisp = NULL;
|
|
}
|
|
|
|
if (SUCCEEDED(hres) && _dwSafetyOptions)
|
|
hres = MakeSafeForScripting((IUnknown**)ppDisp);
|
|
|
|
|
|
// if there was an error *ppDisop is NULL, and so VB realizes
|
|
// this is a "nothing" dispatch -- returning failure causes
|
|
// error boxes to appear. ugh.
|
|
|
|
return S_OK;
|
|
}
|
|
|
|
HRESULT CWebBrowserOC::get_TopLevelContainer(VARIANT_BOOL * pBool)
|
|
{
|
|
PROPMSG(TEXT("get_TopLevelContainer"));
|
|
|
|
if (!pBool)
|
|
return E_INVALIDARG;
|
|
|
|
*pBool = FALSE;
|
|
|
|
return S_OK;
|
|
}
|
|
|
|
|
|
void FireEvent_OnSetWindowPos(IUnknown *punkCPContainer, DISPID dispid, long lValue)
|
|
{
|
|
VARIANTARG args[1];
|
|
IUnknown_CPContainerInvokeParam(punkCPContainer, DIID_DWebBrowserEvents2,
|
|
dispid, args, 1, VT_I4, lValue);
|
|
}
|
|
|
|
HRESULT CWebBrowserOC::get_Left(long * pl)
|
|
{
|
|
*pl = _rcPos.left;
|
|
return S_OK;
|
|
}
|
|
HRESULT CWebBrowserOC::put_Left(long Left)
|
|
{
|
|
FireEvent_OnSetWindowPos(_pautoEDS, DISPID_WINDOWSETLEFT, Left);
|
|
|
|
if (_pipsite)
|
|
{
|
|
RECT rc = _rcPos;
|
|
rc.left = Left;
|
|
|
|
return _pipsite->OnPosRectChange(&rc);
|
|
}
|
|
else
|
|
{
|
|
TraceMsg(TF_SHDCONTROL, "put_Left has no _pipsite to notify!");
|
|
return E_UNEXPECTED;
|
|
}
|
|
}
|
|
HRESULT CWebBrowserOC::get_Top(long * pl)
|
|
{
|
|
*pl = _rcPos.top;
|
|
return S_OK;
|
|
}
|
|
HRESULT CWebBrowserOC::put_Top(long Top)
|
|
{
|
|
FireEvent_OnSetWindowPos(_pautoEDS, DISPID_WINDOWSETTOP, Top);
|
|
|
|
if (_pipsite)
|
|
{
|
|
RECT rc = _rcPos;
|
|
rc.top = Top;
|
|
|
|
return(_pipsite->OnPosRectChange(&rc));
|
|
}
|
|
else
|
|
{
|
|
TraceMsg(TF_SHDCONTROL, "put_Top has no _pipsite to notify!");
|
|
return(E_UNEXPECTED);
|
|
}
|
|
}
|
|
HRESULT CWebBrowserOC::get_Width(long * pl)
|
|
{
|
|
*pl = _rcPos.right - _rcPos.left;
|
|
return S_OK;
|
|
}
|
|
HRESULT CWebBrowserOC::put_Width(long Width)
|
|
{
|
|
FireEvent_OnSetWindowPos(_pautoEDS, DISPID_WINDOWSETWIDTH, Width);
|
|
|
|
if (_pipsite)
|
|
{
|
|
RECT rc = _rcPos;
|
|
rc.right = rc.left + Width;
|
|
|
|
return(_pipsite->OnPosRectChange(&rc));
|
|
}
|
|
else
|
|
{
|
|
TraceMsg(TF_SHDCONTROL, "put_Width has no _pipsite to notify!");
|
|
return(E_UNEXPECTED);
|
|
}
|
|
}
|
|
HRESULT CWebBrowserOC::get_Height(long * pl)
|
|
{
|
|
*pl = _rcPos.bottom - _rcPos.top;
|
|
return S_OK;
|
|
}
|
|
HRESULT CWebBrowserOC::put_Height(long Height)
|
|
{
|
|
FireEvent_OnSetWindowPos(_pautoEDS, DISPID_WINDOWSETHEIGHT, Height);
|
|
|
|
if (_pipsite)
|
|
{
|
|
RECT rc = _rcPos;
|
|
rc.bottom = rc.top + Height;
|
|
|
|
return(_pipsite->OnPosRectChange(&rc));
|
|
}
|
|
else
|
|
{
|
|
TraceMsg(TF_SHDCONTROL, "put_Height has no _pipsite to notify!");
|
|
return(E_UNEXPECTED);
|
|
}
|
|
}
|
|
|
|
// IWebBrowserApp methods
|
|
//
|
|
WRAP_WB2_DESIGN(PutProperty, (BSTR szProperty, VARIANT vtValue), (szProperty, vtValue))
|
|
WRAP_WB2_DESIGN(GetProperty, (BSTR szProperty, VARIANT * pvtValue), (szProperty, pvtValue))
|
|
WRAP_WB2(get_FullName, (BSTR * pbstrFullName), (pbstrFullName))
|
|
WRAP_WB2(get_Path, (BSTR * pbstrPath), (pbstrPath))
|
|
|
|
HRESULT CWebBrowserOC::Quit()
|
|
{
|
|
return E_FAIL;
|
|
}
|
|
HRESULT CWebBrowserOC::ClientToWindow(int * pcx, int * pcy)
|
|
{
|
|
LONG lX = *pcx, lY = *pcy;
|
|
|
|
VARIANTARG args[2];
|
|
IUnknown_CPContainerInvokeParam(_pautoEDS, DIID_DWebBrowserEvents2,
|
|
DISPID_CLIENTTOHOSTWINDOW, args, 2,
|
|
VT_I4 | VT_BYREF, &lX,
|
|
VT_I4 | VT_BYREF, &lY);
|
|
*pcx = lX;
|
|
*pcy = lY;
|
|
|
|
return S_OK;
|
|
}
|
|
HRESULT CWebBrowserOC::get_Name(BSTR * pbstrName)
|
|
{
|
|
*pbstrName = LoadBSTR(IDS_SHELLEXPLORER);
|
|
return *pbstrName ? S_OK : E_OUTOFMEMORY;
|
|
}
|
|
HRESULT CWebBrowserOC::get_HWND(LONG_PTR * pHWND)
|
|
{
|
|
*pHWND = NULL;
|
|
return E_FAIL;
|
|
}
|
|
|
|
HRESULT CWebBrowserOC::get_FullScreen(VARIANT_BOOL * pBool)
|
|
{
|
|
*pBool = BOOL_TO_VARIANTBOOL(_fFullScreen);
|
|
return S_OK;
|
|
}
|
|
HRESULT CWebBrowserOC::put_FullScreen(VARIANT_BOOL Value)
|
|
{
|
|
_fFullScreen = VARIANTBOOL_TO_BOOL(Value);
|
|
FireEvent_OnAdornment(_pautoEDS, DISPID_ONFULLSCREEN, Value);
|
|
return S_OK;
|
|
}
|
|
HRESULT CWebBrowserOC::get_Visible(VARIANT_BOOL * pBool)
|
|
{
|
|
*pBool = BOOL_TO_VARIANTBOOL(_fVisible);
|
|
return S_OK;
|
|
}
|
|
HRESULT CWebBrowserOC::put_Visible(VARIANT_BOOL Value)
|
|
{
|
|
_fVisible = VARIANTBOOL_TO_BOOL(Value);
|
|
FireEvent_OnAdornment(_pautoEDS, DISPID_ONVISIBLE, Value);
|
|
return S_OK;
|
|
}
|
|
HRESULT CWebBrowserOC::get_StatusBar(VARIANT_BOOL * pBool)
|
|
{
|
|
*pBool = BOOL_TO_VARIANTBOOL(!_fNoStatusBar);
|
|
return S_OK;
|
|
}
|
|
HRESULT CWebBrowserOC::put_StatusBar(VARIANT_BOOL Value)
|
|
{
|
|
_fNoStatusBar = !VARIANTBOOL_TO_BOOL(Value);
|
|
FireEvent_OnAdornment(_pautoEDS, DISPID_ONSTATUSBAR, Value);
|
|
return S_OK;
|
|
}
|
|
HRESULT CWebBrowserOC::get_StatusText(BSTR * pbstr)
|
|
{
|
|
*pbstr = NULL;
|
|
return E_FAIL;
|
|
}
|
|
HRESULT CWebBrowserOC::put_StatusText(BSTR bstr)
|
|
{
|
|
return E_FAIL;
|
|
}
|
|
HRESULT CWebBrowserOC::get_ToolBar(int * pBool)
|
|
{
|
|
// BOGUS: variant values for int type
|
|
*pBool = (!_fNoToolBar) ? VARIANT_TRUE : VARIANT_FALSE;
|
|
return S_OK;
|
|
}
|
|
HRESULT CWebBrowserOC::put_ToolBar(int iToolbar)
|
|
{
|
|
_fNoToolBar = (!iToolbar) ? TRUE : FALSE;
|
|
FireEvent_OnAdornment(_pautoEDS, DISPID_ONTOOLBAR, iToolbar);
|
|
return S_OK;
|
|
}
|
|
HRESULT CWebBrowserOC::get_MenuBar(VARIANT_BOOL * pvbMenuBar)
|
|
{
|
|
*pvbMenuBar = BOOL_TO_VARIANTBOOL(!_fNoMenuBar);
|
|
return S_OK;
|
|
}
|
|
HRESULT CWebBrowserOC::put_MenuBar(VARIANT_BOOL vbMenuBar)
|
|
{
|
|
_fNoMenuBar = !VARIANTBOOL_TO_BOOL(vbMenuBar);
|
|
FireEvent_OnAdornment(_pautoEDS, DISPID_ONMENUBAR, vbMenuBar);
|
|
return S_OK;
|
|
}
|
|
HRESULT CWebBrowserOC::get_AddressBar(VARIANT_BOOL * pvbAddressBar)
|
|
{
|
|
*pvbAddressBar = BOOL_TO_VARIANTBOOL(!_fNoAddressBar);
|
|
return S_OK;
|
|
}
|
|
HRESULT CWebBrowserOC::put_AddressBar(VARIANT_BOOL vbAddressBar)
|
|
{
|
|
_fNoAddressBar = !VARIANTBOOL_TO_BOOL(vbAddressBar);
|
|
FireEvent_OnAdornment(_pautoEDS, DISPID_ONADDRESSBAR, vbAddressBar);
|
|
return S_OK;
|
|
}
|
|
|
|
HRESULT CWebBrowserOC::put_Resizable(VARIANT_BOOL vbResizable)
|
|
{
|
|
FireEvent_OnAdornment(_pautoEDS, DISPID_WINDOWSETRESIZABLE, vbResizable);
|
|
return S_OK;
|
|
}
|
|
|
|
// IWebBrowser2 methods
|
|
//
|
|
WRAP_WB2_DESIGN(QueryStatusWB, (OLECMDID cmdID, OLECMDF * pcmdf), (cmdID, pcmdf))
|
|
WRAP_WB2_DESIGN(ShowBrowserBar, (VARIANT * pvaClsid, VARIANT * pvaShow, VARIANT * pvaSize), (pvaClsid, pvaShow, pvaSize))
|
|
WRAP_WB2(get_ReadyState, (READYSTATE * plReadyState), (plReadyState))
|
|
WRAP_WB2(get_RegisterAsDropTarget, (VARIANT_BOOL * pbRegister), (pbRegister))
|
|
WRAP_WB2(put_RegisterAsDropTarget, (VARIANT_BOOL bRegister), (bRegister))
|
|
WRAP_WB2(get_Offline, (VARIANT_BOOL * pbOffline), (pbOffline))
|
|
WRAP_WB2(put_Offline, (VARIANT_BOOL bOffline), (bOffline))
|
|
WRAP_WB2(get_Silent, (VARIANT_BOOL * pbSilent), (pbSilent))
|
|
WRAP_WB2(put_Silent, (VARIANT_BOOL bSilent), (bSilent))
|
|
|
|
|
|
HRESULT
|
|
CWebBrowserOC::Navigate2(VARIANT * URL,
|
|
VARIANT * Flags,
|
|
VARIANT * TargetFrameName,
|
|
VARIANT * PostData,
|
|
VARIANT * Headers)
|
|
{
|
|
HRESULT hr = S_OK;
|
|
|
|
if (_dwSafetyOptions && ((WORD)VT_BSTR == URL->vt) && URL->bstrVal)
|
|
{
|
|
hr = WrapSpecialUrl(&URL->bstrVal);
|
|
if (SUCCEEDED(hr))
|
|
{
|
|
if (!AccessAllowedToNamedFrame(TargetFrameName))
|
|
hr = E_ACCESSDENIED;
|
|
else
|
|
hr = _pautoWB2->Navigate2(URL, Flags, TargetFrameName, PostData, Headers);
|
|
}
|
|
}
|
|
else
|
|
hr = _pautoWB2->Navigate2(URL, Flags, TargetFrameName, PostData, Headers);
|
|
|
|
return hr;
|
|
}
|
|
|
|
HRESULT CWebBrowserOC::ExecWB(OLECMDID cmdID, OLECMDEXECOPT cmdexecopt,
|
|
VARIANT * pvaIn, VARIANT * pvaOut)
|
|
{
|
|
HRESULT hr = E_FAIL;
|
|
|
|
if ( !_IsDesignMode() )
|
|
{
|
|
|
|
// do not process print preview commands given from script for security reasons
|
|
// Ferhane IE60 Bug#16693
|
|
// Print templates have extra privelages.
|
|
// Print/Preview allows you to specify a custom print template URL as a BSTR or in a safearray.
|
|
// This is a security hole if available from script. Disallow it.
|
|
if ( _fInsideInvokeCall
|
|
&& ( cmdID == OLECMDID_PRINTPREVIEW
|
|
|| cmdID == OLECMDID_PRINT)
|
|
&& pvaIn
|
|
&& ( V_VT(pvaIn) == VT_BSTR
|
|
|| V_VT(pvaIn) == VT_ARRAY)
|
|
)
|
|
{
|
|
return E_ACCESSDENIED; // More meaningful than E_FAIL
|
|
}
|
|
|
|
// if _dwSafetyOptions are set then we are suppossed to be
|
|
// running in secure mode. This means the UI-less printing should NOT
|
|
// be honored. This is a security issue, see ie bug 23620.
|
|
// otherwise just let the call go through
|
|
if ((cmdID == OLECMDID_PRINT) && _dwSafetyOptions)
|
|
{
|
|
// so if the UI-less- request flag is set we need to unset it.
|
|
if (cmdexecopt == OLECMDEXECOPT_DONTPROMPTUSER)
|
|
cmdexecopt = OLECMDEXECOPT_DODEFAULT;
|
|
}
|
|
|
|
// If the optional argument pvargin is not specified make it VT_EMPTY.
|
|
if (pvaIn && (V_VT(pvaIn) == VT_ERROR) && (V_ERROR(pvaIn) == DISP_E_PARAMNOTFOUND))
|
|
{
|
|
V_VT(pvaIn) = VT_EMPTY;
|
|
V_I4(pvaIn) = 0;
|
|
}
|
|
|
|
// If the optional argument pvargin is not specified make it VT_EMPTY.
|
|
if (pvaOut && (V_VT(pvaOut) == VT_ERROR) && (V_ERROR(pvaOut) == DISP_E_PARAMNOTFOUND))
|
|
{
|
|
V_VT(pvaOut) = VT_EMPTY;
|
|
V_I4(pvaOut) = 0;
|
|
}
|
|
|
|
if ( cmdID == OLECMDID_PASTE
|
|
|| cmdID == OLECMDID_COPY
|
|
|| cmdID == OLECMDID_CUT)
|
|
{
|
|
BSTR bstrUrl;
|
|
|
|
if (_dwSafetyOptions)
|
|
return S_OK;
|
|
|
|
if (SUCCEEDED(get_LocationURL(&bstrUrl)))
|
|
{
|
|
DWORD dwPolicy = 0;
|
|
DWORD dwContext = 0;
|
|
|
|
ZoneCheckUrlEx(bstrUrl, &dwPolicy, SIZEOF(dwPolicy), &dwContext, SIZEOF(dwContext),
|
|
URLACTION_SCRIPT_PASTE, 0, NULL);
|
|
|
|
SysFreeString(bstrUrl);
|
|
|
|
if (GetUrlPolicyPermissions(dwPolicy) != URLPOLICY_ALLOW)
|
|
return S_OK;
|
|
}
|
|
}
|
|
|
|
// now pass along the call
|
|
hr = _pautoWB2->ExecWB(cmdID, cmdexecopt, pvaIn, pvaOut);
|
|
}
|
|
|
|
return hr;
|
|
}
|
|
|
|
HRESULT CWebBrowserOC::get_RegisterAsBrowser(VARIANT_BOOL * pbRegister)
|
|
{
|
|
*pbRegister = BOOL_TO_VARIANTBOOL(_fShouldRegisterAsBrowser);
|
|
return S_OK;
|
|
}
|
|
|
|
HRESULT CWebBrowserOC::put_RegisterAsBrowser(VARIANT_BOOL bRegister)
|
|
{
|
|
_fShouldRegisterAsBrowser = VARIANTBOOL_TO_BOOL(bRegister);
|
|
|
|
if (bRegister)
|
|
_RegisterWindow();
|
|
else
|
|
_UnregisterWindow();
|
|
|
|
return S_OK;
|
|
}
|
|
|
|
HRESULT CWebBrowserOC::get_TheaterMode(VARIANT_BOOL * pvbTheaterMode)
|
|
{
|
|
*pvbTheaterMode = BOOL_TO_VARIANTBOOL(_fTheaterMode);
|
|
return S_OK;
|
|
}
|
|
HRESULT CWebBrowserOC::put_TheaterMode(VARIANT_BOOL Value)
|
|
{
|
|
_fTheaterMode = VARIANTBOOL_TO_BOOL(Value);
|
|
FireEvent_OnAdornment(_pautoEDS, DISPID_ONTHEATERMODE, Value);
|
|
return S_OK;
|
|
}
|
|
|
|
// IExpDispSupport
|
|
//
|
|
HRESULT CWebBrowserOC::OnTranslateAccelerator(MSG *pMsg,DWORD grfModifiers)
|
|
{
|
|
return IUnknown_TranslateAcceleratorOCS(_pcli, pMsg, grfModifiers);
|
|
}
|
|
|
|
HRESULT CWebBrowserOC::OnInvoke(DISPID dispidMember, REFIID iid, LCID lcid, WORD wFlags, DISPPARAMS * pdispparams,
|
|
VARIANT * pVarResult, EXCEPINFO * pexcepinfo, UINT * puArgErr)
|
|
{
|
|
// We get first crack at this
|
|
HRESULT hres = _pautoEDS->OnInvoke(dispidMember, iid, lcid, wFlags, pdispparams, pVarResult,pexcepinfo,puArgErr);
|
|
|
|
// let the container get second crack at ambient properties
|
|
//
|
|
if (FAILED(hres))
|
|
{
|
|
if (!_pDispAmbient)
|
|
{
|
|
if (_pcli)
|
|
_pcli->QueryInterface(IID_PPV_ARG(IDispatch, &_pDispAmbient));
|
|
}
|
|
if (_pDispAmbient)
|
|
{
|
|
hres = _pDispAmbient->Invoke(dispidMember, iid, lcid, wFlags, pdispparams, pVarResult,pexcepinfo,puArgErr);
|
|
}
|
|
}
|
|
|
|
return hres;
|
|
}
|
|
|
|
// IExpDispSupportOC
|
|
//
|
|
HRESULT CWebBrowserOC::OnOnControlInfoChanged()
|
|
{
|
|
HRESULT hres = E_NOTIMPL;
|
|
|
|
if (_pcli)
|
|
{
|
|
IOleControlSite* pocs;
|
|
if (SUCCEEDED(_pcli->QueryInterface(IID_PPV_ARG(IOleControlSite, &pocs))))
|
|
{
|
|
hres = pocs->OnControlInfoChanged();
|
|
pocs->Release();
|
|
}
|
|
}
|
|
|
|
return hres;
|
|
}
|
|
HRESULT CWebBrowserOC::GetDoVerbMSG(MSG *pMsg)
|
|
{
|
|
if (_pmsgDoVerb)
|
|
{
|
|
*pMsg = *_pmsgDoVerb;
|
|
return S_OK;
|
|
}
|
|
|
|
return E_FAIL;
|
|
}
|
|
|
|
|
|
HRESULT CWebBrowserOC::LoadHistory(IStream *pstm, IBindCtx *pbc)
|
|
{
|
|
_InitDefault();
|
|
|
|
ASSERT(_psb);
|
|
|
|
HRESULT hr = E_FAIL;
|
|
|
|
if (_psb)
|
|
{
|
|
hr = _psb->LoadHistory(pstm, pbc);
|
|
|
|
_OnLoaded(FAILED(hr));
|
|
|
|
TraceMsg(TF_TRAVELLOG, "WBOC::LoadHistory pstm = %x, pbc = %x, hr = %x", pstm, pbc, hr);
|
|
}
|
|
return hr;
|
|
}
|
|
|
|
HRESULT CWebBrowserOC::SaveHistory(IStream *pstm)
|
|
{
|
|
ASSERT(_psb);
|
|
|
|
TraceMsg(TF_TRAVELLOG, "WBOC::SaveHistory calling psb->SaveHistory");
|
|
|
|
return _psb ? _psb->SaveHistory(pstm) : E_FAIL;
|
|
}
|
|
|
|
HRESULT CWebBrowserOC::SetPositionCookie(DWORD dw)
|
|
{
|
|
ASSERT(_psb);
|
|
|
|
TraceMsg(TF_TRAVELLOG, "WBOC::SetPositionCookie calling psb->GetPositionCookie");
|
|
return _psb ? _psb->SetPositionCookie(dw) : E_FAIL;
|
|
}
|
|
|
|
HRESULT CWebBrowserOC::GetPositionCookie(DWORD *pdw)
|
|
{
|
|
ASSERT(_psb);
|
|
|
|
TraceMsg(TF_TRAVELLOG, "WBOC::GetPositionCookie calling psb->GetPositionCookie");
|
|
return _psb ? _psb->GetPositionCookie(pdw) : E_FAIL;
|
|
}
|
|
|
|
HMODULE CWebBrowserOC::_GetBrowseUI()
|
|
{
|
|
if (_hBrowseUI == HMODULE_NOTLOADED)
|
|
{
|
|
_hBrowseUI = LoadLibrary(TEXT("browseui.dll"));
|
|
}
|
|
|
|
return _hBrowseUI;
|
|
}
|
|
|
|
BOOL CWebBrowserOC::AccessAllowedToNamedFrame(VARIANT *varTargetFrameName)
|
|
{
|
|
BOOL fAllowed = TRUE;
|
|
HRESULT hr = S_OK;
|
|
ITargetFrame2 * pTopTargetFrame = NULL;
|
|
IUnknown * punkTargetFrame = NULL;
|
|
IWebBrowser2 * pIWB2Target = NULL;
|
|
BSTR bstrTargetUrl = NULL;
|
|
BSTR bstrSrcUrl = NULL;
|
|
|
|
if (varTargetFrameName && ((WORD)VT_BSTR == varTargetFrameName->vt) && varTargetFrameName->bstrVal)
|
|
{
|
|
IEFrameAuto * piefa = NULL;
|
|
|
|
hr = _pauto->QueryInterface(IID_PPV_ARG(IEFrameAuto, &piefa));
|
|
if (SUCCEEDED(hr))
|
|
{
|
|
|
|
hr = TargetQueryService((IShellBrowser *)piefa, IID_PPV_ARG(ITargetFrame2, &pTopTargetFrame));
|
|
|
|
if (SUCCEEDED(hr))
|
|
{
|
|
hr = pTopTargetFrame->FindFrame(
|
|
varTargetFrameName->bstrVal,
|
|
FINDFRAME_JUSTTESTEXISTENCE,
|
|
&punkTargetFrame);
|
|
if (SUCCEEDED(hr) && punkTargetFrame)
|
|
{
|
|
// yes, we found a frame with that name. QI for the automation
|
|
// interface on that frame.
|
|
hr = punkTargetFrame->QueryInterface(IID_PPV_ARG(IWebBrowser2, &pIWB2Target));
|
|
|
|
if (SUCCEEDED(hr))
|
|
{
|
|
hr = pIWB2Target->get_LocationURL(&bstrTargetUrl);
|
|
|
|
if (SUCCEEDED(hr))
|
|
{
|
|
hr = _pautoWB2->get_LocationURL(&bstrSrcUrl);
|
|
if (SUCCEEDED(hr))
|
|
{
|
|
fAllowed = AccessAllowed(bstrSrcUrl, bstrTargetUrl);
|
|
SysFreeString(bstrSrcUrl);
|
|
}
|
|
SysFreeString(bstrTargetUrl);
|
|
}
|
|
pIWB2Target->Release();
|
|
}
|
|
punkTargetFrame->Release();
|
|
}
|
|
pTopTargetFrame->Release();
|
|
}
|
|
piefa->Release();
|
|
}
|
|
}
|
|
return fAllowed;
|
|
}
|
|
|
|
|
|
// The SECURELOCK enumeration must be sorted in order of security level, and we may
|
|
// need to insert new values into the middle of the list in future. So we'll map
|
|
// the values to a set of constants.
|
|
|
|
BOOL SecureLockToIconConstant(int nSecureLock, LONG *plIconConstant)
|
|
{
|
|
BOOL fRet = TRUE;
|
|
|
|
switch (nSecureLock)
|
|
{
|
|
case SECURELOCK_SET_UNSECURE : *plIconConstant = secureLockIconUnsecure; break;
|
|
case SECURELOCK_SET_MIXED : *plIconConstant = secureLockIconMixed; break;
|
|
case SECURELOCK_SET_SECUREUNKNOWNBIT : *plIconConstant = secureLockIconSecureUnknownBits; break;
|
|
case SECURELOCK_SET_SECURE40BIT : *plIconConstant = secureLockIconSecure40Bit; break;
|
|
case SECURELOCK_SET_SECURE56BIT : *plIconConstant = secureLockIconSecure56Bit; break;
|
|
case SECURELOCK_SET_SECURE128BIT : *plIconConstant = secureLockIconSecure128Bit; break;
|
|
case SECURELOCK_SET_FORTEZZA : *plIconConstant = secureLockIconSecureFortezza; break;
|
|
default:
|
|
// Don't need to fire an event
|
|
fRet = FALSE;
|
|
}
|
|
|
|
return fRet;
|
|
}
|
|
|
|
void CWebBrowserOC::_OnSetSecureLockIcon(int lock)
|
|
{
|
|
LONG lIconConstant;
|
|
|
|
if (SecureLockToIconConstant(lock, &lIconConstant))
|
|
{
|
|
// Fire the OnUpdateSecurityIcon event only from the DWebBrowserEvents2 connection point
|
|
|
|
VARIANTARG args[1];
|
|
IUnknown_CPContainerInvokeParam(_pautoEDS, DIID_DWebBrowserEvents2,
|
|
DISPID_SETSECURELOCKICON, args, 1, VT_I4, lIconConstant);
|
|
}
|
|
}
|
|
|
|
// CWebBrowserSB implementation
|
|
|
|
CWebBrowserSB::CWebBrowserSB(IUnknown* pauto, CWebBrowserOC* psvo)
|
|
: CBASEBROWSER(NULL)
|
|
, _psvo(psvo)
|
|
{
|
|
_Initialize(0, pauto);
|
|
}
|
|
|
|
CWebBrowserSB::~CWebBrowserSB()
|
|
{
|
|
}
|
|
|
|
HRESULT CWebBrowserSB::QueryInterface(REFIID riid, void ** ppvObj)
|
|
{
|
|
HRESULT hr = CBASEBROWSER::QueryInterface(riid, ppvObj);
|
|
|
|
if (FAILED(hr) && (riid == IID_IIsWebBrowserSB))
|
|
hr = CBASEBROWSER::QueryInterface(IID_IUnknown, ppvObj);
|
|
|
|
return hr;
|
|
}
|
|
|
|
BOOL VirtualTopLevelBrowser(IOleClientSite * pcls)
|
|
{
|
|
IOleContainer * poc;
|
|
BOOL fNonStandard = FALSE;
|
|
|
|
if (SUCCEEDED(pcls->GetContainer(&poc)))
|
|
{
|
|
ITargetContainer * ptc;
|
|
|
|
// Is our container hosting us?
|
|
if (SUCCEEDED(poc->QueryInterface(IID_PPV_ARG(ITargetContainer, &ptc))))
|
|
{
|
|
fNonStandard = TRUE;
|
|
ptc->Release();
|
|
}
|
|
poc->Release();
|
|
}
|
|
|
|
return fNonStandard;
|
|
}
|
|
|
|
HRESULT CWebBrowserSB::SetTopBrowser()
|
|
{
|
|
HRESULT hres = CBASEBROWSER::SetTopBrowser();
|
|
|
|
if (_fTopBrowser && EVAL(_psvo))
|
|
_fNoTopLevelBrowser = VirtualTopLevelBrowser(_psvo->_pcli);
|
|
|
|
return hres;
|
|
}
|
|
|
|
|
|
LRESULT CWebBrowserSB::WndProcBS(HWND hwnd, UINT uMsg, WPARAM wParam, LPARAM lParam)
|
|
{
|
|
LRESULT lret = CBASEBROWSER::WndProcBS(hwnd, uMsg, wParam, lParam);
|
|
|
|
switch(uMsg)
|
|
{
|
|
case WM_DESTROY:
|
|
// Because we won't get WM_NCDESTROY here, we should clean up
|
|
// this member variable here.
|
|
_bbd._hwnd = NULL;
|
|
break;
|
|
}
|
|
|
|
return lret;
|
|
}
|
|
|
|
// *** IOleWindow methods ***
|
|
|
|
// CBASEBROWSER maps SetStatusTextSB to SendControlMsg,
|
|
// so we don't need a CWebBrowserSB::SetStatusTextSB implementation.
|
|
|
|
HRESULT CWebBrowserSB::_EnableModeless(BOOL fEnable, BOOL fDirection)
|
|
{
|
|
HRESULT hres = S_OK;
|
|
|
|
CBASEBROWSER::EnableModelessSB(fEnable);
|
|
|
|
if (fDirection == DIRECTION_FORWARD_TO_PARENT)
|
|
{
|
|
if (_psvo && _psvo->_pipframe)
|
|
{
|
|
hres = _psvo->_pipframe->EnableModeless(fEnable);
|
|
if (!fEnable && _psvo->_fHostedInVB5)
|
|
{
|
|
// APPHACK: VB5 -- If we haven't put up a dialog between the EnableModelessSB(FALSE) call and this
|
|
// call, we'll end up with a message on the queue that will disable all windows.
|
|
// Let's peek for this message and dispatch it if it is VB5's.
|
|
//
|
|
#define VBM_POSTENABLEMODELESS 0x1006
|
|
#define VBM_MAINCLASS1 TEXT("ThunderRT5Main")
|
|
#define VBM_MAINCLASS2 TEXT("ThunderRT6Main")
|
|
#define VBM_MAINCLASS3 TEXT("ThunderMain")
|
|
|
|
MSG msg;
|
|
HWND hwnd = NULL;
|
|
TCHAR strBuf[15];
|
|
|
|
if (PeekMessage( &msg, NULL, VBM_POSTENABLEMODELESS, VBM_POSTENABLEMODELESS, PM_NOREMOVE))
|
|
{
|
|
/* On Win95, apparently PeekMessage can return one type of message
|
|
* outside the range specified: WM_QUIT. Double-check the message we
|
|
* got back.
|
|
*/
|
|
if (msg.message == VBM_POSTENABLEMODELESS)
|
|
{
|
|
GetClassName(msg.hwnd, strBuf, sizeof(strBuf));
|
|
if (StrCmp(strBuf, VBM_MAINCLASS1) == 0 ||
|
|
StrCmp(strBuf, VBM_MAINCLASS2) == 0 ||
|
|
StrCmp(strBuf, VBM_MAINCLASS3) == 0)
|
|
{
|
|
PeekMessage( &msg, msg.hwnd, VBM_POSTENABLEMODELESS, VBM_POSTENABLEMODELESS, PM_REMOVE);
|
|
TraceMsg(TF_SHDCONTROL, "shv CWebBrowserSB::_EnableModeless dispatching VBM_POSTENABLEMODELESS" );
|
|
DispatchMessage(&msg);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
else
|
|
{
|
|
// If we're a subframe
|
|
// AND the EnableModeless(FALSE) count (_cRefCannotNavigate) has become zero
|
|
// AND our window is disabled
|
|
// THEN the likely scenario is that VB5 failed to reenable us. Trace it and reenable
|
|
// ourselves.
|
|
//
|
|
if (!_fTopBrowser
|
|
&& _cRefCannotNavigate == 0
|
|
&& GetWindowLong(_bbd._hwnd, GWL_STYLE) & WS_DISABLED)
|
|
{
|
|
TraceMsg(TF_WARNING, "shv Subframe was left disabled. Reenabling ourselves.");
|
|
EnableWindow(_bbd._hwnd, TRUE);
|
|
}
|
|
}
|
|
}
|
|
else if (_psvo && _psvo->_pcli)
|
|
{
|
|
IShellBrowser* psbParent;
|
|
if (SUCCEEDED(IUnknown_QueryService(_psvo->_pcli, SID_SShellBrowser, IID_PPV_ARG(IShellBrowser, &psbParent))))
|
|
{
|
|
psbParent->EnableModelessSB(fEnable);
|
|
psbParent->Release();
|
|
}
|
|
}
|
|
else
|
|
{
|
|
IOIPAMSG(TEXT("_EnableModeless NOT forwarding on to _pipframe"));
|
|
}
|
|
}
|
|
else // DIRECTION_FORWARD_TO_CHILD
|
|
{
|
|
ASSERT(fDirection == DIRECTION_FORWARD_TO_CHILD);
|
|
if (_bbd._psv)
|
|
{
|
|
hres = _bbd._psv->EnableModelessSV(fEnable);
|
|
}
|
|
else
|
|
{
|
|
IOIPAMSG(TEXT("_EnableModeless NOT forwarding on to _psv"));
|
|
}
|
|
}
|
|
|
|
return hres;
|
|
}
|
|
|
|
HRESULT CWebBrowserSB::EnableModelessSB(BOOL fEnable)
|
|
{
|
|
return _EnableModeless(fEnable, DIRECTION_FORWARD_TO_PARENT);
|
|
}
|
|
|
|
HRESULT CWebBrowserSB::_TranslateAccelerator(LPMSG lpmsg, WORD wID, BOOL fDirection)
|
|
{
|
|
// see if we handle it
|
|
HRESULT hr = CBASEBROWSER::TranslateAcceleratorSB(lpmsg, wID);
|
|
if (hr == S_OK)
|
|
{
|
|
IOIPAMSG(TEXT("_TranslateAccelerator: CBASEBROWSER's TranslateAcceleratorSB handled it"));
|
|
}
|
|
else if (fDirection == DIRECTION_FORWARD_TO_PARENT)
|
|
{
|
|
if (_psvo && _psvo->_pipframe)
|
|
{
|
|
hr = _psvo->_pipframe->TranslateAccelerator(lpmsg, wID);
|
|
}
|
|
else
|
|
{
|
|
IOIPAMSG(TEXT("_TranslateAccelerator NOT forwarding on to _pipframe"));
|
|
hr = S_FALSE;
|
|
}
|
|
}
|
|
else // fDirection == DIRECTION_FORWARD_TO_CHILD
|
|
{
|
|
if (_bbd._psv)
|
|
{
|
|
hr = _bbd._psv->TranslateAccelerator(lpmsg);
|
|
}
|
|
else
|
|
{
|
|
IOIPAMSG(TEXT("_TranslateAccelerator NOT forwarding on to _psv"));
|
|
hr = S_FALSE;
|
|
}
|
|
}
|
|
|
|
return hr;
|
|
}
|
|
|
|
HRESULT CWebBrowserSB::TranslateAcceleratorSB(LPMSG lpmsg, WORD wID)
|
|
{
|
|
return _TranslateAccelerator(lpmsg, wID, DIRECTION_FORWARD_TO_PARENT);
|
|
}
|
|
|
|
HRESULT CWebBrowserSB::SendControlMsg(UINT id, UINT uMsg, WPARAM wParam,
|
|
LPARAM lParam, LRESULT * pret)
|
|
{
|
|
// let CBASEBROWSER try first so we get automation notifications working
|
|
HRESULT hres = CBASEBROWSER::SendControlMsg(id, uMsg, wParam, lParam, pret);
|
|
|
|
// if we're in a blocking frame, our GetControlWindow above will fail
|
|
// causing CBASEBROWSER to fail. try to map to an IOleInPlaceFrame call.
|
|
if (FAILED(hres) && _psvo)
|
|
{
|
|
// forward status bar text changes to the frame.
|
|
if ((id == FCW_STATUS) &&
|
|
(uMsg == SB_SETTEXT || uMsg == SB_SETTEXTW) && // trying to set status text
|
|
(!(wParam & SBT_OWNERDRAW)) && // we don't own the window -- this can't work
|
|
(((wParam & 0x00FF) == 0x00FF) || ((wParam & 0x00FF)== 0))) // simple or 0th item
|
|
{
|
|
WCHAR szStatusText[256];
|
|
|
|
if (uMsg == SB_SETTEXT) {
|
|
if (lParam)
|
|
{
|
|
SHTCharToUnicode((LPTSTR)lParam, szStatusText, ARRAYSIZE(szStatusText));
|
|
}
|
|
else
|
|
{
|
|
szStatusText[0] = L'\0';
|
|
}
|
|
|
|
lParam = (LPARAM) szStatusText;
|
|
}
|
|
else if (!lParam)
|
|
{
|
|
// uMsg == SB_SETTEXTW
|
|
// Found a container that doesn't like null string pointers. Pass an empty string instead.
|
|
// (IE v 4.1 bug 64629)
|
|
szStatusText[0] = 0;
|
|
lParam = (LPARAM) szStatusText;
|
|
}
|
|
|
|
if (_psvo->_pipframe)
|
|
{
|
|
if (pret)
|
|
{
|
|
*pret = 0;
|
|
}
|
|
hres = _psvo->_pipframe->SetStatusText((LPCOLESTR)lParam);
|
|
}
|
|
else
|
|
{
|
|
IOIPAMSG(TEXT("SetStatusTextSB NOT forwarding on to _pipframe"));
|
|
}
|
|
}
|
|
}
|
|
|
|
return hres;
|
|
}
|
|
|
|
|
|
HRESULT CWebBrowserSB::OnViewWindowActive(struct IShellView * psv)
|
|
{
|
|
if (_psvo)
|
|
{
|
|
// The view is notifying us that it just went UIActive,
|
|
// we need to update our state. OC_UIACTIVE normally
|
|
// tells the view to UIActivate itself, but in this case
|
|
// it already is. Avoid an infinite loop and pass FALSE.
|
|
_psvo->_DoActivateChange(NULL, OC_UIACTIVE, FALSE);
|
|
}
|
|
|
|
return CBASEBROWSER::OnViewWindowActive(psv);
|
|
}
|
|
|
|
|
|
LRESULT CWebBrowserSB::_DefWindowProc(HWND hwnd, UINT uMsg, WPARAM wParam, LPARAM lParam)
|
|
{
|
|
// explicitly do nothing...
|
|
// this is just to override CBASEBROWSER's _DefWindowProc.
|
|
return 0;
|
|
}
|
|
|
|
void CWebBrowserSB::_ViewChange(DWORD dwAspect, LONG lindex)
|
|
{
|
|
//
|
|
// forward this notify up to the OC's OBJECTCODE_VIEWCHANGE handler so it
|
|
// gets forwarded on to our container.
|
|
//
|
|
if (_psvo)
|
|
_psvo->_ViewChange(dwAspect, lindex);
|
|
|
|
//
|
|
// also let the base browser handle this view change in case nobody else is
|
|
// handling palette messages. most of the time this will be a nop but in
|
|
// the case where a WM_QUERYNEWPALETTE makes it down to us this will allow
|
|
// us to manage the palette properly.
|
|
//
|
|
CBASEBROWSER::_ViewChange(dwAspect, lindex);
|
|
}
|
|
|
|
HRESULT CWebBrowserSB::ActivatePendingView()
|
|
{
|
|
CVOCBMSG(TEXT("_ActivatePendingView"));
|
|
|
|
// CBASEBROWSER::_ActivatePendingView will send a NavigateComplete
|
|
// event. During this event our parent may destroy us. We then fault
|
|
// dereferencing _psvo below. So we need to wrap this function with
|
|
// an AddRef/Release. (bug 15424)
|
|
//
|
|
AddRef();
|
|
|
|
HRESULT hres = CBASEBROWSER::ActivatePendingView();
|
|
|
|
if (SUCCEEDED(hres) && _psvo)
|
|
_psvo->_OnSetShellView(_bbd._psv);
|
|
|
|
Release();
|
|
|
|
return hres;
|
|
}
|
|
|
|
HRESULT CWebBrowserSB::ReleaseShellView(void)
|
|
{
|
|
CVOCBMSG(TEXT("_ReleaseShellView"));
|
|
|
|
if (_psvo)
|
|
_psvo->_OnReleaseShellView();
|
|
|
|
return CBASEBROWSER::ReleaseShellView();
|
|
}
|
|
|
|
|
|
/// IBrowserService stuff
|
|
HRESULT CWebBrowserSB::GetParentSite(struct IOleInPlaceSite** ppipsite)
|
|
{
|
|
HRESULT hres = E_FAIL; // assume error
|
|
*ppipsite = NULL; // assume error
|
|
|
|
if (_psvo)
|
|
{
|
|
if (_psvo->_pipsite)
|
|
{
|
|
*ppipsite = _psvo->_pipsite;
|
|
_psvo->_pipsite->AddRef();
|
|
hres = S_OK;
|
|
}
|
|
else if (_psvo->_pcli)
|
|
{
|
|
hres = _psvo->_pcli->QueryInterface(IID_PPV_ARG(IOleInPlaceSite, ppipsite));
|
|
}
|
|
else
|
|
{
|
|
// Is it expected?
|
|
TraceMsg(DM_WARNING, "CWBSB::GetParentSite called when _pcli is NULL");
|
|
}
|
|
}
|
|
|
|
return hres;
|
|
}
|
|
|
|
#ifdef FEATURE_FRAMES
|
|
HRESULT CWebBrowserSB::GetOleObject(struct IOleObject** ppobjv)
|
|
{
|
|
if (_psvo == NULL)
|
|
{
|
|
*ppobjv = NULL;
|
|
return E_FAIL;
|
|
}
|
|
return _psvo->QueryInterface(IID_PPV_ARG(IOleObject, ppobjv));
|
|
}
|
|
#endif
|
|
|
|
HRESULT CWebBrowserSB::SetNavigateState(BNSTATE bnstate)
|
|
{
|
|
// Do our own things (such as firing events and update _fNavigate).
|
|
HRESULT hres = CBASEBROWSER::SetNavigateState(bnstate);
|
|
|
|
//
|
|
// Then, tell the container to update the download state.
|
|
// This will start the animation if this OC is either in a frameset
|
|
// or in a browser band.
|
|
//
|
|
VARIANTARG var;
|
|
var.vt = VT_I4;
|
|
var.lVal = _fNavigate;
|
|
Exec(NULL, OLECMDID_SETDOWNLOADSTATE, 0, &var, NULL);
|
|
|
|
return hres;
|
|
}
|
|
|
|
|
|
LRESULT CWebBrowserSB::OnNotify(LPNMHDR pnm)
|
|
{
|
|
switch(pnm->code)
|
|
{
|
|
case SEN_DDEEXECUTE:
|
|
{
|
|
IShellBrowser *psbTop;
|
|
if (pnm->idFrom == 0 && SUCCEEDED(_QueryServiceParent(SID_STopLevelBrowser, IID_PPV_ARG(IShellBrowser, &psbTop))))
|
|
{
|
|
HWND hwndTop;
|
|
|
|
psbTop->GetWindow(&hwndTop);
|
|
psbTop->Release();
|
|
if (psbTop != this)
|
|
return SendMessage(hwndTop, WM_NOTIFY, 0, (LPARAM)pnm);
|
|
}
|
|
break;
|
|
}
|
|
|
|
default:
|
|
return CBASEBROWSER::OnNotify(pnm);
|
|
}
|
|
|
|
return S_OK;
|
|
}
|
|
|
|
// IServiceProvider stuff
|
|
//
|
|
|
|
HRESULT CWebBrowserSB::_QueryServiceParent(REFGUID guidService, REFIID riid, void **ppvObj)
|
|
{
|
|
HRESULT hres = E_FAIL;
|
|
|
|
*ppvObj = NULL;
|
|
|
|
// Pass it on to our parent
|
|
if (_psvo && _psvo->_pcli)
|
|
{
|
|
hres = IUnknown_QueryService(_psvo->_pcli, guidService, riid, ppvObj);
|
|
}
|
|
else
|
|
{
|
|
CVOCBMSG(TEXT("QueryService doesn't have _pipsite!"));
|
|
}
|
|
|
|
return hres;
|
|
}
|
|
|
|
// NOTES:
|
|
// If SID_STopLevelBrowser, go to parent (upto the top level browser)
|
|
// If SID_SWebBrowserApp, go to parent (up to the top level browser automation)
|
|
// If SID_SContainerDispatch, expose CWebBrowserOC (instead of _pauto)
|
|
// Then, try CBASEBROWSER::QueryService, which will handle SID_SHlinkFrame,
|
|
// SID_SUrlHistory, SID_SShellBrowser, etc.
|
|
// If all fails and not SID_SShellBrowser, then we go up the parent chain.
|
|
//
|
|
HRESULT CWebBrowserSB::QueryService(REFGUID guidService, REFIID riid, void **ppvObj)
|
|
{
|
|
HRESULT hr = E_FAIL; // service object not found
|
|
|
|
*ppvObj = NULL; // assume error
|
|
|
|
// if the guidService is SID_QIClientSite then delegate the iid to the
|
|
// container through a queryinterface call.
|
|
if (_psvo && _psvo->_pcli && IsEqualGUID( guidService, SID_QIClientSite))
|
|
{
|
|
return _psvo->_pcli->QueryInterface( riid, ppvObj);
|
|
}
|
|
|
|
// If guidService is SID_STopLevelBrowser, we should not ask the super
|
|
// class to handle. Instead, we ask the parent to handle (if any).
|
|
if (IsEqualGUID(guidService, SID_STopLevelBrowser) ||
|
|
IsEqualGUID(guidService, SID_STopWindow))
|
|
{
|
|
// APPCOMPAT: WebBrowser is not supposed to respond to QS(SID_SInetExp) because
|
|
// it does not support IWebBrowserApp. However, rejecting this causes
|
|
// a stack fault when opening a frame-set. We need to find out what is causing
|
|
// this stack fault but I'll backup this delta for now to stop GPF.
|
|
//
|
|
// || IsEqualGUID(guidService, SID_SWebBrowserApp)
|
|
goto AskParent;
|
|
}
|
|
|
|
if (IsEqualGUID(guidService, SID_STopFrameBrowser))
|
|
{
|
|
BOOL fAskParent = TRUE;
|
|
|
|
// Don't ask the parent if we are a desktop component and we are
|
|
// not doing drag/drop. Treat it as a top level frame. For all other
|
|
// cases, ask the parent.
|
|
if (!IsEqualIID(riid, IID_IDropTarget) && _ptfrm)
|
|
{
|
|
IUnknown *pUnkParent;
|
|
if (SUCCEEDED(_ptfrm->GetParentFrame(&pUnkParent)))
|
|
{
|
|
if (pUnkParent)
|
|
{
|
|
// Has a parent, not a desktop component
|
|
pUnkParent->Release();
|
|
}
|
|
else
|
|
{
|
|
// Doesn't have a parent, must be a desktop component so
|
|
// fall through to call our CBASEBROWSER::QueryService
|
|
fAskParent = FALSE;
|
|
}
|
|
}
|
|
}
|
|
|
|
if (fAskParent)
|
|
goto AskParent;
|
|
}
|
|
|
|
// If the containee is asking for SID_SContainerDispatch (parent),
|
|
// we should return the automation interface of the buddy CWebBrowserOC.
|
|
if (IsEqualGUID(guidService, SID_SContainerDispatch))
|
|
{
|
|
if (_psvo)
|
|
{
|
|
return _psvo->QueryInterface(riid, ppvObj);
|
|
}
|
|
return E_UNEXPECTED;
|
|
}
|
|
|
|
// If the guidService is SID_SVersionHost,
|
|
// give the host a crack at it first
|
|
//
|
|
if (IsEqualGUID(guidService, SID_SVersionHost))
|
|
{
|
|
hr = _QueryServiceParent(guidService, riid, ppvObj);
|
|
|
|
// Return if the host handled the service,
|
|
//
|
|
if (S_OK == hr)
|
|
return hr;
|
|
}
|
|
|
|
hr = CBASEBROWSER::QueryService(guidService, riid, ppvObj);
|
|
|
|
// Notes: If guidService is SID_SShellBrowser, it indicates that
|
|
// the caller wants to talk to the immediate IShellBrowser.
|
|
// We should not try our parent in that case. Doing it so will
|
|
// break nested browser (frame set). In addition, notice that
|
|
// we don't want to go up the parent chain if hr is E_NOINTERFACE
|
|
// (which indicates unsuccessfull QueryInterface).
|
|
//
|
|
// We don't want a shell view in a frame-set add buttons on the
|
|
// toolbar. We should skip AskParent if guidService is SID_SExplroerToolbar.
|
|
|
|
if (FAILED(hr) && hr != E_NOINTERFACE
|
|
&& !IsEqualIID(guidService, SID_SShellBrowser)
|
|
&& !IsEqualIID(guidService, SID_SExplorerToolbar))
|
|
{
|
|
AskParent:
|
|
hr = _QueryServiceParent(guidService, riid, ppvObj);
|
|
|
|
// hey, we're the top-level browser if there ain't no top-level browser
|
|
// above us. (Such as our OC embedded in AOL/CIS/VB.) We must do this
|
|
// or we don't get a _tlGlobal on the top frame, so navigation history
|
|
// is screwy and the back/forward buttons are incorrect.
|
|
if (FAILED(hr) &&
|
|
(IsEqualGUID(guidService, SID_STopLevelBrowser) ||
|
|
IsEqualGUID(guidService, SID_STopFrameBrowser) ||
|
|
IsEqualGUID(guidService, SID_STopWindow)))
|
|
{
|
|
hr = CBASEBROWSER::QueryService(guidService, riid, ppvObj);
|
|
}
|
|
}
|
|
return hr;
|
|
}
|
|
|
|
|
|
// IOleCommandTarget
|
|
//
|
|
// We simply forward to the container above our parent OC
|
|
|
|
HRESULT CWebBrowserSB::QueryStatus(const GUID *pguidCmdGroup, ULONG cCmds, OLECMD rgCmds[], OLECMDTEXT *pcmdtext)
|
|
{
|
|
HRESULT hres = OLECMDERR_E_UNKNOWNGROUP;
|
|
HRESULT hresLocal;
|
|
|
|
if (pguidCmdGroup && IsEqualGUID(*pguidCmdGroup, CGID_ShellDocView))
|
|
{
|
|
hres = S_OK;
|
|
for (ULONG i=0 ; i < cCmds ; i++)
|
|
{
|
|
if (rgCmds[i].cmdID == SHDVID_CANGOBACK ||
|
|
rgCmds[i].cmdID == SHDVID_CANGOFORWARD)
|
|
{
|
|
hresLocal = CBASEBROWSER::QueryStatus(pguidCmdGroup, 1, &rgCmds[i], pcmdtext);
|
|
}
|
|
else if (_psvo && _psvo->_pctContainer)
|
|
{
|
|
hresLocal = _psvo->_pctContainer->QueryStatus(pguidCmdGroup, 1, &rgCmds[i], pcmdtext);
|
|
|
|
if (hresLocal == OLECMDERR_E_UNKNOWNGROUP || hresLocal == OLECMDERR_E_NOTSUPPORTED)
|
|
{
|
|
hresLocal = CBASEBROWSER::QueryStatus(pguidCmdGroup, cCmds, rgCmds, pcmdtext);
|
|
}
|
|
}
|
|
else
|
|
hresLocal = OLECMDERR_E_NOTSUPPORTED;
|
|
if (hresLocal != S_OK) hres = hresLocal;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
if (_psvo && _psvo->_pctContainer)
|
|
hres = _psvo->_pctContainer->QueryStatus(pguidCmdGroup, cCmds, rgCmds, pcmdtext);
|
|
|
|
// if container does not support the command try base browser
|
|
// before we only used to return an error
|
|
if (hres == OLECMDERR_E_UNKNOWNGROUP || hres == OLECMDERR_E_NOTSUPPORTED)
|
|
{
|
|
hres = CBASEBROWSER::QueryStatus(pguidCmdGroup, cCmds, rgCmds, pcmdtext);
|
|
}
|
|
}
|
|
|
|
return hres;
|
|
}
|
|
|
|
|
|
struct WBCMDLIST {
|
|
const GUID* pguidCmdGroup;
|
|
DWORD nCmdID;
|
|
};
|
|
|
|
//
|
|
// SBCMDID_CANCELNAVIGATION:
|
|
// Don't pass SBCMDID_CANCELNAVIGATION up to ROOT browser. Canceling
|
|
// here doesn't need to be forwarded and will cause navigations of to
|
|
// initiated by javascript: navigations in this frame to be aborted.
|
|
//
|
|
// SHDVID_ACTIVATEMENOW:
|
|
// The DocHost's request to activate the pending view must be handled
|
|
// by THIS browser, not the parent's -- if we're in a frameset page,
|
|
// we've probably already activated the top-level browser, now we may
|
|
// be trying to activate an individual frame.
|
|
//
|
|
const WBCMDLIST c_acmdWBSB[] = {
|
|
{ NULL, OLECMDID_HTTPEQUIV },
|
|
{ NULL, OLECMDID_HTTPEQUIV_DONE },
|
|
{ &CGID_ShellDocView, SHDVID_GETPENDINGOBJECT },
|
|
{ &CGID_ShellDocView, SHDVID_ACTIVATEMENOW },
|
|
{ &CGID_ShellDocView, SHDVID_DOCFAMILYCHARSET },
|
|
{ &CGID_Explorer, SBCMDID_CANCELNAVIGATION },
|
|
{ &CGID_Explorer, SBCMDID_CREATESHORTCUT },
|
|
{ &CGID_ShellDocView, SHDVID_CHECKINCACHEIFOFFLINE },
|
|
{ &CGID_ShellDocView, SHDVID_SETPRINTSTATUS },
|
|
{ &CGID_ShellDocView, SHDVID_FIREFILEDOWNLOAD },
|
|
{ &CGID_DocHostCmdPriv, DOCHOST_DOCCANNAVIGATE },
|
|
{ &CGID_InternetExplorer, IECMDID_BEFORENAVIGATE_GETSHELLBROWSE },
|
|
{ &CGID_InternetExplorer, IECMDID_BEFORENAVIGATE_DOEXTERNALBROWSE },
|
|
{ &CGID_InternetExplorer, IECMDID_BEFORENAVIGATE_GETIDLIST },
|
|
{ &CGID_DocHostCmdPriv, DOCHOST_SETBROWSERINDEX },
|
|
};
|
|
|
|
HRESULT CWebBrowserSB::Exec(const GUID *pguidCmdGroup, DWORD nCmdID, DWORD nCmdexecopt, VARIANTARG *pvarargIn, VARIANTARG *pvarargOut)
|
|
{
|
|
HRESULT hres = OLECMDERR_E_UNKNOWNGROUP;
|
|
|
|
//
|
|
// First, test if the spcified command is supposed to processed by
|
|
// this browser or not. If that's the case, just call CBASEBROWSER::Exec
|
|
// and return.
|
|
//
|
|
for (int i=0; i<ARRAYSIZE(c_acmdWBSB); i++)
|
|
{
|
|
if (nCmdID == c_acmdWBSB[i].nCmdID)
|
|
{
|
|
if (pguidCmdGroup==NULL || c_acmdWBSB[i].pguidCmdGroup==NULL)
|
|
{
|
|
if (pguidCmdGroup==c_acmdWBSB[i].pguidCmdGroup)
|
|
{
|
|
return CBASEBROWSER::Exec(pguidCmdGroup, nCmdID, nCmdexecopt, pvarargIn, pvarargOut);
|
|
}
|
|
}
|
|
else if (IsEqualGUID(*pguidCmdGroup, *c_acmdWBSB[i].pguidCmdGroup))
|
|
{
|
|
return CBASEBROWSER::Exec(pguidCmdGroup, nCmdID, nCmdexecopt, pvarargIn, pvarargOut);
|
|
}
|
|
}
|
|
}
|
|
|
|
// In some cases, we need perform some additional operations
|
|
// before passing it to the parent.
|
|
//
|
|
if (pguidCmdGroup == NULL)
|
|
{
|
|
switch(nCmdID) {
|
|
case OLECMDID_SETDOWNLOADSTATE:
|
|
if (pvarargIn)
|
|
{
|
|
_setDescendentNavigate(pvarargIn);
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
else if (IsEqualGUID(*pguidCmdGroup, CGID_ShellDocView))
|
|
{
|
|
switch (nCmdID)
|
|
{
|
|
/* The DocHost's request to activate the pending view must be handled
|
|
* by THIS browser, not the parent's -- then we forward up the chain
|
|
* so that all potentially blocked frames can attempt to deactivate
|
|
*/
|
|
case SHDVID_DEACTIVATEMENOW:
|
|
if (_cbScriptNesting > 0)
|
|
_cbScriptNesting--;
|
|
hres = CBASEBROWSER::Exec(pguidCmdGroup, nCmdID, nCmdexecopt, pvarargIn, pvarargOut);
|
|
if (FAILED(hres) || _cbScriptNesting > 0)
|
|
return hres;
|
|
break;
|
|
|
|
case SHDVID_NODEACTIVATENOW:
|
|
_cbScriptNesting++;
|
|
if (_cbScriptNesting > 1)
|
|
return S_OK;
|
|
break;
|
|
|
|
case SHDVID_DELEGATEWINDOWOM:
|
|
if (_psvo && _psvo->_pauto)
|
|
{
|
|
// Forward this command to the CIEFrameAuto instance for this webOC.
|
|
return IUnknown_Exec(_psvo->_pauto, &CGID_ShellDocView, nCmdID, 0, pvarargIn, NULL);
|
|
}
|
|
break;
|
|
|
|
}
|
|
}
|
|
else if (IsEqualGUID(*pguidCmdGroup, CGID_Explorer))
|
|
{
|
|
// this needs to be handled by the specific browser that
|
|
// received the exec.
|
|
switch (nCmdID)
|
|
{
|
|
case SBCMDID_UPDATETRAVELLOG:
|
|
case SBCMDID_REPLACELOCATION:
|
|
return CBASEBROWSER::Exec(pguidCmdGroup, nCmdID, nCmdexecopt, pvarargIn, pvarargOut);
|
|
|
|
case SBCMDID_SETSECURELOCKICON:
|
|
{
|
|
CBASEBROWSER::Exec(pguidCmdGroup, nCmdID, nCmdexecopt, pvarargIn, pvarargOut);
|
|
|
|
// Let the WebBrowserOC fire the event
|
|
if (_psvo)
|
|
{
|
|
_psvo->_OnSetSecureLockIcon(_bbd._eSecureLockIcon);
|
|
}
|
|
}
|
|
return S_OK;
|
|
}
|
|
}
|
|
else if (IsEqualGUID(CGID_ExplorerBarDoc, *pguidCmdGroup))
|
|
{
|
|
// These are ignored so that Explorer bar changes are done once - and only in response to
|
|
// global changes applied to top Document if frameset of browser.
|
|
// NOT for changes applied to frames
|
|
// NOT for changes applied to browserbands
|
|
return S_OK;
|
|
}
|
|
|
|
//
|
|
// Forward this EXEC to the container (if we have).
|
|
//
|
|
if (_psvo && _psvo->_pctContainer)
|
|
hres = _psvo->_pctContainer->Exec(pguidCmdGroup, nCmdID, nCmdexecopt, pvarargIn, pvarargOut);
|
|
|
|
//
|
|
// if the above exec failed, we're probably in some random container
|
|
// so let CBASEBROWSER try to simulate a top-level frame.
|
|
// might as well be a bit paranoid and make sure it failed with "i dunno"
|
|
//
|
|
if (hres == OLECMDERR_E_UNKNOWNGROUP || hres == OLECMDERR_E_NOTSUPPORTED)
|
|
{
|
|
if (pguidCmdGroup==NULL && nCmdID==OLECMDID_SETDOWNLOADSTATE && _psvo)
|
|
{
|
|
TraceMsg(DM_FORSEARCHBAND, "WBSB::QueryStatus Container does not support OLECMDID_SETDOWNLOADSTATE");
|
|
hres = _psvo->_SetDownloadState(hres, nCmdexecopt, pvarargIn);
|
|
}
|
|
|
|
if (hres != S_OK)
|
|
{
|
|
hres = CBASEBROWSER::Exec(pguidCmdGroup, nCmdID, nCmdexecopt, pvarargIn, pvarargOut);
|
|
}
|
|
}
|
|
|
|
return hres;
|
|
}
|
|
|
|
|
|
HRESULT CWebBrowserSB::_SwitchActivationNow()
|
|
{
|
|
CBASEBROWSER::_SwitchActivationNow();
|
|
|
|
if (_bbd._psv &&
|
|
_psvo &&
|
|
_psvo->_nActivate < OC_INPLACEACTIVE &&
|
|
_psvo->_dwDrawAspect)
|
|
{
|
|
// pass on the SetExtent to the now ready browser...
|
|
IPrivateOleObject * pPrivOle;
|
|
if (SUCCEEDED(_bbd._psv->QueryInterface(IID_PPV_ARG(IPrivateOleObject, &pPrivOle))))
|
|
{
|
|
// we have an ole object, delegate downwards...
|
|
pPrivOle->SetExtent( _psvo->_dwDrawAspect, &_psvo->_sizeHIM );
|
|
pPrivOle->Release();
|
|
}
|
|
}
|
|
return S_OK;
|
|
}
|
|
|
|
BOOL CWebBrowserSB::_HeyMoe_IsWiseGuy()
|
|
{
|
|
BOOL fRet;
|
|
|
|
if (_psvo)
|
|
{
|
|
fRet = _psvo->_HeyMoe_IsWiseGuy();
|
|
}
|
|
else
|
|
{
|
|
fRet = FALSE;
|
|
}
|
|
|
|
return fRet;
|
|
}
|
|
|
|
HRESULT CWebBrowserSB::BrowseObject(LPCITEMIDLIST pidl, UINT wFlags)
|
|
{
|
|
// if client does not specify we will do so for them
|
|
if (SBSP_DEFBROWSER == (wFlags & (SBSP_NEWBROWSER | SBSP_SAMEBROWSER)))
|
|
{
|
|
IShellBrowser *psbDesktop;
|
|
if (SUCCEEDED(QueryService(SID_SShellDesktop, IID_PPV_ARG(IShellBrowser, &psbDesktop))))
|
|
{
|
|
HRESULT hr = psbDesktop->BrowseObject(pidl, wFlags);
|
|
psbDesktop->Release();
|
|
return hr;
|
|
}
|
|
wFlags |= SBSP_SAMEBROWSER; // always navigate in place
|
|
}
|
|
|
|
return CBASEBROWSER::BrowseObject(pidl, wFlags);
|
|
}
|
|
|