src/msw/webview_ie.cpp

   1 /////////////////////////////////////////////////////////////////////////////
   2 // Name:        src/msw/webview_ie.cpp
   3 // Purpose:     wxMSW wxWebViewIE class implementation for web view component
   4 // Author:      Marianne Gagnon
   5 // Id:          $Id$
   6 // Copyright:   (c) 2010 Marianne Gagnon, 2011 Steven Lamerton
   7 // Licence:     wxWindows licence
   8 /////////////////////////////////////////////////////////////////////////////
   9
  10 // For compilers that support precompilation, includes "wx.h".
  11 #include "wx/wxprec.h"
  12
  13 #if defined(__BORLANDC__)
  14     #pragma hdrstop
  15 #endif
  16
  17 #include "wx/msw/webview_ie.h"
  18
  19 #if wxUSE_WEBVIEW && wxUSE_WEBVIEW_IE
  20
  21 #include <olectl.h>
  22 #include <oleidl.h>
  23 #include <exdispid.h>
  24 #include <exdisp.h>
  25 #include <mshtml.h>
  26 #include "wx/msw/registry.h"
  27 #include "wx/msw/missing.h"
  28 #include "wx/filesys.h"
  29 #include "wx/dynlib.h"
  30 #include <initguid.h>
  31 #include <wininet.h>
  32
  33 /* These GUID definitions are our own implementation to support interfaces
  34  * normally in urlmon.h. See include/wx/msw/webview_ie.h
  35  */
  36
  37 namespace {
  38
  39 DEFINE_GUID(wxIID_IInternetProtocolRoot,0x79eac9e3,0xbaf9,0x11ce,0x8c,0x82,0,0xaa,0,0x4b,0xa9,0xb);
  40 DEFINE_GUID(wxIID_IInternetProtocol,0x79eac9e4,0xbaf9,0x11ce,0x8c,0x82,0,0xaa,0,0x4b,0xa9,0xb);
  41 DEFINE_GUID(wxIID_IDocHostUIHandler, 0xbd3f23c0, 0xd43e, 0x11cf, 0x89, 0x3b, 0x00, 0xaa, 0x00, 0xbd, 0xce, 0x1a);
  42 DEFINE_GUID(wxIID_IHTMLElement2,0x3050f434,0x98b5,0x11cf,0xbb,0x82,0,0xaa,0,0xbd,0xce,0x0b);
  43 DEFINE_GUID(wxIID_IMarkupServices,0x3050f4a0,0x98b5,0x11cf,0xbb,0x82,0,0xaa,0,0xbd,0xce,0x0b);
  44 DEFINE_GUID(wxIID_IMarkupContainer,0x3050f5f9,0x98b5,0x11cf,0xbb,0x82,0,0xaa,0,0xbd,0xce,0x0b);
  45
  46 enum //Internal find flags
  47 {
  48     wxWEBVIEW_FIND_ADD_POINTERS =      0x0001,
  49     wxWEBVIEW_FIND_REMOVE_HIGHLIGHT =  0x0002
  50 };
  51
  52 }
  53
  54 //Convenience function for error conversion
  55 #define WX_ERROR_CASE(error, wxerror) \
  56         case error: \
  57             event.SetString(#error); \
  58             event.SetInt(wxerror); \
  59             break;
  60
  61 wxIMPLEMENT_DYNAMIC_CLASS(wxWebViewIE, wxWebView);
  62
  63 BEGIN_EVENT_TABLE(wxWebViewIE, wxControl)
  64     EVT_ACTIVEX(wxID_ANY, wxWebViewIE::onActiveXEvent)
  65     EVT_ERASE_BACKGROUND(wxWebViewIE::onEraseBg)
  66 END_EVENT_TABLE()
  67
  68 bool wxWebViewIE::Create(wxWindow* parent,
  69            wxWindowID id,
  70            const wxString& url,
  71            const wxPoint& pos,
  72            const wxSize& size,
  73            long style,
  74            const wxString& name)
  75 {
  76     if (!wxControl::Create(parent, id, pos, size, style,
  77                            wxDefaultValidator, name))
  78     {
  79         return false;
  80     }
  81
  82     m_webBrowser = NULL;
  83     m_isBusy = false;
  84     m_historyLoadingFromList = false;
  85     m_historyEnabled = true;
  86     m_historyPosition = -1;
  87     m_zoomType = wxWEBVIEW_ZOOM_TYPE_TEXT;
  88     FindClear();
  89
  90     if (::CoCreateInstance(CLSID_WebBrowser, NULL,
  91                            CLSCTX_INPROC_SERVER, // CLSCTX_INPROC,
  92                            IID_IWebBrowser2 , (void**)&m_webBrowser) != 0)
  93     {
  94         wxLogError("Failed to initialize IE, CoCreateInstance returned an error");
  95         return false;
  96     }
  97
  98     m_ie.SetDispatchPtr(m_webBrowser); // wxAutomationObject will release itself
  99
 100     m_webBrowser->put_RegisterAsBrowser(VARIANT_TRUE);
 101     m_webBrowser->put_RegisterAsDropTarget(VARIANT_TRUE);
 102
 103     m_uiHandler = new DocHostUIHandler(this);
 104
 105     m_container = new wxIEContainer(this, IID_IWebBrowser2, m_webBrowser, m_uiHandler);
 106
 107     EnableControlFeature(21 /* FEATURE_DISABLE_NAVIGATION_SOUNDS */);
 108
 109     LoadURL(url);
 110     return true;
 111 }
 112
 113 wxWebViewIE::~wxWebViewIE()
 114 {
 115     wxDynamicLibrary urlMon(wxT("urlmon.dll"));
 116     if(urlMon.HasSymbol(wxT("CoInternetGetSession")))
 117     {
 118         typedef HRESULT (WINAPI *CoInternetGetSession_t)(DWORD,
 119                                                          wxIInternetSession**,
 120                                                          DWORD);
 121         wxDYNLIB_FUNCTION(CoInternetGetSession_t, CoInternetGetSession, urlMon);
 122
 123         wxIInternetSession* session;
 124         HRESULT res = (*pfnCoInternetGetSession)(0, &session, 0);
 125         if(FAILED(res))
 126         {
 127             wxFAIL_MSG("Could not retrive internet session");
 128         }
 129
 130         for(unsigned int i = 0; i < m_factories.size(); i++)
 131         {
 132             session->UnregisterNameSpace(m_factories[i],
 133                                         (m_factories[i]->GetName()).wc_str());
 134             m_factories[i]->Release();
 135         }
 136     }
 137     FindClear();
 138 }
 139
 140 void wxWebViewIE::LoadURL(const wxString& url)
 141 {
 142     m_ie.CallMethod("Navigate", wxConvertStringToOle(url));
 143 }
 144
 145 void wxWebViewIE::DoSetPage(const wxString& html, const wxString& baseUrl)
 146 {
 147     BSTR bstr = SysAllocString(OLESTR(""));
 148     SAFEARRAY *psaStrings = SafeArrayCreateVector(VT_VARIANT, 0, 1);
 149     if (psaStrings != NULL)
 150     {
 151         VARIANT *param;
 152         HRESULT hr = SafeArrayAccessData(psaStrings, (LPVOID*)&param);
 153         param->vt = VT_BSTR;
 154         param->bstrVal = bstr;
 155
 156         hr = SafeArrayUnaccessData(psaStrings);
 157
 158         wxCOMPtr<IHTMLDocument2> document(GetDocument());
 159
 160         if(!document)
 161             return;
 162
 163         document->write(psaStrings);
 164         document->close();
 165
 166         SafeArrayDestroy(psaStrings);
 167
 168         bstr = SysAllocString(html.wc_str());
 169
 170         // Creates a new one-dimensional array
 171         psaStrings = SafeArrayCreateVector(VT_VARIANT, 0, 1);
 172         if (psaStrings != NULL)
 173         {
 174             hr = SafeArrayAccessData(psaStrings, (LPVOID*)&param);
 175             param->vt = VT_BSTR;
 176             param->bstrVal = bstr;
 177             hr = SafeArrayUnaccessData(psaStrings);
 178
 179             document = GetDocument();
 180
 181             if(!document)
 182                 return;
 183
 184             document->write(psaStrings);
 185
 186             // SafeArrayDestroy calls SysFreeString for each BSTR
 187             SafeArrayDestroy(psaStrings);
 188
 189             //We send the events when we are done to mimic webkit
 190             //Navigated event
 191             wxWebViewEvent event(wxEVT_WEBVIEW_NAVIGATED,
 192                                  GetId(), baseUrl, "");
 193             event.SetEventObject(this);
 194             HandleWindowEvent(event);
 195
 196             //Document complete event
 197             event.SetEventType(wxEVT_WEBVIEW_LOADED);
 198             event.SetEventObject(this);
 199             HandleWindowEvent(event);
 200         }
 201         else
 202         {
 203             wxLogError("wxWebViewIE::SetPage() : psaStrings is NULL");
 204         }
 205     }
 206     else
 207     {
 208         wxLogError("wxWebViewIE::SetPage() : psaStrings is NULL during clear");
 209     }
 210 }
 211
 212 wxString wxWebViewIE::GetPageSource() const
 213 {
 214     wxCOMPtr<IHTMLDocument2> document(GetDocument());
 215
 216     if(document)
 217     {
 218         wxCOMPtr<IHTMLElement> bodyTag;
 219         wxCOMPtr<IHTMLElement> htmlTag;
 220         wxString source;
 221         HRESULT hr = document->get_body(&bodyTag);
 222         if(SUCCEEDED(hr))
 223         {
 224             hr = bodyTag->get_parentElement(&htmlTag);
 225             if(SUCCEEDED(hr))
 226             {
 227                 BSTR bstr;
 228                 htmlTag->get_outerHTML(&bstr);
 229                 source = wxString(bstr);
 230             }
 231         }
 232         return source;
 233     }
 234     else
 235     {
 236         return "";
 237     }
 238 }
 239
 240 wxWebViewZoom wxWebViewIE::GetZoom() const
 241 {
 242     switch( m_zoomType )
 243     {
 244         case wxWEBVIEW_ZOOM_TYPE_LAYOUT:
 245             return GetIEOpticalZoom();
 246         case wxWEBVIEW_ZOOM_TYPE_TEXT:
 247             return GetIETextZoom();
 248         default:
 249             wxFAIL;
 250     }
 251
 252     //Dummy return to stop compiler warnings
 253     return wxWEBVIEW_ZOOM_MEDIUM;
 254
 255 }
 256
 257 void wxWebViewIE::SetZoom(wxWebViewZoom zoom)
 258 {
 259     switch( m_zoomType )
 260     {
 261         case wxWEBVIEW_ZOOM_TYPE_LAYOUT:
 262             SetIEOpticalZoom(zoom);
 263             break;
 264         case wxWEBVIEW_ZOOM_TYPE_TEXT:
 265             SetIETextZoom(zoom);
 266             break;
 267         default:
 268             wxFAIL;
 269     }
 270 }
 271
 272 void wxWebViewIE::SetIETextZoom(wxWebViewZoom level)
 273 {
 274     //We do not use OLECMDID_OPTICAL_GETZOOMRANGE as the docs say the range
 275     //is 0 to 4 so the check is unnecessary, these match exactly with the
 276     //enum values
 277     VARIANT zoomVariant;
 278     VariantInit (&zoomVariant);
 279     V_VT(&zoomVariant) = VT_I4;
 280     V_I4(&zoomVariant) = level;
 281
 282 #if wxDEBUG_LEVEL
 283     HRESULT result =
 284 #endif
 285             m_webBrowser->ExecWB(OLECMDID_ZOOM,
 286                                  OLECMDEXECOPT_DONTPROMPTUSER,
 287                                  &zoomVariant, NULL);
 288     wxASSERT(result == S_OK);
 289 }
 290
 291 wxWebViewZoom wxWebViewIE::GetIETextZoom() const
 292 {
 293     VARIANT zoomVariant;
 294     VariantInit (&zoomVariant);
 295     V_VT(&zoomVariant) = VT_I4;
 296
 297 #if wxDEBUG_LEVEL
 298     HRESULT result =
 299 #endif
 300             m_webBrowser->ExecWB(OLECMDID_ZOOM,
 301                                  OLECMDEXECOPT_DONTPROMPTUSER,
 302                                  NULL, &zoomVariant);
 303     wxASSERT(result == S_OK);
 304
 305     //We can safely cast here as we know that the range matches our enum
 306     return static_cast<wxWebViewZoom>(V_I4(&zoomVariant));
 307 }
 308
 309 void wxWebViewIE::SetIEOpticalZoom(wxWebViewZoom level)
 310 {
 311     //We do not use OLECMDID_OPTICAL_GETZOOMRANGE as the docs say the range
 312     //is 10 to 1000 so the check is unnecessary
 313     VARIANT zoomVariant;
 314     VariantInit (&zoomVariant);
 315     V_VT(&zoomVariant) = VT_I4;
 316
 317     //We make a somewhat arbitray map here, taken from values used by webkit
 318     switch(level)
 319     {
 320         case wxWEBVIEW_ZOOM_TINY:
 321             V_I4(&zoomVariant) = 60;
 322             break;
 323         case wxWEBVIEW_ZOOM_SMALL:
 324             V_I4(&zoomVariant) = 80;
 325             break;
 326         case wxWEBVIEW_ZOOM_MEDIUM:
 327             V_I4(&zoomVariant) = 100;
 328             break;
 329         case wxWEBVIEW_ZOOM_LARGE:
 330             V_I4(&zoomVariant) = 130;
 331             break;
 332         case wxWEBVIEW_ZOOM_LARGEST:
 333             V_I4(&zoomVariant) = 160;
 334             break;
 335         default:
 336             wxFAIL;
 337     }
 338
 339 #if wxDEBUG_LEVEL
 340     HRESULT result =
 341 #endif
 342             m_webBrowser->ExecWB((OLECMDID)63 /*OLECMDID_OPTICAL_ZOOM*/,
 343                                  OLECMDEXECOPT_DODEFAULT,
 344                                  &zoomVariant,
 345                                  NULL);
 346     wxASSERT(result == S_OK);
 347 }
 348
 349 wxWebViewZoom wxWebViewIE::GetIEOpticalZoom() const
 350 {
 351     VARIANT zoomVariant;
 352     VariantInit (&zoomVariant);
 353     V_VT(&zoomVariant) = VT_I4;
 354
 355 #if wxDEBUG_LEVEL
 356     HRESULT result =
 357 #endif
 358             m_webBrowser->ExecWB((OLECMDID)63 /*OLECMDID_OPTICAL_ZOOM*/,
 359                                  OLECMDEXECOPT_DODEFAULT, NULL,
 360                                  &zoomVariant);
 361     wxASSERT(result == S_OK);
 362
 363     const int zoom = V_I4(&zoomVariant);
 364
 365     //We make a somewhat arbitray map here, taken from values used by webkit
 366     if (zoom <= 65)
 367     {
 368         return wxWEBVIEW_ZOOM_TINY;
 369     }
 370     else if (zoom > 65 && zoom <= 90)
 371     {
 372         return wxWEBVIEW_ZOOM_SMALL;
 373     }
 374     else if (zoom > 90 && zoom <= 115)
 375     {
 376         return wxWEBVIEW_ZOOM_MEDIUM;
 377     }
 378     else if (zoom > 115 && zoom <= 145)
 379     {
 380         return wxWEBVIEW_ZOOM_LARGE;
 381     }
 382     else /*if (zoom > 145) */ //Using else removes a compiler warning
 383     {
 384         return wxWEBVIEW_ZOOM_LARGEST;
 385     }
 386 }
 387
 388 void wxWebViewIE::SetZoomType(wxWebViewZoomType type)
 389 {
 390     m_zoomType = type;
 391 }
 392
 393 wxWebViewZoomType wxWebViewIE::GetZoomType() const
 394 {
 395     return m_zoomType;
 396 }
 397
 398 bool wxWebViewIE::CanSetZoomType(wxWebViewZoomType type) const
 399 {
 400     //IE 6 and below only support text zoom, so check the registry to see what
 401     //version we actually have
 402     wxRegKey key(wxRegKey::HKLM, "Software\\Microsoft\\Internet Explorer");
 403     wxString value;
 404     key.QueryValue("Version", value);
 405
 406     long version = wxAtoi(value.Left(1));
 407     if(version <= 6 && type == wxWEBVIEW_ZOOM_TYPE_LAYOUT)
 408         return false;
 409     else
 410         return true;
 411 }
 412
 413 void wxWebViewIE::Print()
 414 {
 415     m_webBrowser->ExecWB(OLECMDID_PRINTPREVIEW,
 416                          OLECMDEXECOPT_DODEFAULT, NULL, NULL);
 417 }
 418
 419 bool wxWebViewIE::CanGoBack() const
 420 {
 421     if(m_historyEnabled)
 422         return m_historyPosition > 0;
 423     else
 424         return false;
 425 }
 426
 427 bool wxWebViewIE::CanGoForward() const
 428 {
 429     if(m_historyEnabled)
 430         return m_historyPosition != static_cast<int>(m_historyList.size()) - 1;
 431     else
 432         return false;
 433 }
 434
 435 void wxWebViewIE::LoadHistoryItem(wxSharedPtr<wxWebViewHistoryItem> item)
 436 {
 437     int pos = -1;
 438     for(unsigned int i = 0; i < m_historyList.size(); i++)
 439     {
 440         //We compare the actual pointers to find the correct item
 441         if(m_historyList[i].get() == item.get())
 442             pos = i;
 443     }
 444     wxASSERT_MSG(pos != static_cast<int>(m_historyList.size()),
 445                  "invalid history item");
 446     m_historyLoadingFromList = true;
 447     LoadURL(item->GetUrl());
 448     m_historyPosition = pos;
 449 }
 450
 451 wxVector<wxSharedPtr<wxWebViewHistoryItem> > wxWebViewIE::GetBackwardHistory()
 452 {
 453     wxVector<wxSharedPtr<wxWebViewHistoryItem> > backhist;
 454     //As we don't have std::copy or an iterator constructor in the wxwidgets
 455     //native vector we construct it by hand
 456     for(int i = 0; i < m_historyPosition; i++)
 457     {
 458         backhist.push_back(m_historyList[i]);
 459     }
 460     return backhist;
 461 }
 462
 463 wxVector<wxSharedPtr<wxWebViewHistoryItem> > wxWebViewIE::GetForwardHistory()
 464 {
 465     wxVector<wxSharedPtr<wxWebViewHistoryItem> > forwardhist;
 466     //As we don't have std::copy or an iterator constructor in the wxwidgets
 467     //native vector we construct it by hand
 468     for(int i = m_historyPosition + 1; i < static_cast<int>(m_historyList.size()); i++)
 469     {
 470         forwardhist.push_back(m_historyList[i]);
 471     }
 472     return forwardhist;
 473 }
 474
 475 void wxWebViewIE::GoBack()
 476 {
 477     LoadHistoryItem(m_historyList[m_historyPosition - 1]);
 478 }
 479
 480 void wxWebViewIE::GoForward()
 481 {
 482     LoadHistoryItem(m_historyList[m_historyPosition + 1]);
 483 }
 484
 485 void wxWebViewIE::Stop()
 486 {
 487     m_ie.CallMethod("Stop");
 488 }
 489
 490 void wxWebViewIE::ClearHistory()
 491 {
 492     m_historyList.clear();
 493     m_historyPosition = -1;
 494 }
 495
 496 void wxWebViewIE::EnableHistory(bool enable)
 497 {
 498     m_historyEnabled = enable;
 499     m_historyList.clear();
 500     m_historyPosition = -1;
 501 }
 502
 503 void wxWebViewIE::Reload(wxWebViewReloadFlags flags)
 504 {
 505     VARIANTARG level;
 506     VariantInit(&level);
 507     V_VT(&level) = VT_I2;
 508
 509     switch(flags)
 510     {
 511         case wxWEBVIEW_RELOAD_DEFAULT:
 512             V_I2(&level) = REFRESH_NORMAL;
 513             break;
 514         case wxWEBVIEW_RELOAD_NO_CACHE:
 515             V_I2(&level) = REFRESH_COMPLETELY;
 516             break;
 517         default:
 518             wxFAIL_MSG("Unexpected reload type");
 519     }
 520
 521     m_webBrowser->Refresh2(&level);
 522 }
 523
 524 bool wxWebViewIE::IsOfflineMode()
 525 {
 526     wxVariant out = m_ie.GetProperty("Offline");
 527
 528     wxASSERT(out.GetType() == "bool");
 529
 530     return out.GetBool();
 531 }
 532
 533 void wxWebViewIE::SetOfflineMode(bool offline)
 534 {
 535     // FIXME: the wxWidgets docs do not really document what the return
 536     //        parameter of PutProperty is
 537 #if wxDEBUG_LEVEL
 538     const bool success =
 539 #endif
 540             m_ie.PutProperty("Offline", (offline ?
 541                                          VARIANT_TRUE :
 542                                          VARIANT_FALSE));
 543     wxASSERT(success);
 544 }
 545
 546 bool wxWebViewIE::IsBusy() const
 547 {
 548     if (m_isBusy) return true;
 549
 550     wxVariant out = m_ie.GetProperty("Busy");
 551
 552     wxASSERT(out.GetType() == "bool");
 553
 554     return out.GetBool();
 555 }
 556
 557 wxString wxWebViewIE::GetCurrentURL() const
 558 {
 559     wxVariant out = m_ie.GetProperty("LocationURL");
 560
 561     wxASSERT(out.GetType() == "string");
 562     return out.GetString();
 563 }
 564
 565 wxString wxWebViewIE::GetCurrentTitle() const
 566 {
 567     wxCOMPtr<IHTMLDocument2> document(GetDocument());
 568
 569     if(document)
 570     {
 571         BSTR title;
 572         document->get_nameProp(&title);
 573         return wxString(title);
 574     }
 575     else
 576     {
 577         return "";
 578     }
 579 }
 580
 581 bool wxWebViewIE::CanCut() const
 582 {
 583     return CanExecCommand("Cut");
 584 }
 585
 586 bool wxWebViewIE::CanCopy() const
 587 {
 588     return CanExecCommand("Copy");
 589 }
 590
 591 bool wxWebViewIE::CanPaste() const
 592 {
 593     return CanExecCommand("Paste");
 594 }
 595
 596 void wxWebViewIE::Cut()
 597 {
 598     ExecCommand("Cut");
 599 }
 600
 601 void wxWebViewIE::Copy()
 602 {
 603     ExecCommand("Copy");
 604 }
 605
 606 void wxWebViewIE::Paste()
 607 {
 608     ExecCommand("Paste");
 609 }
 610
 611 bool wxWebViewIE::CanUndo() const
 612 {
 613     return CanExecCommand("Undo");
 614 }
 615
 616 bool wxWebViewIE::CanRedo() const
 617 {
 618     return CanExecCommand("Redo");
 619 }
 620
 621 void wxWebViewIE::Undo()
 622 {
 623     ExecCommand("Undo");
 624 }
 625
 626 void wxWebViewIE::Redo()
 627 {
 628     ExecCommand("Redo");
 629 }
 630
 631 long wxWebViewIE::Find(const wxString& text, int flags)
 632 {
 633     //If the text is empty then we clear.
 634     if(text.IsEmpty())
 635     {
 636         ClearSelection();
 637         if(m_findFlags & wxWEBVIEW_FIND_HIGHLIGHT_RESULT)
 638         {
 639             FindInternal(m_findText, (m_findFlags &~ wxWEBVIEW_FIND_HIGHLIGHT_RESULT), wxWEBVIEW_FIND_REMOVE_HIGHLIGHT);
 640         }
 641         FindClear();
 642         return wxNOT_FOUND;
 643     }
 644     //Have we done this search before?
 645     if(m_findText == text)
 646     {
 647         //Just do a highlight?
 648         if((flags & wxWEBVIEW_FIND_HIGHLIGHT_RESULT) != (m_findFlags & wxWEBVIEW_FIND_HIGHLIGHT_RESULT))
 649         {
 650             m_findFlags = flags;
 651             if(!m_findPointers.empty())
 652             {
 653                 FindInternal(m_findText, m_findFlags, ((flags & wxWEBVIEW_FIND_HIGHLIGHT_RESULT) == 0 ? wxWEBVIEW_FIND_REMOVE_HIGHLIGHT : 0));
 654             }
 655             return m_findPosition;
 656         }
 657         else if(((m_findFlags & wxWEBVIEW_FIND_ENTIRE_WORD) == (flags & wxWEBVIEW_FIND_ENTIRE_WORD)) && ((m_findFlags & wxWEBVIEW_FIND_MATCH_CASE) == (flags&wxWEBVIEW_FIND_MATCH_CASE)))
 658         {
 659             m_findFlags = flags;
 660             return FindNext(((flags & wxWEBVIEW_FIND_BACKWARDS) ? -1 : 1));
 661         }
 662     }
 663     //Remove old highlight if any.
 664     if(m_findFlags & wxWEBVIEW_FIND_HIGHLIGHT_RESULT)
 665     {
 666         FindInternal(m_findText, (m_findFlags &~ wxWEBVIEW_FIND_HIGHLIGHT_RESULT), wxWEBVIEW_FIND_REMOVE_HIGHLIGHT);
 667     }
 668     //Reset find variables.
 669     FindClear();
 670     ClearSelection();
 671     m_findText = text;
 672     m_findFlags = flags;
 673     //find the text and return wxNOT_FOUND if there are no matches.
 674     FindInternal(text, flags, wxWEBVIEW_FIND_ADD_POINTERS);
 675     if(m_findPointers.empty())
 676         return wxNOT_FOUND;
 677
 678     // Or their number if there are.
 679     return m_findPointers.size();
 680 }
 681
 682 void wxWebViewIE::SetEditable(bool enable)
 683 {
 684     wxCOMPtr<IHTMLDocument2> document(GetDocument());
 685
 686     if(document)
 687     {
 688         if( enable )
 689             document->put_designMode(SysAllocString(L"On"));
 690         else
 691             document->put_designMode(SysAllocString(L"Off"));
 692
 693     }
 694 }
 695
 696 bool wxWebViewIE::IsEditable() const
 697 {
 698     wxCOMPtr<IHTMLDocument2> document(GetDocument());
 699
 700     if(document)
 701     {
 702         BSTR mode;
 703         document->get_designMode(&mode);
 704         if(wxString(mode) == "On")
 705             return true;
 706         else
 707             return false;
 708     }
 709     else
 710     {
 711         return false;
 712     }
 713 }
 714
 715 void wxWebViewIE::SelectAll()
 716 {
 717     ExecCommand("SelectAll");
 718 }
 719
 720 bool wxWebViewIE::HasSelection() const
 721 {
 722     wxCOMPtr<IHTMLDocument2> document(GetDocument());
 723
 724     if(document)
 725     {
 726         wxCOMPtr<IHTMLSelectionObject> selection;
 727         wxString sel;
 728         HRESULT hr = document->get_selection(&selection);
 729         if(SUCCEEDED(hr))
 730         {
 731             BSTR type;
 732             selection->get_type(&type);
 733             sel = wxString(type);
 734         }
 735         return sel != "None";
 736     }
 737     else
 738     {
 739         return false;
 740     }
 741 }
 742
 743 void wxWebViewIE::DeleteSelection()
 744 {
 745     ExecCommand("Delete");
 746 }
 747
 748 wxString wxWebViewIE::GetSelectedText() const
 749 {
 750     wxCOMPtr<IHTMLDocument2> document(GetDocument());
 751
 752     if(document)
 753     {
 754         wxCOMPtr<IHTMLSelectionObject> selection;
 755         wxString selected;
 756         HRESULT hr = document->get_selection(&selection);
 757         if(SUCCEEDED(hr))
 758         {
 759             wxCOMPtr<IDispatch> disrange;
 760             hr = selection->createRange(&disrange);
 761             if(SUCCEEDED(hr))
 762             {
 763                 wxCOMPtr<IHTMLTxtRange> range;
 764                 hr = disrange->QueryInterface(IID_IHTMLTxtRange, (void**)&range);
 765                 if(SUCCEEDED(hr))
 766                 {
 767                     BSTR text;
 768                     range->get_text(&text);
 769                     selected = wxString(text);
 770                 }
 771             }
 772         }
 773         return selected;
 774     }
 775     else
 776     {
 777         return "";
 778     }
 779 }
 780
 781 wxString wxWebViewIE::GetSelectedSource() const
 782 {
 783     wxCOMPtr<IHTMLDocument2> document(GetDocument());
 784
 785     if(document)
 786     {
 787         wxCOMPtr<IHTMLSelectionObject> selection;
 788         wxString selected;
 789         HRESULT hr = document->get_selection(&selection);
 790         if(SUCCEEDED(hr))
 791         {
 792             wxCOMPtr<IDispatch> disrange;
 793             hr = selection->createRange(&disrange);
 794             if(SUCCEEDED(hr))
 795             {
 796                 wxCOMPtr<IHTMLTxtRange> range;
 797                 hr = disrange->QueryInterface(IID_IHTMLTxtRange, (void**)&range);
 798                 if(SUCCEEDED(hr))
 799                 {
 800                     BSTR text;
 801                     range->get_htmlText(&text);
 802                     selected = wxString(text);
 803                 }
 804             }
 805         }
 806         return selected;
 807     }
 808     else
 809     {
 810         return "";
 811     }
 812 }
 813
 814 void wxWebViewIE::ClearSelection()
 815 {
 816     wxCOMPtr<IHTMLDocument2> document(GetDocument());
 817
 818     if(document)
 819     {
 820         wxCOMPtr<IHTMLSelectionObject> selection;
 821         wxString selected;
 822         HRESULT hr = document->get_selection(&selection);
 823         if(SUCCEEDED(hr))
 824         {
 825             selection->empty();
 826         }
 827     }
 828 }
 829
 830 wxString wxWebViewIE::GetPageText() const
 831 {
 832     wxCOMPtr<IHTMLDocument2> document(GetDocument());
 833
 834     if(document)
 835     {
 836         wxString text;
 837         wxCOMPtr<IHTMLElement> body;
 838         HRESULT hr = document->get_body(&body);
 839         if(SUCCEEDED(hr))
 840         {
 841             BSTR out;
 842             body->get_innerText(&out);
 843             text = wxString(out);
 844         }
 845         return text;
 846     }
 847     else
 848     {
 849         return "";
 850     }
 851 }
 852
 853 void wxWebViewIE::RunScript(const wxString& javascript)
 854 {
 855     wxCOMPtr<IHTMLDocument2> document(GetDocument());
 856
 857     if(document)
 858     {
 859         wxCOMPtr<IHTMLWindow2> window;
 860         wxString language = "javascript";
 861         HRESULT hr = document->get_parentWindow(&window);
 862         if(SUCCEEDED(hr))
 863         {
 864             VARIANT level;
 865             VariantInit(&level);
 866             V_VT(&level) = VT_EMPTY;
 867             window->execScript(SysAllocString(javascript.wc_str()),
 868                                SysAllocString(language.wc_str()),
 869                                &level);
 870         }
 871     }
 872 }
 873
 874 void wxWebViewIE::RegisterHandler(wxSharedPtr<wxWebViewHandler> handler)
 875 {
 876     wxDynamicLibrary urlMon(wxT("urlmon.dll"));
 877     if(urlMon.HasSymbol(wxT("CoInternetGetSession")))
 878     {
 879         typedef HRESULT (WINAPI *CoInternetGetSession_t)(DWORD, wxIInternetSession**, DWORD);
 880         wxDYNLIB_FUNCTION(CoInternetGetSession_t, CoInternetGetSession, urlMon);
 881
 882         ClassFactory* cf = new ClassFactory(handler);
 883         wxIInternetSession* session;
 884         HRESULT res = (*pfnCoInternetGetSession)(0, &session, 0);
 885         if(FAILED(res))
 886         {
 887             wxFAIL_MSG("Could not retrive internet session");
 888         }
 889
 890         HRESULT hr = session->RegisterNameSpace(cf, CLSID_FileProtocol,
 891                                                 handler->GetName().wc_str(),
 892                                                 0, NULL, 0);
 893         if(FAILED(hr))
 894         {
 895             wxFAIL_MSG("Could not register protocol");
 896         }
 897         m_factories.push_back(cf);
 898     }
 899     else
 900     {
 901         wxFAIL_MSG("urlmon does not contain CoInternetGetSession");
 902     }
 903 }
 904
 905 bool wxWebViewIE::CanExecCommand(wxString command) const
 906 {
 907     wxCOMPtr<IHTMLDocument2> document(GetDocument());
 908
 909     if(document)
 910     {
 911         VARIANT_BOOL enabled;
 912
 913         document->queryCommandEnabled(SysAllocString(command.wc_str()), &enabled);
 914
 915         return (enabled == VARIANT_TRUE);
 916     }
 917     else
 918     {
 919         return false;
 920     }
 921
 922 }
 923
 924 void wxWebViewIE::ExecCommand(wxString command)
 925 {
 926     wxCOMPtr<IHTMLDocument2> document(GetDocument());
 927
 928     if(document)
 929     {
 930         document->execCommand(SysAllocString(command.wc_str()), VARIANT_FALSE, VARIANT(), NULL);
 931     }
 932 }
 933
 934 wxCOMPtr<IHTMLDocument2> wxWebViewIE::GetDocument() const
 935 {
 936     wxCOMPtr<IDispatch> dispatch;
 937     wxCOMPtr<IHTMLDocument2> document;
 938     HRESULT result = m_webBrowser->get_Document(&dispatch);
 939     if(dispatch && SUCCEEDED(result))
 940     {
 941         //document is set to null automatically if the interface isn't supported
 942         dispatch->QueryInterface(IID_IHTMLDocument2, (void**)&document);
 943     }
 944     return document;
 945 }
 946
 947 bool wxWebViewIE::IsElementVisible(wxCOMPtr<IHTMLElement> elm)
 948 {
 949     wxCOMPtr<IHTMLElement> elm1 = elm;
 950     BSTR tmp_bstr;
 951     bool is_visible = true;
 952     //This method is not perfect but it does discover most of the hidden elements.
 953     //so if a better solution is found, then please do improve.
 954     while(elm1)
 955     {
 956         wxCOMPtr<wxIHTMLElement2> elm2;
 957         if(SUCCEEDED(elm1->QueryInterface(wxIID_IHTMLElement2, (void**) &elm2)))
 958         {
 959             wxCOMPtr<wxIHTMLCurrentStyle> style;
 960             if(SUCCEEDED(elm2->get_currentStyle(&style)))
 961             {
 962                 //Check if the object has the style display:none.
 963                 if((style->get_display(&tmp_bstr) != S_OK) ||
 964                    (tmp_bstr != NULL && (_wcsicmp(tmp_bstr, L"none") == 0)))
 965                 {
 966                     is_visible = false;
 967                 }
 968                 //Check if the object has the style visibility:hidden.
 969                 if((is_visible && (style->get_visibility(&tmp_bstr) != S_OK)) ||
 970                   (tmp_bstr != NULL && _wcsicmp(tmp_bstr, L"hidden") == 0))
 971                 {
 972                     is_visible = false;
 973                 }
 974                 style->Release();
 975             }
 976             elm2->Release();
 977         }
 978
 979         //Lets check the object's parent element.
 980         IHTMLElement* parent;
 981         if(is_visible && SUCCEEDED(elm1->get_parentElement(&parent)))
 982         {
 983             elm1 = parent;
 984         }
 985         else
 986         {
 987             elm1->Release();
 988             break;
 989         }
 990     }
 991     return is_visible;
 992 }
 993
 994 void wxWebViewIE::FindInternal(const wxString& text, int flags, int internal_flag)
 995 {
 996     long find_flag = 0;
 997     wxCOMPtr<wxIMarkupServices> pIMS;
 998     wxCOMPtr<IHTMLDocument2> document = GetDocument();
 999
1000     //This function does the acutal work.
1001     if(document && SUCCEEDED(document->QueryInterface(wxIID_IMarkupServices, (void **)&pIMS)))
1002     {
1003         wxCOMPtr<wxIMarkupContainer> pIMC;
1004         if(SUCCEEDED(document->QueryInterface(wxIID_IMarkupContainer, (void **)&pIMC)))
1005         {
1006             wxCOMPtr<wxIMarkupPointer> ptrBegin, ptrEnd;
1007             BSTR attr_bstr = SysAllocString(L"style=\"background-color:#ffff00\"");
1008             BSTR text_bstr = SysAllocString(text.wc_str());
1009             pIMS->CreateMarkupPointer(&ptrBegin);
1010             pIMS->CreateMarkupPointer(&ptrEnd);
1011
1012             ptrBegin->SetGravity(wxPOINTER_GRAVITY_Right);
1013             ptrBegin->MoveToContainer(pIMC, TRUE);
1014             //Create the find flag from the wx one.
1015             if(flags & wxWEBVIEW_FIND_ENTIRE_WORD)
1016             {
1017                 find_flag |= wxFINDTEXT_WHOLEWORD;
1018             }
1019             if(flags & wxWEBVIEW_FIND_MATCH_CASE)
1020             {
1021                 find_flag |= wxFINDTEXT_MATCHCASE;
1022             }
1023
1024             //A little speed-up to avoid to re-alloc in the positions vector.
1025             if(text.Len() < 3 && m_findPointers.capacity() < 500)
1026             {
1027                m_findPointers.reserve(text.Len() == 1 ? 1000 : 500);
1028             }
1029
1030             while(ptrBegin->FindText(text_bstr, find_flag, ptrEnd, NULL) == S_OK)
1031             {
1032                 wxCOMPtr<IHTMLElement> elm;
1033                 if(ptrBegin->CurrentScope(&elm) == S_OK)
1034                 {
1035                     if(IsElementVisible(elm))
1036                     {
1037                         //Highlight the word if the flag was set.
1038                         if(flags & wxWEBVIEW_FIND_HIGHLIGHT_RESULT)
1039                         {
1040                             IHTMLElement* pFontEl;
1041                             pIMS->CreateElement(wxTAGID_FONT, attr_bstr, &pFontEl);
1042                             pIMS->InsertElement(pFontEl, ptrBegin, ptrEnd);
1043                         }
1044                         if(internal_flag & wxWEBVIEW_FIND_REMOVE_HIGHLIGHT)
1045                         {
1046                             IHTMLElement* pFontEl;
1047                             ptrBegin->CurrentScope(&pFontEl);
1048                             pIMS->RemoveElement(pFontEl);
1049                             pFontEl->Release();
1050                         }
1051                         if(internal_flag & wxWEBVIEW_FIND_ADD_POINTERS)
1052                         {
1053                             wxIMarkupPointer *cptrBegin, *cptrEnd;
1054                             pIMS->CreateMarkupPointer(&cptrBegin);
1055                             pIMS->CreateMarkupPointer(&cptrEnd);
1056                             cptrBegin->MoveToPointer(ptrBegin);
1057                             cptrEnd->MoveToPointer(ptrEnd);
1058                             m_findPointers.push_back(wxFindPointers(cptrBegin,cptrEnd));
1059                         }
1060                     }
1061                 }
1062                 ptrBegin->MoveToPointer(ptrEnd);
1063             }
1064             //Clean up.
1065             SysFreeString(text_bstr);
1066             SysFreeString(attr_bstr);
1067         }
1068     }
1069 }
1070
1071 long wxWebViewIE::FindNext(int direction)
1072 {
1073     //Don't bother if we have no pointers set.
1074     if(m_findPointers.empty())
1075     {
1076         return wxNOT_FOUND;
1077     }
1078     //Manage the find position and do some checks.
1079     if(direction > 0)
1080     {
1081         m_findPosition++;
1082     }
1083     else
1084     {
1085         m_findPosition--;
1086     }
1087
1088     if(m_findPosition >= (signed)m_findPointers.size())
1089     {
1090         if(m_findFlags & wxWEBVIEW_FIND_WRAP)
1091         {
1092             m_findPosition = 0;
1093         }
1094         else
1095         {
1096             m_findPosition--;
1097             return wxNOT_FOUND;
1098         }
1099     }
1100     else if(m_findPosition < 0)
1101     {
1102         if(m_findFlags & wxWEBVIEW_FIND_WRAP)
1103         {
1104             m_findPosition = m_findPointers.size()-1;
1105         }
1106         else
1107         {
1108             m_findPosition++;
1109             return wxNOT_FOUND;
1110         }
1111     }
1112
1113     wxCOMPtr<IHTMLDocument2> document = GetDocument();
1114     wxCOMPtr<IHTMLElement> body_element;
1115
1116     long ret = -1;
1117     //Now try to create a range from the body.
1118     if(document && SUCCEEDED(document->get_body(&body_element)))
1119     {
1120         wxCOMPtr<IHTMLBodyElement> body;
1121         if(SUCCEEDED(body_element->QueryInterface(IID_IHTMLBodyElement,(void**)&body)))
1122         {
1123             wxCOMPtr<wxIHTMLTxtRange> range;
1124             if(SUCCEEDED(body->createTextRange((IHTMLTxtRange**)(&range))))
1125             {
1126                 wxCOMPtr<wxIMarkupServices> pIMS;
1127                 //So far so good, now we try to position our find pointers.
1128                 if(SUCCEEDED(document->QueryInterface(wxIID_IMarkupServices,(void **)&pIMS)))
1129                 {
1130                     wxIMarkupPointer *begin = m_findPointers[m_findPosition].begin, *end = m_findPointers[m_findPosition].end;
1131                     if(pIMS->MoveRangeToPointers(begin,end,range) == S_OK && range->select() == S_OK)
1132                     {
1133                         ret = m_findPosition;
1134                     }
1135                 }
1136             }
1137         }
1138     }
1139     return ret;
1140 }
1141
1142 void wxWebViewIE::FindClear()
1143 {
1144     //Reset find variables.
1145     m_findText.Empty();
1146     m_findFlags = wxWEBVIEW_FIND_DEFAULT;
1147     m_findPosition = -1;
1148
1149     //The m_findPointers contains pointers for the found text.
1150     //Since it uses ref counting we call release on the pointers first
1151     //before we remove them from the vector. In other words do not just
1152     //remove elements from m_findPointers without calling release first
1153     //or you will get a memory leak.
1154     size_t count = m_findPointers.size();
1155     for(size_t i = 0; i < count; i++)
1156     {
1157         m_findPointers[i].begin->Release();
1158         m_findPointers[i].end->Release();
1159     }
1160     m_findPointers.clear();
1161 }
1162
1163 bool wxWebViewIE::EnableControlFeature(long flag, bool enable)
1164 {
1165 #if wxUSE_DYNLIB_CLASS
1166
1167     wxDynamicLibrary urlMon(wxT("urlmon.dll"));
1168     if( urlMon.IsLoaded() &&
1169         urlMon.HasSymbol("CoInternetSetFeatureEnabled") &&
1170         urlMon.HasSymbol("CoInternetIsFeatureEnabled"))
1171     {
1172         typedef HRESULT (WINAPI *CoInternetSetFeatureEnabled_t)(DWORD, DWORD, BOOL);
1173         typedef HRESULT (WINAPI *CoInternetIsFeatureEnabled_t)(DWORD, DWORD);
1174
1175         wxDYNLIB_FUNCTION(CoInternetSetFeatureEnabled_t, CoInternetSetFeatureEnabled, urlMon);
1176         wxDYNLIB_FUNCTION(CoInternetIsFeatureEnabled_t, CoInternetIsFeatureEnabled, urlMon);
1177
1178         HRESULT hr = (*pfnCoInternetIsFeatureEnabled)(flag,
1179                                                       0x2 /* SET_FEATURE_ON_PROCESS */);
1180         if((hr == S_OK && enable) || (hr == S_FALSE && !enable))
1181             return true;
1182
1183         hr = (*pfnCoInternetSetFeatureEnabled)(flag,
1184                                                0x2/* SET_FEATURE_ON_PROCESS */,
1185                                                (enable ? TRUE : FALSE));
1186         if ( FAILED(hr) )
1187         {
1188             wxLogApiError(wxT("CoInternetSetFeatureEnabled"), hr);
1189             return false;
1190         }
1191         return true;
1192     }
1193     return false;
1194 #else
1195     wxUnusedVar(flag);
1196     wxUnusedVar(enable);
1197     return false;
1198 #endif // wxUSE_DYNLIB_CLASS/!wxUSE_DYNLIB_CLASS
1199 }
1200
1201 void wxWebViewIE::onActiveXEvent(wxActiveXEvent& evt)
1202 {
1203     if (m_webBrowser == NULL) return;
1204
1205     switch (evt.GetDispatchId())
1206     {
1207         case DISPID_BEFORENAVIGATE2:
1208         {
1209             m_isBusy = true;
1210
1211             wxString url = evt[1].GetString();
1212             wxString target = evt[3].GetString();
1213
1214             wxWebViewEvent event(wxEVT_WEBVIEW_NAVIGATING,
1215                                  GetId(), url, target);
1216
1217             //skip empty javascript events.
1218             if(url == "javascript:\"\"" && target.IsEmpty())
1219             {
1220                 event.Veto();
1221             }
1222             else
1223             {
1224                 event.SetEventObject(this);
1225                 HandleWindowEvent(event);
1226             }
1227
1228             if (!event.IsAllowed())
1229             {
1230                 wxActiveXEventNativeMSW* nativeParams =
1231                     evt.GetNativeParameters();
1232                 *V_BOOLREF(&nativeParams->pDispParams->rgvarg[0]) = VARIANT_TRUE;
1233             }
1234
1235             // at this point, either the navigation event has been cancelled
1236             // and we're not busy, either it was accepted and IWebBrowser2's
1237             // Busy property will be true; so we don't need our override
1238             // flag anymore.
1239             m_isBusy = false;
1240
1241             break;
1242         }
1243
1244         case DISPID_NAVIGATECOMPLETE2:
1245         {
1246             wxString url = evt[1].GetString();
1247             // TODO: set target parameter if possible
1248             wxString target = wxEmptyString;
1249             wxWebViewEvent event(wxEVT_WEBVIEW_NAVIGATED,
1250                                  GetId(), url, target);
1251             event.SetEventObject(this);
1252             HandleWindowEvent(event);
1253             break;
1254         }
1255
1256         case DISPID_PROGRESSCHANGE:
1257         {
1258             // download progress
1259             break;
1260         }
1261
1262         case DISPID_DOCUMENTCOMPLETE:
1263         {
1264             //Only send a complete even if we are actually finished, this brings
1265             //the event in to line with webkit
1266             READYSTATE rs;
1267             m_webBrowser->get_ReadyState( &rs );
1268             if(rs != READYSTATE_COMPLETE)
1269                 break;
1270
1271             wxString url = evt[1].GetString();
1272
1273             //As we are complete we also add to the history list, but not if the
1274             //page is not the main page, ie it is a subframe
1275             //We also have to check if we are loading a file:// url, if so we
1276             //need to change the comparison as ie passes back a different style
1277             //of url
1278             if(m_historyEnabled && !m_historyLoadingFromList &&
1279               (url == GetCurrentURL() ||
1280               (GetCurrentURL().substr(0, 4) == "file" &&
1281                wxFileSystem::URLToFileName(GetCurrentURL()).GetFullPath() == url)))
1282             {
1283                 //If we are not at the end of the list, then erase everything
1284                 //between us and the end before adding the new page
1285                 if(m_historyPosition != static_cast<int>(m_historyList.size()) - 1)
1286                 {
1287                     m_historyList.erase(m_historyList.begin() + m_historyPosition + 1,
1288                                         m_historyList.end());
1289                 }
1290                 wxSharedPtr<wxWebViewHistoryItem> item(new wxWebViewHistoryItem(url, GetCurrentTitle()));
1291                 m_historyList.push_back(item);
1292                 m_historyPosition++;
1293             }
1294             //Reset as we are done now
1295             m_historyLoadingFromList = false;
1296             //Reset the find values.
1297             FindClear();
1298             // TODO: set target parameter if possible
1299             wxString target = wxEmptyString;
1300             wxWebViewEvent event(wxEVT_WEBVIEW_LOADED, GetId(),
1301                                  url, target);
1302             event.SetEventObject(this);
1303             HandleWindowEvent(event);
1304             break;
1305         }
1306
1307         case DISPID_STATUSTEXTCHANGE:
1308         {
1309             break;
1310         }
1311
1312         case DISPID_TITLECHANGE:
1313         {
1314             wxString title = evt[0].GetString();
1315
1316             wxWebViewEvent event(wxEVT_WEBVIEW_TITLE_CHANGED,
1317                                  GetId(), GetCurrentURL(), "");
1318             event.SetString(title);
1319             event.SetEventObject(this);
1320             HandleWindowEvent(event);
1321             break;
1322         }
1323
1324         case DISPID_NAVIGATEERROR:
1325         {
1326             wxWebViewEvent event(wxEVT_WEBVIEW_ERROR, GetId(),
1327                                  evt[1].GetString(), evt[2].GetString());
1328             event.SetEventObject(this);
1329
1330             switch (evt[3].GetLong())
1331             {
1332                 // 400 Error codes
1333                 WX_ERROR_CASE(HTTP_STATUS_BAD_REQUEST, wxWEBVIEW_NAV_ERR_REQUEST)
1334                 WX_ERROR_CASE(HTTP_STATUS_DENIED, wxWEBVIEW_NAV_ERR_AUTH)
1335                 WX_ERROR_CASE(HTTP_STATUS_PAYMENT_REQ, wxWEBVIEW_NAV_ERR_OTHER)
1336                 WX_ERROR_CASE(HTTP_STATUS_FORBIDDEN, wxWEBVIEW_NAV_ERR_AUTH)
1337                 WX_ERROR_CASE(HTTP_STATUS_NOT_FOUND, wxWEBVIEW_NAV_ERR_NOT_FOUND)
1338                 WX_ERROR_CASE(HTTP_STATUS_BAD_METHOD, wxWEBVIEW_NAV_ERR_REQUEST)
1339                 WX_ERROR_CASE(HTTP_STATUS_NONE_ACCEPTABLE, wxWEBVIEW_NAV_ERR_OTHER)
1340                 WX_ERROR_CASE(HTTP_STATUS_PROXY_AUTH_REQ, wxWEBVIEW_NAV_ERR_AUTH)
1341                 WX_ERROR_CASE(HTTP_STATUS_REQUEST_TIMEOUT, wxWEBVIEW_NAV_ERR_CONNECTION)
1342                 WX_ERROR_CASE(HTTP_STATUS_CONFLICT, wxWEBVIEW_NAV_ERR_REQUEST)
1343                 WX_ERROR_CASE(HTTP_STATUS_GONE, wxWEBVIEW_NAV_ERR_NOT_FOUND)
1344                 WX_ERROR_CASE(HTTP_STATUS_LENGTH_REQUIRED, wxWEBVIEW_NAV_ERR_REQUEST)
1345                 WX_ERROR_CASE(HTTP_STATUS_PRECOND_FAILED, wxWEBVIEW_NAV_ERR_REQUEST)
1346                 WX_ERROR_CASE(HTTP_STATUS_REQUEST_TOO_LARGE, wxWEBVIEW_NAV_ERR_REQUEST)
1347                 WX_ERROR_CASE(HTTP_STATUS_URI_TOO_LONG, wxWEBVIEW_NAV_ERR_REQUEST)
1348                 WX_ERROR_CASE(HTTP_STATUS_UNSUPPORTED_MEDIA, wxWEBVIEW_NAV_ERR_REQUEST)
1349                 WX_ERROR_CASE(HTTP_STATUS_RETRY_WITH, wxWEBVIEW_NAV_ERR_OTHER)
1350
1351                 // 500 - Error codes
1352                 WX_ERROR_CASE(HTTP_STATUS_SERVER_ERROR, wxWEBVIEW_NAV_ERR_CONNECTION)
1353                 WX_ERROR_CASE(HTTP_STATUS_NOT_SUPPORTED, wxWEBVIEW_NAV_ERR_CONNECTION)
1354                 WX_ERROR_CASE(HTTP_STATUS_BAD_GATEWAY, wxWEBVIEW_NAV_ERR_CONNECTION)
1355                 WX_ERROR_CASE(HTTP_STATUS_SERVICE_UNAVAIL, wxWEBVIEW_NAV_ERR_CONNECTION)
1356                 WX_ERROR_CASE(HTTP_STATUS_GATEWAY_TIMEOUT, wxWEBVIEW_NAV_ERR_CONNECTION)
1357                 WX_ERROR_CASE(HTTP_STATUS_VERSION_NOT_SUP, wxWEBVIEW_NAV_ERR_REQUEST)
1358
1359                 // URL Moniker error codes
1360                 WX_ERROR_CASE(INET_E_INVALID_URL, wxWEBVIEW_NAV_ERR_REQUEST)
1361                 WX_ERROR_CASE(INET_E_NO_SESSION, wxWEBVIEW_NAV_ERR_CONNECTION)
1362                 WX_ERROR_CASE(INET_E_CANNOT_CONNECT, wxWEBVIEW_NAV_ERR_CONNECTION)
1363                 WX_ERROR_CASE(INET_E_RESOURCE_NOT_FOUND, wxWEBVIEW_NAV_ERR_NOT_FOUND)
1364                 WX_ERROR_CASE(INET_E_OBJECT_NOT_FOUND, wxWEBVIEW_NAV_ERR_NOT_FOUND)
1365                 WX_ERROR_CASE(INET_E_DATA_NOT_AVAILABLE, wxWEBVIEW_NAV_ERR_NOT_FOUND)
1366                 WX_ERROR_CASE(INET_E_DOWNLOAD_FAILURE, wxWEBVIEW_NAV_ERR_CONNECTION)
1367                 WX_ERROR_CASE(INET_E_AUTHENTICATION_REQUIRED, wxWEBVIEW_NAV_ERR_AUTH)
1368                 WX_ERROR_CASE(INET_E_NO_VALID_MEDIA, wxWEBVIEW_NAV_ERR_REQUEST)
1369                 WX_ERROR_CASE(INET_E_CONNECTION_TIMEOUT, wxWEBVIEW_NAV_ERR_CONNECTION)
1370                 WX_ERROR_CASE(INET_E_INVALID_REQUEST, wxWEBVIEW_NAV_ERR_REQUEST)
1371                 WX_ERROR_CASE(INET_E_UNKNOWN_PROTOCOL, wxWEBVIEW_NAV_ERR_REQUEST)
1372                 WX_ERROR_CASE(INET_E_SECURITY_PROBLEM, wxWEBVIEW_NAV_ERR_SECURITY)
1373                 WX_ERROR_CASE(INET_E_CANNOT_LOAD_DATA, wxWEBVIEW_NAV_ERR_OTHER)
1374                 WX_ERROR_CASE(INET_E_REDIRECT_FAILED, wxWEBVIEW_NAV_ERR_OTHER)
1375                 WX_ERROR_CASE(INET_E_REDIRECT_TO_DIR, wxWEBVIEW_NAV_ERR_REQUEST)
1376                 WX_ERROR_CASE(INET_E_CANNOT_LOCK_REQUEST, wxWEBVIEW_NAV_ERR_OTHER)
1377                 WX_ERROR_CASE(INET_E_USE_EXTEND_BINDING, wxWEBVIEW_NAV_ERR_OTHER)
1378                 WX_ERROR_CASE(INET_E_TERMINATED_BIND, wxWEBVIEW_NAV_ERR_OTHER)
1379                 WX_ERROR_CASE(INET_E_INVALID_CERTIFICATE, wxWEBVIEW_NAV_ERR_CERTIFICATE)
1380                 WX_ERROR_CASE(INET_E_CODE_DOWNLOAD_DECLINED, wxWEBVIEW_NAV_ERR_USER_CANCELLED)
1381                 WX_ERROR_CASE(INET_E_RESULT_DISPATCHED, wxWEBVIEW_NAV_ERR_OTHER)
1382                 WX_ERROR_CASE(INET_E_CANNOT_REPLACE_SFP_FILE, wxWEBVIEW_NAV_ERR_SECURITY)
1383                 WX_ERROR_CASE(INET_E_CODE_INSTALL_BLOCKED_BY_HASH_POLICY, wxWEBVIEW_NAV_ERR_SECURITY)
1384                 WX_ERROR_CASE(INET_E_CODE_INSTALL_SUPPRESSED, wxWEBVIEW_NAV_ERR_SECURITY)
1385             }
1386             HandleWindowEvent(event);
1387             break;
1388         }
1389         case DISPID_NEWWINDOW3:
1390         {
1391             wxString url = evt[4].GetString();
1392
1393             wxWebViewEvent event(wxEVT_WEBVIEW_NEWWINDOW,
1394                                  GetId(), url, wxEmptyString);
1395             event.SetEventObject(this);
1396             HandleWindowEvent(event);
1397
1398             //We always cancel this event otherwise an Internet Exporer window
1399             //is opened for the url
1400             wxActiveXEventNativeMSW* nativeParams = evt.GetNativeParameters();
1401             *V_BOOLREF(&nativeParams->pDispParams->rgvarg[3]) = VARIANT_TRUE;
1402             break;
1403         }
1404     }
1405
1406     evt.Skip();
1407 }
1408
1409 VirtualProtocol::VirtualProtocol(wxSharedPtr<wxWebViewHandler> handler)
1410 {
1411     m_file = NULL;
1412     m_handler = handler;
1413 }
1414
1415 BEGIN_IID_TABLE(VirtualProtocol)
1416     ADD_IID(Unknown)
1417     ADD_RAW_IID(wxIID_IInternetProtocolRoot)
1418     ADD_RAW_IID(wxIID_IInternetProtocol)
1419 END_IID_TABLE;
1420
1421 IMPLEMENT_IUNKNOWN_METHODS(VirtualProtocol)
1422
1423 HRESULT STDMETHODCALLTYPE VirtualProtocol::Start(LPCWSTR szUrl, wxIInternetProtocolSink *pOIProtSink,
1424                                wxIInternetBindInfo *pOIBindInfo, DWORD grfPI,
1425                                HANDLE_PTR dwReserved)
1426 {
1427     wxUnusedVar(szUrl);
1428     wxUnusedVar(pOIBindInfo);
1429     wxUnusedVar(grfPI);
1430     wxUnusedVar(dwReserved);
1431     m_protocolSink = pOIProtSink;
1432
1433     //We get the file itself from the protocol handler
1434     m_file = m_handler->GetFile(szUrl);
1435
1436
1437     if(!m_file)
1438         return INET_E_RESOURCE_NOT_FOUND;
1439
1440     //We return the stream length for current and total size as we can always
1441     //read the whole file from the stream
1442     wxFileOffset length = m_file->GetStream()->GetLength();
1443     m_protocolSink->ReportData(wxBSCF_FIRSTDATANOTIFICATION |
1444                                wxBSCF_DATAFULLYAVAILABLE |
1445                                wxBSCF_LASTDATANOTIFICATION,
1446                                length, length);
1447     return S_OK;
1448 }
1449
1450 HRESULT STDMETHODCALLTYPE VirtualProtocol::Read(void *pv, ULONG cb, ULONG *pcbRead)
1451 {
1452     //If the file is null we return false to indicte it is finished
1453     if(!m_file)
1454         return S_FALSE;
1455
1456     wxStreamError err = m_file->GetStream()->Read(pv, cb).GetLastError();
1457     *pcbRead = m_file->GetStream()->LastRead();
1458
1459     if(err == wxSTREAM_NO_ERROR)
1460     {
1461         if(*pcbRead < cb)
1462         {
1463             wxDELETE(m_file);
1464             m_protocolSink->ReportResult(S_OK, 0, NULL);
1465         }
1466         //As we are not eof there is more data
1467         return S_OK;
1468     }
1469     else if(err == wxSTREAM_EOF)
1470     {
1471         wxDELETE(m_file);
1472         m_protocolSink->ReportResult(S_OK, 0, NULL);
1473         //We are eof and so finished
1474         return S_OK;
1475     }
1476     else if(err ==  wxSTREAM_READ_ERROR)
1477     {
1478         wxDELETE(m_file);
1479         return INET_E_DOWNLOAD_FAILURE;
1480     }
1481     else
1482     {
1483         //Dummy return to suppress a compiler warning
1484         wxFAIL;
1485         return INET_E_DOWNLOAD_FAILURE;
1486     }
1487 }
1488
1489 BEGIN_IID_TABLE(ClassFactory)
1490     ADD_IID(Unknown)
1491     ADD_IID(ClassFactory)
1492 END_IID_TABLE;
1493
1494 IMPLEMENT_IUNKNOWN_METHODS(ClassFactory)
1495
1496 HRESULT STDMETHODCALLTYPE ClassFactory::CreateInstance(IUnknown* pUnkOuter, REFIID riid,
1497                                      void ** ppvObject)
1498 {
1499     if (pUnkOuter)
1500         return CLASS_E_NOAGGREGATION;
1501     VirtualProtocol* vp = new VirtualProtocol(m_handler);
1502     vp->AddRef();
1503     HRESULT hr = vp->QueryInterface(riid, ppvObject);
1504     vp->Release();
1505     return hr;
1506
1507 }
1508
1509 STDMETHODIMP ClassFactory::LockServer(BOOL fLock)
1510 {
1511     wxUnusedVar(fLock);
1512     return S_OK;
1513 }
1514
1515 wxIEContainer::wxIEContainer(wxWindow *parent, REFIID iid, IUnknown *pUnk,
1516                              DocHostUIHandler* uiHandler) :
1517     wxActiveXContainer(parent,iid,pUnk)
1518 {
1519     m_uiHandler = uiHandler;
1520 }
1521
1522 wxIEContainer::~wxIEContainer()
1523 {
1524 }
1525
1526 bool wxIEContainer::QueryClientSiteInterface(REFIID iid, void **_interface,
1527                                              const char *&desc)
1528 {
1529     if (m_uiHandler && IsEqualIID(iid, wxIID_IDocHostUIHandler))
1530     {
1531         *_interface = (IUnknown *) (wxIDocHostUIHandler *) m_uiHandler;
1532         desc = "IDocHostUIHandler";
1533         return true;
1534     }
1535     return false;
1536 }
1537
1538 HRESULT wxSTDCALL DocHostUIHandler::ShowContextMenu(DWORD dwID, POINT *ppt,
1539                                           IUnknown *pcmdtReserved,
1540                                           IDispatch *pdispReserved)
1541 {
1542     wxUnusedVar(dwID);
1543     wxUnusedVar(ppt);
1544     wxUnusedVar(pcmdtReserved);
1545     wxUnusedVar(pdispReserved);
1546     if(m_browser->IsContextMenuEnabled())
1547         return E_NOTIMPL;
1548     else
1549         return S_OK;
1550 }
1551
1552 HRESULT wxSTDCALL DocHostUIHandler::GetHostInfo(DOCHOSTUIINFO *pInfo)
1553 {
1554     //don't show 3d border and enable themes.
1555     pInfo->dwFlags = pInfo->dwFlags | DOCHOSTUIFLAG_NO3DBORDER | DOCHOSTUIFLAG_THEME;
1556     return S_OK;
1557 }
1558
1559 HRESULT wxSTDCALL DocHostUIHandler::ShowUI(DWORD dwID,
1560                                  IOleInPlaceActiveObject *pActiveObject,
1561                                  IOleCommandTarget *pCommandTarget,
1562                                  IOleInPlaceFrame *pFrame,
1563                                  IOleInPlaceUIWindow *pDoc)
1564 {
1565     wxUnusedVar(dwID);
1566     wxUnusedVar(pActiveObject);
1567     wxUnusedVar(pCommandTarget);
1568     wxUnusedVar(pFrame);
1569     wxUnusedVar(pDoc);
1570     return S_FALSE;
1571 }
1572
1573 HRESULT wxSTDCALL DocHostUIHandler::HideUI(void)
1574 {
1575     return E_NOTIMPL;
1576 }
1577
1578 HRESULT wxSTDCALL DocHostUIHandler::UpdateUI(void)
1579 {
1580     return E_NOTIMPL;
1581 }
1582
1583 HRESULT wxSTDCALL DocHostUIHandler::EnableModeless(BOOL fEnable)
1584 {
1585     wxUnusedVar(fEnable);
1586     return E_NOTIMPL;
1587 }
1588
1589 HRESULT wxSTDCALL DocHostUIHandler::OnDocWindowActivate(BOOL fActivate)
1590 {
1591     wxUnusedVar(fActivate);
1592     return E_NOTIMPL;
1593 }
1594
1595 HRESULT wxSTDCALL DocHostUIHandler::OnFrameWindowActivate(BOOL fActivate)
1596 {
1597     wxUnusedVar(fActivate);
1598     return E_NOTIMPL;
1599 }
1600
1601 HRESULT wxSTDCALL DocHostUIHandler::ResizeBorder(LPCRECT prcBorder,
1602                                        IOleInPlaceUIWindow *pUIWindow,
1603                                        BOOL fFrameWindow)
1604 {
1605     wxUnusedVar(prcBorder);
1606     wxUnusedVar(pUIWindow);
1607     wxUnusedVar(fFrameWindow);
1608     return E_NOTIMPL;
1609 }
1610
1611 HRESULT wxSTDCALL DocHostUIHandler::TranslateAccelerator(LPMSG lpMsg,
1612                                                const GUID *pguidCmdGroup,
1613                                                DWORD nCmdID)
1614 {
1615     if(lpMsg && lpMsg->message == WM_KEYDOWN)
1616     {
1617         // check control is down but that it isn't right-alt which is mapped to
1618         // alt + ctrl
1619         if(GetKeyState(VK_CONTROL) & 0x8000 &&
1620          !(GetKeyState(VK_MENU) & 0x8000))
1621         {
1622             //skip the accelerators used by the control
1623             switch(lpMsg->wParam)
1624             {
1625                 case 'F':
1626                 case 'L':
1627                 case 'N':
1628                 case 'O':
1629                 case 'P':
1630                     return S_OK;
1631             }
1632         }
1633         //skip F5
1634         if(lpMsg->wParam == VK_F5)
1635         {
1636             return S_OK;
1637         }
1638     }
1639
1640     wxUnusedVar(pguidCmdGroup);
1641     wxUnusedVar(nCmdID);
1642     return E_NOTIMPL;
1643 }
1644
1645 HRESULT wxSTDCALL DocHostUIHandler::GetOptionKeyPath(LPOLESTR *pchKey,DWORD dw)
1646 {
1647     wxUnusedVar(pchKey);
1648     wxUnusedVar(dw);
1649     return E_NOTIMPL;
1650 }
1651
1652 HRESULT wxSTDCALL DocHostUIHandler::GetDropTarget(IDropTarget *pDropTarget,
1653                                         IDropTarget **ppDropTarget)
1654 {
1655     wxUnusedVar(pDropTarget);
1656     wxUnusedVar(ppDropTarget);
1657     return E_NOTIMPL;
1658 }
1659
1660 HRESULT wxSTDCALL DocHostUIHandler::GetExternal(IDispatch **ppDispatch)
1661 {
1662     wxUnusedVar(ppDispatch);
1663     return E_NOTIMPL;
1664 }
1665
1666 HRESULT wxSTDCALL DocHostUIHandler::TranslateUrl(DWORD dwTranslate,
1667                                        OLECHAR *pchURLIn,
1668                                        OLECHAR **ppchURLOut)
1669 {
1670     wxUnusedVar(dwTranslate);
1671     wxUnusedVar(pchURLIn);
1672     wxUnusedVar(ppchURLOut);
1673     return E_NOTIMPL;
1674 }
1675
1676 HRESULT wxSTDCALL DocHostUIHandler::FilterDataObject(IDataObject *pDO, IDataObject **ppDORet)
1677 {
1678     wxUnusedVar(pDO);
1679     wxUnusedVar(ppDORet);
1680     return E_NOTIMPL;
1681 }
1682
1683 BEGIN_IID_TABLE(DocHostUIHandler)
1684     ADD_IID(Unknown)
1685     ADD_RAW_IID(wxIID_IDocHostUIHandler)
1686 END_IID_TABLE;
1687
1688 IMPLEMENT_IUNKNOWN_METHODS(DocHostUIHandler)
1689
1690 #endif // wxUSE_WEBVIEW && wxUSE_WEBVIEW_IE