reactos/subsys/system/ibrowser/webchild.h

   1 /*
   2  * Copyright 2004, 2005 Martin Fuchs
   3  *
   4  * This library is free software; you can redistribute it and/or
   5  * modify it under the terms of the GNU Lesser General Public
   6  * License as published by the Free Software Foundation; either
   7  * version 2.1 of the License, or (at your option) any later version.
   8  *
   9  * This library is distributed in the hope that it will be useful,
  10  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  11  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  12  * Lesser General Public License for more details.
  13  *
  14  * You should have received a copy of the GNU Lesser General Public
  15  * License along with this library; if not, write to the Free Software
  16  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
  17  */
  18
  19
  20  //
  21  // ROS Internet Web Browser
  22  //
  23  // webchild.h
  24  //
  25  // Martin Fuchs, 25.01.2005
  26  //
  27
  28
  29 #ifndef _MSC_VER
  30 #include <exdisp.h>             // for IConnectionPointContainer
  31 #include <exdispid.h>   // for DWebBrowserEvents2 IDs
  32 #endif
  33
  34 #ifndef DISPID_BEFORENAVIGATE   // missing in MinGW (as of 07.02.2004)
  35 #define DISPID_BEFORENAVIGATE                   100
  36 #define DISPID_NAVIGATECOMPLETE                 101
  37 #define DISPID_STATUSTEXTCHANGE                 102
  38 #define DISPID_QUIT                                             103
  39 #define DISPID_DOWNLOADCOMPLETE                 104
  40 #define DISPID_COMMANDSTATECHANGE               105
  41 #define DISPID_DOWNLOADBEGIN                    106
  42 #define DISPID_NEWWINDOW                                107
  43 #define DISPID_PROGRESSCHANGE                   108
  44 #define DISPID_WINDOWMOVE                               109
  45 #define DISPID_WINDOWRESIZE                             110
  46 #define DISPID_WINDOWACTIVATE                   111
  47 #define DISPID_PROPERTYCHANGE                   112
  48 #define DISPID_TITLECHANGE                              113
  49 #define DISPID_TITLEICONCHANGE                  114
  50 #define DISPID_FRAMEBEFORENAVIGATE              200
  51 #define DISPID_FRAMENAVIGATECOMPLETE    201
  52 #define DISPID_FRAMENEWWINDOW                   204
  53
  54 #define DISPID_NAVIGATECOMPLETE2                252
  55 #define DISPID_ONQUIT                                   253
  56 #define DISPID_ONVISIBLE                                254
  57 #define DISPID_ONTOOLBAR                                255
  58 #define DISPID_ONMENUBAR                                256
  59 #define DISPID_ONSTATUSBAR                              257
  60 #define DISPID_ONFULLSCREEN                             258
  61 #define DISPID_DOCUMENTCOMPLETE                 259
  62 #define DISPID_ONTHEATERMODE                    260
  63 #define DISPID_ONADDRESSBAR                             261
  64 #define DISPID_WINDOWSETRESIZABLE               262
  65 #define DISPID_WINDOWCLOSING                    263
  66 #define DISPID_WINDOWSETLEFT                    264
  67 #define DISPID_WINDOWSETTOP                             265
  68 #define DISPID_WINDOWSETWIDTH                   266
  69 #define DISPID_WINDOWSETHEIGHT                  267
  70 #define DISPID_CLIENTTOHOSTWINDOW               268
  71 #define DISPID_SETSECURELOCKICON                269
  72 #define DISPID_FILEDOWNLOAD                             270
  73 #define DISPID_NAVIGATEERROR                    271
  74 #define DISPID_PRIVACYIMPACTEDSTATECHANGE 272
  75 #endif
  76
  77 #ifndef V_INT   // missing in MinGW (as of 07.02.2004)
  78 #define V_INT(x) V_UNION(x, intVal)
  79 #endif
  80
  81 #ifdef _MSC_VER
  82 #define NOVTABLE __declspec(novtable)
  83 #else
  84 #define NOVTABLE
  85 #endif
  86 #define ANSUNC
  87
  88 #ifdef _MSC_VER
  89 #pragma warning(disable: 4355)  // use of 'this' for initialization of _connector
  90 #endif
  91
  92
  93 struct NOVTABLE ComSrvObject    // NOVTABLE erlaubt, da protected Destruktor
  94 {
  95 protected:
  96         ComSrvObject() : _ref(1) {}
  97         virtual ~ComSrvObject() {}
  98
  99         ULONG   _ref;
 100 };
 101
 102 struct SimpleComObject : public ComSrvObject
 103 {
 104         ULONG IncRef() {return ++_ref;}
 105         ULONG DecRef() {ULONG ref=--_ref; if (!ref) {_ref++; delete this;} return ref;}
 106 };
 107
 108
 109  // server object interfaces
 110
 111 template<typename BASE> struct IComSrvQI : public BASE
 112 {
 113         IComSrvQI(REFIID uuid_base)
 114          :      _uuid_base(uuid_base)
 115         {
 116         }
 117
 118         STDMETHODIMP QueryInterface(REFIID riid, LPVOID* ppv) {*ppv=0;
 119          if (IsEqualIID(riid, _uuid_base) ||
 120                  IsEqualIID(riid, IID_IUnknown)) {*ppv=static_cast<BASE*>(this); this->AddRef(); return S_OK;}
 121          return E_NOINTERFACE;}
 122
 123 protected:
 124         IComSrvQI() {}
 125
 126         REFIID  _uuid_base;
 127 };
 128
 129 template<> struct IComSrvQI<IUnknown> : public IUnknown
 130 {
 131         STDMETHODIMP QueryInterface(REFIID riid, LPVOID* ppv) {*ppv=0;
 132          if (IsEqualIID(riid, IID_IUnknown)) {*ppv=this; AddRef(); return S_OK;}
 133          return E_NOINTERFACE;}
 134
 135 protected:
 136         IComSrvQI<IUnknown>() {}
 137 };
 138
 139
 140 template<typename BASE, typename OBJ>
 141         class IComSrvBase : public IComSrvQI<BASE>
 142 {
 143         typedef IComSrvQI<BASE> super;
 144
 145 protected:
 146         IComSrvBase(REFIID uuid_base)
 147          :      super(uuid_base)
 148         {
 149         }
 150
 151 public:
 152         STDMETHODIMP_(ULONG) AddRef() {return static_cast<OBJ*>(this)->IncRef();}
 153         STDMETHODIMP_(ULONG) Release() {return static_cast<OBJ*>(this)->DecRef();}
 154 };
 155
 156
 157 template<typename T> struct ConnectionPoint : public SIfacePtr<T>
 158 {
 159         ConnectionPoint(IConnectionPointContainer* pCPC, REFIID riid)
 160         {
 161                 CheckError(pCPC->FindConnectionPoint(riid, &this->_p));
 162         }
 163 };
 164
 165 struct EventConnection
 166 {
 167         EventConnection(IConnectionPoint* connectionpoint, IUnknown* sink)
 168         {
 169                 CheckError(connectionpoint->Advise(sink, &_cookie));
 170                 _connectionpoint = connectionpoint;
 171         }
 172
 173         template<typename T> EventConnection(T& connectionpoint, IUnknown* sink)
 174         {
 175                 CheckError(connectionpoint->Advise(sink, &_cookie));
 176                 _connectionpoint = connectionpoint;
 177         }
 178
 179 /*      template<typename T> EventConnection(SIfacePtr<T>& connectionpoint, IUnknown* sink)
 180         {
 181                 CheckError(connectionpoint->Advise(sink, &_cookie));
 182                 _connectionpoint = connectionpoint.GetPtr();
 183         } */
 184
 185 /*      template<typename T> EventConnection(T& connectionpoint, IUnknown* sink)
 186         {
 187                 CheckError(connectionpoint->Advise(sink, &_cookie));
 188                 _connectionpoint = connectionpoint;
 189         } */
 190
 191         ~EventConnection()
 192         {
 193                 if (_connectionpoint)
 194                         _connectionpoint->Unadvise(_cookie);
 195         }
 196
 197 protected:
 198         SIfacePtr<IConnectionPoint> _connectionpoint;
 199         DWORD   _cookie;
 200 };
 201
 202 struct EventConnector : public EventConnection
 203 {
 204         EventConnector(IUnknown* unknown, REFIID riid, IUnknown* sink)
 205          :      EventConnection(ConnectionPoint<IConnectionPoint>(
 206                                 SIfacePtr<IConnectionPointContainer>(unknown, IID_IConnectionPointContainer), riid), sink)
 207         {
 208         }
 209 };
 210
 211
 212 struct OleInPlaceClient : public SimpleComObject,
 213                                                         public IOleClientSite,
 214                                                         public IOleInPlaceSite
 215 {
 216 protected:
 217         HWND    _hwnd;
 218
 219 public:
 220         OleInPlaceClient(HWND hwnd=0)
 221          :      _hwnd(hwnd)
 222         {
 223         }
 224
 225         void attach(HWND hwnd)
 226         {
 227                 _hwnd = hwnd;
 228         }
 229
 230         HRESULT attach_control(IOleObject* ole_obj, LONG iVerb=OLEIVERB_INPLACEACTIVATE, HWND hwndParent=0, LPCRECT pRect=NULL)
 231         {
 232                 HRESULT hr = ole_obj->SetClientSite(this);
 233                 if (FAILED(hr))
 234                         return hr;
 235
 236 //              hr = ole_obj->SetHostNames(app, doc));
 237
 238                 hr = ole_obj->DoVerb(iVerb, NULL, this, 0, 0/*hwnd*/, NULL/*&rcPos*/);
 239
 240                 return hr;
 241         }
 242
 243         HRESULT detach(IOleObject* ole_obj, DWORD dwSaveOption=OLECLOSE_SAVEIFDIRTY)
 244         {
 245                 HRESULT hr = ole_obj->Close(dwSaveOption);
 246
 247                 _hwnd = 0;
 248
 249                 return hr;
 250         }
 251
 252         STDMETHODIMP QueryInterface(REFIID riid, LPVOID* ppv)
 253         {
 254                 if (IsEqualIID(riid, IID_IOleClientSite))
 255                         {*ppv=static_cast<IOleClientSite*>(this); IncRef(); return S_OK;}
 256
 257                 if (IsEqualIID(riid, IID_IOleInPlaceSite))
 258                         {*ppv=static_cast<IOleInPlaceSite*>(this); IncRef(); return S_OK;}
 259
 260                 if (IsEqualIID(riid, IID_IUnknown))
 261                         {*ppv=static_cast<IOleClientSite/*oder auch IOleInPlaceSite*/*>(this); IncRef(); return S_OK;}
 262
 263                 return E_NOINTERFACE;
 264         }
 265
 266         STDMETHODIMP_(ULONG) AddRef() {return IncRef();}
 267         STDMETHODIMP_(ULONG) Release() {return DecRef();}
 268
 269
 270          // IOleWindow:
 271
 272         virtual /* [input_sync] */ HRESULT STDMETHODCALLTYPE GetWindow(/* [out] */ HWND __RPC_FAR *phwnd)
 273         {
 274                 *phwnd = _hwnd;
 275                 return S_OK;
 276         }
 277
 278         virtual HRESULT STDMETHODCALLTYPE ContextSensitiveHelp(/* [in] */ BOOL fEnterMode)
 279         {
 280                 return E_NOTIMPL;
 281         }
 282
 283
 284          // IOleClientSite:
 285
 286         virtual HRESULT STDMETHODCALLTYPE SaveObject()
 287         {
 288                 return E_NOTIMPL;
 289         }
 290
 291         virtual HRESULT STDMETHODCALLTYPE GetMoniker(DWORD dwAssign, DWORD dwWhichMoniker, IMoniker __RPC_FAR *__RPC_FAR *ppmk)
 292         {
 293                 return E_NOTIMPL;
 294         }
 295
 296         virtual HRESULT STDMETHODCALLTYPE GetContainer(IOleContainer __RPC_FAR *__RPC_FAR *ppContainer)
 297         {
 298                 ppContainer = 0;
 299                 return E_NOINTERFACE;
 300         }
 301
 302         virtual HRESULT STDMETHODCALLTYPE ShowObject()
 303         {
 304                 return S_OK;
 305         }
 306
 307         virtual HRESULT STDMETHODCALLTYPE OnShowWindow(BOOL fShow)
 308         {
 309                 return S_OK;
 310         }
 311
 312         virtual HRESULT STDMETHODCALLTYPE RequestNewObjectLayout()
 313         {
 314                 return S_OK;
 315         }
 316
 317
 318          // IOleInPlaceSite:
 319
 320         virtual HRESULT STDMETHODCALLTYPE CanInPlaceActivate()
 321         {
 322                 return S_OK;
 323         }
 324
 325         virtual HRESULT STDMETHODCALLTYPE OnInPlaceActivate()
 326         {
 327                 return S_OK;
 328         }
 329
 330         virtual HRESULT STDMETHODCALLTYPE OnUIActivate()
 331         {
 332                 return S_OK;
 333         }
 334
 335         virtual HRESULT STDMETHODCALLTYPE GetWindowContext(
 336                 /* [out] */ IOleInPlaceFrame __RPC_FAR *__RPC_FAR *ppFrame,
 337                 /* [out] */ IOleInPlaceUIWindow __RPC_FAR *__RPC_FAR *ppDoc,
 338                 /* [out] */ LPRECT lprcPosRect,
 339                 /* [out] */ LPRECT lprcClipRect,
 340                 /* [out][in] */ LPOLEINPLACEFRAMEINFO lpFrameInfo)
 341         {
 342                 ClientRect rect(_hwnd);
 343
 344                 ppFrame = 0;
 345                 ppDoc = 0;
 346                 *lprcPosRect = rect;
 347                 *lprcClipRect = rect;
 348
 349                 assert(lpFrameInfo->cb>=sizeof(OLEINPLACEFRAMEINFO));
 350                 lpFrameInfo->fMDIApp = FALSE;
 351                 lpFrameInfo->hwndFrame = 0;
 352                 lpFrameInfo->haccel = 0;
 353                 lpFrameInfo->cAccelEntries = 0;
 354
 355                 return S_OK;
 356         }
 357
 358         virtual HRESULT STDMETHODCALLTYPE Scroll(/* [in] */ SIZE scrollExtant)
 359         {
 360                 return S_OK;
 361         }
 362
 363         virtual HRESULT STDMETHODCALLTYPE OnUIDeactivate(/* [in] */ BOOL fUndoable)
 364         {
 365                 return S_OK;
 366         }
 367
 368         virtual HRESULT STDMETHODCALLTYPE OnInPlaceDeactivate()
 369         {
 370                 return S_OK;
 371         }
 372
 373         virtual HRESULT STDMETHODCALLTYPE DiscardUndoState()
 374         {
 375                 return S_OK;
 376         }
 377
 378         virtual HRESULT STDMETHODCALLTYPE DeactivateAndUndo()
 379         {
 380                 return S_OK;
 381         }
 382
 383         virtual HRESULT STDMETHODCALLTYPE OnPosRectChange(/* [in] */ LPCRECT lprcPosRect)
 384         {
 385                 return S_OK;
 386         }
 387 };
 388
 389
 390  // window with in place activates Active-X Control
 391
 392 template<typename BASE, typename SMARTPTR> struct IPCtrlWindow : public BASE
 393 {
 394         typedef BASE super;
 395
 396         IPCtrlWindow(HWND hwnd)
 397          :      super(hwnd)
 398         {
 399         }
 400
 401         template<typename T> IPCtrlWindow(HWND hwnd, T& info)
 402          :      super(hwnd, info)
 403         {
 404         }
 405
 406         HRESULT create_control(HWND hwnd, REFIID clsid, REFIID riid)
 407         {
 408                  // Erzeugen einer Instanz des Controls
 409                 HRESULT hr = _control.CreateInstance(clsid, riid);
 410                 if (FAILED(hr))
 411                         return hr;
 412
 413                 _client_side.attach(hwnd);
 414
 415                 hr = _client_side.attach_control(SIfacePtr<IOleObject>(_control, IID_IOleObject)/*, OLEIVERB_INPLACEACTIVATE,
 416                                                                                         hwnd, &Rect(10, 10, 500, 500)*/);
 417                 if (FAILED(hr))
 418                         return hr;
 419
 420                  // try to get a IOleInPlaceObject interface for window resizing
 421                 return _control.QueryInterface(IID_IOleInPlaceObject, &_in_place_object);       // _in_place_object = _control
 422         }
 423
 424 protected:
 425         LRESULT WndProc(UINT nmsg, WPARAM wparam, LPARAM lparam)
 426         {
 427                 if (nmsg == WM_SIZE) {
 428                         if (_in_place_object) {
 429                                 RECT rect = {0, 0, LOWORD(lparam), HIWORD(lparam)};
 430
 431                                 _in_place_object->SetObjectRects(&rect, &rect);
 432                         }
 433                 } else if (nmsg == WM_CLOSE) {
 434                         _in_place_object = NULL;
 435
 436                         if (_control) {
 437                                 _client_side.detach(SIfacePtr<IOleObject>(_control, IID_IOleObject), OLECLOSE_NOSAVE);
 438                                 _control = NULL;
 439                         }
 440                 }
 441
 442                 return super::WndProc(nmsg, wparam, lparam);
 443         }
 444
 445         ComInit _usingCOM;
 446         SMARTPTR _control;
 447         OleInPlaceClient _client_side;
 448         SIfacePtr<IOleInPlaceObject> _in_place_object;
 449 };
 450
 451
 452
 453 #include "exdispid.h"
 454
 455
 456 struct DWebBrowserEvents2IF
 457 {
 458     virtual void StatusTextChange(const BStr& text)
 459                 {}
 460
 461     virtual void ProgressChange(long progress, long progressMax)
 462                 {}
 463
 464     virtual void WindowMove()
 465                 {}
 466
 467     virtual void WindowResize()
 468                 {}
 469
 470     virtual void WindowActivate()
 471                 {}
 472
 473     virtual void PropertyChange(const BStr& property)
 474                 {}
 475
 476     virtual void DownloadComplete()
 477                 {}
 478
 479     virtual void CommandStateChange(long command, bool enable)
 480                 {}
 481
 482     virtual void DownloadBegin()
 483                 {}
 484
 485     virtual void NewWindow2(IDispatch** ppDisp, VARIANT_BOOL& cancel)
 486                 {}
 487
 488     virtual void TitleChange(const BStr& text)
 489                 {}
 490
 491     virtual void TitleIconChange(const BStr& text)
 492                 {}
 493
 494         virtual void FrameBeforeNavigate(const BStr& url, long flags, const BStr& targetFrameName, VARIANT* postData, const BStr& headers, VARIANT_BOOL& cancel)
 495                 {}
 496
 497         virtual void FrameNavigateComplete(const BStr& url)
 498                 {}
 499
 500         virtual void FrameNewWindow(const BStr&url, long flags, const BStr& targetFrameName, VARIANT* postData, const BStr& headers, VARIANT_BOOL& processed)
 501                 {}
 502
 503     virtual void BeforeNavigate2(IDispatch* pDisp, const Variant& url, const Variant& flags,
 504                                                         const Variant& targetFrameName, const Variant& postData,
 505                                                         const Variant& headers, VARIANT_BOOL& cancel)
 506                 {}
 507
 508     virtual void NavigateComplete2(IDispatch* pDisp, const Variant& url)
 509                 {}
 510
 511     virtual void OnQuit()
 512                 {}
 513
 514         virtual void OnVisible(bool Visible)
 515                 {}
 516
 517         virtual void OnToolbar(bool Visible)
 518                 {}
 519
 520         virtual void OnMenubar(bool Visible)
 521                 {}
 522
 523         virtual void OnStatusbar(bool Visible)
 524                 {}
 525
 526         virtual void OnFullscreen(bool Visible)
 527                 {}
 528
 529     virtual void DocumentComplete()
 530                 {}
 531
 532         virtual void OnTheatermode(bool Visible)
 533                 {}
 534
 535         virtual void OnAddressbar(bool Visible)
 536                 {}
 537
 538         virtual void WindowSetResizable(bool Visible)
 539                 {}
 540
 541         virtual void WindowClosing(VARIANT_BOOL IsChildWindow, VARIANT_BOOL& cancel)
 542                 {}
 543
 544         virtual void WindowSetLeft(long Left)
 545                 {}
 546
 547         virtual void WindowSetTop(long Top)
 548                 {}
 549
 550         virtual void WindowSetWidth(long Width)
 551                 {}
 552
 553         virtual void WindowSetHeight(long Height)
 554                 {}
 555
 556         virtual void ClientToHostWindow(long& CX, long& CY)
 557                 {}
 558
 559         virtual void SetSecureLockIcon(long SecureLockIcon)
 560                 {}
 561
 562     virtual void FileDownload(Variant& cancel)
 563                 {}
 564
 565     virtual void NavigateError(IDispatch* pDisp, const Variant& url, const Variant& Frame, const Variant& StatusCode, VARIANT_BOOL& cancel)
 566                 {}
 567
 568     virtual void PrivacyImpactedStateChange(bool bImpacted)
 569                 {}
 570 };
 571
 572
 573  // The web browser control has to be initialized completely before being able,
 574  // to display a page, that does not access internet.
 575 struct ANSUNC BrowserNavigator
 576 {
 577         BrowserNavigator();
 578
 579         void    attach(IWebBrowser* browser);
 580         void    goto_url(LPCTSTR url);
 581         void    set_html_page(const String& html_txt);
 582         void    navigated(LPCTSTR url);
 583
 584         IWebBrowser* get_browser() {return _browser.get();}
 585
 586 protected:
 587         SIfacePtr<IWebBrowser> _browser;
 588         String  _new_url;
 589         String  _new_html_txt;
 590         bool    _browser_initialized;
 591 };
 592
 593
 594  // MinGW defines a wrong FixedDWebBrowserEvents2 interface with virtual functions for DISPID calls, so we use our own, corrected version:
 595 interface FixedDWebBrowserEvents2 : public IDispatch
 596 {
 597 };
 598
 599 struct ANSUNC DWebBrowserEvents2Impl : public SimpleComObject,
 600                                         public IComSrvBase<FixedDWebBrowserEvents2, DWebBrowserEvents2Impl>,
 601                                         public DWebBrowserEvents2IF
 602 {
 603         typedef IComSrvBase<FixedDWebBrowserEvents2, DWebBrowserEvents2Impl> super;
 604
 605
 606         DWebBrowserEvents2IF* _callback;
 607
 608
 609         DWebBrowserEvents2Impl(BrowserNavigator& navigator)
 610          :      super(DIID_DWebBrowserEvents2),
 611                 _navigator(navigator)
 612         {
 613                 _callback = this;
 614         }
 615
 616
 617 /*       // IUnknown
 618     STDMETHOD(QueryInterface)(REFIID riid, LPVOID* ppv)
 619         {
 620                 *ppv = NULL;
 621
 622                 if (SUCCEEDED(super::QueryInterface(riid, ppv)))
 623                         return S_OK;
 624
 625                 return E_NOINTERFACE;
 626         } */
 627
 628
 629          // IDispatch
 630         STDMETHOD(GetTypeInfoCount)(UINT* pctinfo)
 631                 {return E_NOTIMPL;}
 632
 633         STDMETHOD(GetTypeInfo)(UINT iTInfo, LCID lcid, ITypeInfo** ppTInfo)
 634                 {return E_NOTIMPL;}
 635
 636         STDMETHOD(GetIDsOfNames)(REFIID riid, LPOLESTR* rgszNames, UINT cNames, LCID lcid, DISPID* rgDispId)
 637                 {return E_NOTIMPL;}
 638
 639         STDMETHOD(Invoke)(DISPID dispIdMember, REFIID riid, LCID lcid, WORD wFlags,
 640                                                 DISPPARAMS __RPC_FAR *pDispParams, VARIANT __RPC_FAR *pVarResult, EXCEPINFO __RPC_FAR *pExcepInfo, UINT __RPC_FAR *puArgErr)
 641         {
 642                 switch(dispIdMember) {
 643                   case DISPID_STATUSTEXTCHANGE:
 644                         _callback->StatusTextChange((BStr)Variant(pDispParams->rgvarg[0]));
 645                         break;
 646
 647                   case DISPID_COMMANDSTATECHANGE:
 648                         _callback->CommandStateChange(Variant(pDispParams->rgvarg[1]), Variant(pDispParams->rgvarg[0]));
 649                         break;
 650
 651                   case DISPID_DOWNLOADBEGIN:
 652                         _callback->DownloadBegin();
 653                         break;
 654
 655                   case DISPID_PROGRESSCHANGE:   // sent when download progress is updated
 656                         _callback->ProgressChange(Variant(pDispParams->rgvarg[1]), Variant(pDispParams->rgvarg[0]));
 657                         break;
 658
 659                   case DISPID_WINDOWMOVE:               // sent when main window has been moved
 660                         _callback->WindowMove();
 661                         break;
 662
 663                   case DISPID_WINDOWRESIZE:             // sent when main window has been sized
 664                         _callback->WindowResize();
 665                         break;
 666
 667                   case DISPID_WINDOWACTIVATE:   // sent when main window has been activated
 668                         _callback->WindowActivate();
 669                         break;
 670
 671                   case DISPID_PROPERTYCHANGE:   // sent when the PutProperty method is called
 672                         _callback->PropertyChange((BStr)Variant(pDispParams->rgvarg[0]));
 673                         break;
 674
 675                   case DISPID_TITLECHANGE:              // sent when the document title changes
 676                         _callback->TitleChange((BStr)Variant(pDispParams->rgvarg[0]));
 677                         break;
 678
 679                   case DISPID_TITLEICONCHANGE:  // sent when the top level window icon may have changed.
 680                         _callback->TitleIconChange((BStr)Variant(pDispParams->rgvarg[0]));
 681                         break;
 682
 683
 684                         // anything below here is not present in DWebBrowserEvents, only in DWebBrowserEvents2: ->
 685
 686                   case DISPID_FRAMEBEFORENAVIGATE:
 687                         if (pDispParams->cArgs != 6)
 688                                 return E_INVALIDARG;
 689                         if (V_VT(&pDispParams->rgvarg[0]) != (VT_BOOL|VT_BYREF))
 690                                 return E_INVALIDARG;
 691                         _callback->FrameBeforeNavigate(
 692                                                                   (BStr)Variant(&pDispParams->rgvarg[5]), Variant(&pDispParams->rgvarg[4]),
 693                                                                   (BStr)Variant(&pDispParams->rgvarg[3]), &pDispParams->rgvarg[2],
 694                                                                   (BStr)Variant(&pDispParams->rgvarg[1]), *V_BOOLREF(&pDispParams->rgvarg[0]));
 695                         break;
 696
 697                   case DISPID_FRAMENAVIGATECOMPLETE:
 698                         if (pDispParams->cArgs != 1)
 699                                 return E_INVALIDARG;
 700                         _callback->FrameNavigateComplete((BStr)Variant(pDispParams->rgvarg[0]));
 701                         break;
 702
 703                   case DISPID_FRAMENEWWINDOW:
 704                         if (pDispParams->cArgs != 6)
 705                                 return E_INVALIDARG;
 706                         if (V_VT(&pDispParams->rgvarg[0]) != (VT_BOOL|VT_BYREF))
 707                                 return E_INVALIDARG;
 708                         _callback->FrameNewWindow((BStr)Variant(&pDispParams->rgvarg[5]), Variant(&pDispParams->rgvarg[4]),
 709                                                                   (BStr)Variant(&pDispParams->rgvarg[3]), &pDispParams->rgvarg[2],
 710                                                                   (BStr)Variant(&pDispParams->rgvarg[1]), *V_BOOLREF(&pDispParams->rgvarg[0]));
 711                         break;
 712
 713                   case DISPID_BEFORENAVIGATE2:  // hyperlink clicked on
 714                         if (pDispParams->cArgs != 7)
 715                                 return E_INVALIDARG;
 716                         if (V_VT(&pDispParams->rgvarg[0]) != (VT_BOOL|VT_BYREF))
 717                                 return E_INVALIDARG;
 718                         _callback->BeforeNavigate2(Variant(pDispParams->rgvarg[6]),
 719                                                                   pDispParams->rgvarg[5], &pDispParams->rgvarg[4],
 720                                                                   pDispParams->rgvarg[3], &pDispParams->rgvarg[2],
 721                                                                   pDispParams->rgvarg[1], *V_BOOLREF(&pDispParams->rgvarg[0]));
 722                         break;
 723
 724                   case DISPID_NEWWINDOW2:               // sent when a new window should be created
 725                         if (pDispParams->cArgs != 2)
 726                                 return E_INVALIDARG;
 727                         if (V_VT(&pDispParams->rgvarg[0]) != (VT_BOOL|VT_BYREF))
 728                                 return E_INVALIDARG;
 729                         if (V_VT(&pDispParams->rgvarg[1]) != (VT_DISPATCH|VT_BYREF))
 730                                 return E_INVALIDARG;
 731                         _callback->NewWindow2(V_DISPATCHREF(&pDispParams->rgvarg[1]), *V_BOOLREF(&pDispParams->rgvarg[0]));
 732                         break;
 733
 734                   case DISPID_NAVIGATECOMPLETE2:// UIActivate new document
 735                         if (pDispParams->cArgs != 2)
 736                                 return E_INVALIDARG;
 737
 738                          // notify the navigator
 739                         NavigateComplete2(Variant(pDispParams->rgvarg[1]), Variant(pDispParams->rgvarg[0]));
 740
 741                         _callback->NavigateComplete2(Variant(pDispParams->rgvarg[1]), Variant(pDispParams->rgvarg[0]));
 742                         break;
 743
 744                   case DISPID_ONQUIT:
 745                         _callback->OnQuit();
 746                         break;
 747
 748                   case DISPID_ONVISIBLE:                // sent when the window goes visible/hidden
 749                         if (pDispParams->cArgs != 1)
 750                                 return E_INVALIDARG;
 751                         _callback->OnVisible(Variant(pDispParams->rgvarg[0]));
 752                         break;
 753
 754                   case DISPID_ONTOOLBAR:                // sent when the toolbar should be shown/hidden
 755                         if (pDispParams->cArgs != 1)
 756                                 return E_INVALIDARG;
 757                         _callback->OnToolbar(Variant(pDispParams->rgvarg[0]));
 758                         break;
 759
 760                   case DISPID_ONMENUBAR:                // sent when the menubar should be shown/hidden
 761                         if (pDispParams->cArgs != 1)
 762                                 return E_INVALIDARG;
 763                         _callback->OnMenubar(Variant(pDispParams->rgvarg[0]));
 764                         break;
 765
 766                   case DISPID_ONSTATUSBAR:              // sent when the statusbar should be shown/hidden
 767                         if (pDispParams->cArgs != 1)
 768                                 return E_INVALIDARG;
 769                         _callback->OnStatusbar(Variant(pDispParams->rgvarg[0]));
 770                         break;
 771
 772                   case DISPID_ONFULLSCREEN:             // sent when kiosk mode should be on/off
 773                         if (pDispParams->cArgs != 1)
 774                                 return E_INVALIDARG;
 775                         _callback->OnFullscreen(Variant(pDispParams->rgvarg[0]));
 776                         break;
 777
 778                   case DISPID_DOCUMENTCOMPLETE:// new document goes ReadyState_Complete
 779                         _callback->DocumentComplete();
 780                         break;
 781
 782                   case DISPID_DOWNLOADCOMPLETE:
 783                         _callback->DownloadComplete();
 784                         break;
 785
 786                   case DISPID_ONTHEATERMODE:    // sent when theater mode should be on/off
 787                         if (pDispParams->cArgs != 1)
 788                                 return E_INVALIDARG;
 789                         _callback->OnTheatermode(Variant(pDispParams->rgvarg[0]));
 790                         break;
 791
 792                   case DISPID_ONADDRESSBAR:             // sent when the address bar should be shown/hidden
 793                         if (pDispParams->cArgs != 1)
 794                                 return E_INVALIDARG;
 795                         _callback->OnAddressbar(Variant(pDispParams->rgvarg[0]));
 796                         break;
 797
 798                   case DISPID_WINDOWSETRESIZABLE:// sent to set the style of the host window frame
 799                         if (pDispParams->cArgs != 1)
 800                                 return E_INVALIDARG;
 801                         _callback->WindowSetResizable(Variant(pDispParams->rgvarg[0]));
 802                         break;
 803
 804                   case DISPID_WINDOWCLOSING:    // sent before script window.close closes the window
 805                         if (pDispParams->cArgs != 2)
 806                                 return E_INVALIDARG;
 807                         if (V_VT(&pDispParams->rgvarg[0]) != (VT_BOOL|VT_BYREF))
 808                                 return E_INVALIDARG;
 809                         _callback->WindowClosing(Variant(pDispParams->rgvarg[1]), *V_BOOLREF(&pDispParams->rgvarg[0]));
 810                         break;
 811
 812                   case DISPID_WINDOWSETLEFT:    // sent when the put_left method is called on the WebOC
 813                         if (pDispParams->cArgs != 1)
 814                                 return E_INVALIDARG;
 815                         _callback->WindowSetLeft(Variant(pDispParams->rgvarg[0]));
 816                         break;
 817
 818                   case DISPID_WINDOWSETTOP:             // sent when the put_top method is called on the WebOC
 819                         if (pDispParams->cArgs != 1)
 820                                 return E_INVALIDARG;
 821                         _callback->WindowSetTop(Variant(pDispParams->rgvarg[0]));
 822                         break;
 823
 824                   case DISPID_WINDOWSETWIDTH:   // sent when the put_width method is called on the WebOC
 825                         if (pDispParams->cArgs != 1)
 826                                 return E_INVALIDARG;
 827                         _callback->WindowSetWidth(Variant(pDispParams->rgvarg[0]));
 828                         break;
 829
 830                   case DISPID_WINDOWSETHEIGHT:  // sent when the put_height method is called on the WebOC
 831                         if (pDispParams->cArgs != 1)
 832                                 return E_INVALIDARG;
 833                         _callback->WindowSetHeight(Variant(pDispParams->rgvarg[0]));
 834                         break;
 835
 836                   case DISPID_CLIENTTOHOSTWINDOW:// sent during window.open to request conversion of dimensions
 837                         if (pDispParams->cArgs != 2)
 838                                 return E_INVALIDARG;
 839                         if (V_VT(&pDispParams->rgvarg[0]) != (VT_I4|VT_BYREF))
 840                                 return E_INVALIDARG;
 841                         if (V_VT(&pDispParams->rgvarg[1]) != (VT_I4|VT_BYREF))
 842                                 return E_INVALIDARG;
 843                         _callback->ClientToHostWindow(*V_I4REF(&pDispParams->rgvarg[1]), *V_I4REF(&pDispParams->rgvarg[0]));
 844                         break;
 845
 846                   case DISPID_SETSECURELOCKICON:// sent to suggest the appropriate security icon to show
 847                         if (pDispParams->cArgs != 1)
 848                                 return E_INVALIDARG;
 849                         _callback->SetSecureLockIcon(Variant(pDispParams->rgvarg[0]));
 850                         break;
 851
 852                   case DISPID_FILEDOWNLOAD: {   // Fired to indicate the File Download dialog is opening
 853                         if (pDispParams->cArgs != 1)    //@@ every time 2 ?!
 854                                 return E_INVALIDARG;
 855                         Variant var(pDispParams->rgvarg[0]);
 856                         _callback->FileDownload(var);}
 857                         break;
 858
 859                   case DISPID_NAVIGATEERROR:    // Fired to indicate the a binding error has occured
 860                         if (pDispParams->cArgs != 5)
 861                                 return E_INVALIDARG;
 862                         if (V_VT(&pDispParams->rgvarg[0]) != (VT_BOOL|VT_BYREF))
 863                                 return E_INVALIDARG;
 864                         _callback->NavigateError(Variant(pDispParams->rgvarg[4]), Variant(pDispParams->rgvarg[3]),
 865                                                                 Variant(pDispParams->rgvarg[2]), Variant(pDispParams->rgvarg[1]),
 866                                                                 *V_BOOLREF(&pDispParams->rgvarg[0]));
 867                         break;
 868
 869                   case DISPID_PRIVACYIMPACTEDSTATECHANGE:// Fired when the user's browsing experience is impacted
 870                         if (pDispParams->cArgs != 1)
 871                                 return E_INVALIDARG;
 872                         _callback->PrivacyImpactedStateChange(Variant(pDispParams->rgvarg[0]));
 873                         break;
 874
 875                   default:
 876                         return NOERROR;
 877                 }
 878
 879                 return S_OK;
 880         }
 881
 882 protected:
 883         BrowserNavigator& _navigator;
 884
 885         void NavigateComplete2(IDispatch* pDisp, const Variant& url)
 886         {
 887                 String adr = (BStr)url;
 888
 889                 _navigator.navigated(adr);
 890         }
 891 };
 892
 893
 894  /// encapsulation of the Web control
 895 struct WebChildWindow : public IPCtrlWindow<ChildWindow, SIfacePtr<IWebBrowser2> >,
 896                                                 public DWebBrowserEvents2Impl
 897 {
 898         typedef IPCtrlWindow<ChildWindow, SIfacePtr<IWebBrowser2> > super;
 899         typedef DWebBrowserEvents2Impl web_super;
 900
 901         WebChildWindow(HWND hwnd, const WebChildWndInfo& info);
 902
 903         static WebChildWindow* create(const WebChildWndInfo& info)
 904         {
 905                 ChildWindow* child = ChildWindow::create(info,
 906                         WINDOW_CREATOR_INFO(WebChildWindow,WebChildWndInfo), CLASSNAME_CHILDWND, NULL, WS_CHILD|WS_VISIBLE);
 907
 908                 return static_cast<WebChildWindow*>(child);
 909         }
 910
 911
 912          // DWebBrowserEvents2Impl overides ->
 913
 914     void BeforeNavigate2(IDispatch* pDisp, const Variant& url, const Variant& flags,
 915                                                         const Variant& targetFrameName, const Variant& postData,
 916                                                         const Variant& headers, VARIANT_BOOL& cancel)
 917         {
 918                 //String adr = (BStr)url;
 919         }
 920
 921     void NavigateComplete2(IDispatch* pDisp, const Variant& url)
 922         {
 923                 web_super::NavigateComplete2(pDisp, url);
 924
 925                 set_url(String(BStr(url)));
 926         }
 927
 928     void StatusTextChange(const BStr& text)
 929         {
 930                 _statusText = text;
 931                 SendMessage(_hwndFrame, PM_SETSTATUSTEXT, 0, (LPARAM)_statusText.c_str());
 932         }
 933
 934     void ProgressChange(long Progress, long ProgressMax)
 935         {
 936         }
 937
 938     void WindowMove()
 939         {
 940         }
 941
 942     void WindowResize()
 943         {
 944         }
 945
 946     void WindowActivate()
 947         {
 948         }
 949
 950     void PropertyChange(const BStr& Property)
 951         {
 952                 Variant value;
 953                 _control->GetProperty(Property, &value);
 954         }
 955
 956     void CommandStateChange(long command/*CSC_NAVIGATEFORWARD, CSC_NAVIGATEBACK*/, bool enable)
 957         {
 958         }
 959
 960     void DownloadBegin()
 961         {
 962         }
 963
 964     void NewWindow2(IDispatch** ppDisp, VARIANT_BOOL& cancel)
 965         {
 966                 //*ppDisp = ;
 967                 //cancel = TRUE;
 968         }
 969
 970     void TitleChange(const BStr& text)
 971         {
 972                 SetWindowText(_hwnd, String(text));
 973         }
 974
 975     void TitleIconChange(const BStr& text)
 976         {
 977         }
 978
 979     void FrameBeforeNavigate(const BStr& url, long flags, const BStr& targetFrameName, VARIANT* postData, const BStr& headers, VARIANT_BOOL& cancel)
 980         {
 981         }
 982
 983     void FrameNavigateComplete(const BStr& url)
 984         {
 985         }
 986
 987     void FrameNewWindow(const BStr& url, long flags, const BStr& targetFrameName, VARIANT* postData, const BStr& headers, VARIANT_BOOL& processed)
 988         {
 989         }
 990
 991     void OnQuit()
 992         {
 993         }
 994
 995         void OnVisible(bool Visible)
 996         {
 997         }
 998
 999         void OnToolbar(bool Visible)
1000         {
1001         }
1002
1003         void OnMenubar(bool Visible)
1004         {
1005         }
1006
1007         void OnStatusbar(bool Visible)
1008         {
1009         }
1010
1011         void OnFullscreen(bool Visible)
1012         {
1013         }
1014
1015     void DocumentComplete()
1016         {
1017         }
1018
1019         void OnTheatermode(bool Visible)
1020         {
1021         }
1022
1023         void OnAddressbar(bool Visible)
1024         {
1025         }
1026
1027         void WindowSetResizable(bool Visible)
1028         {
1029         }
1030
1031         void WindowClosing(VARIANT_BOOL IsChildWindow, VARIANT_BOOL& cancel)
1032         {
1033         }
1034
1035         void WindowSetLeft(long Left)
1036         {
1037         }
1038
1039         void WindowSetTop(long Top)
1040         {
1041         }
1042
1043         void WindowSetWidth(long Width)
1044         {
1045         }
1046
1047         void WindowSetHeight(long Height)
1048         {
1049         }
1050
1051         void ClientToHostWindow(long& CX, long& CY)
1052         {
1053         }
1054
1055         void SetSecureLockIcon(long SecureLockIcon)
1056         {
1057         }
1058
1059     void FileDownload(Variant& cancel)
1060         {
1061         }
1062
1063     void NavigateError(IDispatch* pDisp, const Variant& url, const Variant& Frame, const Variant& StatusCode, VARIANT_BOOL& cancel)
1064         {
1065         }
1066
1067     void PrivacyImpactedStateChange(bool bImpacted)
1068         {
1069         }
1070
1071
1072 protected:
1073         BrowserNavigator _navigator;
1074         auto_ptr<EventConnector> _connector;
1075
1076         LRESULT WndProc(UINT nmsg, WPARAM wparam, LPARAM lparam);
1077
1078         virtual String jump_to_int(LPCTSTR url);
1079 };