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