webchild.h

Go to the documentation of this file.
00001 /*
00002  * Copyright 2004, 2005 Martin Fuchs
00003  *
00004  * This library is free software; you can redistribute it and/or
00005  * modify it under the terms of the GNU Lesser General Public
00006  * License as published by the Free Software Foundation; either
00007  * version 2.1 of the License, or (at your option) any later version.
00008  *
00009  * This library is distributed in the hope that it will be useful,
00010  * but WITHOUT ANY WARRANTY; without even the implied warranty of
00011  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
00012  * Lesser General Public License for more details.
00013  *
00014  * You should have received a copy of the GNU Lesser General Public
00015  * License along with this library; if not, write to the Free Software
00016  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
00017  */
00018 
00019 
00020  //
00021  // Explorer clone
00022  //
00023  // webchild.h
00024  //
00025  // Martin Fuchs, 08.02.2004
00026  //
00027 
00028 
00029 #ifndef _MSC_VER
00030 #include <exdisp.h>     // for IConnectionPointContainer
00031 #include <exdispid.h>   // for DWebBrowserEvents2 IDs
00032 #endif
00033 
00034 #ifndef DISPID_BEFORENAVIGATE   // missing in MinGW (as of 07.02.2004)
00035 #define DISPID_BEFORENAVIGATE           100
00036 #define DISPID_NAVIGATECOMPLETE         101
00037 #define DISPID_STATUSTEXTCHANGE         102
00038 #define DISPID_QUIT                     103
00039 #define DISPID_DOWNLOADCOMPLETE         104
00040 #define DISPID_COMMANDSTATECHANGE       105
00041 #define DISPID_DOWNLOADBEGIN            106
00042 #define DISPID_NEWWINDOW                107
00043 #define DISPID_PROGRESSCHANGE           108
00044 #define DISPID_WINDOWMOVE               109
00045 #define DISPID_WINDOWRESIZE             110
00046 #define DISPID_WINDOWACTIVATE           111
00047 #define DISPID_PROPERTYCHANGE           112
00048 #define DISPID_TITLECHANGE              113
00049 #define DISPID_TITLEICONCHANGE          114
00050 #define DISPID_FRAMEBEFORENAVIGATE      200
00051 #define DISPID_FRAMENAVIGATECOMPLETE    201
00052 #define DISPID_FRAMENEWWINDOW           204
00053 
00054 #define DISPID_NAVIGATECOMPLETE2        252
00055 #define DISPID_ONQUIT                   253
00056 #define DISPID_ONVISIBLE                254
00057 #define DISPID_ONTOOLBAR                255
00058 #define DISPID_ONMENUBAR                256
00059 #define DISPID_ONSTATUSBAR              257
00060 #define DISPID_ONFULLSCREEN             258
00061 #define DISPID_DOCUMENTCOMPLETE         259
00062 #define DISPID_ONTHEATERMODE            260
00063 #define DISPID_ONADDRESSBAR             261
00064 #define DISPID_WINDOWSETRESIZABLE       262
00065 #define DISPID_WINDOWCLOSING            263
00066 #define DISPID_WINDOWSETLEFT            264
00067 #define DISPID_WINDOWSETTOP             265
00068 #define DISPID_WINDOWSETWIDTH           266
00069 #define DISPID_WINDOWSETHEIGHT          267
00070 #define DISPID_CLIENTTOHOSTWINDOW       268
00071 #define DISPID_SETSECURELOCKICON        269
00072 #define DISPID_FILEDOWNLOAD             270
00073 #define DISPID_NAVIGATEERROR            271
00074 #define DISPID_PRIVACYIMPACTEDSTATECHANGE 272
00075 #endif
00076 
00077 #ifndef V_INT   // missing in MinGW (as of 07.02.2004)
00078 #define V_INT(x) V_UNION(x, intVal)
00079 #endif
00080 
00081 #ifdef _MSC_VER
00082 #pragma warning(disable: 4355)  // use of 'this' for initialization of _connector
00083 #endif
00084 
00085 
00086 template<typename T> struct ConnectionPoint : public SIfacePtr<T>
00087 {
00088     ConnectionPoint(IConnectionPointContainer* pCPC, REFIID riid)
00089     {
00090         CheckError(pCPC->FindConnectionPoint(riid, &this->_p));
00091     }
00092 };
00093 
00094 struct EventConnection
00095 {
00096     EventConnection(IConnectionPoint* connectionpoint, IUnknown* sink)
00097     {
00098         CheckError(connectionpoint->Advise(sink, &_cookie));
00099         _connectionpoint = connectionpoint;
00100     }
00101 
00102     template<typename T> EventConnection(T& connectionpoint, IUnknown* sink)
00103     {
00104         CheckError(connectionpoint->Advise(sink, &_cookie));
00105         _connectionpoint = connectionpoint;
00106     }
00107 
00108 /*  template<typename T> EventConnection(SIfacePtr<T>& connectionpoint, IUnknown* sink)
00109     {
00110         CheckError(connectionpoint->Advise(sink, &_cookie));
00111         _connectionpoint = connectionpoint.GetPtr();
00112     } */
00113 
00114 /*  template<typename T> EventConnection(T& connectionpoint, IUnknown* sink)
00115     {
00116         CheckError(connectionpoint->Advise(sink, &_cookie));
00117         _connectionpoint = connectionpoint;
00118     } */
00119 
00120     ~EventConnection()
00121     {
00122         if (_connectionpoint)
00123             _connectionpoint->Unadvise(_cookie);
00124     }
00125 
00126 protected:
00127     SIfacePtr<IConnectionPoint> _connectionpoint;
00128     DWORD   _cookie;
00129 };
00130 
00131 struct EventConnector : public EventConnection
00132 {
00133     EventConnector(IUnknown* unknown, REFIID riid, IUnknown* sink)
00134      :  EventConnection(ConnectionPoint<IConnectionPoint>(
00135                 SIfacePtr<IConnectionPointContainer>(unknown, IID_IConnectionPointContainer), riid), sink)
00136     {
00137     }
00138 };
00139 
00140 
00141 struct OleInPlaceClient : public SimpleComObject,
00142                             public IOleClientSite,
00143                             public IOleInPlaceSite
00144 {
00145 protected:
00146     HWND    _hwnd;
00147 
00148 public:
00149     OleInPlaceClient(HWND hwnd=0)
00150      :  _hwnd(hwnd)
00151     {
00152     }
00153 
00154     void attach(HWND hwnd)
00155     {
00156         _hwnd = hwnd;
00157     }
00158 
00159     HRESULT attach_control(IOleObject* ole_obj, LONG iVerb=OLEIVERB_INPLACEACTIVATE, HWND hwndParent=0, LPCRECT pRect=NULL)
00160     {
00161         HRESULT hr = ole_obj->SetClientSite(this);
00162         if (FAILED(hr))
00163             return hr;
00164 
00165 //      hr = ole_obj->SetHostNames(app, doc));
00166 
00167         hr = ole_obj->DoVerb(iVerb, NULL, this, 0, 0/*hwnd*/, NULL/*&rcPos*/);
00168 
00169         return hr;
00170     }
00171 
00172     HRESULT detach(IOleObject* ole_obj, DWORD dwSaveOption=OLECLOSE_SAVEIFDIRTY)
00173     {
00174         HRESULT hr = ole_obj->Close(dwSaveOption);
00175 
00176         _hwnd = 0;
00177 
00178         return hr;
00179     }
00180 
00181     STDMETHODIMP QueryInterface(REFIID riid, LPVOID* ppv)
00182     {
00183         if (IsEqualIID(riid, IID_IOleClientSite))
00184             {*ppv=static_cast<IOleClientSite*>(this); IncRef(); return S_OK;}
00185 
00186         if (IsEqualIID(riid, IID_IOleInPlaceSite))
00187             {*ppv=static_cast<IOleInPlaceSite*>(this); IncRef(); return S_OK;}
00188 
00189         if (IsEqualIID(riid, IID_IUnknown))
00190             {*ppv=static_cast<IOleClientSite/*oder auch IOleInPlaceSite*/*>(this); IncRef(); return S_OK;}
00191 
00192         return E_NOINTERFACE;
00193     }
00194 
00195     STDMETHODIMP_(ULONG) AddRef() {return IncRef();}
00196     STDMETHODIMP_(ULONG) Release() {return DecRef();}
00197 
00198 
00199      // IOleWindow:
00200 
00201     virtual /* [input_sync] */ HRESULT STDMETHODCALLTYPE GetWindow(/* [out] */ HWND __RPC_FAR *phwnd)
00202     {
00203         *phwnd = _hwnd;
00204         return S_OK;
00205     }
00206 
00207     virtual HRESULT STDMETHODCALLTYPE ContextSensitiveHelp(/* [in] */ BOOL fEnterMode)
00208     {
00209         return E_NOTIMPL;
00210     }
00211 
00212 
00213      // IOleClientSite:
00214 
00215     virtual HRESULT STDMETHODCALLTYPE SaveObject()
00216     {
00217         return E_NOTIMPL;
00218     }
00219 
00220     virtual HRESULT STDMETHODCALLTYPE GetMoniker(DWORD dwAssign, DWORD dwWhichMoniker, IMoniker __RPC_FAR *__RPC_FAR *ppmk)
00221     {
00222         return E_NOTIMPL;
00223     }
00224 
00225     virtual HRESULT STDMETHODCALLTYPE GetContainer(IOleContainer __RPC_FAR *__RPC_FAR *ppContainer)
00226     {
00227         ppContainer = 0;
00228         return E_NOINTERFACE;
00229     }
00230 
00231     virtual HRESULT STDMETHODCALLTYPE ShowObject()
00232     {
00233         return S_OK;
00234     }
00235 
00236     virtual HRESULT STDMETHODCALLTYPE OnShowWindow(BOOL fShow)
00237     {
00238         return S_OK;
00239     }
00240 
00241     virtual HRESULT STDMETHODCALLTYPE RequestNewObjectLayout()
00242     {
00243         return S_OK;
00244     }
00245 
00246 
00247      // IOleInPlaceSite:
00248 
00249     virtual HRESULT STDMETHODCALLTYPE CanInPlaceActivate()
00250     {
00251         return S_OK;
00252     }
00253 
00254     virtual HRESULT STDMETHODCALLTYPE OnInPlaceActivate()
00255     {
00256         return S_OK;
00257     }
00258 
00259     virtual HRESULT STDMETHODCALLTYPE OnUIActivate()
00260     {
00261         return S_OK;
00262     }
00263 
00264     virtual HRESULT STDMETHODCALLTYPE GetWindowContext(
00265         /* [out] */ IOleInPlaceFrame __RPC_FAR *__RPC_FAR *ppFrame,
00266         /* [out] */ IOleInPlaceUIWindow __RPC_FAR *__RPC_FAR *ppDoc,
00267         /* [out] */ LPRECT lprcPosRect,
00268         /* [out] */ LPRECT lprcClipRect,
00269         /* [out][in] */ LPOLEINPLACEFRAMEINFO lpFrameInfo)
00270     {
00271         ClientRect rect(_hwnd);
00272 
00273         ppFrame = 0;
00274         ppDoc = 0;
00275         *lprcPosRect = rect;
00276         *lprcClipRect = rect;
00277 
00278         assert(lpFrameInfo->cb>=sizeof(OLEINPLACEFRAMEINFO));
00279         lpFrameInfo->fMDIApp = FALSE;   //@@
00280         lpFrameInfo->hwndFrame = 0;
00281         lpFrameInfo->haccel = 0;
00282         lpFrameInfo->cAccelEntries = 0;
00283 
00284         return S_OK;
00285     }
00286 
00287     virtual HRESULT STDMETHODCALLTYPE Scroll(/* [in] */ SIZE scrollExtant)
00288     {
00289         return S_OK;
00290     }
00291 
00292     virtual HRESULT STDMETHODCALLTYPE OnUIDeactivate(/* [in] */ BOOL fUndoable)
00293     {
00294         return S_OK;
00295     }
00296 
00297     virtual HRESULT STDMETHODCALLTYPE OnInPlaceDeactivate()
00298     {
00299         return S_OK;
00300     }
00301 
00302     virtual HRESULT STDMETHODCALLTYPE DiscardUndoState()
00303     {
00304         return S_OK;
00305     }
00306 
00307     virtual HRESULT STDMETHODCALLTYPE DeactivateAndUndo()
00308     {
00309         return S_OK;
00310     }
00311 
00312     virtual HRESULT STDMETHODCALLTYPE OnPosRectChange(/* [in] */ LPCRECT lprcPosRect)
00313     {
00314         return S_OK;
00315     }
00316 };
00317 
00318 
00319  // window with in place activates Active-X Control
00320 
00321 template<typename BASE, typename SMARTPTR> struct IPCtrlWindow : public BASE
00322 {
00323     typedef BASE super;
00324 
00325     IPCtrlWindow(HWND hwnd)
00326      :  super(hwnd)
00327     {
00328     }
00329 
00330     template<typename T> IPCtrlWindow(HWND hwnd, T& info)
00331      :  super(hwnd, info)
00332     {
00333     }
00334 
00335     HRESULT create_control(HWND hwnd, REFIID clsid, REFIID riid)
00336     {
00337          // Erzeugen einer Instanz des Controls
00338         HRESULT hr = _control.CreateInstance(clsid, riid);
00339         if (FAILED(hr))
00340             return hr;
00341 
00342         _client_side.attach(hwnd);
00343 
00344         hr = _client_side.attach_control(SIfacePtr<IOleObject>(_control, IID_IOleObject)/*, OLEIVERB_INPLACEACTIVATE,
00345                                             hwnd, &Rect(10, 10, 500, 500)*/);
00346         if (FAILED(hr))
00347             return hr;
00348 
00349          // try to get a IOleInPlaceObject interface for window resizing
00350         return _control.QueryInterface(IID_IOleInPlaceObject, &_in_place_object);   // _in_place_object = _control
00351     }
00352 
00353 protected:
00354     LRESULT WndProc(UINT nmsg, WPARAM wparam, LPARAM lparam)
00355     {
00356         if (nmsg == WM_SIZE) {
00357             if (_in_place_object) {
00358                 RECT rect = {0, 0, LOWORD(lparam), HIWORD(lparam)};
00359 
00360                 _in_place_object->SetObjectRects(&rect, &rect);
00361             }
00362         } else if (nmsg == WM_CLOSE) {
00363             _in_place_object = NULL;
00364 
00365             if (_control) {
00366                 _client_side.detach(SIfacePtr<IOleObject>(_control, IID_IOleObject), OLECLOSE_NOSAVE);
00367                 _control = NULL;
00368             }
00369         }
00370 
00371         return super::WndProc(nmsg, wparam, lparam);
00372     }
00373 
00374     ComInit _usingCOM;
00375     SMARTPTR _control;
00376     OleInPlaceClient _client_side;
00377     SIfacePtr<IOleInPlaceObject> _in_place_object;
00378 };
00379 
00380 
00381 
00382 #include "exdispid.h"
00383 
00384 
00385 struct DWebBrowserEvents2IF
00386 {
00387     virtual ~DWebBrowserEvents2IF() {}
00388 
00389     virtual void StatusTextChange(const BStr& text)
00390         {}
00391 
00392     virtual void ProgressChange(long progress, long progressMax)
00393         {}
00394 
00395     virtual void WindowMove()
00396         {}
00397 
00398     virtual void WindowResize()
00399         {}
00400 
00401     virtual void WindowActivate()
00402         {}
00403 
00404     virtual void PropertyChange(const BStr& property)
00405         {}
00406 
00407     virtual void DownloadComplete()
00408         {}
00409 
00410     virtual void CommandStateChange(long command, bool enable)
00411         {}
00412 
00413     virtual void DownloadBegin()
00414         {}
00415 
00416     virtual void NewWindow2(IDispatch** ppDisp, VARIANT_BOOL& cancel)
00417         {}
00418 
00419     virtual void TitleChange(const BStr& text)
00420         {}
00421 
00422     virtual void TitleIconChange(const BStr& text)
00423         {}
00424 
00425     virtual void FrameBeforeNavigate(const BStr& url, long flags, const BStr& targetFrameName, VARIANT* postData, const BStr& headers, VARIANT_BOOL& cancel)
00426         {}
00427 
00428     virtual void FrameNavigateComplete(const BStr& url)
00429         {}
00430 
00431     virtual void FrameNewWindow(const BStr&url, long flags, const BStr& targetFrameName, VARIANT* postData, const BStr& headers, VARIANT_BOOL& processed)
00432         {}
00433 
00434     virtual void BeforeNavigate2(IDispatch* pDisp, const Variant& url, const Variant& flags,
00435                             const Variant& targetFrameName, const Variant& postData,
00436                             const Variant& headers, VARIANT_BOOL& cancel)
00437         {}
00438 
00439     virtual void NavigateComplete2(IDispatch* pDisp, const Variant& url)
00440         {}
00441 
00442     virtual void OnQuit()
00443         {}
00444 
00445     virtual void OnVisible(bool Visible)
00446         {}
00447 
00448     virtual void OnToolbar(bool Visible)
00449         {}
00450 
00451     virtual void OnMenubar(bool Visible)
00452         {}
00453 
00454     virtual void OnStatusbar(bool Visible)
00455         {}
00456 
00457     virtual void OnFullscreen(bool Visible)
00458         {}
00459 
00460     virtual void DocumentComplete()
00461         {}
00462 
00463     virtual void OnTheatermode(bool Visible)
00464         {}
00465 
00466     virtual void OnAddressbar(bool Visible)
00467         {}
00468 
00469     virtual void WindowSetResizable(bool Visible)
00470         {}
00471 
00472     virtual void WindowClosing(VARIANT_BOOL IsChildWindow, VARIANT_BOOL& cancel)
00473         {}
00474 
00475     virtual void WindowSetLeft(long Left)
00476         {}
00477 
00478     virtual void WindowSetTop(long Top)
00479         {}
00480 
00481     virtual void WindowSetWidth(long Width)
00482         {}
00483 
00484     virtual void WindowSetHeight(long Height)
00485         {}
00486 
00487     virtual void ClientToHostWindow(long& CX, long& CY)
00488         {}
00489 
00490     virtual void SetSecureLockIcon(long SecureLockIcon)
00491         {}
00492 
00493     virtual void FileDownload(Variant& cancel)
00494         {}
00495 
00496     virtual void NavigateError(IDispatch* pDisp, const Variant& url, const Variant& Frame, const Variant& StatusCode, VARIANT_BOOL& cancel)
00497         {}
00498 
00499     virtual void PrivacyImpactedStateChange(bool bImpacted)
00500         {}
00501 };
00502 
00503 
00504  // The web browser control has to be initialized completely before being able,
00505  // to display a page, that does not access internet.
00506 struct ANSUNC BrowserNavigator
00507 {
00508     BrowserNavigator();
00509 
00510     void    attach(IWebBrowser* browser);
00511     void    goto_url(LPCTSTR url);
00512     void    set_html_page(const String& html_txt);
00513     void    navigated(LPCTSTR url);
00514 
00515     IWebBrowser* get_browser() {return _browser.get();}
00516 
00517 protected:
00518     SIfacePtr<IWebBrowser> _browser;
00519     String  _new_url;
00520     String  _new_html_txt;
00521     bool    _browser_initialized;
00522 };
00523 
00524 
00525  // MinGW defines a wrong FixedDWebBrowserEvents2 interface with virtual functions for DISPID calls, so we use our own, corrected version:
00526 interface FixedDWebBrowserEvents2 : public IDispatch
00527 {
00528 #ifdef __GNUC__
00529     virtual ~FixedDWebBrowserEvents2() {}
00530 #endif
00531 };
00532 
00533 struct ANSUNC DWebBrowserEvents2Impl
00534  :  public IComSrvBase<FixedDWebBrowserEvents2, DWebBrowserEvents2Impl>, public SimpleComObject,
00535     public DWebBrowserEvents2IF
00536 {
00537     typedef IComSrvBase<FixedDWebBrowserEvents2, DWebBrowserEvents2Impl> super;
00538 
00539 
00540     DWebBrowserEvents2IF* _callback;
00541 
00542 
00543     DWebBrowserEvents2Impl(BrowserNavigator& navigator)
00544      :  super(DIID_DWebBrowserEvents2),
00545         _navigator(navigator)
00546     {
00547         _callback = this;
00548     }
00549 
00550 
00551 /*   // IUnknown
00552     STDMETHOD(QueryInterface)(REFIID riid, LPVOID* ppv)
00553     {
00554         *ppv = NULL;
00555 
00556         if (SUCCEEDED(super::QueryInterface(riid, ppv)))
00557             return S_OK;
00558 
00559         return E_NOINTERFACE;
00560     } */
00561 
00562 
00563      // IDispatch
00564     STDMETHOD(GetTypeInfoCount)(UINT* pctinfo)
00565         {return E_NOTIMPL;}
00566 
00567     STDMETHOD(GetTypeInfo)(UINT iTInfo, LCID lcid, ITypeInfo** ppTInfo)
00568         {return E_NOTIMPL;}
00569 
00570     STDMETHOD(GetIDsOfNames)(REFIID riid, LPOLESTR* rgszNames, UINT cNames, LCID lcid, DISPID* rgDispId)
00571         {return E_NOTIMPL;}
00572 
00573     STDMETHOD(Invoke)(DISPID dispIdMember, REFIID riid, LCID lcid, WORD wFlags,
00574                         DISPPARAMS __RPC_FAR *pDispParams, VARIANT __RPC_FAR *pVarResult, EXCEPINFO __RPC_FAR *pExcepInfo, UINT __RPC_FAR *puArgErr)
00575     {
00576         switch(dispIdMember) {
00577           case DISPID_STATUSTEXTCHANGE:
00578             _callback->StatusTextChange((BStr)Variant(pDispParams->rgvarg[0]));
00579             break;
00580 
00581           case DISPID_COMMANDSTATECHANGE:
00582             _callback->CommandStateChange(Variant(pDispParams->rgvarg[1]), Variant(pDispParams->rgvarg[0]));
00583             break;
00584 
00585           case DISPID_DOWNLOADBEGIN:
00586             _callback->DownloadBegin();
00587             break;
00588 
00589           case DISPID_PROGRESSCHANGE:   // sent when download progress is updated
00590             _callback->ProgressChange(Variant(pDispParams->rgvarg[1]), Variant(pDispParams->rgvarg[0]));
00591             break;
00592 
00593           case DISPID_WINDOWMOVE:       // sent when main window has been moved
00594             _callback->WindowMove();
00595             break;
00596 
00597           case DISPID_WINDOWRESIZE:     // sent when main window has been sized
00598             _callback->WindowResize();
00599             break;
00600 
00601           case DISPID_WINDOWACTIVATE:   // sent when main window has been activated
00602             _callback->WindowActivate();
00603             break;
00604 
00605           case DISPID_PROPERTYCHANGE:   // sent when the PutProperty method is called
00606             _callback->PropertyChange((BStr)Variant(pDispParams->rgvarg[0]));
00607             break;
00608 
00609           case DISPID_TITLECHANGE:      // sent when the document title changes
00610             _callback->TitleChange((BStr)Variant(pDispParams->rgvarg[0]));
00611             break;
00612 
00613           case DISPID_TITLEICONCHANGE:  // sent when the top level window icon may have changed.
00614             _callback->TitleIconChange((BStr)Variant(pDispParams->rgvarg[0]));
00615             break;
00616 
00617 
00618             // anything below here is not present in DWebBrowserEvents, only in DWebBrowserEvents2: ->
00619 
00620           case DISPID_FRAMEBEFORENAVIGATE:
00621             if (pDispParams->cArgs != 6)
00622                 return E_INVALIDARG;
00623             if (V_VT(&pDispParams->rgvarg[0]) != (VT_BOOL|VT_BYREF))
00624                 return E_INVALIDARG;
00625             _callback->FrameBeforeNavigate(
00626                                   (BStr)Variant(&pDispParams->rgvarg[5]), Variant(&pDispParams->rgvarg[4]),
00627                                   (BStr)Variant(&pDispParams->rgvarg[3]), &pDispParams->rgvarg[2],
00628                                   (BStr)Variant(&pDispParams->rgvarg[1]), *V_BOOLREF(&pDispParams->rgvarg[0]));
00629             break;
00630 
00631           case DISPID_FRAMENAVIGATECOMPLETE:
00632             if (pDispParams->cArgs != 1)
00633                 return E_INVALIDARG;
00634             _callback->FrameNavigateComplete((BStr)Variant(pDispParams->rgvarg[0]));
00635             break;
00636 
00637           case DISPID_FRAMENEWWINDOW:
00638             if (pDispParams->cArgs != 6)
00639                 return E_INVALIDARG;
00640             if (V_VT(&pDispParams->rgvarg[0]) != (VT_BOOL|VT_BYREF))
00641                 return E_INVALIDARG;
00642             _callback->FrameNewWindow((BStr)Variant(&pDispParams->rgvarg[5]), Variant(&pDispParams->rgvarg[4]),
00643                                   (BStr)Variant(&pDispParams->rgvarg[3]), &pDispParams->rgvarg[2],
00644                                   (BStr)Variant(&pDispParams->rgvarg[1]), *V_BOOLREF(&pDispParams->rgvarg[0]));
00645             break;
00646 
00647           case DISPID_BEFORENAVIGATE2:  // hyperlink clicked on
00648             if (pDispParams->cArgs != 7)
00649                 return E_INVALIDARG;
00650             if (V_VT(&pDispParams->rgvarg[0]) != (VT_BOOL|VT_BYREF))
00651                 return E_INVALIDARG;
00652             _callback->BeforeNavigate2(Variant(pDispParams->rgvarg[6]),
00653                                   pDispParams->rgvarg[5], &pDispParams->rgvarg[4],
00654                                   pDispParams->rgvarg[3], &pDispParams->rgvarg[2],
00655                                   pDispParams->rgvarg[1], *V_BOOLREF(&pDispParams->rgvarg[0]));
00656             break;
00657 
00658           case DISPID_NEWWINDOW2:       // sent when a new window should be created
00659             if (pDispParams->cArgs != 2)
00660                 return E_INVALIDARG;
00661             if (V_VT(&pDispParams->rgvarg[0]) != (VT_BOOL|VT_BYREF))
00662                 return E_INVALIDARG;
00663             if (V_VT(&pDispParams->rgvarg[1]) != (VT_DISPATCH|VT_BYREF))
00664                 return E_INVALIDARG;
00665             _callback->NewWindow2(V_DISPATCHREF(&pDispParams->rgvarg[1]), *V_BOOLREF(&pDispParams->rgvarg[0]));
00666             break;
00667 
00668           case DISPID_NAVIGATECOMPLETE2:// UIActivate new document
00669             if (pDispParams->cArgs != 2)
00670                 return E_INVALIDARG;
00671 
00672              // notify the navigator
00673             NavigateComplete2(Variant(pDispParams->rgvarg[1]), Variant(pDispParams->rgvarg[0]));
00674 
00675             _callback->NavigateComplete2(Variant(pDispParams->rgvarg[1]), Variant(pDispParams->rgvarg[0]));
00676             break;
00677 
00678           case DISPID_ONQUIT:
00679             _callback->OnQuit();
00680             break;
00681 
00682           case DISPID_ONVISIBLE:        // sent when the window goes visible/hidden
00683             if (pDispParams->cArgs != 1)
00684                 return E_INVALIDARG;
00685             _callback->OnVisible(Variant(pDispParams->rgvarg[0]));
00686             break;
00687 
00688           case DISPID_ONTOOLBAR:        // sent when the toolbar should be shown/hidden
00689             if (pDispParams->cArgs != 1)
00690                 return E_INVALIDARG;
00691             _callback->OnToolbar(Variant(pDispParams->rgvarg[0]));
00692             break;
00693 
00694           case DISPID_ONMENUBAR:        // sent when the menubar should be shown/hidden
00695             if (pDispParams->cArgs != 1)
00696                 return E_INVALIDARG;
00697             _callback->OnMenubar(Variant(pDispParams->rgvarg[0]));
00698             break;
00699 
00700           case DISPID_ONSTATUSBAR:      // sent when the statusbar should be shown/hidden
00701             if (pDispParams->cArgs != 1)
00702                 return E_INVALIDARG;
00703             _callback->OnStatusbar(Variant(pDispParams->rgvarg[0]));
00704             break;
00705 
00706           case DISPID_ONFULLSCREEN:     // sent when kiosk mode should be on/off
00707             if (pDispParams->cArgs != 1)
00708                 return E_INVALIDARG;
00709             _callback->OnFullscreen(Variant(pDispParams->rgvarg[0]));
00710             break;
00711 
00712           case DISPID_DOCUMENTCOMPLETE:// new document goes ReadyState_Complete
00713             _callback->DocumentComplete();
00714             break;
00715 
00716           case DISPID_DOWNLOADCOMPLETE:
00717             _callback->DownloadComplete();
00718             break;
00719 
00720           case DISPID_ONTHEATERMODE:    // sent when theater mode should be on/off
00721             if (pDispParams->cArgs != 1)
00722                 return E_INVALIDARG;
00723             _callback->OnTheatermode(Variant(pDispParams->rgvarg[0]));
00724             break;
00725 
00726           case DISPID_ONADDRESSBAR:     // sent when the address bar should be shown/hidden
00727             if (pDispParams->cArgs != 1)
00728                 return E_INVALIDARG;
00729             _callback->OnAddressbar(Variant(pDispParams->rgvarg[0]));
00730             break;
00731 
00732           case DISPID_WINDOWSETRESIZABLE:// sent to set the style of the host window frame
00733             if (pDispParams->cArgs != 1)
00734                 return E_INVALIDARG;
00735             _callback->WindowSetResizable(Variant(pDispParams->rgvarg[0]));
00736             break;
00737 
00738           case DISPID_WINDOWCLOSING:    // sent before script window.close closes the window
00739             if (pDispParams->cArgs != 2)
00740                 return E_INVALIDARG;
00741             if (V_VT(&pDispParams->rgvarg[0]) != (VT_BOOL|VT_BYREF))
00742                 return E_INVALIDARG;
00743             _callback->WindowClosing(Variant(pDispParams->rgvarg[1]), *V_BOOLREF(&pDispParams->rgvarg[0]));
00744             break;
00745 
00746           case DISPID_WINDOWSETLEFT:    // sent when the put_left method is called on the WebOC
00747             if (pDispParams->cArgs != 1)
00748                 return E_INVALIDARG;
00749             _callback->WindowSetLeft(Variant(pDispParams->rgvarg[0]));
00750             break;
00751 
00752           case DISPID_WINDOWSETTOP:     // sent when the put_top method is called on the WebOC
00753             if (pDispParams->cArgs != 1)
00754                 return E_INVALIDARG;
00755             _callback->WindowSetTop(Variant(pDispParams->rgvarg[0]));
00756             break;
00757 
00758           case DISPID_WINDOWSETWIDTH:   // sent when the put_width method is called on the WebOC
00759             if (pDispParams->cArgs != 1)
00760                 return E_INVALIDARG;
00761             _callback->WindowSetWidth(Variant(pDispParams->rgvarg[0]));
00762             break;
00763 
00764           case DISPID_WINDOWSETHEIGHT:  // sent when the put_height method is called on the WebOC
00765             if (pDispParams->cArgs != 1)
00766                 return E_INVALIDARG;
00767             _callback->WindowSetHeight(Variant(pDispParams->rgvarg[0]));
00768             break;
00769 
00770           case DISPID_CLIENTTOHOSTWINDOW:// sent during window.open to request conversion of dimensions
00771           {
00772             long cx, cy;
00773             if (pDispParams->cArgs != 2)
00774                 return E_INVALIDARG;
00775             if (V_VT(&pDispParams->rgvarg[0]) != (VT_I4|VT_BYREF))
00776                 return E_INVALIDARG;
00777             if (V_VT(&pDispParams->rgvarg[1]) != (VT_I4|VT_BYREF))
00778                 return E_INVALIDARG;
00779             cx = *V_I4REF(&pDispParams->rgvarg[1]);
00780             cy = *V_I4REF(&pDispParams->rgvarg[0]);
00781             _callback->ClientToHostWindow(cx, cy);
00782             break;
00783           }
00784 
00785           case DISPID_SETSECURELOCKICON:// sent to suggest the appropriate security icon to show
00786             if (pDispParams->cArgs != 1)
00787                 return E_INVALIDARG;
00788             _callback->SetSecureLockIcon(Variant(pDispParams->rgvarg[0]));
00789             break;
00790 
00791           case DISPID_FILEDOWNLOAD: {   // Fired to indicate the File Download dialog is opening
00792             if (pDispParams->cArgs != 1)    //@@ every time 2 ?!
00793                 return E_INVALIDARG;
00794             Variant var(pDispParams->rgvarg[0]);
00795             _callback->FileDownload(var);}
00796             break;
00797 
00798           case DISPID_NAVIGATEERROR:    // Fired to indicate the a binding error has occured
00799             if (pDispParams->cArgs != 5)
00800                 return E_INVALIDARG;
00801             if (V_VT(&pDispParams->rgvarg[0]) != (VT_BOOL|VT_BYREF))
00802                 return E_INVALIDARG;
00803             _callback->NavigateError(Variant(pDispParams->rgvarg[4]), Variant(pDispParams->rgvarg[3]),
00804                                 Variant(pDispParams->rgvarg[2]), Variant(pDispParams->rgvarg[1]),
00805                                 *V_BOOLREF(&pDispParams->rgvarg[0]));
00806             break;
00807 
00808           case DISPID_PRIVACYIMPACTEDSTATECHANGE:// Fired when the user's browsing experience is impacted
00809             if (pDispParams->cArgs != 1)
00810                 return E_INVALIDARG;
00811             _callback->PrivacyImpactedStateChange(Variant(pDispParams->rgvarg[0]));
00812             break;
00813 
00814           default:
00815             return NOERROR;
00816         }
00817 
00818         return S_OK;
00819     }
00820 
00821 protected:
00822     BrowserNavigator& _navigator;
00823 
00824     void NavigateComplete2(IDispatch* pDisp, const Variant& url)
00825     {
00826         String adr = (BStr)url;
00827 
00828         _navigator.navigated(adr);
00829     }
00830 };
00831 
00832 
00833  /// encapsulation of Web control in MDI child windows
00834 struct WebChildWindow : public IPCtrlWindow<ChildWindow, SIfacePtr<IWebBrowser2> >,
00835                         public DWebBrowserEvents2Impl
00836 {
00837     typedef IPCtrlWindow<ChildWindow, SIfacePtr<IWebBrowser2> > super;
00838     typedef DWebBrowserEvents2Impl web_super;
00839 
00840     WebChildWindow(HWND hwnd, const WebChildWndInfo& info);
00841 
00842     static WebChildWindow* create(const FileChildWndInfo& info)
00843     {
00844         ChildWindow* child = ChildWindow::create(info, info._pos.rcNormalPosition,
00845             WINDOW_CREATOR_INFO(WebChildWindow,WebChildWndInfo), CLASSNAME_CHILDWND, NULL, info._pos.showCmd==SW_SHOWMAXIMIZED? WS_MAXIMIZE: 0);
00846 
00847         return static_cast<WebChildWindow*>(child);
00848     }
00849 
00850 
00851      // DWebBrowserEvents2Impl overides ->
00852 
00853     void BeforeNavigate2(IDispatch* pDisp, const Variant& url, const Variant& flags,
00854                             const Variant& targetFrameName, const Variant& postData,
00855                             const Variant& headers, VARIANT_BOOL& cancel)
00856     {
00857         //String adr = (BStr)url;
00858     }
00859 
00860     void NavigateComplete2(IDispatch* pDisp, const Variant& url)
00861     {
00862         web_super::NavigateComplete2(pDisp, url);
00863 
00864         set_url(String(BStr(url)));
00865     }
00866 
00867     void StatusTextChange(const BStr& text)
00868     {
00869         _statusText = text;
00870         SendMessage(_hwndFrame, PM_SETSTATUSTEXT, 0, (LPARAM)_statusText.c_str());
00871     }
00872 
00873     void ProgressChange(long Progress, long ProgressMax)
00874     {
00875     }
00876 
00877     void WindowMove()
00878     {
00879     }
00880 
00881     void WindowResize()
00882     {
00883     }
00884 
00885     void WindowActivate()
00886     {
00887     }
00888 
00889     void PropertyChange(const BStr& Property)
00890     {
00891         Variant value;
00892         _control->GetProperty(Property, &value);
00893     }
00894 
00895     void CommandStateChange(long command/*CSC_NAVIGATEFORWARD, CSC_NAVIGATEBACK*/, bool enable)
00896     {
00897     }
00898 
00899     void DownloadBegin()
00900     {
00901     }
00902 
00903     void NewWindow2(IDispatch** ppDisp, VARIANT_BOOL& cancel)
00904     {
00905         //*ppDisp = ;
00906         //cancel = TRUE;
00907     }
00908 
00909     void TitleChange(const BStr& text)
00910     {
00911         SetWindowText(_hwnd, String(text));
00912     }
00913 
00914     void TitleIconChange(const BStr& text)
00915     {
00916     }
00917 
00918     void FrameBeforeNavigate(const BStr& url, long flags, const BStr& targetFrameName, VARIANT* postData, const BStr& headers, VARIANT_BOOL& cancel)
00919     {
00920     }
00921 
00922     void FrameNavigateComplete(const BStr& url)
00923     {
00924     }
00925 
00926     void FrameNewWindow(const BStr& url, long flags, const BStr& targetFrameName, VARIANT* postData, const BStr& headers, VARIANT_BOOL& processed)
00927     {
00928     }
00929 
00930     void OnQuit()
00931     {
00932     }
00933 
00934     void OnVisible(bool Visible)
00935     {
00936     }
00937 
00938     void OnToolbar(bool Visible)
00939     {
00940     }
00941 
00942     void OnMenubar(bool Visible)
00943     {
00944     }
00945 
00946     void OnStatusbar(bool Visible)
00947     {
00948     }
00949 
00950     void OnFullscreen(bool Visible)
00951     {
00952     }
00953 
00954     void DocumentComplete()
00955     {
00956     }
00957 
00958     void OnTheatermode(bool Visible)
00959     {
00960     }
00961 
00962     void OnAddressbar(bool Visible)
00963     {
00964     }
00965 
00966     void WindowSetResizable(bool Visible)
00967     {
00968     }
00969 
00970     void WindowClosing(VARIANT_BOOL IsChildWindow, VARIANT_BOOL& cancel)
00971     {
00972     }
00973 
00974     void WindowSetLeft(long Left)
00975     {
00976     }
00977 
00978     void WindowSetTop(long Top)
00979     {
00980     }
00981 
00982     void WindowSetWidth(long Width)
00983     {
00984     }
00985 
00986     void WindowSetHeight(long Height)
00987     {
00988     }
00989 
00990     void ClientToHostWindow(long& CX, long& CY)
00991     {
00992     }
00993 
00994     void SetSecureLockIcon(long SecureLockIcon)
00995     {
00996     }
00997 
00998     void FileDownload(Variant& cancel)
00999     {
01000     }
01001 
01002     void NavigateError(IDispatch* pDisp, const Variant& url, const Variant& Frame, const Variant& StatusCode, VARIANT_BOOL& cancel)
01003     {
01004     }
01005 
01006     void PrivacyImpactedStateChange(bool bImpacted)
01007     {
01008     }
01009 
01010 
01011 protected:
01012     BrowserNavigator _navigator;
01013     auto_ptr<EventConnector> _connector;
01014 
01015     LRESULT WndProc(UINT nmsg, WPARAM wparam, LPARAM lparam);
01016 
01017     virtual String jump_to_int(LPCTSTR url);
01018 };

ROS Explorer Source Code Documentation
generated on 02.01.2013 by doxygen

ROS Explorer Homepage