src/gtk/webview_webkit.cpp

   1 /////////////////////////////////////////////////////////////////////////////
   2 // Name:        src/gtk/webview_webkit.cpp
   3 // Purpose:     GTK WebKit backend for web view component
   4 // Author:      Marianne Gagnon, Robert Roebling
   5 // Id:          $Id$
   6 // Copyright:   (c) 2010 Marianne Gagnon, 1998 Robert Roebling
   7 // Licence:     wxWindows licence
   8 /////////////////////////////////////////////////////////////////////////////
   9
  10 // For compilers that support precompilation, includes "wx.h".
  11 #include "wx/wxprec.h"
  12
  13 #if wxUSE_WEBVIEW_WEBKIT
  14
  15 #include "wx/stockitem.h"
  16 #include "wx/gtk/webview_webkit.h"
  17 #include "wx/gtk/control.h"
  18 #include "wx/gtk/private.h"
  19 #include "webkit/webkit.h"
  20
  21 // ----------------------------------------------------------------------------
  22 // GTK callbacks
  23 // ----------------------------------------------------------------------------
  24
  25 extern "C"
  26 {
  27
  28 static void
  29 wxgtk_webview_webkit_load_status(GtkWidget* widget,
  30                                  GParamSpec*,
  31                                  wxWebViewWebKit *webKitCtrl)
  32 {
  33     if (!webKitCtrl->m_ready) return;
  34
  35     wxString url = webKitCtrl->GetCurrentURL();
  36
  37     WebKitLoadStatus status;
  38     g_object_get(G_OBJECT(widget), "load-status", &status, NULL);
  39
  40     wxString target; // TODO: get target (if possible)
  41
  42     if (status == WEBKIT_LOAD_FINISHED)
  43     {
  44         webKitCtrl->m_busy = false;
  45         wxWebNavigationEvent thisEvent(wxEVT_COMMAND_WEB_VIEW_LOADED,
  46                                        webKitCtrl->GetId(),
  47                                        url, target, false);
  48
  49         if (webKitCtrl && webKitCtrl->GetEventHandler())
  50             webKitCtrl->GetEventHandler()->ProcessEvent(thisEvent);
  51     }
  52     else if (status ==  WEBKIT_LOAD_COMMITTED)
  53     {
  54         webKitCtrl->m_busy = true;
  55         wxWebNavigationEvent thisEvent(wxEVT_COMMAND_WEB_VIEW_NAVIGATED,
  56                                        webKitCtrl->GetId(),
  57                                        url, target, false);
  58
  59         if (webKitCtrl && webKitCtrl->GetEventHandler())
  60             webKitCtrl->GetEventHandler()->ProcessEvent(thisEvent);
  61     }
  62 }
  63
  64 static gboolean
  65 wxgtk_webview_webkit_navigation(WebKitWebView*,
  66                                 WebKitWebFrame *frame,
  67                                 WebKitNetworkRequest *request,
  68                                 WebKitWebNavigationAction*,
  69                                 WebKitWebPolicyDecision *policy_decision,
  70                                 wxWebViewWebKit *webKitCtrl)
  71 {
  72     webKitCtrl->m_busy = true;
  73
  74     const gchar* uri = webkit_network_request_get_uri(request);
  75
  76     wxString target = webkit_web_frame_get_name (frame);
  77     wxWebNavigationEvent thisEvent(wxEVT_COMMAND_WEB_VIEW_NAVIGATING,
  78                                    webKitCtrl->GetId(),
  79                                    wxString( uri, wxConvUTF8 ),
  80                                    target,
  81                                    true);
  82
  83     if (webKitCtrl && webKitCtrl->GetEventHandler())
  84         webKitCtrl->GetEventHandler()->ProcessEvent(thisEvent);
  85
  86     if (thisEvent.IsVetoed())
  87     {
  88         webKitCtrl->m_busy = false;
  89         webkit_web_policy_decision_ignore(policy_decision);
  90         return TRUE;
  91     }
  92     else
  93     {
  94         return FALSE;
  95     }
  96 }
  97
  98 static gboolean
  99 wxgtk_webview_webkit_error(WebKitWebView*,
 100                            WebKitWebFrame*,
 101                            gchar *uri,
 102                            gpointer web_error,
 103                            wxWebViewWebKit* webKitWindow)
 104 {
 105     webKitWindow->m_busy = false;
 106     wxWebNavigationError type = wxWEB_NAV_ERR_OTHER;
 107
 108     GError* error = (GError*)web_error;
 109     wxString description(error->message, wxConvUTF8);
 110
 111     if (strcmp(g_quark_to_string(error->domain), "soup_http_error_quark") == 0)
 112     {
 113         switch (error->code)
 114         {
 115             case SOUP_STATUS_CANCELLED:
 116                 type = wxWEB_NAV_ERR_USER_CANCELLED;
 117                 break;
 118
 119             case SOUP_STATUS_CANT_RESOLVE:
 120             case SOUP_STATUS_NOT_FOUND:
 121                 type = wxWEB_NAV_ERR_NOT_FOUND;
 122                 break;
 123
 124             case SOUP_STATUS_CANT_RESOLVE_PROXY:
 125             case SOUP_STATUS_CANT_CONNECT:
 126             case SOUP_STATUS_CANT_CONNECT_PROXY:
 127             case SOUP_STATUS_SSL_FAILED:
 128             case SOUP_STATUS_IO_ERROR:
 129                 type = wxWEB_NAV_ERR_CONNECTION;
 130                 break;
 131
 132             case SOUP_STATUS_MALFORMED:
 133             //case SOUP_STATUS_TOO_MANY_REDIRECTS:
 134                 type = wxWEB_NAV_ERR_REQUEST;
 135                 break;
 136
 137             //case SOUP_STATUS_NO_CONTENT:
 138             //case SOUP_STATUS_RESET_CONTENT:
 139
 140             case SOUP_STATUS_BAD_REQUEST:
 141                 type = wxWEB_NAV_ERR_REQUEST;
 142                 break;
 143
 144             case SOUP_STATUS_UNAUTHORIZED:
 145             case SOUP_STATUS_FORBIDDEN:
 146                 type = wxWEB_NAV_ERR_AUTH;
 147                 break;
 148
 149             case SOUP_STATUS_METHOD_NOT_ALLOWED:
 150             case SOUP_STATUS_NOT_ACCEPTABLE:
 151                 type = wxWEB_NAV_ERR_SECURITY;
 152                 break;
 153
 154             case SOUP_STATUS_PROXY_AUTHENTICATION_REQUIRED:
 155                 type = wxWEB_NAV_ERR_AUTH;
 156                 break;
 157
 158             case SOUP_STATUS_REQUEST_TIMEOUT:
 159                 type = wxWEB_NAV_ERR_CONNECTION;
 160                 break;
 161
 162             //case SOUP_STATUS_PAYMENT_REQUIRED:
 163             case SOUP_STATUS_REQUEST_ENTITY_TOO_LARGE:
 164             case SOUP_STATUS_REQUEST_URI_TOO_LONG:
 165             case SOUP_STATUS_UNSUPPORTED_MEDIA_TYPE:
 166                 type = wxWEB_NAV_ERR_REQUEST;
 167                 break;
 168
 169             case SOUP_STATUS_BAD_GATEWAY:
 170             case SOUP_STATUS_SERVICE_UNAVAILABLE:
 171             case SOUP_STATUS_GATEWAY_TIMEOUT:
 172                 type = wxWEB_NAV_ERR_CONNECTION;
 173                 break;
 174
 175             case SOUP_STATUS_HTTP_VERSION_NOT_SUPPORTED:
 176                 type = wxWEB_NAV_ERR_REQUEST;
 177                 break;
 178             //case SOUP_STATUS_INSUFFICIENT_STORAGE:
 179             //case SOUP_STATUS_NOT_EXTENDED:
 180         }
 181     }
 182     else if (strcmp(g_quark_to_string(error->domain),
 183                     "webkit-network-error-quark") == 0)
 184     {
 185         switch (error->code)
 186         {
 187             //WEBKIT_NETWORK_ERROR_FAILED:
 188             //WEBKIT_NETWORK_ERROR_TRANSPORT:
 189
 190             case WEBKIT_NETWORK_ERROR_UNKNOWN_PROTOCOL:
 191                 type = wxWEB_NAV_ERR_REQUEST;
 192                 break;
 193
 194             case WEBKIT_NETWORK_ERROR_CANCELLED:
 195                 type = wxWEB_NAV_ERR_USER_CANCELLED;
 196                 break;
 197
 198             case WEBKIT_NETWORK_ERROR_FILE_DOES_NOT_EXIST:
 199                 type = wxWEB_NAV_ERR_NOT_FOUND;
 200                 break;
 201         }
 202     }
 203     else if (strcmp(g_quark_to_string(error->domain),
 204                     "webkit-policy-error-quark") == 0)
 205     {
 206         switch (error->code)
 207         {
 208             //case WEBKIT_POLICY_ERROR_FAILED:
 209             //case WEBKIT_POLICY_ERROR_CANNOT_SHOW_MIME_TYPE:
 210             //case WEBKIT_POLICY_ERROR_CANNOT_SHOW_URL:
 211             //case WEBKIT_POLICY_ERROR_FRAME_LOAD_INTERRUPTED_BY_POLICY_CHANGE:
 212             case WEBKIT_POLICY_ERROR_CANNOT_USE_RESTRICTED_PORT:
 213                 type = wxWEB_NAV_ERR_SECURITY;
 214                 break;
 215         }
 216     }
 217     /*
 218     webkit_plugin_error_quark
 219     else
 220     {
 221         printf("Error domain %s\n", g_quark_to_string(error->domain));
 222     }
 223     */
 224
 225     wxWebNavigationEvent thisEvent(wxEVT_COMMAND_WEB_VIEW_ERROR,
 226                                    webKitWindow->GetId(),
 227                                    uri,
 228                                    wxEmptyString,
 229                                    false);
 230     thisEvent.SetString(description);
 231     thisEvent.SetInt(type);
 232
 233     if (webKitWindow && webKitWindow->GetEventHandler())
 234     {
 235         webKitWindow->GetEventHandler()->ProcessEvent(thisEvent);
 236     }
 237
 238     return FALSE;
 239 }
 240
 241 static gboolean
 242 wxgtk_webview_webkit_new_window(WebKitWebView*,
 243                                 WebKitWebFrame *frame,
 244                                 WebKitNetworkRequest *request,
 245                                 WebKitWebNavigationAction*,
 246                                 WebKitWebPolicyDecision *policy_decision,
 247                                 wxWebViewWebKit *webKitCtrl)
 248 {
 249     const gchar* uri = webkit_network_request_get_uri(request);
 250
 251     wxString target = webkit_web_frame_get_name (frame);
 252     wxWebNavigationEvent thisEvent(wxEVT_COMMAND_WEB_VIEW_NEWWINDOW,
 253                                    webKitCtrl->GetId(),
 254                                    wxString( uri, wxConvUTF8 ),
 255                                    target,
 256                                    true);
 257
 258     if (webKitCtrl && webKitCtrl->GetEventHandler())
 259         webKitCtrl->GetEventHandler()->ProcessEvent(thisEvent);
 260
 261     if (thisEvent.IsVetoed())
 262     {
 263         webkit_web_policy_decision_ignore(policy_decision);
 264     }
 265     else
 266     {
 267         webkit_web_policy_decision_use(policy_decision);
 268     }
 269     return TRUE;
 270 }
 271
 272 } // extern "C"
 273
 274 //-----------------------------------------------------------------------------
 275 // wxWebViewWebKit
 276 //-----------------------------------------------------------------------------
 277
 278 //IMPLEMENT_DYNAMIC_CLASS(wxWebViewWebKit, wxControl)
 279
 280 bool wxWebViewWebKit::Create(wxWindow *parent,
 281                       wxWindowID id,
 282                       const wxString &url,
 283                       const wxPoint& pos,
 284                       const wxSize& size,
 285                       long style,
 286                       const wxString& name)
 287 {
 288     m_ready = false;
 289     m_busy = false;
 290
 291     if (!PreCreation( parent, pos, size ) ||
 292         !CreateBase( parent, id, pos, size, style, wxDefaultValidator, name ))
 293     {
 294         wxFAIL_MSG( wxT("wxWebViewWebKit creation failed") );
 295         return false;
 296     }
 297
 298     GtkWidget *scrolled_window = gtk_scrolled_window_new (NULL, NULL);
 299     web_view = webkit_web_view_new ();
 300     g_object_ref(web_view); // TODO: check memory management
 301
 302     m_widget = scrolled_window;
 303     g_object_ref(m_widget); // TODO: check memory management
 304
 305     /* Place the WebKitWebView in the GtkScrolledWindow */
 306     gtk_container_add (GTK_CONTAINER (scrolled_window), web_view);
 307     gtk_widget_show(m_widget);
 308     gtk_widget_show(web_view);
 309
 310     g_signal_connect_after(web_view, "notify::load-status",
 311                            G_CALLBACK(wxgtk_webview_webkit_load_status),
 312                            this);
 313     g_signal_connect_after(web_view, "navigation-policy-decision-requested",
 314                            G_CALLBACK(wxgtk_webview_webkit_navigation),
 315                            this);
 316     g_signal_connect_after(web_view, "load-error",
 317                            G_CALLBACK(wxgtk_webview_webkit_error),
 318                            this);
 319
 320     g_signal_connect_after(web_view, "new-window-policy-decision-requested",
 321                            G_CALLBACK(wxgtk_webview_webkit_new_window), this);
 322
 323     m_parent->DoAddChild( this );
 324
 325     PostCreation(size);
 326
 327     /* Open a webpage */
 328     webkit_web_view_load_uri (WEBKIT_WEB_VIEW (web_view), url);
 329
 330     //Get the initial history limit so we can enable and disable it later
 331     WebKitWebBackForwardList* history;
 332     history = webkit_web_view_get_back_forward_list(WEBKIT_WEB_VIEW(web_view));
 333     m_historyLimit = webkit_web_back_forward_list_get_limit(history);
 334
 335     m_ready = true;
 336
 337     return true;
 338 }
 339
 340 bool wxWebViewWebKit::Enable( bool enable )
 341 {
 342     if (!wxControl::Enable(enable))
 343         return false;
 344
 345     gtk_widget_set_sensitive(GTK_BIN(m_widget)->child, enable);
 346
 347     //if (enable)
 348     //    GTKFixSensitivity();
 349
 350     return true;
 351 }
 352
 353 GdkWindow*
 354 wxWebViewWebKit::GTKGetWindow(wxArrayGdkWindows& WXUNUSED(windows)) const
 355 {
 356     GdkWindow* window = gtk_widget_get_parent_window(m_widget);
 357     return window;
 358 }
 359
 360 void wxWebViewWebKit::ZoomIn()
 361 {
 362     webkit_web_view_zoom_in (WEBKIT_WEB_VIEW(web_view));
 363 }
 364
 365 void wxWebViewWebKit::ZoomOut()
 366 {
 367     webkit_web_view_zoom_out (WEBKIT_WEB_VIEW(web_view));
 368 }
 369
 370 void wxWebViewWebKit::SetWebkitZoom(float level)
 371 {
 372     webkit_web_view_set_zoom_level (WEBKIT_WEB_VIEW(web_view), level);
 373 }
 374
 375 float wxWebViewWebKit::GetWebkitZoom()
 376 {
 377     return webkit_web_view_get_zoom_level (WEBKIT_WEB_VIEW(web_view));
 378 }
 379
 380 void wxWebViewWebKit::Stop()
 381 {
 382      webkit_web_view_stop_loading (WEBKIT_WEB_VIEW(web_view));
 383 }
 384
 385 void wxWebViewWebKit::Reload(wxWebViewReloadFlags flags)
 386 {
 387     if (flags & wxWEB_VIEW_RELOAD_NO_CACHE)
 388     {
 389         webkit_web_view_reload_bypass_cache (WEBKIT_WEB_VIEW(web_view));
 390     }
 391     else
 392     {
 393         webkit_web_view_reload (WEBKIT_WEB_VIEW(web_view));
 394     }
 395 }
 396
 397 void wxWebViewWebKit::LoadUrl(const wxString& url)
 398 {
 399     webkit_web_view_load_uri(WEBKIT_WEB_VIEW(web_view), wxGTK_CONV(url));
 400 }
 401
 402
 403 void wxWebViewWebKit::GoBack()
 404 {
 405     webkit_web_view_go_back (WEBKIT_WEB_VIEW(web_view));
 406 }
 407
 408 void wxWebViewWebKit::GoForward()
 409 {
 410     webkit_web_view_go_forward (WEBKIT_WEB_VIEW(web_view));
 411 }
 412
 413
 414 bool wxWebViewWebKit::CanGoBack()
 415 {
 416     return webkit_web_view_can_go_back (WEBKIT_WEB_VIEW(web_view));
 417 }
 418
 419
 420 bool wxWebViewWebKit::CanGoForward()
 421 {
 422     return webkit_web_view_can_go_forward (WEBKIT_WEB_VIEW(web_view));
 423 }
 424
 425 void wxWebViewWebKit::ClearHistory()
 426 {
 427     WebKitWebBackForwardList* history;
 428     history = webkit_web_view_get_back_forward_list(WEBKIT_WEB_VIEW(web_view));
 429     webkit_web_back_forward_list_clear(history);
 430 }
 431
 432 void wxWebViewWebKit::EnableHistory(bool enable)
 433 {
 434     WebKitWebBackForwardList* history;
 435     history = webkit_web_view_get_back_forward_list(WEBKIT_WEB_VIEW(web_view));
 436     if(enable)
 437     {
 438         webkit_web_back_forward_list_set_limit(history, m_historyLimit);
 439     }
 440     else
 441     {
 442         webkit_web_back_forward_list_set_limit(history, 0);
 443     }
 444 }
 445
 446 wxVector<wxSharedPtr<wxWebHistoryItem> > wxWebViewWebKit::GetBackwardHistory()
 447 {
 448     wxVector<wxSharedPtr<wxWebHistoryItem> > backhist;
 449     WebKitWebBackForwardList* history;
 450     history = webkit_web_view_get_back_forward_list(WEBKIT_WEB_VIEW(web_view));
 451     GList* list = webkit_web_back_forward_list_get_back_list_with_limit(history,
 452                                                                         m_historyLimit);
 453     //We need to iterate in reverse to get the order we desire
 454     for(int i = g_list_length(list) - 1; i >= 0 ; i--)
 455     {
 456         WebKitWebHistoryItem* gtkitem = (WebKitWebHistoryItem*)g_list_nth_data(list, i);
 457         wxSharedPtr<wxWebHistoryItem> item(new wxWebHistoryItem(
 458                                            webkit_web_history_item_get_uri(gtkitem),
 459                                            webkit_web_history_item_get_title(gtkitem)));
 460         backhist.push_back(item);
 461         m_historyMap[item] = gtkitem;
 462     }
 463     return backhist;
 464 }
 465
 466 wxVector<wxSharedPtr<wxWebHistoryItem> > wxWebViewWebKit::GetForwardHistory()
 467 {
 468     wxVector<wxSharedPtr<wxWebHistoryItem> > forwardhist;
 469     WebKitWebBackForwardList* history;
 470     history = webkit_web_view_get_back_forward_list(WEBKIT_WEB_VIEW(web_view));
 471     GList* list = webkit_web_back_forward_list_get_forward_list_with_limit(history,
 472                                                                            m_historyLimit);
 473     for(guint i = 0; i < g_list_length(list); i++)
 474     {
 475         WebKitWebHistoryItem* gtkitem = (WebKitWebHistoryItem*)g_list_nth_data(list, i);
 476         wxSharedPtr<wxWebHistoryItem> item(new wxWebHistoryItem(
 477                                            webkit_web_history_item_get_uri(gtkitem),
 478                                            webkit_web_history_item_get_title(gtkitem)));
 479         forwardhist.push_back(item);
 480         m_historyMap[item] = gtkitem;
 481     }
 482     return forwardhist;
 483 }
 484
 485 void wxWebViewWebKit::LoadHistoryItem(wxSharedPtr<wxWebHistoryItem> item)
 486 {
 487     WebKitWebHistoryItem* gtkitem = m_historyMap[item];
 488     if(gtkitem)
 489     {
 490         WebKitWebBackForwardList* history;
 491         history = webkit_web_view_get_back_forward_list(WEBKIT_WEB_VIEW(web_view));
 492         webkit_web_back_forward_list_go_to_item(history, gtkitem);
 493     }
 494 }
 495
 496 bool wxWebViewWebKit::CanCut()
 497 {
 498     return webkit_web_view_can_cut_clipboard(WEBKIT_WEB_VIEW(web_view));
 499 }
 500
 501 bool wxWebViewWebKit::CanCopy()
 502 {
 503     return webkit_web_view_can_copy_clipboard(WEBKIT_WEB_VIEW(web_view));
 504 }
 505
 506 bool wxWebViewWebKit::CanPaste()
 507 {
 508     return webkit_web_view_can_paste_clipboard(WEBKIT_WEB_VIEW(web_view));
 509 }
 510
 511 void wxWebViewWebKit::Cut()
 512 {
 513     webkit_web_view_cut_clipboard(WEBKIT_WEB_VIEW(web_view));
 514 }
 515
 516 void wxWebViewWebKit::Copy()
 517 {
 518     webkit_web_view_copy_clipboard(WEBKIT_WEB_VIEW(web_view));
 519 }
 520
 521 void wxWebViewWebKit::Paste()
 522 {
 523     webkit_web_view_paste_clipboard(WEBKIT_WEB_VIEW(web_view));
 524 }
 525
 526 bool wxWebViewWebKit::CanUndo()
 527 {
 528     return webkit_web_view_can_undo(WEBKIT_WEB_VIEW(web_view));
 529 }
 530
 531 bool wxWebViewWebKit::CanRedo()
 532 {
 533     return webkit_web_view_can_redo(WEBKIT_WEB_VIEW(web_view));
 534 }
 535
 536 void wxWebViewWebKit::Undo()
 537 {
 538     webkit_web_view_undo(WEBKIT_WEB_VIEW(web_view));
 539 }
 540
 541 void wxWebViewWebKit::Redo()
 542 {
 543     webkit_web_view_redo(WEBKIT_WEB_VIEW(web_view));
 544 }
 545
 546 wxString wxWebViewWebKit::GetCurrentURL()
 547 {
 548     // FIXME: check which encoding the web kit control uses instead of
 549     // assuming UTF8 (here and elsewhere too)
 550     return wxString::FromUTF8(webkit_web_view_get_uri(
 551                                 WEBKIT_WEB_VIEW(web_view)));
 552 }
 553
 554
 555 wxString wxWebViewWebKit::GetCurrentTitle()
 556 {
 557     return wxString::FromUTF8(webkit_web_view_get_title(
 558                                 WEBKIT_WEB_VIEW(web_view)));
 559 }
 560
 561
 562 wxString wxWebViewWebKit::GetPageSource()
 563 {
 564     WebKitWebFrame* frame = webkit_web_view_get_main_frame(
 565         WEBKIT_WEB_VIEW(web_view));
 566     WebKitWebDataSource* src = webkit_web_frame_get_data_source (frame);
 567
 568     // TODO: check encoding with
 569     // const gchar*
 570     // webkit_web_data_source_get_encoding(WebKitWebDataSource *data_source);
 571     return wxString(webkit_web_data_source_get_data (src)->str, wxConvUTF8);
 572 }
 573
 574
 575 wxWebViewZoom wxWebViewWebKit::GetZoom()
 576 {
 577     float zoom = GetWebkitZoom();
 578
 579     // arbitrary way to map float zoom to our common zoom enum
 580     if (zoom <= 0.65)
 581     {
 582         return wxWEB_VIEW_ZOOM_TINY;
 583     }
 584     else if (zoom > 0.65 && zoom <= 0.90)
 585     {
 586         return wxWEB_VIEW_ZOOM_SMALL;
 587     }
 588     else if (zoom > 0.90 && zoom <= 1.15)
 589     {
 590         return wxWEB_VIEW_ZOOM_MEDIUM;
 591     }
 592     else if (zoom > 1.15 && zoom <= 1.45)
 593     {
 594         return wxWEB_VIEW_ZOOM_LARGE;
 595     }
 596     else if (zoom > 1.45)
 597     {
 598         return wxWEB_VIEW_ZOOM_LARGEST;
 599     }
 600
 601     // to shut up compilers, this can never be reached logically
 602     wxASSERT(false);
 603     return wxWEB_VIEW_ZOOM_MEDIUM;
 604 }
 605
 606
 607 void wxWebViewWebKit::SetZoom(wxWebViewZoom zoom)
 608 {
 609     // arbitrary way to map our common zoom enum to float zoom
 610     switch (zoom)
 611     {
 612         case wxWEB_VIEW_ZOOM_TINY:
 613             SetWebkitZoom(0.6f);
 614             break;
 615
 616         case wxWEB_VIEW_ZOOM_SMALL:
 617             SetWebkitZoom(0.8f);
 618             break;
 619
 620         case wxWEB_VIEW_ZOOM_MEDIUM:
 621             SetWebkitZoom(1.0f);
 622             break;
 623
 624         case wxWEB_VIEW_ZOOM_LARGE:
 625             SetWebkitZoom(1.3);
 626             break;
 627
 628         case wxWEB_VIEW_ZOOM_LARGEST:
 629             SetWebkitZoom(1.6);
 630             break;
 631
 632         default:
 633             wxASSERT(false);
 634     }
 635 }
 636
 637 void wxWebViewWebKit::SetZoomType(wxWebViewZoomType type)
 638 {
 639     webkit_web_view_set_full_content_zoom(WEBKIT_WEB_VIEW(web_view),
 640                                           (type == wxWEB_VIEW_ZOOM_TYPE_LAYOUT ?
 641                                           TRUE : FALSE));
 642 }
 643
 644 wxWebViewZoomType wxWebViewWebKit::GetZoomType() const
 645 {
 646     gboolean fczoom = webkit_web_view_get_full_content_zoom(
 647             WEBKIT_WEB_VIEW(web_view));
 648
 649     if (fczoom) return wxWEB_VIEW_ZOOM_TYPE_LAYOUT;
 650     else        return wxWEB_VIEW_ZOOM_TYPE_TEXT;
 651 }
 652
 653 bool wxWebViewWebKit::CanSetZoomType(wxWebViewZoomType) const
 654 {
 655     // this port supports all zoom types
 656     return true;
 657 }
 658
 659 void wxWebViewWebKit::SetPage(const wxString& html, const wxString& baseUri)
 660 {
 661     webkit_web_view_load_string (WEBKIT_WEB_VIEW(web_view),
 662                                  html.mb_str(wxConvUTF8),
 663                                  "text/html",
 664                                  "UTF-8",
 665                                  baseUri.mb_str(wxConvUTF8));
 666 }
 667
 668 void wxWebViewWebKit::Print()
 669 {
 670     WebKitWebFrame* frame = webkit_web_view_get_main_frame(
 671             WEBKIT_WEB_VIEW(web_view));
 672     webkit_web_frame_print (frame);
 673
 674     // GtkPrintOperationResult  webkit_web_frame_print_full
 675     //      (WebKitWebFrame *frame,
 676     //       GtkPrintOperation *operation,
 677     //       GtkPrintOperationAction action,
 678     //       GError **error);
 679
 680 }
 681
 682
 683 bool wxWebViewWebKit::IsBusy()
 684 {
 685     return m_busy;
 686
 687     // This code looks nice but returns true after a page was cancelled
 688     /*
 689     WebKitLoadStatus status = webkit_web_view_get_load_status
 690             (WEBKIT_WEB_VIEW(web_view));
 691
 692
 693 #if WEBKIT_CHECK_VERSION(1,1,16)
 694     // WEBKIT_LOAD_FAILED is new in webkit 1.1.16
 695     if (status == WEBKIT_LOAD_FAILED)
 696     {
 697         return false;
 698     }
 699 #endif
 700     if (status == WEBKIT_LOAD_FINISHED)
 701     {
 702         return false;
 703     }
 704
 705     return true;
 706      */
 707 }
 708
 709 void wxWebViewWebKit::SetEditable(bool enable)
 710 {
 711     webkit_web_view_set_editable(WEBKIT_WEB_VIEW(web_view), enable);
 712 }
 713
 714 bool wxWebViewWebKit::IsEditable()
 715 {
 716     return webkit_web_view_get_editable(WEBKIT_WEB_VIEW(web_view));
 717 }
 718
 719 void wxWebViewWebKit::DeleteSelection()
 720 {
 721     webkit_web_view_delete_selection(WEBKIT_WEB_VIEW(web_view));
 722 }
 723
 724 bool wxWebViewWebKit::HasSelection()
 725 {
 726     return webkit_web_view_has_selection(WEBKIT_WEB_VIEW(web_view));
 727 }
 728
 729 void wxWebViewWebKit::SelectAll()
 730 {
 731     webkit_web_view_select_all(WEBKIT_WEB_VIEW(web_view));
 732 }
 733
 734 wxString wxWebViewWebKit::GetSelectedText()
 735 {
 736     WebKitDOMDocument* doc;
 737     WebKitDOMDOMWindow* win;
 738     WebKitDOMDOMSelection* sel;
 739     WebKitDOMRange* range;
 740
 741     doc = webkit_web_view_get_dom_document(WEBKIT_WEB_VIEW(web_view));
 742     win = webkit_dom_document_get_default_view(WEBKIT_DOM_DOCUMENT(doc));
 743     sel = webkit_dom_dom_window_get_selection(WEBKIT_DOM_DOM_WINDOW(win));
 744     range = webkit_dom_dom_selection_get_range_at(WEBKIT_DOM_DOM_SELECTION(sel),
 745                                                   0, NULL);
 746     return wxString(webkit_dom_range_get_text(WEBKIT_DOM_RANGE(range)),
 747                     wxConvUTF8);
 748 }
 749
 750 wxString wxWebViewWebKit::GetSelectedSource()
 751 {
 752     WebKitDOMDocument* doc;
 753     WebKitDOMDOMWindow* win;
 754     WebKitDOMDOMSelection* sel;
 755     WebKitDOMRange* range;
 756     WebKitDOMElement* div;
 757     WebKitDOMDocumentFragment* clone;
 758     WebKitDOMHTMLElement* html;
 759
 760     doc = webkit_web_view_get_dom_document(WEBKIT_WEB_VIEW(web_view));
 761     win = webkit_dom_document_get_default_view(WEBKIT_DOM_DOCUMENT(doc));
 762     sel = webkit_dom_dom_window_get_selection(WEBKIT_DOM_DOM_WINDOW(win));
 763     range = webkit_dom_dom_selection_get_range_at(WEBKIT_DOM_DOM_SELECTION(sel),
 764                                                   0, NULL);
 765     div = webkit_dom_document_create_element(WEBKIT_DOM_DOCUMENT(doc), "div", NULL);
 766
 767     clone = webkit_dom_range_clone_contents(WEBKIT_DOM_RANGE(range), NULL);
 768     webkit_dom_node_append_child(&div->parent_instance, &clone->parent_instance, NULL);
 769     html = (WebKitDOMHTMLElement*)div;
 770
 771     return wxString(webkit_dom_html_element_get_inner_html(WEBKIT_DOM_HTML_ELEMENT(html)),
 772                     wxConvUTF8);
 773 }
 774
 775 void wxWebViewWebKit::ClearSelection()
 776 {
 777     WebKitDOMDocument* doc;
 778     WebKitDOMDOMWindow* win;
 779     WebKitDOMDOMSelection* sel;
 780
 781     doc = webkit_web_view_get_dom_document(WEBKIT_WEB_VIEW(web_view));
 782     win = webkit_dom_document_get_default_view(WEBKIT_DOM_DOCUMENT(doc));
 783     sel = webkit_dom_dom_window_get_selection(WEBKIT_DOM_DOM_WINDOW(win));
 784     webkit_dom_dom_selection_remove_all_ranges(WEBKIT_DOM_DOM_SELECTION(sel));
 785
 786 }
 787
 788 wxString wxWebViewWebKit::GetPageText()
 789 {
 790     WebKitDOMDocument* doc;
 791     WebKitDOMHTMLElement* body;
 792
 793     doc = webkit_web_view_get_dom_document(WEBKIT_WEB_VIEW(web_view));
 794     body = webkit_dom_document_get_body(WEBKIT_DOM_DOCUMENT(doc));
 795     return wxString(webkit_dom_html_element_get_inner_text(WEBKIT_DOM_HTML_ELEMENT(body)),
 796                     wxConvUTF8);
 797 }
 798
 799 void wxWebViewWebKit::RunScript(const wxString& javascript)
 800 {
 801     webkit_web_view_execute_script(WEBKIT_WEB_VIEW(web_view),
 802                                    javascript.mb_str(wxConvUTF8));
 803 }
 804
 805 // static
 806 wxVisualAttributes
 807 wxWebViewWebKit::GetClassDefaultAttributes(wxWindowVariant WXUNUSED(variant))
 808 {
 809      return GetDefaultAttributesFromGTKWidget(webkit_web_view_new);
 810 }
 811
 812
 813 #endif // wxHAVE_WEB_BACKEND_GTK_WEBKIT