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

IBrowser Source Code Documentation
generated on 18.09.2008 by doxygen

Homepage