reactos/modules/rosapps/applications/explorer-old/shell/webchild.h

1019 lines
25 KiB
C++

/*
* Copyright 2004, 2005 Martin Fuchs
*
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public
* License as published by the Free Software Foundation; either
* version 2.1 of the License, or (at your option) any later version.
*
* This library is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public
* License along with this library; if not, write to the Free Software
* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
*/
//
// Explorer clone
//
// webchild.h
//
// Martin Fuchs, 08.02.2004
//
#ifndef _MSC_VER
#include <exdisp.h> // for IConnectionPointContainer
#include <exdispid.h> // for DWebBrowserEvents2 IDs
#endif
#ifndef DISPID_BEFORENAVIGATE // missing in MinGW (as of 07.02.2004)
#define DISPID_BEFORENAVIGATE 100
#define DISPID_NAVIGATECOMPLETE 101
#define DISPID_STATUSTEXTCHANGE 102
#define DISPID_QUIT 103
#define DISPID_DOWNLOADCOMPLETE 104
#define DISPID_COMMANDSTATECHANGE 105
#define DISPID_DOWNLOADBEGIN 106
#define DISPID_NEWWINDOW 107
#define DISPID_PROGRESSCHANGE 108
#define DISPID_WINDOWMOVE 109
#define DISPID_WINDOWRESIZE 110
#define DISPID_WINDOWACTIVATE 111
#define DISPID_PROPERTYCHANGE 112
#define DISPID_TITLECHANGE 113
#define DISPID_TITLEICONCHANGE 114
#define DISPID_FRAMEBEFORENAVIGATE 200
#define DISPID_FRAMENAVIGATECOMPLETE 201
#define DISPID_FRAMENEWWINDOW 204
#define DISPID_NAVIGATECOMPLETE2 252
#define DISPID_ONQUIT 253
#define DISPID_ONVISIBLE 254
#define DISPID_ONTOOLBAR 255
#define DISPID_ONMENUBAR 256
#define DISPID_ONSTATUSBAR 257
#define DISPID_ONFULLSCREEN 258
#define DISPID_DOCUMENTCOMPLETE 259
#define DISPID_ONTHEATERMODE 260
#define DISPID_ONADDRESSBAR 261
#define DISPID_WINDOWSETRESIZABLE 262
#define DISPID_WINDOWCLOSING 263
#define DISPID_WINDOWSETLEFT 264
#define DISPID_WINDOWSETTOP 265
#define DISPID_WINDOWSETWIDTH 266
#define DISPID_WINDOWSETHEIGHT 267
#define DISPID_CLIENTTOHOSTWINDOW 268
#define DISPID_SETSECURELOCKICON 269
#define DISPID_FILEDOWNLOAD 270
#define DISPID_NAVIGATEERROR 271
#define DISPID_PRIVACYIMPACTEDSTATECHANGE 272
#endif
#ifndef V_INT // missing in MinGW (as of 07.02.2004)
#define V_INT(x) V_UNION(x, intVal)
#endif
#ifdef _MSC_VER
#pragma warning(disable: 4355) // use of 'this' for initialization of _connector
#endif
template<typename T> struct ConnectionPoint : public SIfacePtr<T>
{
ConnectionPoint(IConnectionPointContainer* pCPC, REFIID riid)
{
CheckError(pCPC->FindConnectionPoint(riid, &this->_p));
}
};
struct EventConnection
{
EventConnection(IConnectionPoint* connectionpoint, IUnknown* sink)
{
CheckError(connectionpoint->Advise(sink, &_cookie));
_connectionpoint = connectionpoint;
}
template<typename T> EventConnection(T& connectionpoint, IUnknown* sink)
{
CheckError(connectionpoint->Advise(sink, &_cookie));
_connectionpoint = connectionpoint;
}
/* template<typename T> EventConnection(SIfacePtr<T>& connectionpoint, IUnknown* sink)
{
CheckError(connectionpoint->Advise(sink, &_cookie));
_connectionpoint = connectionpoint.GetPtr();
} */
/* template<typename T> EventConnection(T& connectionpoint, IUnknown* sink)
{
CheckError(connectionpoint->Advise(sink, &_cookie));
_connectionpoint = connectionpoint;
} */
~EventConnection()
{
if (_connectionpoint)
_connectionpoint->Unadvise(_cookie);
}
protected:
SIfacePtr<IConnectionPoint> _connectionpoint;
DWORD _cookie;
};
struct EventConnector : public EventConnection
{
EventConnector(IUnknown* unknown, REFIID riid, IUnknown* sink)
: EventConnection(ConnectionPoint<IConnectionPoint>(
SIfacePtr<IConnectionPointContainer>(unknown, IID_IConnectionPointContainer), riid), sink)
{
}
};
struct OleInPlaceClient : public SimpleComObject,
public IOleClientSite,
public IOleInPlaceSite
{
protected:
HWND _hwnd;
public:
OleInPlaceClient(HWND hwnd=0)
: _hwnd(hwnd)
{
}
void attach(HWND hwnd)
{
_hwnd = hwnd;
}
HRESULT attach_control(IOleObject* ole_obj, LONG iVerb=OLEIVERB_INPLACEACTIVATE, HWND hwndParent=0, LPCRECT pRect=NULL)
{
HRESULT hr = ole_obj->SetClientSite(this);
if (FAILED(hr))
return hr;
// hr = ole_obj->SetHostNames(app, doc));
hr = ole_obj->DoVerb(iVerb, NULL, this, 0, 0/*hwnd*/, NULL/*&rcPos*/);
return hr;
}
HRESULT detach(IOleObject* ole_obj, DWORD dwSaveOption=OLECLOSE_SAVEIFDIRTY)
{
HRESULT hr = ole_obj->Close(dwSaveOption);
_hwnd = 0;
return hr;
}
STDMETHODIMP QueryInterface(REFIID riid, LPVOID* ppv)
{
if (IsEqualIID(riid, IID_IOleClientSite))
{*ppv=static_cast<IOleClientSite*>(this); IncRef(); return S_OK;}
if (IsEqualIID(riid, IID_IOleInPlaceSite))
{*ppv=static_cast<IOleInPlaceSite*>(this); IncRef(); return S_OK;}
if (IsEqualIID(riid, IID_IUnknown))
{*ppv=static_cast<IOleClientSite/*oder auch IOleInPlaceSite*/*>(this); IncRef(); return S_OK;}
return E_NOINTERFACE;
}
STDMETHODIMP_(ULONG) AddRef() {return IncRef();}
STDMETHODIMP_(ULONG) Release() {return DecRef();}
// IOleWindow:
virtual /* [input_sync] */ HRESULT STDMETHODCALLTYPE GetWindow(/* [out] */ HWND __RPC_FAR *phwnd)
{
*phwnd = _hwnd;
return S_OK;
}
virtual HRESULT STDMETHODCALLTYPE ContextSensitiveHelp(/* [in] */ BOOL fEnterMode)
{
return E_NOTIMPL;
}
// IOleClientSite:
virtual HRESULT STDMETHODCALLTYPE SaveObject()
{
return E_NOTIMPL;
}
virtual HRESULT STDMETHODCALLTYPE GetMoniker(DWORD dwAssign, DWORD dwWhichMoniker, IMoniker __RPC_FAR *__RPC_FAR *ppmk)
{
return E_NOTIMPL;
}
virtual HRESULT STDMETHODCALLTYPE GetContainer(IOleContainer __RPC_FAR *__RPC_FAR *ppContainer)
{
ppContainer = 0;
return E_NOINTERFACE;
}
virtual HRESULT STDMETHODCALLTYPE ShowObject()
{
return S_OK;
}
virtual HRESULT STDMETHODCALLTYPE OnShowWindow(BOOL fShow)
{
return S_OK;
}
virtual HRESULT STDMETHODCALLTYPE RequestNewObjectLayout()
{
return S_OK;
}
// IOleInPlaceSite:
virtual HRESULT STDMETHODCALLTYPE CanInPlaceActivate()
{
return S_OK;
}
virtual HRESULT STDMETHODCALLTYPE OnInPlaceActivate()
{
return S_OK;
}
virtual HRESULT STDMETHODCALLTYPE OnUIActivate()
{
return S_OK;
}
virtual HRESULT STDMETHODCALLTYPE GetWindowContext(
/* [out] */ IOleInPlaceFrame __RPC_FAR *__RPC_FAR *ppFrame,
/* [out] */ IOleInPlaceUIWindow __RPC_FAR *__RPC_FAR *ppDoc,
/* [out] */ LPRECT lprcPosRect,
/* [out] */ LPRECT lprcClipRect,
/* [out][in] */ LPOLEINPLACEFRAMEINFO lpFrameInfo)
{
ClientRect rect(_hwnd);
ppFrame = 0;
ppDoc = 0;
*lprcPosRect = rect;
*lprcClipRect = rect;
assert(lpFrameInfo->cb>=sizeof(OLEINPLACEFRAMEINFO));
lpFrameInfo->fMDIApp = FALSE; //@@
lpFrameInfo->hwndFrame = 0;
lpFrameInfo->haccel = 0;
lpFrameInfo->cAccelEntries = 0;
return S_OK;
}
virtual HRESULT STDMETHODCALLTYPE Scroll(/* [in] */ SIZE scrollExtant)
{
return S_OK;
}
virtual HRESULT STDMETHODCALLTYPE OnUIDeactivate(/* [in] */ BOOL fUndoable)
{
return S_OK;
}
virtual HRESULT STDMETHODCALLTYPE OnInPlaceDeactivate()
{
return S_OK;
}
virtual HRESULT STDMETHODCALLTYPE DiscardUndoState()
{
return S_OK;
}
virtual HRESULT STDMETHODCALLTYPE DeactivateAndUndo()
{
return S_OK;
}
virtual HRESULT STDMETHODCALLTYPE OnPosRectChange(/* [in] */ LPCRECT lprcPosRect)
{
return S_OK;
}
};
// window with in place activates Active-X Control
template<typename BASE, typename SMARTPTR> struct IPCtrlWindow : public BASE
{
typedef BASE super;
IPCtrlWindow(HWND hwnd)
: super(hwnd)
{
}
template<typename T> IPCtrlWindow(HWND hwnd, T& info)
: super(hwnd, info)
{
}
HRESULT create_control(HWND hwnd, REFIID clsid, REFIID riid)
{
// Erzeugen einer Instanz des Controls
HRESULT hr = _control.CreateInstance(clsid, riid);
if (FAILED(hr))
return hr;
_client_side.attach(hwnd);
hr = _client_side.attach_control(SIfacePtr<IOleObject>(_control, IID_IOleObject)/*, OLEIVERB_INPLACEACTIVATE,
hwnd, &Rect(10, 10, 500, 500)*/);
if (FAILED(hr))
return hr;
// try to get a IOleInPlaceObject interface for window resizing
return _control.QueryInterface(IID_IOleInPlaceObject, &_in_place_object); // _in_place_object = _control
}
protected:
LRESULT WndProc(UINT nmsg, WPARAM wparam, LPARAM lparam)
{
if (nmsg == WM_SIZE) {
if (_in_place_object) {
RECT rect = {0, 0, LOWORD(lparam), HIWORD(lparam)};
_in_place_object->SetObjectRects(&rect, &rect);
}
} else if (nmsg == WM_CLOSE) {
_in_place_object = NULL;
if (_control) {
_client_side.detach(SIfacePtr<IOleObject>(_control, IID_IOleObject), OLECLOSE_NOSAVE);
_control = NULL;
}
}
return super::WndProc(nmsg, wparam, lparam);
}
ComInit _usingCOM;
SMARTPTR _control;
OleInPlaceClient _client_side;
SIfacePtr<IOleInPlaceObject> _in_place_object;
};
#include "exdispid.h"
struct DWebBrowserEvents2IF
{
virtual ~DWebBrowserEvents2IF() {}
virtual void StatusTextChange(const BStr& text)
{}
virtual void ProgressChange(long progress, long progressMax)
{}
virtual void WindowMove()
{}
virtual void WindowResize()
{}
virtual void WindowActivate()
{}
virtual void PropertyChange(const BStr& property)
{}
virtual void DownloadComplete()
{}
virtual void CommandStateChange(long command, bool enable)
{}
virtual void DownloadBegin()
{}
virtual void NewWindow2(IDispatch** ppDisp, VARIANT_BOOL& cancel)
{}
virtual void TitleChange(const BStr& text)
{}
virtual void TitleIconChange(const BStr& text)
{}
virtual void FrameBeforeNavigate(const BStr& url, long flags, const BStr& targetFrameName, VARIANT* postData, const BStr& headers, VARIANT_BOOL& cancel)
{}
virtual void FrameNavigateComplete(const BStr& url)
{}
virtual void FrameNewWindow(const BStr&url, long flags, const BStr& targetFrameName, VARIANT* postData, const BStr& headers, VARIANT_BOOL& processed)
{}
virtual void BeforeNavigate2(IDispatch* pDisp, const Variant& url, const Variant& flags,
const Variant& targetFrameName, const Variant& postData,
const Variant& headers, VARIANT_BOOL& cancel)
{}
virtual void NavigateComplete2(IDispatch* pDisp, const Variant& url)
{}
virtual void OnQuit()
{}
virtual void OnVisible(bool Visible)
{}
virtual void OnToolbar(bool Visible)
{}
virtual void OnMenubar(bool Visible)
{}
virtual void OnStatusbar(bool Visible)
{}
virtual void OnFullscreen(bool Visible)
{}
virtual void DocumentComplete()
{}
virtual void OnTheatermode(bool Visible)
{}
virtual void OnAddressbar(bool Visible)
{}
virtual void WindowSetResizable(bool Visible)
{}
virtual void WindowClosing(VARIANT_BOOL IsChildWindow, VARIANT_BOOL& cancel)
{}
virtual void WindowSetLeft(long Left)
{}
virtual void WindowSetTop(long Top)
{}
virtual void WindowSetWidth(long Width)
{}
virtual void WindowSetHeight(long Height)
{}
virtual void ClientToHostWindow(long& CX, long& CY)
{}
virtual void SetSecureLockIcon(long SecureLockIcon)
{}
virtual void FileDownload(Variant& cancel)
{}
virtual void NavigateError(IDispatch* pDisp, const Variant& url, const Variant& Frame, const Variant& StatusCode, VARIANT_BOOL& cancel)
{}
virtual void PrivacyImpactedStateChange(bool bImpacted)
{}
};
// The web browser control has to be initialized completely before being able,
// to display a page, that does not access internet.
struct ANSUNC BrowserNavigator
{
BrowserNavigator();
void attach(IWebBrowser* browser);
void goto_url(LPCTSTR url);
void set_html_page(const String& html_txt);
void navigated(LPCTSTR url);
IWebBrowser* get_browser() {return _browser.get();}
protected:
SIfacePtr<IWebBrowser> _browser;
String _new_url;
String _new_html_txt;
bool _browser_initialized;
};
// MinGW defines a wrong FixedDWebBrowserEvents2 interface with virtual functions for DISPID calls, so we use our own, corrected version:
interface FixedDWebBrowserEvents2 : public IDispatch
{
#ifdef __GNUC__
virtual ~FixedDWebBrowserEvents2() {}
#endif
};
struct ANSUNC DWebBrowserEvents2Impl
: public IComSrvBase<FixedDWebBrowserEvents2, DWebBrowserEvents2Impl>, public SimpleComObject,
public DWebBrowserEvents2IF
{
typedef IComSrvBase<FixedDWebBrowserEvents2, DWebBrowserEvents2Impl> super;
DWebBrowserEvents2IF* _callback;
DWebBrowserEvents2Impl(BrowserNavigator& navigator)
: super(DIID_DWebBrowserEvents2),
_navigator(navigator)
{
_callback = this;
}
/* // IUnknown
STDMETHOD(QueryInterface)(REFIID riid, LPVOID* ppv)
{
*ppv = NULL;
if (SUCCEEDED(super::QueryInterface(riid, ppv)))
return S_OK;
return E_NOINTERFACE;
} */
// IDispatch
STDMETHOD(GetTypeInfoCount)(UINT* pctinfo)
{return E_NOTIMPL;}
STDMETHOD(GetTypeInfo)(UINT iTInfo, LCID lcid, ITypeInfo** ppTInfo)
{return E_NOTIMPL;}
STDMETHOD(GetIDsOfNames)(REFIID riid, LPOLESTR* rgszNames, UINT cNames, LCID lcid, DISPID* rgDispId)
{return E_NOTIMPL;}
STDMETHOD(Invoke)(DISPID dispIdMember, REFIID riid, LCID lcid, WORD wFlags,
DISPPARAMS __RPC_FAR *pDispParams, VARIANT __RPC_FAR *pVarResult, EXCEPINFO __RPC_FAR *pExcepInfo, UINT __RPC_FAR *puArgErr)
{
switch(dispIdMember) {
case DISPID_STATUSTEXTCHANGE:
_callback->StatusTextChange((BStr)Variant(pDispParams->rgvarg[0]));
break;
case DISPID_COMMANDSTATECHANGE:
_callback->CommandStateChange(Variant(pDispParams->rgvarg[1]), Variant(pDispParams->rgvarg[0]));
break;
case DISPID_DOWNLOADBEGIN:
_callback->DownloadBegin();
break;
case DISPID_PROGRESSCHANGE: // sent when download progress is updated
_callback->ProgressChange(Variant(pDispParams->rgvarg[1]), Variant(pDispParams->rgvarg[0]));
break;
case DISPID_WINDOWMOVE: // sent when main window has been moved
_callback->WindowMove();
break;
case DISPID_WINDOWRESIZE: // sent when main window has been sized
_callback->WindowResize();
break;
case DISPID_WINDOWACTIVATE: // sent when main window has been activated
_callback->WindowActivate();
break;
case DISPID_PROPERTYCHANGE: // sent when the PutProperty method is called
_callback->PropertyChange((BStr)Variant(pDispParams->rgvarg[0]));
break;
case DISPID_TITLECHANGE: // sent when the document title changes
_callback->TitleChange((BStr)Variant(pDispParams->rgvarg[0]));
break;
case DISPID_TITLEICONCHANGE: // sent when the top level window icon may have changed.
_callback->TitleIconChange((BStr)Variant(pDispParams->rgvarg[0]));
break;
// anything below here is not present in DWebBrowserEvents, only in DWebBrowserEvents2: ->
case DISPID_FRAMEBEFORENAVIGATE:
if (pDispParams->cArgs != 6)
return E_INVALIDARG;
if (V_VT(&pDispParams->rgvarg[0]) != (VT_BOOL|VT_BYREF))
return E_INVALIDARG;
_callback->FrameBeforeNavigate(
(BStr)Variant(&pDispParams->rgvarg[5]), Variant(&pDispParams->rgvarg[4]),
(BStr)Variant(&pDispParams->rgvarg[3]), &pDispParams->rgvarg[2],
(BStr)Variant(&pDispParams->rgvarg[1]), *V_BOOLREF(&pDispParams->rgvarg[0]));
break;
case DISPID_FRAMENAVIGATECOMPLETE:
if (pDispParams->cArgs != 1)
return E_INVALIDARG;
_callback->FrameNavigateComplete((BStr)Variant(pDispParams->rgvarg[0]));
break;
case DISPID_FRAMENEWWINDOW:
if (pDispParams->cArgs != 6)
return E_INVALIDARG;
if (V_VT(&pDispParams->rgvarg[0]) != (VT_BOOL|VT_BYREF))
return E_INVALIDARG;
_callback->FrameNewWindow((BStr)Variant(&pDispParams->rgvarg[5]), Variant(&pDispParams->rgvarg[4]),
(BStr)Variant(&pDispParams->rgvarg[3]), &pDispParams->rgvarg[2],
(BStr)Variant(&pDispParams->rgvarg[1]), *V_BOOLREF(&pDispParams->rgvarg[0]));
break;
case DISPID_BEFORENAVIGATE2: // hyperlink clicked on
if (pDispParams->cArgs != 7)
return E_INVALIDARG;
if (V_VT(&pDispParams->rgvarg[0]) != (VT_BOOL|VT_BYREF))
return E_INVALIDARG;
_callback->BeforeNavigate2(Variant(pDispParams->rgvarg[6]),
pDispParams->rgvarg[5], &pDispParams->rgvarg[4],
pDispParams->rgvarg[3], &pDispParams->rgvarg[2],
pDispParams->rgvarg[1], *V_BOOLREF(&pDispParams->rgvarg[0]));
break;
case DISPID_NEWWINDOW2: // sent when a new window should be created
if (pDispParams->cArgs != 2)
return E_INVALIDARG;
if (V_VT(&pDispParams->rgvarg[0]) != (VT_BOOL|VT_BYREF))
return E_INVALIDARG;
if (V_VT(&pDispParams->rgvarg[1]) != (VT_DISPATCH|VT_BYREF))
return E_INVALIDARG;
_callback->NewWindow2(V_DISPATCHREF(&pDispParams->rgvarg[1]), *V_BOOLREF(&pDispParams->rgvarg[0]));
break;
case DISPID_NAVIGATECOMPLETE2:// UIActivate new document
if (pDispParams->cArgs != 2)
return E_INVALIDARG;
// notify the navigator
NavigateComplete2(Variant(pDispParams->rgvarg[1]), Variant(pDispParams->rgvarg[0]));
_callback->NavigateComplete2(Variant(pDispParams->rgvarg[1]), Variant(pDispParams->rgvarg[0]));
break;
case DISPID_ONQUIT:
_callback->OnQuit();
break;
case DISPID_ONVISIBLE: // sent when the window goes visible/hidden
if (pDispParams->cArgs != 1)
return E_INVALIDARG;
_callback->OnVisible(Variant(pDispParams->rgvarg[0]));
break;
case DISPID_ONTOOLBAR: // sent when the toolbar should be shown/hidden
if (pDispParams->cArgs != 1)
return E_INVALIDARG;
_callback->OnToolbar(Variant(pDispParams->rgvarg[0]));
break;
case DISPID_ONMENUBAR: // sent when the menubar should be shown/hidden
if (pDispParams->cArgs != 1)
return E_INVALIDARG;
_callback->OnMenubar(Variant(pDispParams->rgvarg[0]));
break;
case DISPID_ONSTATUSBAR: // sent when the statusbar should be shown/hidden
if (pDispParams->cArgs != 1)
return E_INVALIDARG;
_callback->OnStatusbar(Variant(pDispParams->rgvarg[0]));
break;
case DISPID_ONFULLSCREEN: // sent when kiosk mode should be on/off
if (pDispParams->cArgs != 1)
return E_INVALIDARG;
_callback->OnFullscreen(Variant(pDispParams->rgvarg[0]));
break;
case DISPID_DOCUMENTCOMPLETE:// new document goes ReadyState_Complete
_callback->DocumentComplete();
break;
case DISPID_DOWNLOADCOMPLETE:
_callback->DownloadComplete();
break;
case DISPID_ONTHEATERMODE: // sent when theater mode should be on/off
if (pDispParams->cArgs != 1)
return E_INVALIDARG;
_callback->OnTheatermode(Variant(pDispParams->rgvarg[0]));
break;
case DISPID_ONADDRESSBAR: // sent when the address bar should be shown/hidden
if (pDispParams->cArgs != 1)
return E_INVALIDARG;
_callback->OnAddressbar(Variant(pDispParams->rgvarg[0]));
break;
case DISPID_WINDOWSETRESIZABLE:// sent to set the style of the host window frame
if (pDispParams->cArgs != 1)
return E_INVALIDARG;
_callback->WindowSetResizable(Variant(pDispParams->rgvarg[0]));
break;
case DISPID_WINDOWCLOSING: // sent before script window.close closes the window
if (pDispParams->cArgs != 2)
return E_INVALIDARG;
if (V_VT(&pDispParams->rgvarg[0]) != (VT_BOOL|VT_BYREF))
return E_INVALIDARG;
_callback->WindowClosing(Variant(pDispParams->rgvarg[1]), *V_BOOLREF(&pDispParams->rgvarg[0]));
break;
case DISPID_WINDOWSETLEFT: // sent when the put_left method is called on the WebOC
if (pDispParams->cArgs != 1)
return E_INVALIDARG;
_callback->WindowSetLeft(Variant(pDispParams->rgvarg[0]));
break;
case DISPID_WINDOWSETTOP: // sent when the put_top method is called on the WebOC
if (pDispParams->cArgs != 1)
return E_INVALIDARG;
_callback->WindowSetTop(Variant(pDispParams->rgvarg[0]));
break;
case DISPID_WINDOWSETWIDTH: // sent when the put_width method is called on the WebOC
if (pDispParams->cArgs != 1)
return E_INVALIDARG;
_callback->WindowSetWidth(Variant(pDispParams->rgvarg[0]));
break;
case DISPID_WINDOWSETHEIGHT: // sent when the put_height method is called on the WebOC
if (pDispParams->cArgs != 1)
return E_INVALIDARG;
_callback->WindowSetHeight(Variant(pDispParams->rgvarg[0]));
break;
case DISPID_CLIENTTOHOSTWINDOW:// sent during window.open to request conversion of dimensions
{
long cx, cy;
if (pDispParams->cArgs != 2)
return E_INVALIDARG;
if (V_VT(&pDispParams->rgvarg[0]) != (VT_I4|VT_BYREF))
return E_INVALIDARG;
if (V_VT(&pDispParams->rgvarg[1]) != (VT_I4|VT_BYREF))
return E_INVALIDARG;
cx = *V_I4REF(&pDispParams->rgvarg[1]);
cy = *V_I4REF(&pDispParams->rgvarg[0]);
_callback->ClientToHostWindow(cx, cy);
break;
}
case DISPID_SETSECURELOCKICON:// sent to suggest the appropriate security icon to show
if (pDispParams->cArgs != 1)
return E_INVALIDARG;
_callback->SetSecureLockIcon(Variant(pDispParams->rgvarg[0]));
break;
case DISPID_FILEDOWNLOAD: { // Fired to indicate the File Download dialog is opening
if (pDispParams->cArgs != 1) //@@ every time 2 ?!
return E_INVALIDARG;
Variant var(pDispParams->rgvarg[0]);
_callback->FileDownload(var);}
break;
case DISPID_NAVIGATEERROR: // Fired to indicate the a binding error has occured
if (pDispParams->cArgs != 5)
return E_INVALIDARG;
if (V_VT(&pDispParams->rgvarg[0]) != (VT_BOOL|VT_BYREF))
return E_INVALIDARG;
_callback->NavigateError(Variant(pDispParams->rgvarg[4]), Variant(pDispParams->rgvarg[3]),
Variant(pDispParams->rgvarg[2]), Variant(pDispParams->rgvarg[1]),
*V_BOOLREF(&pDispParams->rgvarg[0]));
break;
case DISPID_PRIVACYIMPACTEDSTATECHANGE:// Fired when the user's browsing experience is impacted
if (pDispParams->cArgs != 1)
return E_INVALIDARG;
_callback->PrivacyImpactedStateChange(Variant(pDispParams->rgvarg[0]));
break;
default:
return NOERROR;
}
return S_OK;
}
protected:
BrowserNavigator& _navigator;
void NavigateComplete2(IDispatch* pDisp, const Variant& url)
{
String adr = (BStr)url;
_navigator.navigated(adr);
}
};
/// encapsulation of Web control in MDI child windows
struct WebChildWindow : public IPCtrlWindow<ChildWindow, SIfacePtr<IWebBrowser2> >,
public DWebBrowserEvents2Impl
{
typedef IPCtrlWindow<ChildWindow, SIfacePtr<IWebBrowser2> > super;
typedef DWebBrowserEvents2Impl web_super;
WebChildWindow(HWND hwnd, const WebChildWndInfo& info);
static WebChildWindow* create(const FileChildWndInfo& info)
{
ChildWindow* child = ChildWindow::create(info, info._pos.rcNormalPosition,
WINDOW_CREATOR_INFO(WebChildWindow,WebChildWndInfo), CLASSNAME_CHILDWND, NULL, info._pos.showCmd==SW_SHOWMAXIMIZED? WS_MAXIMIZE: 0);
return static_cast<WebChildWindow*>(child);
}
// DWebBrowserEvents2Impl overides ->
void BeforeNavigate2(IDispatch* pDisp, const Variant& url, const Variant& flags,
const Variant& targetFrameName, const Variant& postData,
const Variant& headers, VARIANT_BOOL& cancel)
{
//String adr = (BStr)url;
}
void NavigateComplete2(IDispatch* pDisp, const Variant& url)
{
web_super::NavigateComplete2(pDisp, url);
set_url(String(BStr(url)));
}
void StatusTextChange(const BStr& text)
{
_statusText = text;
SendMessage(_hwndFrame, PM_SETSTATUSTEXT, 0, (LPARAM)_statusText.c_str());
}
void ProgressChange(long Progress, long ProgressMax)
{
}
void WindowMove()
{
}
void WindowResize()
{
}
void WindowActivate()
{
}
void PropertyChange(const BStr& Property)
{
Variant value;
_control->GetProperty(Property, &value);
}
void CommandStateChange(long command/*CSC_NAVIGATEFORWARD, CSC_NAVIGATEBACK*/, bool enable)
{
}
void DownloadBegin()
{
}
void NewWindow2(IDispatch** ppDisp, VARIANT_BOOL& cancel)
{
//*ppDisp = ;
//cancel = TRUE;
}
void TitleChange(const BStr& text)
{
SetWindowText(_hwnd, String(text));
}
void TitleIconChange(const BStr& text)
{
}
void FrameBeforeNavigate(const BStr& url, long flags, const BStr& targetFrameName, VARIANT* postData, const BStr& headers, VARIANT_BOOL& cancel)
{
}
void FrameNavigateComplete(const BStr& url)
{
}
void FrameNewWindow(const BStr& url, long flags, const BStr& targetFrameName, VARIANT* postData, const BStr& headers, VARIANT_BOOL& processed)
{
}
void OnQuit()
{
}
void OnVisible(bool Visible)
{
}
void OnToolbar(bool Visible)
{
}
void OnMenubar(bool Visible)
{
}
void OnStatusbar(bool Visible)
{
}
void OnFullscreen(bool Visible)
{
}
void DocumentComplete()
{
}
void OnTheatermode(bool Visible)
{
}
void OnAddressbar(bool Visible)
{
}
void WindowSetResizable(bool Visible)
{
}
void WindowClosing(VARIANT_BOOL IsChildWindow, VARIANT_BOOL& cancel)
{
}
void WindowSetLeft(long Left)
{
}
void WindowSetTop(long Top)
{
}
void WindowSetWidth(long Width)
{
}
void WindowSetHeight(long Height)
{
}
void ClientToHostWindow(long& CX, long& CY)
{
}
void SetSecureLockIcon(long SecureLockIcon)
{
}
void FileDownload(Variant& cancel)
{
}
void NavigateError(IDispatch* pDisp, const Variant& url, const Variant& Frame, const Variant& StatusCode, VARIANT_BOOL& cancel)
{
}
void PrivacyImpactedStateChange(bool bImpacted)
{
}
protected:
BrowserNavigator _navigator;
auto_ptr<EventConnector> _connector;
LRESULT WndProc(UINT nmsg, WPARAM wparam, LPARAM lparam);
virtual String jump_to_int(LPCTSTR url);
};