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     //We always want the user to handle this themselves
 262     webkit_web_policy_decision_ignore(policy_decision);
 263     return TRUE;
 264 }
 265
 266 } // extern "C"
 267
 268 //-----------------------------------------------------------------------------
 269 // wxWebViewWebKit
 270 //-----------------------------------------------------------------------------
 271
 272 //IMPLEMENT_DYNAMIC_CLASS(wxWebViewWebKit, wxControl)
 273
 274 bool wxWebViewWebKit::Create(wxWindow *parent,
 275                       wxWindowID id,
 276                       const wxString &url,
 277                       const wxPoint& pos,
 278                       const wxSize& size,
 279                       long style,
 280                       const wxString& name)
 281 {
 282     m_ready = false;
 283     m_busy = false;
 284
 285     if (!PreCreation( parent, pos, size ) ||
 286         !CreateBase( parent, id, pos, size, style, wxDefaultValidator, name ))
 287     {
 288         wxFAIL_MSG( wxT("wxWebViewWebKit creation failed") );
 289         return false;
 290     }
 291
 292     GtkWidget *scrolled_window = gtk_scrolled_window_new (NULL, NULL);
 293     web_view = webkit_web_view_new ();
 294     g_object_ref(web_view); // TODO: check memory management
 295
 296     m_widget = scrolled_window;
 297     g_object_ref(m_widget); // TODO: check memory management
 298
 299     /* Place the WebKitWebView in the GtkScrolledWindow */
 300     gtk_container_add (GTK_CONTAINER (scrolled_window), web_view);
 301     gtk_widget_show(m_widget);
 302     gtk_widget_show(web_view);
 303
 304     g_signal_connect_after(web_view, "notify::load-status",
 305                            G_CALLBACK(wxgtk_webview_webkit_load_status),
 306                            this);
 307     g_signal_connect_after(web_view, "navigation-policy-decision-requested",
 308                            G_CALLBACK(wxgtk_webview_webkit_navigation),
 309                            this);
 310     g_signal_connect_after(web_view, "load-error",
 311                            G_CALLBACK(wxgtk_webview_webkit_error),
 312                            this);
 313
 314     g_signal_connect_after(web_view, "new-window-policy-decision-requested",
 315                            G_CALLBACK(wxgtk_webview_webkit_new_window), this);
 316
 317     m_parent->DoAddChild( this );
 318
 319     PostCreation(size);
 320
 321     /* Open a webpage */
 322     webkit_web_view_load_uri (WEBKIT_WEB_VIEW (web_view), url);
 323
 324     //Get the initial history limit so we can enable and disable it later
 325     WebKitWebBackForwardList* history;
 326     history = webkit_web_view_get_back_forward_list(WEBKIT_WEB_VIEW(web_view));
 327     m_historyLimit = webkit_web_back_forward_list_get_limit(history);
 328
 329     m_ready = true;
 330
 331     return true;
 332 }
 333
 334 bool wxWebViewWebKit::Enable( bool enable )
 335 {
 336     if (!wxControl::Enable(enable))
 337         return false;
 338
 339     gtk_widget_set_sensitive(GTK_BIN(m_widget)->child, enable);
 340
 341     //if (enable)
 342     //    GTKFixSensitivity();
 343
 344     return true;
 345 }
 346
 347 GdkWindow*
 348 wxWebViewWebKit::GTKGetWindow(wxArrayGdkWindows& WXUNUSED(windows)) const
 349 {
 350     GdkWindow* window = gtk_widget_get_parent_window(m_widget);
 351     return window;
 352 }
 353
 354 void wxWebViewWebKit::ZoomIn()
 355 {
 356     webkit_web_view_zoom_in (WEBKIT_WEB_VIEW(web_view));
 357 }
 358
 359 void wxWebViewWebKit::ZoomOut()
 360 {
 361     webkit_web_view_zoom_out (WEBKIT_WEB_VIEW(web_view));
 362 }
 363
 364 void wxWebViewWebKit::SetWebkitZoom(float level)
 365 {
 366     webkit_web_view_set_zoom_level (WEBKIT_WEB_VIEW(web_view), level);
 367 }
 368
 369 float wxWebViewWebKit::GetWebkitZoom()
 370 {
 371     return webkit_web_view_get_zoom_level (WEBKIT_WEB_VIEW(web_view));
 372 }
 373
 374 void wxWebViewWebKit::Stop()
 375 {
 376      webkit_web_view_stop_loading (WEBKIT_WEB_VIEW(web_view));
 377 }
 378
 379 void wxWebViewWebKit::Reload(wxWebViewReloadFlags flags)
 380 {
 381     if (flags & wxWEB_VIEW_RELOAD_NO_CACHE)
 382     {
 383         webkit_web_view_reload_bypass_cache (WEBKIT_WEB_VIEW(web_view));
 384     }
 385     else
 386     {
 387         webkit_web_view_reload (WEBKIT_WEB_VIEW(web_view));
 388     }
 389 }
 390
 391 void wxWebViewWebKit::LoadUrl(const wxString& url)
 392 {
 393     webkit_web_view_load_uri(WEBKIT_WEB_VIEW(web_view), wxGTK_CONV(url));
 394 }
 395
 396
 397 void wxWebViewWebKit::GoBack()
 398 {
 399     webkit_web_view_go_back (WEBKIT_WEB_VIEW(web_view));
 400 }
 401
 402 void wxWebViewWebKit::GoForward()
 403 {
 404     webkit_web_view_go_forward (WEBKIT_WEB_VIEW(web_view));
 405 }
 406
 407
 408 bool wxWebViewWebKit::CanGoBack()
 409 {
 410     return webkit_web_view_can_go_back (WEBKIT_WEB_VIEW(web_view));
 411 }
 412
 413
 414 bool wxWebViewWebKit::CanGoForward()
 415 {
 416     return webkit_web_view_can_go_forward (WEBKIT_WEB_VIEW(web_view));
 417 }
 418
 419 void wxWebViewWebKit::ClearHistory()
 420 {
 421     WebKitWebBackForwardList* history;
 422     history = webkit_web_view_get_back_forward_list(WEBKIT_WEB_VIEW(web_view));
 423     webkit_web_back_forward_list_clear(history);
 424 }
 425
 426 void wxWebViewWebKit::EnableHistory(bool enable)
 427 {
 428     WebKitWebBackForwardList* history;
 429     history = webkit_web_view_get_back_forward_list(WEBKIT_WEB_VIEW(web_view));
 430     if(enable)
 431     {
 432         webkit_web_back_forward_list_set_limit(history, m_historyLimit);
 433     }
 434     else
 435     {
 436         webkit_web_back_forward_list_set_limit(history, 0);
 437     }
 438 }
 439
 440 wxVector<wxSharedPtr<wxWebHistoryItem> > wxWebViewWebKit::GetBackwardHistory()
 441 {
 442     wxVector<wxSharedPtr<wxWebHistoryItem> > backhist;
 443     WebKitWebBackForwardList* history;
 444     history = webkit_web_view_get_back_forward_list(WEBKIT_WEB_VIEW(web_view));
 445     GList* list = webkit_web_back_forward_list_get_back_list_with_limit(history,
 446                                                                         m_historyLimit);
 447     //We need to iterate in reverse to get the order we desire
 448     for(int i = g_list_length(list) - 1; i >= 0 ; i--)
 449     {
 450         WebKitWebHistoryItem* gtkitem = (WebKitWebHistoryItem*)g_list_nth_data(list, i);
 451         wxSharedPtr<wxWebHistoryItem> item(new wxWebHistoryItem(
 452                                            webkit_web_history_item_get_uri(gtkitem),
 453                                            webkit_web_history_item_get_title(gtkitem)));
 454         backhist.push_back(item);
 455         m_historyMap[item] = gtkitem;
 456     }
 457     return backhist;
 458 }
 459
 460 wxVector<wxSharedPtr<wxWebHistoryItem> > wxWebViewWebKit::GetForwardHistory()
 461 {
 462     wxVector<wxSharedPtr<wxWebHistoryItem> > forwardhist;
 463     WebKitWebBackForwardList* history;
 464     history = webkit_web_view_get_back_forward_list(WEBKIT_WEB_VIEW(web_view));
 465     GList* list = webkit_web_back_forward_list_get_forward_list_with_limit(history,
 466                                                                            m_historyLimit);
 467     for(guint i = 0; i < g_list_length(list); i++)
 468     {
 469         WebKitWebHistoryItem* gtkitem = (WebKitWebHistoryItem*)g_list_nth_data(list, i);
 470         wxSharedPtr<wxWebHistoryItem> item(new wxWebHistoryItem(
 471                                            webkit_web_history_item_get_uri(gtkitem),
 472                                            webkit_web_history_item_get_title(gtkitem)));
 473         forwardhist.push_back(item);
 474         m_historyMap[item] = gtkitem;
 475     }
 476     return forwardhist;
 477 }
 478
 479 void wxWebViewWebKit::LoadHistoryItem(wxSharedPtr<wxWebHistoryItem> item)
 480 {
 481     WebKitWebHistoryItem* gtkitem = m_historyMap[item];
 482     if(gtkitem)
 483     {
 484         WebKitWebBackForwardList* history;
 485         history = webkit_web_view_get_back_forward_list(WEBKIT_WEB_VIEW(web_view));
 486         webkit_web_back_forward_list_go_to_item(history, gtkitem);
 487     }
 488 }
 489
 490 bool wxWebViewWebKit::CanCut()
 491 {
 492     return webkit_web_view_can_cut_clipboard(WEBKIT_WEB_VIEW(web_view));
 493 }
 494
 495 bool wxWebViewWebKit::CanCopy()
 496 {
 497     return webkit_web_view_can_copy_clipboard(WEBKIT_WEB_VIEW(web_view));
 498 }
 499
 500 bool wxWebViewWebKit::CanPaste()
 501 {
 502     return webkit_web_view_can_paste_clipboard(WEBKIT_WEB_VIEW(web_view));
 503 }
 504
 505 void wxWebViewWebKit::Cut()
 506 {
 507     webkit_web_view_cut_clipboard(WEBKIT_WEB_VIEW(web_view));
 508 }
 509
 510 void wxWebViewWebKit::Copy()
 511 {
 512     webkit_web_view_copy_clipboard(WEBKIT_WEB_VIEW(web_view));
 513 }
 514
 515 void wxWebViewWebKit::Paste()
 516 {
 517     webkit_web_view_paste_clipboard(WEBKIT_WEB_VIEW(web_view));
 518 }
 519
 520 bool wxWebViewWebKit::CanUndo()
 521 {
 522     return webkit_web_view_can_undo(WEBKIT_WEB_VIEW(web_view));
 523 }
 524
 525 bool wxWebViewWebKit::CanRedo()
 526 {
 527     return webkit_web_view_can_redo(WEBKIT_WEB_VIEW(web_view));
 528 }
 529
 530 void wxWebViewWebKit::Undo()
 531 {
 532     webkit_web_view_undo(WEBKIT_WEB_VIEW(web_view));
 533 }
 534
 535 void wxWebViewWebKit::Redo()
 536 {
 537     webkit_web_view_redo(WEBKIT_WEB_VIEW(web_view));
 538 }
 539
 540 wxString wxWebViewWebKit::GetCurrentURL()
 541 {
 542     // FIXME: check which encoding the web kit control uses instead of
 543     // assuming UTF8 (here and elsewhere too)
 544     return wxString::FromUTF8(webkit_web_view_get_uri(
 545                                 WEBKIT_WEB_VIEW(web_view)));
 546 }
 547
 548
 549 wxString wxWebViewWebKit::GetCurrentTitle()
 550 {
 551     return wxString::FromUTF8(webkit_web_view_get_title(
 552                                 WEBKIT_WEB_VIEW(web_view)));
 553 }
 554
 555
 556 wxString wxWebViewWebKit::GetPageSource()
 557 {
 558     WebKitWebFrame* frame = webkit_web_view_get_main_frame(
 559         WEBKIT_WEB_VIEW(web_view));
 560     WebKitWebDataSource* src = webkit_web_frame_get_data_source (frame);
 561
 562     // TODO: check encoding with
 563     // const gchar*
 564     // webkit_web_data_source_get_encoding(WebKitWebDataSource *data_source);
 565     return wxString(webkit_web_data_source_get_data (src)->str, wxConvUTF8);
 566 }
 567
 568
 569 wxWebViewZoom wxWebViewWebKit::GetZoom()
 570 {
 571     float zoom = GetWebkitZoom();
 572
 573     // arbitrary way to map float zoom to our common zoom enum
 574     if (zoom <= 0.65)
 575     {
 576         return wxWEB_VIEW_ZOOM_TINY;
 577     }
 578     else if (zoom > 0.65 && zoom <= 0.90)
 579     {
 580         return wxWEB_VIEW_ZOOM_SMALL;
 581     }
 582     else if (zoom > 0.90 && zoom <= 1.15)
 583     {
 584         return wxWEB_VIEW_ZOOM_MEDIUM;
 585     }
 586     else if (zoom > 1.15 && zoom <= 1.45)
 587     {
 588         return wxWEB_VIEW_ZOOM_LARGE;
 589     }
 590     else if (zoom > 1.45)
 591     {
 592         return wxWEB_VIEW_ZOOM_LARGEST;
 593     }
 594
 595     // to shut up compilers, this can never be reached logically
 596     wxASSERT(false);
 597     return wxWEB_VIEW_ZOOM_MEDIUM;
 598 }
 599
 600
 601 void wxWebViewWebKit::SetZoom(wxWebViewZoom zoom)
 602 {
 603     // arbitrary way to map our common zoom enum to float zoom
 604     switch (zoom)
 605     {
 606         case wxWEB_VIEW_ZOOM_TINY:
 607             SetWebkitZoom(0.6f);
 608             break;
 609
 610         case wxWEB_VIEW_ZOOM_SMALL:
 611             SetWebkitZoom(0.8f);
 612             break;
 613
 614         case wxWEB_VIEW_ZOOM_MEDIUM:
 615             SetWebkitZoom(1.0f);
 616             break;
 617
 618         case wxWEB_VIEW_ZOOM_LARGE:
 619             SetWebkitZoom(1.3);
 620             break;
 621
 622         case wxWEB_VIEW_ZOOM_LARGEST:
 623             SetWebkitZoom(1.6);
 624             break;
 625
 626         default:
 627             wxASSERT(false);
 628     }
 629 }
 630
 631 void wxWebViewWebKit::SetZoomType(wxWebViewZoomType type)
 632 {
 633     webkit_web_view_set_full_content_zoom(WEBKIT_WEB_VIEW(web_view),
 634                                           (type == wxWEB_VIEW_ZOOM_TYPE_LAYOUT ?
 635                                           TRUE : FALSE));
 636 }
 637
 638 wxWebViewZoomType wxWebViewWebKit::GetZoomType() const
 639 {
 640     gboolean fczoom = webkit_web_view_get_full_content_zoom(
 641             WEBKIT_WEB_VIEW(web_view));
 642
 643     if (fczoom) return wxWEB_VIEW_ZOOM_TYPE_LAYOUT;
 644     else        return wxWEB_VIEW_ZOOM_TYPE_TEXT;
 645 }
 646
 647 bool wxWebViewWebKit::CanSetZoomType(wxWebViewZoomType) const
 648 {
 649     // this port supports all zoom types
 650     return true;
 651 }
 652
 653 void wxWebViewWebKit::SetPage(const wxString& html, const wxString& baseUri)
 654 {
 655     webkit_web_view_load_string (WEBKIT_WEB_VIEW(web_view),
 656                                  html.mb_str(wxConvUTF8),
 657                                  "text/html",
 658                                  "UTF-8",
 659                                  baseUri.mb_str(wxConvUTF8));
 660 }
 661
 662 void wxWebViewWebKit::Print()
 663 {
 664     WebKitWebFrame* frame = webkit_web_view_get_main_frame(
 665             WEBKIT_WEB_VIEW(web_view));
 666     webkit_web_frame_print (frame);
 667
 668     // GtkPrintOperationResult  webkit_web_frame_print_full
 669     //      (WebKitWebFrame *frame,
 670     //       GtkPrintOperation *operation,
 671     //       GtkPrintOperationAction action,
 672     //       GError **error);
 673
 674 }
 675
 676
 677 bool wxWebViewWebKit::IsBusy()
 678 {
 679     return m_busy;
 680
 681     // This code looks nice but returns true after a page was cancelled
 682     /*
 683     WebKitLoadStatus status = webkit_web_view_get_load_status
 684             (WEBKIT_WEB_VIEW(web_view));
 685
 686
 687 #if WEBKIT_CHECK_VERSION(1,1,16)
 688     // WEBKIT_LOAD_FAILED is new in webkit 1.1.16
 689     if (status == WEBKIT_LOAD_FAILED)
 690     {
 691         return false;
 692     }
 693 #endif
 694     if (status == WEBKIT_LOAD_FINISHED)
 695     {
 696         return false;
 697     }
 698
 699     return true;
 700      */
 701 }
 702
 703 void wxWebViewWebKit::SetEditable(bool enable)
 704 {
 705     webkit_web_view_set_editable(WEBKIT_WEB_VIEW(web_view), enable);
 706 }
 707
 708 bool wxWebViewWebKit::IsEditable()
 709 {
 710     return webkit_web_view_get_editable(WEBKIT_WEB_VIEW(web_view));
 711 }
 712
 713 void wxWebViewWebKit::DeleteSelection()
 714 {
 715     webkit_web_view_delete_selection(WEBKIT_WEB_VIEW(web_view));
 716 }
 717
 718 bool wxWebViewWebKit::HasSelection()
 719 {
 720     return webkit_web_view_has_selection(WEBKIT_WEB_VIEW(web_view));
 721 }
 722
 723 void wxWebViewWebKit::SelectAll()
 724 {
 725     webkit_web_view_select_all(WEBKIT_WEB_VIEW(web_view));
 726 }
 727
 728 wxString wxWebViewWebKit::GetSelectedText()
 729 {
 730     WebKitDOMDocument* doc;
 731     WebKitDOMDOMWindow* win;
 732     WebKitDOMDOMSelection* sel;
 733     WebKitDOMRange* range;
 734
 735     doc = webkit_web_view_get_dom_document(WEBKIT_WEB_VIEW(web_view));
 736     win = webkit_dom_document_get_default_view(WEBKIT_DOM_DOCUMENT(doc));
 737     sel = webkit_dom_dom_window_get_selection(WEBKIT_DOM_DOM_WINDOW(win));
 738     range = webkit_dom_dom_selection_get_range_at(WEBKIT_DOM_DOM_SELECTION(sel),
 739                                                   0, NULL);
 740     return wxString(webkit_dom_range_get_text(WEBKIT_DOM_RANGE(range)),
 741                     wxConvUTF8);
 742 }
 743
 744 wxString wxWebViewWebKit::GetSelectedSource()
 745 {
 746     WebKitDOMDocument* doc;
 747     WebKitDOMDOMWindow* win;
 748     WebKitDOMDOMSelection* sel;
 749     WebKitDOMRange* range;
 750     WebKitDOMElement* div;
 751     WebKitDOMDocumentFragment* clone;
 752     WebKitDOMHTMLElement* html;
 753
 754     doc = webkit_web_view_get_dom_document(WEBKIT_WEB_VIEW(web_view));
 755     win = webkit_dom_document_get_default_view(WEBKIT_DOM_DOCUMENT(doc));
 756     sel = webkit_dom_dom_window_get_selection(WEBKIT_DOM_DOM_WINDOW(win));
 757     range = webkit_dom_dom_selection_get_range_at(WEBKIT_DOM_DOM_SELECTION(sel),
 758                                                   0, NULL);
 759     div = webkit_dom_document_create_element(WEBKIT_DOM_DOCUMENT(doc), "div", NULL);
 760
 761     clone = webkit_dom_range_clone_contents(WEBKIT_DOM_RANGE(range), NULL);
 762     webkit_dom_node_append_child(&div->parent_instance, &clone->parent_instance, NULL);
 763     html = (WebKitDOMHTMLElement*)div;
 764
 765     return wxString(webkit_dom_html_element_get_inner_html(WEBKIT_DOM_HTML_ELEMENT(html)),
 766                     wxConvUTF8);
 767 }
 768
 769 void wxWebViewWebKit::ClearSelection()
 770 {
 771     WebKitDOMDocument* doc;
 772     WebKitDOMDOMWindow* win;
 773     WebKitDOMDOMSelection* sel;
 774
 775     doc = webkit_web_view_get_dom_document(WEBKIT_WEB_VIEW(web_view));
 776     win = webkit_dom_document_get_default_view(WEBKIT_DOM_DOCUMENT(doc));
 777     sel = webkit_dom_dom_window_get_selection(WEBKIT_DOM_DOM_WINDOW(win));
 778     webkit_dom_dom_selection_remove_all_ranges(WEBKIT_DOM_DOM_SELECTION(sel));
 779
 780 }
 781
 782 wxString wxWebViewWebKit::GetPageText()
 783 {
 784     WebKitDOMDocument* doc;
 785     WebKitDOMHTMLElement* body;
 786
 787     doc = webkit_web_view_get_dom_document(WEBKIT_WEB_VIEW(web_view));
 788     body = webkit_dom_document_get_body(WEBKIT_DOM_DOCUMENT(doc));
 789     return wxString(webkit_dom_html_element_get_inner_text(WEBKIT_DOM_HTML_ELEMENT(body)),
 790                     wxConvUTF8);
 791 }
 792
 793 void wxWebViewWebKit::RunScript(const wxString& javascript)
 794 {
 795     webkit_web_view_execute_script(WEBKIT_WEB_VIEW(web_view),
 796                                    javascript.mb_str(wxConvUTF8));
 797 }
 798
 799 // static
 800 wxVisualAttributes
 801 wxWebViewWebKit::GetClassDefaultAttributes(wxWindowVariant WXUNUSED(variant))
 802 {
 803      return GetDefaultAttributesFromGTKWidget(webkit_web_view_new);
 804 }
 805
 806
 807 #endif // wxHAVE_WEB_BACKEND_GTK_WEBKIT