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