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