Google Git
Sign in
chromium / external / github.com / WebKit / webkit / ee85abb681b51aa33f6b2adb2e5043dc2f02b90a / . / Source / WebKit2 / UIProcess / API / gtk / WebKitWebView.cpp
blob: 85b078a181e18ad86462893254e01f7a6c8f9ebf [file] [log] [blame]
/*
* Copyright (C) 2011 Igalia S.L.
* Portions Copyright (c) 2011 Motorola Mobility, Inc. All rights reserved.
*
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Library General Public
* License as published by the Free Software Foundation; either
* version 2 of the License, or (at your option) any later version.
*
* This library is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* Library General Public License for more details.
*
* You should have received a copy of the GNU Library General Public License
* along with this library; see the file COPYING.LIB. If not, write to
* the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
* Boston, MA 02110-1301, USA.
*/
#include "config.h"
#include "WebKitWebView.h"
#include "APIData.h"
#include "ImageOptions.h"
#include "WebCertificateInfo.h"
#include "WebContextMenuItem.h"
#include "WebContextMenuItemData.h"
#include "WebKitAuthenticationDialog.h"
#include "WebKitAuthenticationRequestPrivate.h"
#include "WebKitBackForwardListPrivate.h"
#include "WebKitCertificateInfoPrivate.h"
#include "WebKitContextMenuClient.h"
#include "WebKitContextMenuItemPrivate.h"
#include "WebKitContextMenuPrivate.h"
#include "WebKitDownloadPrivate.h"
#include "WebKitEnumTypes.h"
#include "WebKitError.h"
#include "WebKitFaviconDatabasePrivate.h"
#include "WebKitFormClient.h"
#include "WebKitFullscreenClient.h"
#include "WebKitHitTestResultPrivate.h"
#include "WebKitJavascriptResultPrivate.h"
#include "WebKitLoaderClient.h"
#include "WebKitMarshal.h"
#include "WebKitPolicyClient.h"
#include "WebKitPrintOperationPrivate.h"
#include "WebKitPrivate.h"
#include "WebKitResponsePolicyDecision.h"
#include "WebKitScriptDialogPrivate.h"
#include "WebKitUIClient.h"
#include "WebKitURIRequestPrivate.h"
#include "WebKitURIResponsePrivate.h"
#include "WebKitWebContextPrivate.h"
#include "WebKitWebInspectorPrivate.h"
#include "WebKitWebResourcePrivate.h"
#include "WebKitWebViewBasePrivate.h"
#include "WebKitWebViewGroupPrivate.h"
#include "WebKitWebViewPrivate.h"
#include "WebKitWindowPropertiesPrivate.h"
#include <JavaScriptCore/APICast.h>
#include <WebCore/CertificateInfo.h>
#include <WebCore/DragIcon.h>
#include <WebCore/GUniquePtrGtk.h>
#include <WebCore/GUniquePtrSoup.h>
#include <WebCore/GtkUtilities.h>
#include <WebCore/RefPtrCairo.h>
#include <glib/gi18n-lib.h>
#include <wtf/gobject/GRefPtr.h>
#include <wtf/text/CString.h>
using namespace WebKit;
using namespace WebCore;
/**
* SECTION: WebKitWebView
* @Short_description: The central class of the WebKit2GTK+ API
* @Title: WebKitWebView
*
* #WebKitWebView is the central class of the WebKit2GTK+ API. It is
* responsible for managing the drawing of the content and forwarding
* of events. You can load any URI into the #WebKitWebView or a data
* string. With #WebKitSettings you can control various aspects of the
* rendering and loading of the content.
*
* Note that #WebKitWebView is scrollable by itself, so you don't need
* to embed it in a #GtkScrolledWindow.
*/
enum {
LOAD_CHANGED,
LOAD_FAILED,
LOAD_FAILED_WITH_TLS_ERRORS,
CREATE,
READY_TO_SHOW,
RUN_AS_MODAL,
CLOSE,
SCRIPT_DIALOG,
DECIDE_POLICY,
PERMISSION_REQUEST,
MOUSE_TARGET_CHANGED,
PRINT,
RESOURCE_LOAD_STARTED,
ENTER_FULLSCREEN,
LEAVE_FULLSCREEN,
RUN_FILE_CHOOSER,
CONTEXT_MENU,
CONTEXT_MENU_DISMISSED,
SUBMIT_FORM,
INSECURE_CONTENT_DETECTED,
WEB_PROCESS_CRASHED,
AUTHENTICATE,
LAST_SIGNAL
};
enum {
PROP_0,
PROP_WEB_CONTEXT,
PROP_RELATED_VIEW,
PROP_GROUP,
PROP_USER_CONTENT_MANAGER,
PROP_TITLE,
PROP_ESTIMATED_LOAD_PROGRESS,
PROP_FAVICON,
PROP_URI,
PROP_ZOOM_LEVEL,
PROP_IS_LOADING
};
typedef HashMap<uint64_t, GRefPtr<WebKitWebResource> > LoadingResourcesMap;
typedef HashMap<uint64_t, GRefPtr<GTask> > SnapshotResultsMap;
struct _WebKitWebViewPrivate {
~_WebKitWebViewPrivate()
{
if (javascriptGlobalContext)
JSGlobalContextRelease(javascriptGlobalContext);
// For modal dialogs, make sure the main loop is stopped when finalizing the webView.
if (modalLoop && g_main_loop_is_running(modalLoop.get()))
g_main_loop_quit(modalLoop.get());
}
WebKitWebContext* context;
WebKitWebView* relatedView;
CString title;
CString customTextEncoding;
double estimatedLoadProgress;
CString activeURI;
bool isLoading;
bool waitingForMainResource;
unsigned long mainResourceResponseHandlerID;
WebKitLoadEvent lastDelayedEvent;
GRefPtr<WebKitBackForwardList> backForwardList;
GRefPtr<WebKitSettings> settings;
unsigned long settingsChangedHandlerID;
GRefPtr<WebKitWebViewGroup> group;
GRefPtr<WebKitUserContentManager> userContentManager;
GRefPtr<WebKitWindowProperties> windowProperties;
GRefPtr<GMainLoop> modalLoop;
GRefPtr<WebKitHitTestResult> mouseTargetHitTestResult;
unsigned mouseTargetModifiers;
GRefPtr<WebKitFindController> findController;
JSGlobalContextRef javascriptGlobalContext;
GRefPtr<WebKitWebResource> mainResource;
LoadingResourcesMap loadingResourcesMap;
GRefPtr<WebKitWebInspector> inspector;
RefPtr<cairo_surface_t> favicon;
GRefPtr<GCancellable> faviconCancellable;
CString faviconURI;
unsigned long faviconChangedHandlerID;
SnapshotResultsMap snapshotResultsMap;
GRefPtr<WebKitAuthenticationRequest> authenticationRequest;
};
static guint signals[LAST_SIGNAL] = { 0, };
WEBKIT_DEFINE_TYPE(WebKitWebView, webkit_web_view, WEBKIT_TYPE_WEB_VIEW_BASE)
static inline WebPageProxy* getPage(WebKitWebView* webView)
{
return webkitWebViewBaseGetPage(reinterpret_cast<WebKitWebViewBase*>(webView));
}
static gboolean webkitWebViewLoadFail(WebKitWebView* webView, WebKitLoadEvent, const char* failingURI, GError* error)
{
if (g_error_matches(error, WEBKIT_NETWORK_ERROR, WEBKIT_NETWORK_ERROR_CANCELLED)
|| g_error_matches(error, WEBKIT_POLICY_ERROR, WEBKIT_POLICY_ERROR_FRAME_LOAD_INTERRUPTED_BY_POLICY_CHANGE)
|| g_error_matches(error, WEBKIT_PLUGIN_ERROR, WEBKIT_PLUGIN_ERROR_WILL_HANDLE_LOAD))
return FALSE;
GUniquePtr<char> htmlString(g_strdup_printf("<html><body>%s</body></html>", error->message));
webkit_web_view_load_alternate_html(webView, htmlString.get(), failingURI, 0);
return TRUE;
}
static GtkWidget* webkitWebViewCreate(WebKitWebView*, WebKitNavigationAction*)
{
return nullptr;
}
static GtkWidget* webkitWebViewCreateJavaScriptDialog(WebKitWebView* webView, GtkMessageType type, GtkButtonsType buttons, int defaultResponse, const char* message)
{
GtkWidget* parent = gtk_widget_get_toplevel(GTK_WIDGET(webView));
GtkWidget* dialog = gtk_message_dialog_new(widgetIsOnscreenToplevelWindow(parent) ? GTK_WINDOW(parent) : 0,
GTK_DIALOG_DESTROY_WITH_PARENT, type, buttons, "%s", message);
GUniquePtr<char> title(g_strdup_printf("JavaScript - %s", webkit_web_view_get_uri(webView)));
gtk_window_set_title(GTK_WINDOW(dialog), title.get());
gtk_dialog_set_default_response(GTK_DIALOG(dialog), defaultResponse);
return dialog;
}
static gboolean webkitWebViewScriptDialog(WebKitWebView* webView, WebKitScriptDialog* scriptDialog)
{
GtkWidget* dialog = 0;
switch (scriptDialog->type) {
case WEBKIT_SCRIPT_DIALOG_ALERT:
dialog = webkitWebViewCreateJavaScriptDialog(webView, GTK_MESSAGE_WARNING, GTK_BUTTONS_CLOSE, GTK_RESPONSE_CLOSE, scriptDialog->message.data());
gtk_dialog_run(GTK_DIALOG(dialog));
break;
case WEBKIT_SCRIPT_DIALOG_CONFIRM:
dialog = webkitWebViewCreateJavaScriptDialog(webView, GTK_MESSAGE_QUESTION, GTK_BUTTONS_OK_CANCEL, GTK_RESPONSE_OK, scriptDialog->message.data());
scriptDialog->confirmed = gtk_dialog_run(GTK_DIALOG(dialog)) == GTK_RESPONSE_OK;
break;
case WEBKIT_SCRIPT_DIALOG_PROMPT:
dialog = webkitWebViewCreateJavaScriptDialog(webView, GTK_MESSAGE_QUESTION, GTK_BUTTONS_OK_CANCEL, GTK_RESPONSE_OK, scriptDialog->message.data());
GtkWidget* entry = gtk_entry_new();
gtk_entry_set_text(GTK_ENTRY(entry), scriptDialog->defaultText.data());
gtk_container_add(GTK_CONTAINER(gtk_dialog_get_content_area(GTK_DIALOG(dialog))), entry);
gtk_entry_set_activates_default(GTK_ENTRY(entry), TRUE);
gtk_widget_show(entry);
if (gtk_dialog_run(GTK_DIALOG(dialog)) == GTK_RESPONSE_OK)
scriptDialog->text = gtk_entry_get_text(GTK_ENTRY(entry));
break;
}
gtk_widget_destroy(dialog);
return TRUE;
}
static gboolean webkitWebViewDecidePolicy(WebKitWebView*, WebKitPolicyDecision* decision, WebKitPolicyDecisionType decisionType)
{
if (decisionType != WEBKIT_POLICY_DECISION_TYPE_RESPONSE) {
webkit_policy_decision_use(decision);
return TRUE;
}
WebKitURIResponse* response = webkit_response_policy_decision_get_response(WEBKIT_RESPONSE_POLICY_DECISION(decision));
const ResourceResponse& resourceResponse = webkitURIResponseGetResourceResponse(response);
if (resourceResponse.isAttachment()) {
webkit_policy_decision_download(decision);
return TRUE;
}
if (webkit_response_policy_decision_is_mime_type_supported(WEBKIT_RESPONSE_POLICY_DECISION(decision)))
webkit_policy_decision_use(decision);
else
webkit_policy_decision_ignore(decision);
return TRUE;
}
static gboolean webkitWebViewPermissionRequest(WebKitWebView*, WebKitPermissionRequest* request)
{
webkit_permission_request_deny(request);
return TRUE;
}
static void allowModalDialogsChanged(WebKitSettings* settings, GParamSpec*, WebKitWebView* webView)
{
WebPageProxy* page = webkitWebViewBaseGetPage(WEBKIT_WEB_VIEW_BASE(webView));
if (!page)
return;
getPage(webView)->setCanRunModal(webkit_settings_get_allow_modal_dialogs(settings));
}
static void zoomTextOnlyChanged(WebKitSettings* settings, GParamSpec*, WebKitWebView* webView)
{
WebPageProxy* page = getPage(webView);
gboolean zoomTextOnly = webkit_settings_get_zoom_text_only(settings);
gdouble pageZoomLevel = zoomTextOnly ? 1 : page->textZoomFactor();
gdouble textZoomLevel = zoomTextOnly ? page->pageZoomFactor() : 1;
page->setPageAndTextZoomFactors(pageZoomLevel, textZoomLevel);
}
static void userAgentChanged(WebKitSettings* settings, GParamSpec*, WebKitWebView* webView)
{
getPage(webView)->setCustomUserAgent(String::fromUTF8(webkit_settings_get_user_agent(settings)));
}
static void webkitWebViewUpdateFavicon(WebKitWebView* webView, cairo_surface_t* favicon)
{
WebKitWebViewPrivate* priv = webView->priv;
if (priv->favicon.get() == favicon)
return;
priv->favicon = favicon;
g_object_notify(G_OBJECT(webView), "favicon");
}
static void webkitWebViewCancelFaviconRequest(WebKitWebView* webView)
{
if (!webView->priv->faviconCancellable)
return;
g_cancellable_cancel(webView->priv->faviconCancellable.get());
webView->priv->faviconCancellable = 0;
}
static void gotFaviconCallback(GObject* object, GAsyncResult* result, gpointer userData)
{
GUniqueOutPtr<GError> error;
RefPtr<cairo_surface_t> favicon = adoptRef(webkit_favicon_database_get_favicon_finish(WEBKIT_FAVICON_DATABASE(object), result, &error.outPtr()));
if (g_error_matches(error.get(), G_IO_ERROR, G_IO_ERROR_CANCELLED))
return;
WebKitWebView* webView = WEBKIT_WEB_VIEW(userData);
webkitWebViewUpdateFavicon(webView, favicon.get());
webView->priv->faviconCancellable = 0;
}
static void webkitWebViewRequestFavicon(WebKitWebView* webView)
{
webkitWebViewCancelFaviconRequest(webView);
WebKitWebViewPrivate* priv = webView->priv;
priv->faviconCancellable = adoptGRef(g_cancellable_new());
WebKitFaviconDatabase* database = webkit_web_context_get_favicon_database(priv->context);
webkit_favicon_database_get_favicon(database, priv->activeURI.data(), priv->faviconCancellable.get(), gotFaviconCallback, webView);
}
static void webkitWebViewUpdateFaviconURI(WebKitWebView* webView, const char* faviconURI)
{
if (webView->priv->faviconURI == faviconURI)
return;
webView->priv->faviconURI = faviconURI;
webkitWebViewRequestFavicon(webView);
}
static void faviconChangedCallback(WebKitFaviconDatabase*, const char* pageURI, const char* faviconURI, WebKitWebView* webView)
{
if (webView->priv->activeURI != pageURI)
return;
webkitWebViewUpdateFaviconURI(webView, faviconURI);
}
static void webkitWebViewUpdateSettings(WebKitWebView* webView)
{
// We keep a ref of the current settings to disconnect the signals when settings change in the group.
webView->priv->settings = webkit_web_view_get_settings(webView);
WebKitSettings* settings = webView->priv->settings.get();
WebPageProxy* page = getPage(webView);
page->setCanRunModal(webkit_settings_get_allow_modal_dialogs(settings));
page->setCustomUserAgent(String::fromUTF8(webkit_settings_get_user_agent(settings)));
webkitWebViewBaseUpdatePreferences(WEBKIT_WEB_VIEW_BASE(webView));
g_signal_connect(settings, "notify::allow-modal-dialogs", G_CALLBACK(allowModalDialogsChanged), webView);
g_signal_connect(settings, "notify::zoom-text-only", G_CALLBACK(zoomTextOnlyChanged), webView);
g_signal_connect(settings, "notify::user-agent", G_CALLBACK(userAgentChanged), webView);
}
static void webkitWebViewDisconnectSettingsSignalHandlers(WebKitWebView* webView)
{
WebKitSettings* settings = webView->priv->settings.get();
g_signal_handlers_disconnect_by_func(settings, reinterpret_cast<gpointer>(allowModalDialogsChanged), webView);
g_signal_handlers_disconnect_by_func(settings, reinterpret_cast<gpointer>(zoomTextOnlyChanged), webView);
g_signal_handlers_disconnect_by_func(settings, reinterpret_cast<gpointer>(userAgentChanged), webView);
}
static void webkitWebViewSettingsChanged(WebKitWebViewGroup*, GParamSpec*, WebKitWebView* webView)
{
webkitWebViewDisconnectSettingsSignalHandlers(webView);
webkitWebViewUpdateSettings(webView);
}
static void webkitWebViewDisconnectSettingsChangedSignalHandler(WebKitWebView* webView)
{
WebKitWebViewPrivate* priv = webView->priv;
if (priv->settingsChangedHandlerID)
g_signal_handler_disconnect(webkit_web_view_get_group(webView), priv->settingsChangedHandlerID);
priv->settingsChangedHandlerID = 0;
}
static void webkitWebViewDisconnectMainResourceResponseChangedSignalHandler(WebKitWebView* webView)
{
WebKitWebViewPrivate* priv = webView->priv;
if (priv->mainResourceResponseHandlerID)
g_signal_handler_disconnect(priv->mainResource.get(), priv->mainResourceResponseHandlerID);
priv->mainResourceResponseHandlerID = 0;
}
static void webkitWebViewWatchForChangesInFavicon(WebKitWebView* webView)
{
WebKitWebViewPrivate* priv = webView->priv;
if (priv->faviconChangedHandlerID)
return;
WebKitFaviconDatabase* database = webkit_web_context_get_favicon_database(priv->context);
priv->faviconChangedHandlerID = g_signal_connect(database, "favicon-changed", G_CALLBACK(faviconChangedCallback), webView);
}
static void webkitWebViewDisconnectFaviconDatabaseSignalHandlers(WebKitWebView* webView)
{
WebKitWebViewPrivate* priv = webView->priv;
if (priv->faviconChangedHandlerID)
g_signal_handler_disconnect(webkit_web_context_get_favicon_database(priv->context), priv->faviconChangedHandlerID);
priv->faviconChangedHandlerID = 0;
}
static gboolean webkitWebViewAuthenticate(WebKitWebView* webView, WebKitAuthenticationRequest* request)
{
CredentialStorageMode credentialStorageMode = webkit_authentication_request_can_save_credentials(request) ? AllowPersistentStorage : DisallowPersistentStorage;
webkitWebViewBaseAddAuthenticationDialog(WEBKIT_WEB_VIEW_BASE(webView), webkitAuthenticationDialogNew(request, credentialStorageMode));
return TRUE;
}
static void fileChooserDialogResponseCallback(GtkDialog* dialog, gint responseID, WebKitFileChooserRequest* request)
{
GRefPtr<WebKitFileChooserRequest> adoptedRequest = adoptGRef(request);
if (responseID == GTK_RESPONSE_ACCEPT) {
GUniquePtr<GSList> filesList(gtk_file_chooser_get_filenames(GTK_FILE_CHOOSER(dialog)));
GRefPtr<GPtrArray> filesArray = adoptGRef(g_ptr_array_new());
for (GSList* file = filesList.get(); file; file = g_slist_next(file))
g_ptr_array_add(filesArray.get(), file->data);
g_ptr_array_add(filesArray.get(), 0);
webkit_file_chooser_request_select_files(adoptedRequest.get(), reinterpret_cast<const gchar* const*>(filesArray->pdata));
} else
webkit_file_chooser_request_cancel(adoptedRequest.get());
gtk_widget_destroy(GTK_WIDGET(dialog));
}
static gboolean webkitWebViewRunFileChooser(WebKitWebView* webView, WebKitFileChooserRequest* request)
{
GtkWidget* toplevel = gtk_widget_get_toplevel(GTK_WIDGET(webView));
if (!widgetIsOnscreenToplevelWindow(toplevel))
toplevel = 0;
gboolean allowsMultipleSelection = webkit_file_chooser_request_get_select_multiple(request);
GtkWidget* dialog = gtk_file_chooser_dialog_new(allowsMultipleSelection ? _("Select Files") : _("Select File"),
toplevel ? GTK_WINDOW(toplevel) : 0,
GTK_FILE_CHOOSER_ACTION_OPEN,
GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL,
GTK_STOCK_OPEN, GTK_RESPONSE_ACCEPT,
NULL);
if (GtkFileFilter* filter = webkit_file_chooser_request_get_mime_types_filter(request))
gtk_file_chooser_set_filter(GTK_FILE_CHOOSER(dialog), filter);
gtk_file_chooser_set_select_multiple(GTK_FILE_CHOOSER(dialog), allowsMultipleSelection);
if (const gchar* const* selectedFiles = webkit_file_chooser_request_get_selected_files(request))
gtk_file_chooser_select_filename(GTK_FILE_CHOOSER(dialog), selectedFiles[0]);
g_signal_connect(dialog, "response", G_CALLBACK(fileChooserDialogResponseCallback), g_object_ref(request));
gtk_widget_show(dialog);
return TRUE;
}
static void webkitWebViewHandleDownloadRequest(WebKitWebViewBase* webViewBase, DownloadProxy* downloadProxy)
{
GRefPtr<WebKitDownload> download = webkitWebContextGetOrCreateDownload(downloadProxy);
webkitDownloadSetWebView(download.get(), WEBKIT_WEB_VIEW(webViewBase));
}
static void webkitWebViewConstructed(GObject* object)
{
if (G_OBJECT_CLASS(webkit_web_view_parent_class)->constructed)
G_OBJECT_CLASS(webkit_web_view_parent_class)->constructed(object);
WebKitWebView* webView = WEBKIT_WEB_VIEW(object);
WebKitWebViewPrivate* priv = webView->priv;
webkitWebContextCreatePageForWebView(priv->context, webView, priv->group.get(), priv->userContentManager.get(), priv->relatedView);
// The related view is only valid during the construction.
priv->relatedView = nullptr;
webkitWebViewBaseSetDownloadRequestHandler(WEBKIT_WEB_VIEW_BASE(webView), webkitWebViewHandleDownloadRequest);
attachLoaderClientToView(webView);
attachUIClientToView(webView);
attachPolicyClientToView(webView);
attachFullScreenClientToView(webView);
attachContextMenuClientToView(webView);
attachFormClientToView(webView);
priv->backForwardList = adoptGRef(webkitBackForwardListCreate(&getPage(webView)->backForwardList()));
priv->windowProperties = adoptGRef(webkitWindowPropertiesCreate());
webkitWebViewUpdateSettings(webView);
priv->settingsChangedHandlerID =
g_signal_connect(webkit_web_view_get_group(webView), "notify::settings", G_CALLBACK(webkitWebViewSettingsChanged), webView);
}
static void webkitWebViewSetProperty(GObject* object, guint propId, const GValue* value, GParamSpec* paramSpec)
{
WebKitWebView* webView = WEBKIT_WEB_VIEW(object);
switch (propId) {
case PROP_WEB_CONTEXT: {
gpointer webContext = g_value_get_object(value);
webView->priv->context = webContext ? WEBKIT_WEB_CONTEXT(webContext) : webkit_web_context_get_default();
break;
}
case PROP_RELATED_VIEW: {
gpointer relatedView = g_value_get_object(value);
webView->priv->relatedView = relatedView ? WEBKIT_WEB_VIEW(relatedView) : nullptr;
break;
}
case PROP_GROUP: {
gpointer group = g_value_get_object(value);
webView->priv->group = group ? WEBKIT_WEB_VIEW_GROUP(group) : 0;
break;
}
case PROP_USER_CONTENT_MANAGER: {
gpointer userContentManager = g_value_get_object(value);
webView->priv->userContentManager = userContentManager ? WEBKIT_USER_CONTENT_MANAGER(userContentManager) : nullptr;
break;
}
case PROP_ZOOM_LEVEL:
webkit_web_view_set_zoom_level(webView, g_value_get_double(value));
break;
default:
G_OBJECT_WARN_INVALID_PROPERTY_ID(object, propId, paramSpec);
}
}
static void webkitWebViewGetProperty(GObject* object, guint propId, GValue* value, GParamSpec* paramSpec)
{
WebKitWebView* webView = WEBKIT_WEB_VIEW(object);
switch (propId) {
case PROP_WEB_CONTEXT:
g_value_set_object(value, webView->priv->context);
break;
case PROP_GROUP:
g_value_set_object(value, webkit_web_view_get_group(webView));
break;
case PROP_USER_CONTENT_MANAGER:
g_value_set_object(value, webkit_web_view_get_user_content_manager(webView));
break;
case PROP_TITLE:
g_value_set_string(value, webView->priv->title.data());
break;
case PROP_ESTIMATED_LOAD_PROGRESS:
g_value_set_double(value, webkit_web_view_get_estimated_load_progress(webView));
break;
case PROP_FAVICON:
g_value_set_pointer(value, webkit_web_view_get_favicon(webView));
break;
case PROP_URI:
g_value_set_string(value, webkit_web_view_get_uri(webView));
break;
case PROP_ZOOM_LEVEL:
g_value_set_double(value, webkit_web_view_get_zoom_level(webView));
break;
case PROP_IS_LOADING:
g_value_set_boolean(value, webkit_web_view_is_loading(webView));
break;
default:
G_OBJECT_WARN_INVALID_PROPERTY_ID(object, propId, paramSpec);
}
}
static void webkitWebViewDispose(GObject* object)
{
WebKitWebView* webView = WEBKIT_WEB_VIEW(object);
webkitWebViewCancelFaviconRequest(webView);
webkitWebViewDisconnectMainResourceResponseChangedSignalHandler(webView);
webkitWebViewDisconnectSettingsChangedSignalHandler(webView);
webkitWebViewDisconnectSettingsSignalHandlers(webView);
webkitWebViewDisconnectFaviconDatabaseSignalHandlers(webView);
webkitWebContextWebViewDestroyed(webView->priv->context, webView);
G_OBJECT_CLASS(webkit_web_view_parent_class)->dispose(object);
}
static gboolean webkitWebViewAccumulatorObjectHandled(GSignalInvocationHint*, GValue* returnValue, const GValue* handlerReturn, gpointer)
{
void* object = g_value_get_object(handlerReturn);
if (object)
g_value_set_object(returnValue, object);
return !object;
}
static void webkit_web_view_class_init(WebKitWebViewClass* webViewClass)
{
GObjectClass* gObjectClass = G_OBJECT_CLASS(webViewClass);
gObjectClass->constructed = webkitWebViewConstructed;
gObjectClass->set_property = webkitWebViewSetProperty;
gObjectClass->get_property = webkitWebViewGetProperty;
gObjectClass->dispose = webkitWebViewDispose;
webViewClass->load_failed = webkitWebViewLoadFail;
webViewClass->create = webkitWebViewCreate;
webViewClass->script_dialog = webkitWebViewScriptDialog;
webViewClass->decide_policy = webkitWebViewDecidePolicy;
webViewClass->permission_request = webkitWebViewPermissionRequest;
webViewClass->run_file_chooser = webkitWebViewRunFileChooser;
webViewClass->authenticate = webkitWebViewAuthenticate;
/**
* WebKitWebView:web-context:
*
* The #WebKitWebContext of the view.
*/
g_object_class_install_property(gObjectClass,
PROP_WEB_CONTEXT,
g_param_spec_object("web-context",
_("Web Context"),
_("The web context for the view"),
WEBKIT_TYPE_WEB_CONTEXT,
static_cast<GParamFlags>(WEBKIT_PARAM_READWRITE | G_PARAM_CONSTRUCT_ONLY)));
/**
* WebKitWebView:related-view:
*
* The related #WebKitWebView used when creating the view to share the
* same web process. This property is not readable because the related
* web view is only valid during the object construction.
*
* Since: 2.4
*/
g_object_class_install_property(
gObjectClass,
PROP_RELATED_VIEW,
g_param_spec_object(
"related-view",
_("Related WebView"),
_("The related WebKitWebView used when creating the view to share the same web process"),
WEBKIT_TYPE_WEB_VIEW,
static_cast<GParamFlags>(WEBKIT_PARAM_WRITABLE | G_PARAM_CONSTRUCT_ONLY)));
/**
* WebKitWebView:group:
*
* The #WebKitWebViewGroup of the view.
*/
g_object_class_install_property(
gObjectClass,
PROP_GROUP,
g_param_spec_object(
"group",
_("WebView Group"),
_("The WebKitWebViewGroup of the view"),
WEBKIT_TYPE_WEB_VIEW_GROUP,
static_cast<GParamFlags>(WEBKIT_PARAM_READWRITE | G_PARAM_CONSTRUCT_ONLY)));
/**
* WebKitWebView:user-content-manager:
*
* The #WebKitUserContentManager of the view.
*
* Since: 2.6
*/
g_object_class_install_property(
gObjectClass,
PROP_USER_CONTENT_MANAGER,
g_param_spec_object(
"user-content-manager",
_("WebView user content manager"),
_("The WebKitUserContentManager of the view"),
WEBKIT_TYPE_USER_CONTENT_MANAGER,
static_cast<GParamFlags>(WEBKIT_PARAM_READWRITE | G_PARAM_CONSTRUCT_ONLY)));
/**
* WebKitWebView:title:
*
* The main frame document title of this #WebKitWebView. If
* the title has not been received yet, it will be %NULL.
*/
g_object_class_install_property(gObjectClass,
PROP_TITLE,
g_param_spec_string("title",
_("Title"),
_("Main frame document title"),
0,
WEBKIT_PARAM_READABLE));
/**
* WebKitWebView:estimated-load-progress:
*
* An estimate of the percent completion for the current loading operation.
* This value will range from 0.0 to 1.0 and, once a load completes,
* will remain at 1.0 until a new load starts, at which point it
* will be reset to 0.0.
* The value is an estimate based on the total number of bytes expected
* to be received for a document, including all its possible subresources
* and child documents.
*/
g_object_class_install_property(gObjectClass,
PROP_ESTIMATED_LOAD_PROGRESS,
g_param_spec_double("estimated-load-progress",
_("Estimated Load Progress"),
_("An estimate of the percent completion for a document load"),
0.0, 1.0, 0.0,
WEBKIT_PARAM_READABLE));
/**
* WebKitWebView:favicon:
*
* The favicon currently associated to the #WebKitWebView.
* See webkit_web_view_get_favicon() for more details.
*/
g_object_class_install_property(gObjectClass,
PROP_FAVICON,
g_param_spec_pointer("favicon",
_("Favicon"),
_("The favicon associated to the view, if any"),
WEBKIT_PARAM_READABLE));
/**
* WebKitWebView:uri:
*
* The current active URI of the #WebKitWebView.
* See webkit_web_view_get_uri() for more details.
*/
g_object_class_install_property(gObjectClass,
PROP_URI,
g_param_spec_string("uri",
_("URI"),
_("The current active URI of the view"),
0,
WEBKIT_PARAM_READABLE));
/**
* WebKitWebView:zoom-level:
*
* The zoom level of the #WebKitWebView content.
* See webkit_web_view_set_zoom_level() for more details.
*/
g_object_class_install_property(gObjectClass,
PROP_ZOOM_LEVEL,
g_param_spec_double("zoom-level",
"Zoom level",
_("The zoom level of the view content"),
0, G_MAXDOUBLE, 1,
WEBKIT_PARAM_READWRITE));
/**
* WebKitWebView:is-loading:
*
* Whether the #WebKitWebView is currently loading a page. This property becomes
* %TRUE as soon as a new load operation is requested and before the
* #WebKitWebView::load-changed signal is emitted with %WEBKIT_LOAD_STARTED and
* at that point the active URI is the requested one.
* When the load operation finishes the property is set to %FALSE before
* #WebKitWebView::load-changed is emitted with %WEBKIT_LOAD_FINISHED.
*/
g_object_class_install_property(gObjectClass,
PROP_IS_LOADING,
g_param_spec_boolean("is-loading",
"Is Loading",
_("Whether the view is loading a page"),
FALSE,
WEBKIT_PARAM_READABLE));
/**
* WebKitWebView::load-changed:
* @web_view: the #WebKitWebView on which the signal is emitted
* @load_event: the #WebKitLoadEvent
*
* Emitted when the a load operation in @web_view changes.
* The signal is always emitted with %WEBKIT_LOAD_STARTED when a
* new load request is made and %WEBKIT_LOAD_FINISHED when the load
* finishes successfully or due to an error. When the ongoing load
* operation fails #WebKitWebView::load-failed signal is emitted
* before #WebKitWebView::load-changed is emitted with
* %WEBKIT_LOAD_FINISHED.
* If a redirection is received from the server, this signal is emitted
* with %WEBKIT_LOAD_REDIRECTED after the initial emission with
* %WEBKIT_LOAD_STARTED and before %WEBKIT_LOAD_COMMITTED.
* When the page content starts arriving the signal is emitted with
* %WEBKIT_LOAD_COMMITTED event.
*
* You can handle this signal and use a switch to track any ongoing
* load operation.
*
* <informalexample><programlisting>
* static void web_view_load_changed (WebKitWebView *web_view,
* WebKitLoadEvent load_event,
* gpointer user_data)
* {
* switch (load_event) {
* case WEBKIT_LOAD_STARTED:
* /<!-- -->* New load, we have now a provisional URI *<!-- -->/
* provisional_uri = webkit_web_view_get_uri (web_view);
* /<!-- -->* Here we could start a spinner or update the
* <!-- -->* location bar with the provisional URI *<!-- -->/
* break;
* case WEBKIT_LOAD_REDIRECTED:
* redirected_uri = webkit_web_view_get_uri (web_view);
* break;
* case WEBKIT_LOAD_COMMITTED:
* /<!-- -->* The load is being performed. Current URI is
* <!-- -->* the final one and it won't change unless a new
* <!-- -->* load is requested or a navigation within the
* <!-- -->* same page is performed *<!-- -->/
* uri = webkit_web_view_get_uri (web_view);
* break;
* case WEBKIT_LOAD_FINISHED:
* /<!-- -->* Load finished, we can now stop the spinner *<!-- -->/
* break;
* }
* }
* </programlisting></informalexample>
*/
signals[LOAD_CHANGED] =
g_signal_new("load-changed",
G_TYPE_FROM_CLASS(webViewClass),
G_SIGNAL_RUN_LAST,
G_STRUCT_OFFSET(WebKitWebViewClass, load_changed),
0, 0,
g_cclosure_marshal_VOID__ENUM,
G_TYPE_NONE, 1,
WEBKIT_TYPE_LOAD_EVENT);
/**
* WebKitWebView::load-failed:
* @web_view: the #WebKitWebView on which the signal is emitted
* @load_event: the #WebKitLoadEvent of the load operation
* @failing_uri: the URI that failed to load
* @error: the #GError that was triggered
*
* Emitted when an error occurs during a load operation.
* If the error happened when starting to load data for a page
* @load_event will be %WEBKIT_LOAD_STARTED. If it happened while
* loading a committed data source @load_event will be %WEBKIT_LOAD_COMMITTED.
* Since a load error causes the load operation to finish, the signal
* WebKitWebView::load-changed will always be emitted with
* %WEBKIT_LOAD_FINISHED event right after this one.
*
* By default, if the signal is not handled, a stock error page will be displayed.
* You need to handle the signal if you want to provide your own error page.
*
* Returns: %TRUE to stop other handlers from being invoked for the event.
* %FALSE to propagate the event further.
*/
signals[LOAD_FAILED] =
g_signal_new("load-failed",
G_TYPE_FROM_CLASS(webViewClass),
G_SIGNAL_RUN_LAST,
G_STRUCT_OFFSET(WebKitWebViewClass, load_failed),
g_signal_accumulator_true_handled, 0,
webkit_marshal_BOOLEAN__ENUM_STRING_POINTER,
G_TYPE_BOOLEAN, 3,
WEBKIT_TYPE_LOAD_EVENT,
G_TYPE_STRING,
G_TYPE_POINTER);
/**
* WebKitWebView::load-failed-with-tls-errors:
* @web_view: the #WebKitWebView on which the signal is emitted
* @info: a #WebKitCertificateInfo
* @host: the host on which the error occurred
*
* Emitted when a TLS error occurs during a load operation. The @info
* object contains information about the error such as the #GTlsCertificate
* and the #GTlsCertificateFlags. To allow an exception for this certificate
* and this host use webkit_web_context_allow_tls_certificate_for_host().
*
* To handle this signal asynchronously you should copy the #WebKitCertificateInfo
* with webkit_certificate_info_copy() and return %TRUE.
*
* If %FALSE is returned, #WebKitWebView::load-failed will be emitted. The load
* will finish regardless of the returned value.
*
* Returns: %TRUE to stop other handlers from being invoked for the event.
* %FALSE to propagate the event further.
*
* Since: 2.4
*/
signals[LOAD_FAILED_WITH_TLS_ERRORS] =
g_signal_new("load-failed-with-tls-errors",
G_TYPE_FROM_CLASS(webViewClass),
G_SIGNAL_RUN_LAST,
G_STRUCT_OFFSET(WebKitWebViewClass, load_failed_with_tls_errors),
g_signal_accumulator_true_handled, 0 /* accumulator data */,
webkit_marshal_BOOLEAN__BOXED_STRING,
G_TYPE_BOOLEAN, 2, /* number of parameters */
WEBKIT_TYPE_CERTIFICATE_INFO | G_SIGNAL_TYPE_STATIC_SCOPE,
G_TYPE_STRING);
/**
* WebKitWebView::create:
* @web_view: the #WebKitWebView on which the signal is emitted
* @navigation_action: a #WebKitNavigationAction
*
* Emitted when the creation of a new #WebKitWebView is requested.
* If this signal is handled the signal handler should return the
* newly created #WebKitWebView.
*
* The #WebKitNavigationAction parameter contains information about the
* navigation action that triggered this signal.
*
* When using %WEBKIT_PROCESS_MODEL_MULTIPLE_SECONDARY_PROCESSES
* process model, the new #WebKitWebView should be related to
* @web_view to share the same web process, see webkit_web_view_new_with_related_view()
* for more details.
*
* The new #WebKitWebView should not be displayed to the user
* until the #WebKitWebView::ready-to-show signal is emitted.
*
* Returns: (transfer full): a newly allocated #WebKitWebView widget
* or %NULL to propagate the event further.
*/
signals[CREATE] = g_signal_new(
"create",
G_TYPE_FROM_CLASS(webViewClass),
G_SIGNAL_RUN_LAST,
G_STRUCT_OFFSET(WebKitWebViewClass, create),
webkitWebViewAccumulatorObjectHandled, 0,
g_cclosure_marshal_generic,
GTK_TYPE_WIDGET, 1,
WEBKIT_TYPE_NAVIGATION_ACTION | G_SIGNAL_TYPE_STATIC_SCOPE);
/**
* WebKitWebView::ready-to-show:
* @web_view: the #WebKitWebView on which the signal is emitted
*
* Emitted after #WebKitWebView::create on the newly created #WebKitWebView
* when it should be displayed to the user. When this signal is emitted
* all the information about how the window should look, including
* size, position, whether the location, status and scrollbars
* should be displayed, is already set on the #WebKitWindowProperties
* of @web_view. See also webkit_web_view_get_window_properties().
*/
signals[READY_TO_SHOW] =
g_signal_new("ready-to-show",
G_TYPE_FROM_CLASS(webViewClass),
G_SIGNAL_RUN_LAST,
G_STRUCT_OFFSET(WebKitWebViewClass, ready_to_show),
0, 0,
g_cclosure_marshal_VOID__VOID,
G_TYPE_NONE, 0);
/**
* WebKitWebView::run-as-modal:
* @web_view: the #WebKitWebView on which the signal is emitted
*
* Emitted after #WebKitWebView::ready-to-show on the newly
* created #WebKitWebView when JavaScript code calls
* <function>window.showModalDialog</function>. The purpose of
* this signal is to allow the client application to prepare the
* new view to behave as modal. Once the signal is emitted a new
* mainloop will be run to block user interaction in the parent
* #WebKitWebView until the new dialog is closed.
*/
signals[RUN_AS_MODAL] =
g_signal_new("run-as-modal",
G_TYPE_FROM_CLASS(webViewClass),
G_SIGNAL_RUN_LAST,
G_STRUCT_OFFSET(WebKitWebViewClass, run_as_modal),
0, 0,
g_cclosure_marshal_VOID__VOID,
G_TYPE_NONE, 0);
/**
* WebKitWebView::close:
* @webView: the #WebKitWebView on which the signal is emitted
*
* Emitted when closing a #WebKitWebView is requested. This occurs when a
* call is made from JavaScript's <function>window.close</function> function.
* It is the owner's responsibility to handle this signal to hide or
* destroy the #WebKitWebView, if necessary.
*/
signals[CLOSE] =
g_signal_new("close",
G_TYPE_FROM_CLASS(webViewClass),
G_SIGNAL_RUN_LAST,
G_STRUCT_OFFSET(WebKitWebViewClass, close),
0, 0,
g_cclosure_marshal_VOID__VOID,
G_TYPE_NONE, 0);
/**
* WebKitWebView::script-dialog:
* @web_view: the #WebKitWebView on which the signal is emitted
* @dialog: the #WebKitScriptDialog to show
*
* Emitted when JavaScript code calls <function>window.alert</function>,
* <function>window.confirm</function> or <function>window.prompt</function>.
* The @dialog parameter should be used to build the dialog.
* If the signal is not handled a different dialog will be built and shown depending
* on the dialog type:
* <itemizedlist>
* <listitem><para>
* %WEBKIT_SCRIPT_DIALOG_ALERT: message dialog with a single Close button.
* </para></listitem>
* <listitem><para>
* %WEBKIT_SCRIPT_DIALOG_CONFIRM: message dialog with OK and Cancel buttons.
* </para></listitem>
* <listitem><para>
* %WEBKIT_SCRIPT_DIALOG_PROMPT: message dialog with OK and Cancel buttons and
* a text entry with the default text.
* </para></listitem>
* </itemizedlist>
*
* Returns: %TRUE to stop other handlers from being invoked for the event.
* %FALSE to propagate the event further.
*/
signals[SCRIPT_DIALOG] =
g_signal_new("script-dialog",
G_TYPE_FROM_CLASS(webViewClass),
G_SIGNAL_RUN_LAST,
G_STRUCT_OFFSET(WebKitWebViewClass, script_dialog),
g_signal_accumulator_true_handled, 0,
webkit_marshal_BOOLEAN__BOXED,
G_TYPE_BOOLEAN, 1,
WEBKIT_TYPE_SCRIPT_DIALOG | G_SIGNAL_TYPE_STATIC_SCOPE);
/**
* WebKitWebView::decide-policy:
* @web_view: the #WebKitWebView on which the signal is emitted
* @decision: the #WebKitPolicyDecision
* @decision_type: a #WebKitPolicyDecisionType denoting the type of @decision
*
* This signal is emitted when WebKit is requesting the client to decide a policy
* decision, such as whether to navigate to a page, open a new window or whether or
* not to download a resource. The #WebKitNavigationPolicyDecision passed in the
* @decision argument is a generic type, but should be casted to a more
* specific type when making the decision. For example:
*
* <informalexample><programlisting>
* static gboolean
* decide_policy_cb (WebKitWebView *web_view,
* WebKitPolicyDecision *decision,
* WebKitPolicyDecisionType type)
* {
* switch (type) {
* case WEBKIT_POLICY_DECISION_TYPE_NAVIGATION_ACTION:
* WebKitNavigationPolicyDecision *navigation_decision = WEBKIT_NAVIGATION_POLICY_DECISION (decision);
* /<!-- -->* Make a policy decision here. *<!-- -->/
* break;
* case WEBKIT_POLICY_DECISION_TYPE_NEW_WINDOW_ACTION:
* WebKitNavigationPolicyDecision *navigation_decision = WEBKIT_NAVIGATION_POLICY_DECISION (decision);
* /<!-- -->* Make a policy decision here. *<!-- -->/
* break;
* case WEBKIT_POLICY_DECISION_TYPE_RESPONSE:
* WebKitResponsePolicyDecision *response = WEBKIT_RESPONSE_POLICY_DECISION (decision);
* /<!-- -->* Make a policy decision here. *<!-- -->/
* break;
* default:
* /<!-- -->* Making no decision results in webkit_policy_decision_use(). *<!-- -->/
* return FALSE;
* }
* return TRUE;
* }
* </programlisting></informalexample>
*
* It is possible to make policy decision asynchronously, by simply calling g_object_ref()
* on the @decision argument and returning %TRUE to block the default signal handler.
* If the last reference is removed on a #WebKitPolicyDecision and no decision has been
* made explicitly, webkit_policy_decision_use() will be the default policy decision. The
* default signal handler will simply call webkit_policy_decision_use(). Only the first
* policy decision chosen for a given #WebKitPolicyDecision will have any affect.
*
* Returns: %TRUE to stop other handlers from being invoked for the event.
* %FALSE to propagate the event further.
*
*/
signals[DECIDE_POLICY] =
g_signal_new("decide-policy",
G_TYPE_FROM_CLASS(webViewClass),
G_SIGNAL_RUN_LAST,
G_STRUCT_OFFSET(WebKitWebViewClass, decide_policy),
g_signal_accumulator_true_handled, 0 /* accumulator data */,
webkit_marshal_BOOLEAN__OBJECT_ENUM,
G_TYPE_BOOLEAN, 2, /* number of parameters */
WEBKIT_TYPE_POLICY_DECISION,
WEBKIT_TYPE_POLICY_DECISION_TYPE);
/**
* WebKitWebView::permission-request:
* @web_view: the #WebKitWebView on which the signal is emitted
* @request: the #WebKitPermissionRequest
*
* This signal is emitted when WebKit is requesting the client to
* decide about a permission request, such as allowing the browser
* to switch to fullscreen mode, sharing its location or similar
* operations.
*
* A possible way to use this signal could be through a dialog
* allowing the user decide what to do with the request:
*
* <informalexample><programlisting>
* static gboolean permission_request_cb (WebKitWebView *web_view,
* WebKitPermissionRequest *request,
* GtkWindow *parent_window)
* {
* GtkWidget *dialog = gtk_message_dialog_new (parent_window,
* GTK_DIALOG_MODAL,
* GTK_MESSAGE_QUESTION,
* GTK_BUTTONS_YES_NO,
* "Allow Permission Request?");
* gtk_widget_show (dialog);
* gint result = gtk_dialog_run (GTK_DIALOG (dialog));
*
* switch (result) {
* case GTK_RESPONSE_YES:
* webkit_permission_request_allow (request);
* break;
* default:
* webkit_permission_request_deny (request);
* break;
* }
* gtk_widget_destroy (dialog);
*
* return TRUE;
* }
* </programlisting></informalexample>
*
* It is possible to handle permission requests asynchronously, by
* simply calling g_object_ref() on the @request argument and
* returning %TRUE to block the default signal handler. If the
* last reference is removed on a #WebKitPermissionRequest and the
* request has not been handled, webkit_permission_request_deny()
* will be the default action.
*
* By default, if the signal is not handled,
* webkit_permission_request_deny() will be called over the
* #WebKitPermissionRequest.
*
* Returns: %TRUE to stop other handlers from being invoked for the event.
* %FALSE to propagate the event further.
*
*/
signals[PERMISSION_REQUEST] =
g_signal_new("permission-request",
G_TYPE_FROM_CLASS(webViewClass),
G_SIGNAL_RUN_LAST,
G_STRUCT_OFFSET(WebKitWebViewClass, permission_request),
g_signal_accumulator_true_handled, 0 /* accumulator data */,
webkit_marshal_BOOLEAN__OBJECT,
G_TYPE_BOOLEAN, 1, /* number of parameters */
WEBKIT_TYPE_PERMISSION_REQUEST);
/**
* WebKitWebView::mouse-target-changed:
* @web_view: the #WebKitWebView on which the signal is emitted
* @hit_test_result: a #WebKitHitTestResult
* @modifiers: a bitmask of #GdkModifierType
*
* This signal is emitted when the mouse cursor moves over an
* element such as a link, image or a media element. To determine
* what type of element the mouse cursor is over, a Hit Test is performed
* on the current mouse coordinates and the result is passed in the
* @hit_test_result argument. The @modifiers argument is a bitmask of
* #GdkModifierType flags indicating the state of modifier keys.
* The signal is emitted again when the mouse is moved out of the
* current element with a new @hit_test_result.
*/
signals[MOUSE_TARGET_CHANGED] =
g_signal_new("mouse-target-changed",
G_TYPE_FROM_CLASS(webViewClass),
G_SIGNAL_RUN_LAST,
G_STRUCT_OFFSET(WebKitWebViewClass, mouse_target_changed),
0, 0,
webkit_marshal_VOID__OBJECT_UINT,
G_TYPE_NONE, 2,
WEBKIT_TYPE_HIT_TEST_RESULT,
G_TYPE_UINT);
/**
* WebKitWebView::print:
* @web_view: the #WebKitWebView on which the signal is emitted
* @print_operation: the #WebKitPrintOperation that will handle the print request
*
* Emitted when printing is requested on @web_view, usually by a javascript call,
* before the print dialog is shown. This signal can be used to set the initial
* print settings and page setup of @print_operation to be used as default values in
* the print dialog. You can call webkit_print_operation_set_print_settings() and
* webkit_print_operation_set_page_setup() and then return %FALSE to propagate the
* event so that the print dialog is shown.
*
* You can connect to this signal and return %TRUE to cancel the print operation
* or implement your own print dialog.
*
* Returns: %TRUE to stop other handlers from being invoked for the event.
* %FALSE to propagate the event further.
*/
signals[PRINT] =
g_signal_new("print",
G_TYPE_FROM_CLASS(webViewClass),
G_SIGNAL_RUN_LAST,
G_STRUCT_OFFSET(WebKitWebViewClass, print),
g_signal_accumulator_true_handled, 0,
webkit_marshal_BOOLEAN__OBJECT,
G_TYPE_BOOLEAN, 1,
WEBKIT_TYPE_PRINT_OPERATION);
/**
* WebKitWebView::resource-load-started:
* @web_view: the #WebKitWebView on which the signal is emitted
* @resource: a #WebKitWebResource
* @request: a #WebKitURIRequest
*
* Emitted when a new resource is going to be loaded. The @request parameter
* contains the #WebKitURIRequest that will be sent to the server.
* You can monitor the load operation by connecting to the different signals
* of @resource.
*/
signals[RESOURCE_LOAD_STARTED] =
g_signal_new("resource-load-started",
G_TYPE_FROM_CLASS(webViewClass),
G_SIGNAL_RUN_LAST,
G_STRUCT_OFFSET(WebKitWebViewClass, resource_load_started),
0, 0,
webkit_marshal_VOID__OBJECT_OBJECT,
G_TYPE_NONE, 2,
WEBKIT_TYPE_WEB_RESOURCE,
WEBKIT_TYPE_URI_REQUEST);
/**
* WebKitWebView::enter-fullscreen:
* @web_view: the #WebKitWebView on which the signal is emitted.
*
* Emitted when JavaScript code calls
* <function>element.webkitRequestFullScreen</function>. If the
* signal is not handled the #WebKitWebView will proceed to full screen
* its top level window. This signal can be used by client code to
* request permission to the user prior doing the full screen
* transition and eventually prepare the top-level window
* (e.g. hide some widgets that would otherwise be part of the
* full screen window).
*
* Returns: %TRUE to stop other handlers from being invoked for the event.
* %FALSE to continue emission of the event.
*/
signals[ENTER_FULLSCREEN] =
g_signal_new("enter-fullscreen",
G_TYPE_FROM_CLASS(webViewClass),
G_SIGNAL_RUN_LAST,
G_STRUCT_OFFSET(WebKitWebViewClass, enter_fullscreen),
g_signal_accumulator_true_handled, 0,
webkit_marshal_BOOLEAN__VOID,
G_TYPE_BOOLEAN, 0);
/**
* WebKitWebView::leave-fullscreen:
* @web_view: the #WebKitWebView on which the signal is emitted.
*
* Emitted when the #WebKitWebView is about to restore its top level
* window out of its full screen state. This signal can be used by
* client code to restore widgets hidden during the
* #WebKitWebView::enter-fullscreen stage for instance.
*
* Returns: %TRUE to stop other handlers from being invoked for the event.
* %FALSE to continue emission of the event.
*/
signals[LEAVE_FULLSCREEN] =
g_signal_new("leave-fullscreen",
G_TYPE_FROM_CLASS(webViewClass),
G_SIGNAL_RUN_LAST,
G_STRUCT_OFFSET(WebKitWebViewClass, leave_fullscreen),
g_signal_accumulator_true_handled, 0,
webkit_marshal_BOOLEAN__VOID,
G_TYPE_BOOLEAN, 0);
/**
* WebKitWebView::run-file-chooser:
* @web_view: the #WebKitWebView on which the signal is emitted
* @request: a #WebKitFileChooserRequest
*
* This signal is emitted when the user interacts with a &lt;input
* type='file' /&gt; HTML element, requesting from WebKit to show
* a dialog to select one or more files to be uploaded. To let the
* application know the details of the file chooser, as well as to
* allow the client application to either cancel the request or
* perform an actual selection of files, the signal will pass an
* instance of the #WebKitFileChooserRequest in the @request
* argument.
*
* The default signal handler will asynchronously run a regular
* #GtkFileChooserDialog for the user to interact with.
*
* Returns: %TRUE to stop other handlers from being invoked for the event.
* %FALSE to propagate the event further.
*
*/
signals[RUN_FILE_CHOOSER] =
g_signal_new("run-file-chooser",
G_TYPE_FROM_CLASS(webViewClass),
G_SIGNAL_RUN_LAST,
G_STRUCT_OFFSET(WebKitWebViewClass, run_file_chooser),
g_signal_accumulator_true_handled, 0 /* accumulator data */,
webkit_marshal_BOOLEAN__OBJECT,
G_TYPE_BOOLEAN, 1, /* number of parameters */
WEBKIT_TYPE_FILE_CHOOSER_REQUEST);
/**
* WebKitWebView::context-menu:
* @web_view: the #WebKitWebView on which the signal is emitted
* @context_menu: the proposed #WebKitContextMenu
* @event: the #GdkEvent that triggered the context menu
* @hit_test_result: a #WebKitHitTestResult
*
* Emmited when a context menu is about to be displayed to give the application
* a chance to customize the proposed menu, prevent the menu from being displayed
* or build its own context menu.
* <itemizedlist>
* <listitem><para>
* To customize the proposed menu you can use webkit_context_menu_prepend(),
* webkit_context_menu_append() or webkit_context_menu_insert() to add new
* #WebKitContextMenuItem<!-- -->s to @context_menu, webkit_context_menu_move_item()
* to reorder existing items, or webkit_context_menu_remove() to remove an
* existing item. The signal handler should return %FALSE, and the menu represented
* by @context_menu will be shown.
* </para></listitem>
* <listitem><para>
* To prevent the menu from being displayed you can just connect to this signal
* and return %TRUE so that the proposed menu will not be shown.
* </para></listitem>
* <listitem><para>
* To build your own menu, you can remove all items from the proposed menu with
* webkit_context_menu_remove_all(), add your own items and return %FALSE so
* that the menu will be shown. You can also ignore the proposed #WebKitContextMenu,
* build your own #GtkMenu and return %TRUE to prevent the proposed menu from being shown.
* </para></listitem>
* <listitem><para>
* If you just want the default menu to be shown always, simply don't connect to this
* signal because showing the proposed context menu is the default behaviour.
* </para></listitem>
* </itemizedlist>
*
* If the signal handler returns %FALSE the context menu represented by @context_menu
* will be shown, if it return %TRUE the context menu will not be shown.
*
* The proposed #WebKitContextMenu passed in @context_menu argument is only valid
* during the signal emission.
*
* Returns: %TRUE to stop other handlers from being invoked for the event.
* %FALSE to propagate the event further.
*/
signals[CONTEXT_MENU] =
g_signal_new("context-menu",
G_TYPE_FROM_CLASS(webViewClass),
G_SIGNAL_RUN_LAST,
G_STRUCT_OFFSET(WebKitWebViewClass, context_menu),
g_signal_accumulator_true_handled, 0,
webkit_marshal_BOOLEAN__OBJECT_BOXED_OBJECT,
G_TYPE_BOOLEAN, 3,
WEBKIT_TYPE_CONTEXT_MENU,
GDK_TYPE_EVENT | G_SIGNAL_TYPE_STATIC_SCOPE,
WEBKIT_TYPE_HIT_TEST_RESULT);
/**
* WebKitWebView::context-menu-dismissed:
* @web_view: the #WebKitWebView on which the signal is emitted
*
* Emitted after #WebKitWebView::context-menu signal, if the context menu is shown,
* to notify that the context menu is dismissed.
*/
signals[CONTEXT_MENU_DISMISSED] =
g_signal_new("context-menu-dismissed",
G_TYPE_FROM_CLASS(webViewClass),
G_SIGNAL_RUN_LAST,
G_STRUCT_OFFSET(WebKitWebViewClass, context_menu_dismissed),
0, 0,
g_cclosure_marshal_VOID__VOID,
G_TYPE_NONE, 0);
/**
* WebKitWebView::submit-form:
* @web_view: the #WebKitWebView on which the signal is emitted
* @request: a #WebKitFormSubmissionRequest
*
* This signal is emitted when a form is about to be submitted. The @request
* argument passed contains information about the text fields of the form. This
* is typically used to store login information that can be used later to
* pre-fill the form.
* The form will not be submitted until webkit_form_submission_request_submit() is called.
*
* It is possible to handle the form submission request asynchronously, by
* simply calling g_object_ref() on the @request argument and calling
* webkit_form_submission_request_submit() when done to continue with the form submission.
* If the last reference is removed on a #WebKitFormSubmissionRequest and the
* form has not been submitted, webkit_form_submission_request_submit() will be called.
*/
signals[SUBMIT_FORM] =
g_signal_new("submit-form",
G_TYPE_FROM_CLASS(webViewClass),
G_SIGNAL_RUN_LAST,
G_STRUCT_OFFSET(WebKitWebViewClass, submit_form),
0, 0,
g_cclosure_marshal_VOID__OBJECT,
G_TYPE_NONE, 1,
WEBKIT_TYPE_FORM_SUBMISSION_REQUEST);
/**
* WebKitWebView::insecure-content-detected:
* @web_view: the #WebKitWebView on which the signal is emitted
* @event: the #WebKitInsecureContentEvent
*
* This signal is emitted when insecure content has been detected
* in a page loaded through a secure connection. This typically
* means that a external resource from an unstrusted source has
* been run or displayed, resulting in a mix of HTTPS and
* non-HTTPS content.
*
* You can check the @event parameter to know exactly which kind
* of event has been detected (see #WebKitInsecureContentEvent).
*/
signals[INSECURE_CONTENT_DETECTED] =
g_signal_new("insecure-content-detected",
G_TYPE_FROM_CLASS(webViewClass),
G_SIGNAL_RUN_LAST,
G_STRUCT_OFFSET(WebKitWebViewClass, insecure_content_detected),
0, 0,
g_cclosure_marshal_VOID__ENUM,
G_TYPE_NONE, 1,
WEBKIT_TYPE_INSECURE_CONTENT_EVENT);
/**
* WebKitWebView::web-process-crashed:
* @web_view: the #WebKitWebView
*
* This signal is emitted when the web process crashes.
*
* Returns: %TRUE to stop other handlers from being invoked for the event.
* %FALSE to propagate the event further.
*/
signals[WEB_PROCESS_CRASHED] = g_signal_new(
"web-process-crashed",
G_TYPE_FROM_CLASS(webViewClass),
G_SIGNAL_RUN_LAST,
G_STRUCT_OFFSET(WebKitWebViewClass, web_process_crashed),
g_signal_accumulator_true_handled,
0,
webkit_marshal_BOOLEAN__VOID,
G_TYPE_BOOLEAN, 0);
/**
* WebKitWebView::authenticate:
* @web_view: the #WebKitWebView on which the signal is emitted
* @request: a #WebKitAuthenticationRequest
*
* This signal is emitted when the user is challenged with HTTP
* authentication. To let the application access or supply
* the credentials as well as to allow the client application
* to either cancel the request or perform the authentication,
* the signal will pass an instance of the
* #WebKitAuthenticationRequest in the @request argument.
* To handle this signal asynchronously you should keep a ref
* of the request and return %TRUE. To disable HTTP authentication
* entirely, connect to this signal and simply return %TRUE.
*
* The default signal handler will run a default authentication
* dialog asynchronously for the user to interact with.
*
* Returns: %TRUE to stop other handlers from being invoked for the event.
* %FALSE to propagate the event further.
*
* Since: 2.2
*/
signals[AUTHENTICATE] =
g_signal_new("authenticate",
G_TYPE_FROM_CLASS(webViewClass),
G_SIGNAL_RUN_LAST,
G_STRUCT_OFFSET(WebKitWebViewClass, authenticate),
g_signal_accumulator_true_handled, 0 /* accumulator data */,
webkit_marshal_BOOLEAN__OBJECT,
G_TYPE_BOOLEAN, 1, /* number of parameters */
WEBKIT_TYPE_AUTHENTICATION_REQUEST);
}
static void webkitWebViewSetIsLoading(WebKitWebView* webView, bool isLoading)
{
if (webView->priv->isLoading == isLoading)
return;
webView->priv->isLoading = isLoading;
g_object_freeze_notify(G_OBJECT(webView));
g_object_notify(G_OBJECT(webView), "is-loading");
// Update the URI if a new load has started.
if (webView->priv->isLoading)
webkitWebViewUpdateURI(webView);
g_object_thaw_notify(G_OBJECT(webView));
}
static void webkitWebViewCancelAuthenticationRequest(WebKitWebView* webView)
{
if (!webView->priv->authenticationRequest)
return;
webkit_authentication_request_cancel(webView->priv->authenticationRequest.get());
webView->priv->authenticationRequest.clear();
}
static void webkitWebViewEmitLoadChanged(WebKitWebView* webView, WebKitLoadEvent loadEvent)
{
if (loadEvent == WEBKIT_LOAD_STARTED) {
webkitWebViewSetIsLoading(webView, true);
webkitWebViewWatchForChangesInFavicon(webView);
webkitWebViewCancelAuthenticationRequest(webView);
} else if (loadEvent == WEBKIT_LOAD_FINISHED) {
webkitWebViewSetIsLoading(webView, false);
webkitWebViewCancelAuthenticationRequest(webView);
webkitWebViewDisconnectMainResourceResponseChangedSignalHandler(webView);
} else
webkitWebViewUpdateURI(webView);
g_signal_emit(webView, signals[LOAD_CHANGED], 0, loadEvent);
}
static void webkitWebViewEmitDelayedLoadEvents(WebKitWebView* webView)
{
WebKitWebViewPrivate* priv = webView->priv;
if (!priv->waitingForMainResource)
return;
ASSERT(priv->lastDelayedEvent == WEBKIT_LOAD_COMMITTED || priv->lastDelayedEvent == WEBKIT_LOAD_FINISHED);
if (priv->lastDelayedEvent == WEBKIT_LOAD_FINISHED)
webkitWebViewEmitLoadChanged(webView, WEBKIT_LOAD_COMMITTED);
webkitWebViewEmitLoadChanged(webView, priv->lastDelayedEvent);
priv->waitingForMainResource = false;
}
void webkitWebViewLoadChanged(WebKitWebView* webView, WebKitLoadEvent loadEvent)
{
WebKitWebViewPrivate* priv = webView->priv;
if (loadEvent == WEBKIT_LOAD_STARTED) {
// Finish a possible previous load waiting for main resource.
webkitWebViewEmitDelayedLoadEvents(webView);
webkitWebViewCancelFaviconRequest(webView);
priv->loadingResourcesMap.clear();
priv->mainResource = 0;
priv->waitingForMainResource = false;
} else if (loadEvent == WEBKIT_LOAD_COMMITTED) {
WebKitFaviconDatabase* database = webkit_web_context_get_favicon_database(priv->context);
GUniquePtr<char> faviconURI(webkit_favicon_database_get_favicon_uri(database, priv->activeURI.data()));
webkitWebViewUpdateFaviconURI(webView, faviconURI.get());
if (!priv->mainResource) {
// When a page is loaded from the history cache, the main resource load callbacks
// are called when the main frame load is finished. We want to make sure there's a
// main resource available when load has been committed, so we delay the emission of
// load-changed signal until main resource object has been created.
priv->waitingForMainResource = true;
}
}
if (priv->waitingForMainResource)
priv->lastDelayedEvent = loadEvent;
else
webkitWebViewEmitLoadChanged(webView, loadEvent);
}
void webkitWebViewLoadFailed(WebKitWebView* webView, WebKitLoadEvent loadEvent, const char* failingURI, GError *error)
{
webkitWebViewSetIsLoading(webView, false);
webkitWebViewCancelAuthenticationRequest(webView);
gboolean returnValue;
g_signal_emit(webView, signals[LOAD_FAILED], 0, loadEvent, failingURI, error, &returnValue);
g_signal_emit(webView, signals[LOAD_CHANGED], 0, WEBKIT_LOAD_FINISHED);
}
void webkitWebViewLoadFailedWithTLSErrors(WebKitWebView* webView, const char* failingURI, GError* error, GTlsCertificateFlags tlsErrors, GTlsCertificate* certificate)
{
webkitWebViewSetIsLoading(webView, false);
webkitWebViewCancelAuthenticationRequest(webView);
WebKitTLSErrorsPolicy tlsErrorsPolicy = webkit_web_context_get_tls_errors_policy(webView->priv->context);
if (tlsErrorsPolicy == WEBKIT_TLS_ERRORS_POLICY_FAIL) {
GUniquePtr<SoupURI> soupURI(soup_uri_new(failingURI));
WebKitCertificateInfo info(certificate, tlsErrors);
gboolean returnValue;
g_signal_emit(webView, signals[LOAD_FAILED_WITH_TLS_ERRORS], 0, &info, soupURI->host, &returnValue);
if (!returnValue)
g_signal_emit(webView, signals[LOAD_FAILED], 0, WEBKIT_LOAD_STARTED, failingURI, error, &returnValue);
}
g_signal_emit(webView, signals[LOAD_CHANGED], 0, WEBKIT_LOAD_FINISHED);
}
void webkitWebViewSetTitle(WebKitWebView* webView, const CString& title)
{
WebKitWebViewPrivate* priv = webView->priv;
if (priv->title == title)
return;
priv->title = title;
g_object_notify(G_OBJECT(webView), "title");
}
void webkitWebViewSetEstimatedLoadProgress(WebKitWebView* webView, double estimatedLoadProgress)
{
if (webView->priv->estimatedLoadProgress == estimatedLoadProgress)
return;
webView->priv->estimatedLoadProgress = estimatedLoadProgress;
g_object_notify(G_OBJECT(webView), "estimated-load-progress");
}
void webkitWebViewUpdateURI(WebKitWebView* webView)
{
CString activeURI = getPage(webView)->pageLoadState().activeURL().utf8();
if (webView->priv->activeURI == activeURI)
return;
webView->priv->activeURI = activeURI;
g_object_notify(G_OBJECT(webView), "uri");
}
WebPageProxy* webkitWebViewCreateNewPage(WebKitWebView* webView, const WindowFeatures& windowFeatures, WebKitNavigationAction* navigationAction)
{
WebKitWebView* newWebView;
g_signal_emit(webView, signals[CREATE], 0, navigationAction, &newWebView);
if (!newWebView)
return 0;
webkitWindowPropertiesUpdateFromWebWindowFeatures(newWebView->priv->windowProperties.get(), windowFeatures);
RefPtr<WebPageProxy> newPage = getPage(newWebView);
return newPage.release().leakRef();
}
void webkitWebViewReadyToShowPage(WebKitWebView* webView)
{
g_signal_emit(webView, signals[READY_TO_SHOW], 0, NULL);
}
void webkitWebViewRunAsModal(WebKitWebView* webView)
{
g_signal_emit(webView, signals[RUN_AS_MODAL], 0, NULL);
webView->priv->modalLoop = adoptGRef(g_main_loop_new(0, FALSE));
// This is to suppress warnings about gdk_threads_leave and gdk_threads_enter.
#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wdeprecated-declarations"
gdk_threads_leave();
g_main_loop_run(webView->priv->modalLoop.get());
gdk_threads_enter();
#pragma GCC diagnostic pop
}
void webkitWebViewClosePage(WebKitWebView* webView)
{
g_signal_emit(webView, signals[CLOSE], 0, NULL);
}
void webkitWebViewRunJavaScriptAlert(WebKitWebView* webView, const CString& message)
{
WebKitScriptDialog dialog(WEBKIT_SCRIPT_DIALOG_ALERT, message);
gboolean returnValue;
g_signal_emit(webView, signals[SCRIPT_DIALOG], 0, &dialog, &returnValue);
}
bool webkitWebViewRunJavaScriptConfirm(WebKitWebView* webView, const CString& message)
{
WebKitScriptDialog dialog(WEBKIT_SCRIPT_DIALOG_CONFIRM, message);
gboolean returnValue;
g_signal_emit(webView, signals[SCRIPT_DIALOG], 0, &dialog, &returnValue);
return dialog.confirmed;
}
CString webkitWebViewRunJavaScriptPrompt(WebKitWebView* webView, const CString& message, const CString& defaultText)
{
WebKitScriptDialog dialog(WEBKIT_SCRIPT_DIALOG_PROMPT, message, defaultText);
gboolean returnValue;
g_signal_emit(webView, signals[SCRIPT_DIALOG], 0, &dialog, &returnValue);
return dialog.text;
}
void webkitWebViewMakePolicyDecision(WebKitWebView* webView, WebKitPolicyDecisionType type, WebKitPolicyDecision* decision)
{
gboolean returnValue;
g_signal_emit(webView, signals[DECIDE_POLICY], 0, decision, type, &returnValue);
}
void webkitWebViewMakePermissionRequest(WebKitWebView* webView, WebKitPermissionRequest* request)
{
gboolean returnValue;
g_signal_emit(webView, signals[PERMISSION_REQUEST], 0, request, &returnValue);
}
void webkitWebViewMouseTargetChanged(WebKitWebView* webView, const WebHitTestResult::Data& hitTestResult, unsigned modifiers)
{
webkitWebViewBaseSetTooltipArea(WEBKIT_WEB_VIEW_BASE(webView), hitTestResult.elementBoundingBox);
WebKitWebViewPrivate* priv = webView->priv;
if (priv->mouseTargetHitTestResult
&& priv->mouseTargetModifiers == modifiers
&& webkitHitTestResultCompare(priv->mouseTargetHitTestResult.get(), hitTestResult))
return;
priv->mouseTargetModifiers = modifiers;
priv->mouseTargetHitTestResult = adoptGRef(webkitHitTestResultCreate(hitTestResult));
g_signal_emit(webView, signals[MOUSE_TARGET_CHANGED], 0, priv->mouseTargetHitTestResult.get(), modifiers);
}
void webkitWebViewPrintFrame(WebKitWebView* webView, WebFrameProxy* frame)
{
GRefPtr<WebKitPrintOperation> printOperation = adoptGRef(webkit_print_operation_new(webView));
webkitPrintOperationSetPrintMode(printOperation.get(), PrintInfo::PrintModeSync);
gboolean returnValue;
g_signal_emit(webView, signals[PRINT], 0, printOperation.get(), &returnValue);
if (returnValue)
return;
WebKitPrintOperationResponse response = webkitPrintOperationRunDialogForFrame(printOperation.get(), 0, frame);
if (response == WEBKIT_PRINT_OPERATION_RESPONSE_CANCEL)
return;
g_signal_connect(printOperation.leakRef(), "finished", G_CALLBACK(g_object_unref), 0);
}
static void mainResourceResponseChangedCallback(WebKitWebResource*, GParamSpec*, WebKitWebView* webView)
{
webkitWebViewDisconnectMainResourceResponseChangedSignalHandler(webView);
webkitWebViewEmitDelayedLoadEvents(webView);
}
static void waitForMainResourceResponseIfWaitingForResource(WebKitWebView* webView)
{
WebKitWebViewPrivate* priv = webView->priv;
if (!priv->waitingForMainResource)
return;
webkitWebViewDisconnectMainResourceResponseChangedSignalHandler(webView);
priv->mainResourceResponseHandlerID =
g_signal_connect(priv->mainResource.get(), "notify::response", G_CALLBACK(mainResourceResponseChangedCallback), webView);
}
void webkitWebViewResourceLoadStarted(WebKitWebView* webView, WebFrameProxy* frame, uint64_t resourceIdentifier, WebKitURIRequest* request)
{
WebKitWebViewPrivate* priv = webView->priv;
bool isMainResource = frame->isMainFrame() && !priv->mainResource;
WebKitWebResource* resource = webkitWebResourceCreate(frame, request, isMainResource);
if (isMainResource) {
priv->mainResource = resource;
waitForMainResourceResponseIfWaitingForResource(webView);
}
priv->loadingResourcesMap.set(resourceIdentifier, adoptGRef(resource));
g_signal_emit(webView, signals[RESOURCE_LOAD_STARTED], 0, resource, request);
}
WebKitWebResource* webkitWebViewGetLoadingWebResource(WebKitWebView* webView, uint64_t resourceIdentifier)
{
GRefPtr<WebKitWebResource> resource = webView->priv->loadingResourcesMap.get(resourceIdentifier);
return resource.get();
}
void webkitWebViewRemoveLoadingWebResource(WebKitWebView* webView, uint64_t resourceIdentifier)
{
WebKitWebViewPrivate* priv = webView->priv;
ASSERT(priv->loadingResourcesMap.contains(resourceIdentifier));
priv->loadingResourcesMap.remove(resourceIdentifier);
}
bool webkitWebViewEnterFullScreen(WebKitWebView* webView)
{
gboolean returnValue;
g_signal_emit(webView, signals[ENTER_FULLSCREEN], 0, &returnValue);
return !returnValue;
}
bool webkitWebViewLeaveFullScreen(WebKitWebView* webView)
{
gboolean returnValue;
g_signal_emit(webView, signals[LEAVE_FULLSCREEN], 0, &returnValue);
return !returnValue;
}
void webkitWebViewRunFileChooserRequest(WebKitWebView* webView, WebKitFileChooserRequest* request)
{
gboolean returnValue;
g_signal_emit(webView, signals[RUN_FILE_CHOOSER], 0, request, &returnValue);
}
static bool webkitWebViewShouldShowInputMethodsMenu(WebKitWebView* webView)
{
GtkSettings* settings = gtk_widget_get_settings(GTK_WIDGET(webView));
if (!settings)
return true;
gboolean showInputMethodMenu;
g_object_get(settings, "gtk-show-input-method-menu", &showInputMethodMenu, NULL);
return showInputMethodMenu;
}
static int getUnicodeMenuItemPosition(WebKitContextMenu* contextMenu)
{
GList* items = webkit_context_menu_get_items(contextMenu);
GList* iter;
int i = 0;
for (iter = items, i = 0; iter; iter = g_list_next(iter), ++i) {
WebKitContextMenuItem* item = WEBKIT_CONTEXT_MENU_ITEM(iter->data);
if (webkit_context_menu_item_is_separator(item))
continue;
if (webkit_context_menu_item_get_stock_action(item) == WEBKIT_CONTEXT_MENU_ACTION_UNICODE)
return i;
}
return -1;
}
static void webkitWebViewCreateAndAppendInputMethodsMenuItem(WebKitWebView* webView, WebKitContextMenu* contextMenu)
{
if (!webkitWebViewShouldShowInputMethodsMenu(webView))
return;
// Place the im context menu item right before the unicode menu item
// if it's present.
int unicodeMenuItemPosition = getUnicodeMenuItemPosition(contextMenu);
if (unicodeMenuItemPosition == -1)
webkit_context_menu_append(contextMenu, webkit_context_menu_item_new_separator());
GtkIMContext* imContext = webkitWebViewBaseGetIMContext(WEBKIT_WEB_VIEW_BASE(webView));
GtkMenu* imContextMenu = GTK_MENU(gtk_menu_new());
gtk_im_multicontext_append_menuitems(GTK_IM_MULTICONTEXT(imContext), GTK_MENU_SHELL(imContextMenu));
WebKitContextMenuItem* menuItem = webkit_context_menu_item_new_from_stock_action(WEBKIT_CONTEXT_MENU_ACTION_INPUT_METHODS);
webkitContextMenuItemSetSubMenuFromGtkMenu(menuItem, imContextMenu);
webkit_context_menu_insert(contextMenu, menuItem, unicodeMenuItemPosition);
}
static void contextMenuDismissed(GtkMenuShell*, WebKitWebView* webView)
{
g_signal_emit(webView, signals[CONTEXT_MENU_DISMISSED], 0, NULL);
}
void webkitWebViewPopulateContextMenu(WebKitWebView* webView, API::Array* proposedMenu, WebHitTestResult* webHitTestResult)
{
WebKitWebViewBase* webViewBase = WEBKIT_WEB_VIEW_BASE(webView);
WebContextMenuProxyGtk* contextMenuProxy = webkitWebViewBaseGetActiveContextMenuProxy(webViewBase);
ASSERT(contextMenuProxy);
GRefPtr<WebKitContextMenu> contextMenu = adoptGRef(webkitContextMenuCreate(proposedMenu));
if (webHitTestResult->isContentEditable())
webkitWebViewCreateAndAppendInputMethodsMenuItem(webView, contextMenu.get());
// FIXME: we should use a custom ContextMenuClient at some point, that will receive a
// const WebHitTestResult::Data& that we can use directly here.
WebHitTestResult::Data data;
data.absoluteImageURL = webHitTestResult->absoluteImageURL();
data.absoluteLinkURL = webHitTestResult->absoluteLinkURL();
data.absoluteMediaURL = webHitTestResult->absoluteMediaURL();
data.linkLabel = webHitTestResult->linkLabel();
data.linkTitle = webHitTestResult->linkTitle();
data.isContentEditable = webHitTestResult->isContentEditable();
data.elementBoundingBox = webHitTestResult->elementBoundingBox();
data.isScrollbar = webHitTestResult->isScrollbar();
GRefPtr<WebKitHitTestResult> hitTestResult = adoptGRef(webkitHitTestResultCreate(data));
GUniquePtr<GdkEvent> contextMenuEvent(webkitWebViewBaseTakeContextMenuEvent(webViewBase));
gboolean returnValue;
g_signal_emit(webView, signals[CONTEXT_MENU], 0, contextMenu.get(), contextMenuEvent.get(), hitTestResult.get(), &returnValue);
if (returnValue)
return;
Vector<ContextMenuItem> contextMenuItems;
webkitContextMenuPopulate(contextMenu.get(), contextMenuItems);
contextMenuProxy->populate(contextMenuItems);
g_signal_connect(contextMenuProxy->gtkMenu(), "deactivate", G_CALLBACK(contextMenuDismissed), webView);
// Clear the menu to make sure it's useless after signal emission.
webkit_context_menu_remove_all(contextMenu.get());
}
void webkitWebViewSubmitFormRequest(WebKitWebView* webView, WebKitFormSubmissionRequest* request)
{
g_signal_emit(webView, signals[SUBMIT_FORM], 0, request);
}
void webkitWebViewHandleAuthenticationChallenge(WebKitWebView* webView, AuthenticationChallengeProxy* authenticationChallenge)
{
gboolean privateBrowsingEnabled = webkit_settings_get_enable_private_browsing(webkit_web_view_get_settings(webView));
webView->priv->authenticationRequest = adoptGRef(webkitAuthenticationRequestCreate(authenticationChallenge, privateBrowsingEnabled));
gboolean returnValue;
g_signal_emit(webView, signals[AUTHENTICATE], 0, webView->priv->authenticationRequest.get(), &returnValue);
}
void webkitWebViewInsecureContentDetected(WebKitWebView* webView, WebKitInsecureContentEvent type)
{
g_signal_emit(webView, signals[INSECURE_CONTENT_DETECTED], 0, type);
}
/**
* webkit_web_view_new:
*
* Creates a new #WebKitWebView with the default #WebKitWebContext and the
* default #WebKitWebViewGroup.
* See also webkit_web_view_new_with_context() and webkit_web_view_new_with_group().
*
* Returns: The newly created #WebKitWebView widget
*/
GtkWidget* webkit_web_view_new()
{
return webkit_web_view_new_with_context(webkit_web_context_get_default());
}
/**
* webkit_web_view_new_with_context:
* @context: the #WebKitWebContext to be used by the #WebKitWebView
*
* Creates a new #WebKitWebView with the given #WebKitWebContext and the
* default #WebKitWebViewGroup.
* See also webkit_web_view_new_with_group().
*
* Returns: The newly created #WebKitWebView widget
*/
GtkWidget* webkit_web_view_new_with_context(WebKitWebContext* context)
{
g_return_val_if_fail(WEBKIT_IS_WEB_CONTEXT(context), 0);
return GTK_WIDGET(g_object_new(WEBKIT_TYPE_WEB_VIEW, "web-context", context, NULL));
}
/**
* webkit_web_view_new_with_related_view:
* @web_view: the related #WebKitWebView
*
* Creates a new #WebKitWebView sharing the same web process with @web_view.
* This method doesn't have any effect when %WEBKIT_PROCESS_MODEL_SHARED_SECONDARY_PROCESS
* process model is used, because a single web process is shared for all the web views in the
* same #WebKitWebContext. When using %WEBKIT_PROCESS_MODEL_MULTIPLE_SECONDARY_PROCESSES process model,
* this method should always be used when creating the #WebKitWebView in the #WebKitWebView::create signal.
* You can also use this method to implement other process models based on %WEBKIT_PROCESS_MODEL_MULTIPLE_SECONDARY_PROCESSES,
* like for example, sharing the same web process for all the views in the same security domain.
*
* The newly created #WebKitWebView will also have the same #WebKitUserContentManager as @web_view.
*
* Returns: (transfer full): The newly created #WebKitWebView widget
*
* Since: 2.4
*/
GtkWidget* webkit_web_view_new_with_related_view(WebKitWebView* webView)
{
g_return_val_if_fail(WEBKIT_IS_WEB_VIEW(webView), nullptr);
return GTK_WIDGET(g_object_new(WEBKIT_TYPE_WEB_VIEW,
"user-content-manager", webView->priv->userContentManager.get(),
"related-view", webView,
nullptr));
}
/**
* webkit_web_view_new_with_group:
* @group: a #WebKitWebViewGroup
*
* Creates a new #WebKitWebView with the given #WebKitWebViewGroup.
* The view will be part of @group and it will be affected by the
* group properties like the settings.
*
* Returns: The newly created #WebKitWebView widget
*/
GtkWidget* webkit_web_view_new_with_group(WebKitWebViewGroup* group)
{
g_return_val_if_fail(WEBKIT_IS_WEB_VIEW_GROUP(group), 0);
return GTK_WIDGET(g_object_new(WEBKIT_TYPE_WEB_VIEW, "group", group, NULL));
}
/**
* webkit_web_view_new_with_user_content_manager:
* @user_content_manager: a #WebKitUserContentManager.
*
* Creates a new #WebKitWebView with the given #WebKitUserContentManager.
* The content loaded in the view may be affected by the content injected
* in the view by the user content manager.
*
* Returns: The newly created #WebKitWebView widget
*
* Since: 2.6
*/
GtkWidget* webkit_web_view_new_with_user_content_manager(WebKitUserContentManager* userContentManager)
{
g_return_val_if_fail(WEBKIT_IS_USER_CONTENT_MANAGER(userContentManager), nullptr);
return GTK_WIDGET(g_object_new(WEBKIT_TYPE_WEB_VIEW, "user-content-manager", userContentManager, nullptr));
}
/**
* webkit_web_view_get_context:
* @web_view: a #WebKitWebView
*
* Gets the web context of @web_view.
*
* Returns: (transfer none): the #WebKitWebContext of the view
*/
WebKitWebContext* webkit_web_view_get_context(WebKitWebView *webView)
{
g_return_val_if_fail(WEBKIT_IS_WEB_VIEW(webView), 0);
return webView->priv->context;
}
/**
* webkit_web_view_get_group:
* @web_view: a #WebKitWebView
*
* Gets the group @web_view belongs to.
*
* Returns: (transfer none): the #WebKitWebViewGroup to which the view belongs
*/
WebKitWebViewGroup* webkit_web_view_get_group(WebKitWebView* webView)
{
g_return_val_if_fail(WEBKIT_IS_WEB_VIEW(webView), 0);
if (webView->priv->group)
return webView->priv->group.get();
return webkitWebContextGetDefaultWebViewGroup(webView->priv->context);
}
/**
* webkit_web_view_get_user_content_manager:
* @web_view: a #WebKitWebView
*
* Gets the user content manager associated to @web_view, or %NULL if the
* view does not have an user content manager.
*
* Returns: (transfer none): the #WebKitUserContentManager associated with the view
*
* Since: 2.6
*/
WebKitUserContentManager* webkit_web_view_get_user_content_manager(WebKitWebView* webView)
{
g_return_val_if_fail(WEBKIT_IS_WEB_VIEW(webView), nullptr);
return webView->priv->userContentManager.get();
}
/**
* webkit_web_view_load_uri:
* @web_view: a #WebKitWebView
* @uri: an URI string
*
* Requests loading of the specified URI string.
* You can monitor the load operation by connecting to
* #WebKitWebView::load-changed signal.
*/
void webkit_web_view_load_uri(WebKitWebView* webView, const gchar* uri)
{
g_return_if_fail(WEBKIT_IS_WEB_VIEW(webView));
g_return_if_fail(uri);
GUniquePtr<SoupURI> soupURI(soup_uri_new(uri));
getPage(webView)->loadRequest(URL(soupURI.get()));
}
/**
* webkit_web_view_load_html:
* @web_view: a #WebKitWebView
* @content: The HTML string to load
* @base_uri: (allow-none): The base URI for relative locations or %NULL
*
* Load the given @content string with the specified @base_uri.
* If @base_uri is not %NULL, relative URLs in the @content will be
* resolved against @base_uri and absolute local paths must be children of the @base_uri.
* For security reasons absolute local paths that are not children of @base_uri
* will cause the web process to terminate.
* If you need to include URLs in @content that are local paths in a different
* directory than @base_uri you can build a data URI for them. When @base_uri is %NULL,
* it defaults to "about:blank". The mime type of the document will be "text/html".
* You can monitor the load operation by connecting to #WebKitWebView::load-changed signal.
*/
void webkit_web_view_load_html(WebKitWebView* webView, const gchar* content, const gchar* baseURI)
{
g_return_if_fail(WEBKIT_IS_WEB_VIEW(webView));
g_return_if_fail(content);
getPage(webView)->loadHTMLString(String::fromUTF8(content), String::fromUTF8(baseURI));
}
/**
* webkit_web_view_load_alternate_html:
* @web_view: a #WebKitWebView
* @content: the new content to display as the main page of the @web_view
* @content_uri: the URI for the alternate page content
* @base_uri: (allow-none): the base URI for relative locations or %NULL
*
* Load the given @content string for the URI @content_uri.
* This allows clients to display page-loading errors in the #WebKitWebView itself.
* When this method is called from #WebKitWebView::load-failed signal to show an
* error page, the the back-forward list is maintained appropriately.
* For everything else this method works the same way as webkit_web_view_load_html().
*/
void webkit_web_view_load_alternate_html(WebKitWebView* webView, const gchar* content, const gchar* contentURI, const gchar* baseURI)
{
g_return_if_fail(WEBKIT_IS_WEB_VIEW(webView));
g_return_if_fail(content);
g_return_if_fail(contentURI);
getPage(webView)->loadAlternateHTMLString(String::fromUTF8(content), String::fromUTF8(baseURI), String::fromUTF8(contentURI));
}
/**
* webkit_web_view_load_plain_text:
* @web_view: a #WebKitWebView
* @plain_text: The plain text to load
*
* Load the specified @plain_text string into @web_view. The mime type of
* document will be "text/plain". You can monitor the load
* operation by connecting to #WebKitWebView::load-changed signal.
*/
void webkit_web_view_load_plain_text(WebKitWebView* webView, const gchar* plainText)
{
g_return_if_fail(WEBKIT_IS_WEB_VIEW(webView));
g_return_if_fail(plainText);
getPage(webView)->loadPlainTextString(String::fromUTF8(plainText));
}
/**
* webkit_web_view_load_request:
* @web_view: a #WebKitWebView
* @request: a #WebKitURIRequest to load
*
* Requests loading of the specified #WebKitURIRequest.
* You can monitor the load operation by connecting to
* #WebKitWebView::load-changed signal.
*/
void webkit_web_view_load_request(WebKitWebView* webView, WebKitURIRequest* request)
{
g_return_if_fail(WEBKIT_IS_WEB_VIEW(webView));
g_return_if_fail(WEBKIT_IS_URI_REQUEST(request));
ResourceRequest resourceRequest;
webkitURIRequestGetResourceRequest(request, resourceRequest);
getPage(webView)->loadRequest(resourceRequest);
}
/**
* webkit_web_view_get_page_id:
* @web_view: a #WebKitWebView
*
* Get the identifier of the #WebKitWebPage corresponding to
* the #WebKitWebView
*
* Returns: the page ID of @web_view.
*/
guint64 webkit_web_view_get_page_id(WebKitWebView* webView)
{
g_return_val_if_fail(WEBKIT_IS_WEB_VIEW(webView), 0);
return getPage(webView)->pageID();
}
/**
* webkit_web_view_get_title:
* @web_view: a #WebKitWebView
*
* Gets the value of the #WebKitWebView:title property.
* You can connect to notify::title signal of @web_view to
* be notified when the title has been received.
*
* Returns: The main frame document title of @web_view.
*/
const gchar* webkit_web_view_get_title(WebKitWebView* webView)
{
g_return_val_if_fail(WEBKIT_IS_WEB_VIEW(webView), 0);
return webView->priv->title.data();
}
/**
* webkit_web_view_reload:
* @web_view: a #WebKitWebView
*
* Reloads the current contents of @web_view.
* See also webkit_web_view_reload_bypass_cache().
*/
void webkit_web_view_reload(WebKitWebView* webView)
{
g_return_if_fail(WEBKIT_IS_WEB_VIEW(webView));
getPage(webView)->reload(false);
}
/**
* webkit_web_view_reload_bypass_cache:
* @web_view: a #WebKitWebView
*
* Reloads the current contents of @web_view without
* using any cached data.
*/
void webkit_web_view_reload_bypass_cache(WebKitWebView* webView)
{
g_return_if_fail(WEBKIT_IS_WEB_VIEW(webView));
getPage(webView)->reload(true);
}
/**
* webkit_web_view_stop_loading:
* @web_view: a #WebKitWebView
*
* Stops any ongoing loading operation in @web_view.
* This method does nothing if no content is being loaded.
* If there is a loading operation in progress, it will be cancelled and
* #WebKitWebView::load-failed signal will be emitted with
* %WEBKIT_NETWORK_ERROR_CANCELLED error.
*/
void webkit_web_view_stop_loading(WebKitWebView* webView)
{
g_return_if_fail(WEBKIT_IS_WEB_VIEW(webView));
getPage(webView)->stopLoading();
}
/**
* webkit_web_view_is_loading:
* @web_view: a #WebKitWebView
*
* Gets the value of the #WebKitWebView:is-loading property.
* You can monitor when a #WebKitWebView is loading a page by connecting to
* notify::is-loading signal of @web_view. This is useful when you are
* interesting in knowing when the view is loding something but not in the
* details about the status of the load operation, for example to start a spinner
* when the view is loading a page and stop it when it finishes.
*
* Returns: %TRUE if @web_view is loading a page or %FALSE otherwise.
*/
gboolean webkit_web_view_is_loading(WebKitWebView* webView)
{
g_return_val_if_fail(WEBKIT_IS_WEB_VIEW(webView), FALSE);
return webView->priv->isLoading;
}
/**
* webkit_web_view_go_back:
* @web_view: a #WebKitWebView
*
* Loads the previous history item.
* You can monitor the load operation by connecting to
* #WebKitWebView::load-changed signal.
*/
void webkit_web_view_go_back(WebKitWebView* webView)
{
g_return_if_fail(WEBKIT_IS_WEB_VIEW(webView));
getPage(webView)->goBack();
}
/**
* webkit_web_view_can_go_back:
* @web_view: a #WebKitWebView
*
* Determines whether @web_view has a previous history item.
*
* Returns: %TRUE if able to move back or %FALSE otherwise.
*/
gboolean webkit_web_view_can_go_back(WebKitWebView* webView)
{
g_return_val_if_fail(WEBKIT_IS_WEB_VIEW(webView), FALSE);
return !!getPage(webView)->backForwardList().backItem();
}
/**
* webkit_web_view_go_forward:
* @web_view: a #WebKitWebView
*
* Loads the next history item.
* You can monitor the load operation by connecting to
* #WebKitWebView::load-changed signal.
*/
void webkit_web_view_go_forward(WebKitWebView* webView)
{
g_return_if_fail(WEBKIT_IS_WEB_VIEW(webView));
getPage(webView)->goForward();
}
/**
* webkit_web_view_can_go_forward:
* @web_view: a #WebKitWebView
*
* Determines whether @web_view has a next history item.
*
* Returns: %TRUE if able to move forward or %FALSE otherwise.
*/
gboolean webkit_web_view_can_go_forward(WebKitWebView* webView)
{
g_return_val_if_fail(WEBKIT_IS_WEB_VIEW(webView), FALSE);
return !!getPage(webView)->backForwardList().forwardItem();
}
/**
* webkit_web_view_get_uri:
* @web_view: a #WebKitWebView
*
* Returns the current active URI of @web_view. The active URI might change during
* a load operation:
*
* <orderedlist>
* <listitem><para>
* When nothing has been loaded yet on @web_view the active URI is %NULL.
* </para></listitem>
* <listitem><para>
* When a new load operation starts the active URI is the requested URI:
* <itemizedlist>
* <listitem><para>
* If the load operation was started by webkit_web_view_load_uri(),
* the requested URI is the given one.
* </para></listitem>
* <listitem><para>
* If the load operation was started by webkit_web_view_load_html(),
* the requested URI is "about:blank".
* </para></listitem>
* <listitem><para>
* If the load operation was started by webkit_web_view_load_alternate_html(),
* the requested URI is content URI provided.
* </para></listitem>
* <listitem><para>
* If the load operation was started by webkit_web_view_go_back() or
* webkit_web_view_go_forward(), the requested URI is the original URI
* of the previous/next item in the #WebKitBackForwardList of @web_view.
* </para></listitem>
* <listitem><para>
* If the load operation was started by
* webkit_web_view_go_to_back_forward_list_item(), the requested URI
* is the opriginal URI of the given #WebKitBackForwardListItem.
* </para></listitem>
* </itemizedlist>
* </para></listitem>
* <listitem><para>
* If there is a server redirection during the load operation,
* the active URI is the redirected URI. When the signal
* #WebKitWebView::load-changed is emitted with %WEBKIT_LOAD_REDIRECTED
* event, the active URI is already updated to the redirected URI.
* </para></listitem>
* <listitem><para>
* When the signal #WebKitWebView::load-changed is emitted
* with %WEBKIT_LOAD_COMMITTED event, the active URI is the final
* one and it will not change unless a new load operation is started
* or a navigation action within the same page is performed.
* </para></listitem>
* </orderedlist>
*
* You can monitor the active URI by connecting to the notify::uri
* signal of @web_view.
*
* Returns: the current active URI of @web_view or %NULL
* if nothing has been loaded yet.
*/
const gchar* webkit_web_view_get_uri(WebKitWebView* webView)
{
g_return_val_if_fail(WEBKIT_IS_WEB_VIEW(webView), 0);
return webView->priv->activeURI.data();
}
/**
* webkit_web_view_get_favicon:
* @web_view: a #WebKitWebView
*
* Returns favicon currently associated to @web_view, if any. You can
* connect to notify::favicon signal of @web_view to be notified when
* the favicon is available.
*
* Returns: (transfer none): a pointer to a #cairo_surface_t with the
* favicon or %NULL if there's no icon associated with @web_view.
*/
cairo_surface_t* webkit_web_view_get_favicon(WebKitWebView* webView)
{
g_return_val_if_fail(WEBKIT_IS_WEB_VIEW(webView), 0);
if (webView->priv->activeURI.isNull())
return 0;
return webView->priv->favicon.get();
}
/**
* webkit_web_view_get_custom_charset:
* @web_view: a #WebKitWebView
*
* Returns the current custom character encoding name of @web_view.
*
* Returns: the current custom character encoding name or %NULL if no
* custom character encoding has been set.
*/
const gchar* webkit_web_view_get_custom_charset(WebKitWebView* webView)
{
g_return_val_if_fail(WEBKIT_IS_WEB_VIEW(webView), 0);
String customTextEncoding = getPage(webView)->customTextEncodingName();
if (customTextEncoding.isEmpty())
return 0;
webView->priv->customTextEncoding = customTextEncoding.utf8();
return webView->priv->customTextEncoding.data();
}
/**
* webkit_web_view_set_custom_charset:
* @web_view: a #WebKitWebView
* @charset: (allow-none): a character encoding name or %NULL
*
* Sets the current custom character encoding override of @web_view. The custom
* character encoding will override any text encoding detected via HTTP headers or
* META tags. Calling this method will stop any current load operation and reload the
* current page. Setting the custom character encoding to %NULL removes the character
* encoding override.
*/
void webkit_web_view_set_custom_charset(WebKitWebView* webView, const gchar* charset)
{
g_return_if_fail(WEBKIT_IS_WEB_VIEW(webView));
getPage(webView)->setCustomTextEncodingName(String::fromUTF8(charset));
}
/**
* webkit_web_view_get_estimated_load_progress:
* @web_view: a #WebKitWebView
*
* Gets the value of the #WebKitWebView:estimated-load-progress property.
* You can monitor the estimated progress of a load operation by
* connecting to the notify::estimated-load-progress signal of @web_view.
*
* Returns: an estimate of the of the percent complete for a document
* load as a range from 0.0 to 1.0.
*/
gdouble webkit_web_view_get_estimated_load_progress(WebKitWebView* webView)
{
g_return_val_if_fail(WEBKIT_IS_WEB_VIEW(webView), 0);
return webView->priv->estimatedLoadProgress;
}
/**
* webkit_web_view_get_back_forward_list:
* @web_view: a #WebKitWebView
*
* Obtains the #WebKitBackForwardList associated with the given #WebKitWebView. The
* #WebKitBackForwardList is owned by the #WebKitWebView.
*
* Returns: (transfer none): the #WebKitBackForwardList
*/
WebKitBackForwardList* webkit_web_view_get_back_forward_list(WebKitWebView* webView)
{
g_return_val_if_fail(WEBKIT_IS_WEB_VIEW(webView), 0);
return webView->priv->backForwardList.get();
}
/**
* webkit_web_view_go_to_back_forward_list_item:
* @web_view: a #WebKitWebView
* @list_item: a #WebKitBackForwardListItem
*
* Loads the specific history item @list_item.
* You can monitor the load operation by connecting to
* #WebKitWebView::load-changed signal.
*/
void webkit_web_view_go_to_back_forward_list_item(WebKitWebView* webView, WebKitBackForwardListItem* listItem)
{
g_return_if_fail(WEBKIT_IS_WEB_VIEW(webView));
g_return_if_fail(WEBKIT_IS_BACK_FORWARD_LIST_ITEM(listItem));
getPage(webView)->goToBackForwardItem(webkitBackForwardListItemGetItem(listItem));
}
/**
* webkit_web_view_set_settings:
* @web_view: a #WebKitWebView
* @settings: a #WebKitSettings
*
* Sets the #WebKitSettings to be applied to @web_view.
* This is a convenient method to set new settings to the
* #WebKitWebViewGroup @web_view belongs to.
* New settings are applied immediately on all #WebKitWebView<!-- -->s
* in the @web_view group.
* See also webkit_web_view_group_set_settings().
*/
void webkit_web_view_set_settings(WebKitWebView* webView, WebKitSettings* settings)
{
webkit_web_view_group_set_settings(webkit_web_view_get_group(webView), settings);
}
/**
* webkit_web_view_get_settings:
* @web_view: a #WebKitWebView
*
* Gets the #WebKitSettings currently applied to @web_view.
* This is a convenient method to get the settings of the
* #WebKitWebViewGroup @web_view belongs to.
* #WebKitSettings objects are shared by all the #WebKitWebView<!-- -->s
* in the same #WebKitWebViewGroup, so modifying
* the settings of a #WebKitWebView would affect other
* #WebKitWebView<!-- -->s of the same group.
* See also webkit_web_view_group_get_settings().
*
* Returns: (transfer none): the #WebKitSettings attached to @web_view
*/
WebKitSettings* webkit_web_view_get_settings(WebKitWebView* webView)
{
return webkit_web_view_group_get_settings(webkit_web_view_get_group(webView));
}
/**
* webkit_web_view_get_window_properties:
* @web_view: a #WebKitWebView
*
* Get the #WebKitWindowProperties object containing the properties
* that the window containing @web_view should have.
*
* Returns: (transfer none): the #WebKitWindowProperties of @web_view
*/
WebKitWindowProperties* webkit_web_view_get_window_properties(WebKitWebView* webView)
{
g_return_val_if_fail(WEBKIT_IS_WEB_VIEW(webView), 0);
return webView->priv->windowProperties.get();
}
/**
* webkit_web_view_set_zoom_level:
* @web_view: a #WebKitWebView
* @zoom_level: the zoom level
*
* Set the zoom level of @web_view, i.e. the factor by which the
* view contents are scaled with respect to their original size.
*/
void webkit_web_view_set_zoom_level(WebKitWebView* webView, gdouble zoomLevel)
{
g_return_if_fail(WEBKIT_IS_WEB_VIEW(webView));
if (webkit_web_view_get_zoom_level(webView) == zoomLevel)
return;
WebPageProxy* page = getPage(webView);
if (webkit_settings_get_zoom_text_only(webkit_web_view_get_settings(webView)))
page->setTextZoomFactor(zoomLevel);
else
page->setPageZoomFactor(zoomLevel);
g_object_notify(G_OBJECT(webView), "zoom-level");
}
/**
* webkit_web_view_get_zoom_level:
* @web_view: a #WebKitWebView
*
* Get the zoom level of @web_view, i.e. the factor by which the
* view contents are scaled with respect to their original size.
*
* Returns: the current zoom level of @web_view
*/
gdouble webkit_web_view_get_zoom_level(WebKitWebView* webView)
{
g_return_val_if_fail(WEBKIT_IS_WEB_VIEW(webView), 1);
WebPageProxy* page = getPage(webView);
gboolean zoomTextOnly = webkit_settings_get_zoom_text_only(webkit_web_view_get_settings(webView));
return zoomTextOnly ? page->textZoomFactor() : page->pageZoomFactor();
}
/**
* webkit_web_view_can_execute_editing_command:
* @web_view: a #WebKitWebView
* @command: the command to check
* @cancellable: (allow-none): a #GCancellable or %NULL to ignore
* @callback: (scope async): a #GAsyncReadyCallback to call when the request is satisfied
* @user_data: (closure): the data to pass to callback function
*
* Asynchronously execute the given editing command.
*
* When the operation is finished, @callback will be called. You can then call
* webkit_web_view_can_execute_editing_command_finish() to get the result of the operation.
*/
void webkit_web_view_can_execute_editing_command(WebKitWebView* webView, const char* command, GCancellable* cancellable, GAsyncReadyCallback callback, gpointer userData)
{
g_return_if_fail(WEBKIT_IS_WEB_VIEW(webView));
g_return_if_fail(command);
GTask* task = g_task_new(webView, cancellable, callback, userData);
getPage(webView)->validateCommand(String::fromUTF8(command), [task](const String&, bool isEnabled, int32_t, CallbackBase::Error) {
g_task_return_boolean(adoptGRef(task).get(), isEnabled);
});
}
/**
* webkit_web_view_can_execute_editing_command_finish:
* @web_view: a #WebKitWebView
* @result: a #GAsyncResult
* @error: return location for error or %NULL to ignore
*
* Finish an asynchronous operation started with webkit_web_view_can_execute_editing_command().
*
* Returns: %TRUE if the editing command can be executed or %FALSE otherwise
*/
gboolean webkit_web_view_can_execute_editing_command_finish(WebKitWebView* webView, GAsyncResult* result, GError** error)
{
g_return_val_if_fail(WEBKIT_IS_WEB_VIEW(webView), FALSE);
g_return_val_if_fail(g_task_is_valid(result, webView), FALSE);
return g_task_propagate_boolean(G_TASK(result), error);
}
/**
* webkit_web_view_execute_editing_command:
* @web_view: a #WebKitWebView
* @command: the command to execute
*
* Request to execute the given @command for @web_view. You can use
* webkit_web_view_can_execute_editing_command() to check whether
* it's possible to execute the command.
*/
void webkit_web_view_execute_editing_command(WebKitWebView* webView, const char* command)
{
g_return_if_fail(WEBKIT_IS_WEB_VIEW(webView));
g_return_if_fail(command);
getPage(webView)->executeEditCommand(String::fromUTF8(command));
}
/**
* webkit_web_view_get_find_controller:
* @web_view: the #WebKitWebView
*
* Gets the #WebKitFindController that will allow the caller to query
* the #WebKitWebView for the text to look for.
*
* Returns: (transfer none): the #WebKitFindController associated to
* this particular #WebKitWebView.
*/
WebKitFindController* webkit_web_view_get_find_controller(WebKitWebView* webView)
{
g_return_val_if_fail(WEBKIT_IS_WEB_VIEW(webView), 0);
if (!webView->priv->findController)
webView->priv->findController = adoptGRef(WEBKIT_FIND_CONTROLLER(g_object_new(WEBKIT_TYPE_FIND_CONTROLLER, "web-view", webView, NULL)));
return webView->priv->findController.get();
}
/**
* webkit_web_view_get_javascript_global_context:
* @web_view: a #WebKitWebView
*
* Get the global JavaScript context used by @web_view to deserialize the
* result values of scripts executed with webkit_web_view_run_javascript().
*
* Returns: the <function>JSGlobalContextRef</function> used by @web_view to deserialize
* the result values of scripts.
*/
JSGlobalContextRef webkit_web_view_get_javascript_global_context(WebKitWebView* webView)
{
g_return_val_if_fail(WEBKIT_IS_WEB_VIEW(webView), 0);
if (!webView->priv->javascriptGlobalContext)
webView->priv->javascriptGlobalContext = JSGlobalContextCreate(0);
return webView->priv->javascriptGlobalContext;
}
static void webkitWebViewRunJavaScriptCallback(WebSerializedScriptValue* wkSerializedScriptValue, GTask* task)
{
if (g_task_return_error_if_cancelled(task))
return;
if (!wkSerializedScriptValue) {
g_task_return_new_error(task, WEBKIT_JAVASCRIPT_ERROR, WEBKIT_JAVASCRIPT_ERROR_SCRIPT_FAILED,
_("An exception was raised in JavaScript"));
return;
}
WebKitWebView* webView = WEBKIT_WEB_VIEW(g_task_get_source_object(task));
g_task_return_pointer(task, webkitJavascriptResultCreate(webView, wkSerializedScriptValue),
reinterpret_cast<GDestroyNotify>(webkit_javascript_result_unref));
}
/**
* webkit_web_view_run_javascript:
* @web_view: a #WebKitWebView
* @script: the script to run
* @cancellable: (allow-none): a #GCancellable or %NULL to ignore
* @callback: (scope async): a #GAsyncReadyCallback to call when the script finished
* @user_data: (closure): the data to pass to callback function
*
* Asynchronously run @script in the context of the current page in @web_view. If
* WebKitWebSettings:enable-javascript is FALSE, this method will do nothing.
*
* When the operation is finished, @callback will be called. You can then call
* webkit_web_view_run_javascript_finish() to get the result of the operation.
*/
void webkit_web_view_run_javascript(WebKitWebView* webView, const gchar* script, GCancellable* cancellable, GAsyncReadyCallback callback, gpointer userData)
{
g_return_if_fail(WEBKIT_IS_WEB_VIEW(webView));
g_return_if_fail(script);
GTask* task = g_task_new(webView, cancellable, callback, userData);
getPage(webView)->runJavaScriptInMainFrame(String::fromUTF8(script), [task](WebSerializedScriptValue* serializedScriptValue, CallbackBase::Error) {
webkitWebViewRunJavaScriptCallback(serializedScriptValue, adoptGRef(task).get());
});
}
/**
* webkit_web_view_run_javascript_finish:
* @web_view: a #WebKitWebView
* @result: a #GAsyncResult
* @error: return location for error or %NULL to ignore
*
* Finish an asynchronous operation started with webkit_web_view_run_javascript().
*
* This is an example of using webkit_web_view_run_javascript() with a script returning
* a string:
*
* <informalexample><programlisting>
* static void
* web_view_javascript_finished (GObject *object,
* GAsyncResult *result,
* gpointer user_data)
* {
* WebKitJavascriptResult *js_result;
* JSValueRef value;
* JSGlobalContextRef context;
* GError *error = NULL;
*
* js_result = webkit_web_view_run_javascript_finish (WEBKIT_WEB_VIEW (object), result, &error);
* if (!js_result) {
* g_warning ("Error running javascript: %s", error->message);
* g_error_free (error);
* return;
* }
*
* context = webkit_javascript_result_get_global_context (js_result);
* value = webkit_javascript_result_get_value (js_result);
* if (JSValueIsString (context, value)) {
* JSStringRef js_str_value;
* gchar *str_value;
* gsize str_length;
*
* js_str_value = JSValueToStringCopy (context, value, NULL);
* str_length = JSStringGetMaximumUTF8CStringSize (js_str_value);
* str_value = (gchar *)g_malloc (str_length);
* JSStringGetUTF8CString (js_str_value, str_value, str_length);
* JSStringRelease (js_str_value);
* g_print ("Script result: %s\n", str_value);
* g_free (str_value);
* } else {
* g_warning ("Error running javascript: unexpected return value");
* }
* webkit_javascript_result_unref (js_result);
* }
*
* static void
* web_view_get_link_url (WebKitWebView *web_view,
* const gchar *link_id)
* {
* gchar *script;
*
* script = g_strdup_printf ("window.document.getElementById('%s').href;", link_id);
* webkit_web_view_run_javascript (web_view, script, NULL, web_view_javascript_finished, NULL);
* g_free (script);
* }
* </programlisting></informalexample>
*
* Returns: (transfer full): a #WebKitJavascriptResult with the result of the last executed statement in @script
* or %NULL in case of error
*/
WebKitJavascriptResult* webkit_web_view_run_javascript_finish(WebKitWebView* webView, GAsyncResult* result, GError** error)
{
g_return_val_if_fail(WEBKIT_IS_WEB_VIEW(webView), 0);
g_return_val_if_fail(g_task_is_valid(result, webView), 0);
return static_cast<WebKitJavascriptResult*>(g_task_propagate_pointer(G_TASK(result), error));
}
static void resourcesStreamReadCallback(GObject* object, GAsyncResult* result, gpointer userData)
{
GRefPtr<GTask> task = adoptGRef(G_TASK(userData));
GError* error = 0;
g_output_stream_splice_finish(G_OUTPUT_STREAM(object), result, &error);
if (error) {
g_task_return_error(task.get(), error);
return;
}
WebKitWebView* webView = WEBKIT_WEB_VIEW(g_task_get_source_object(task.get()));
gpointer outputStreamData = g_memory_output_stream_get_data(G_MEMORY_OUTPUT_STREAM(object));
getPage(webView)->runJavaScriptInMainFrame(String::fromUTF8(reinterpret_cast<const gchar*>(outputStreamData)),
[task](WebSerializedScriptValue* serializedScriptValue, CallbackBase::Error) {
webkitWebViewRunJavaScriptCallback(serializedScriptValue, task.get());
});
}
/**
* webkit_web_view_run_javascript_from_gresource:
* @web_view: a #WebKitWebView
* @resource: the location of the resource to load
* @cancellable: (allow-none): a #GCancellable or %NULL to ignore
* @callback: (scope async): a #GAsyncReadyCallback to call when the script finished
* @user_data: (closure): the data to pass to callback function
*
* Asynchronously run the script from @resource in the context of the
* current page in @web_view.
*
* When the operation is finished, @callback will be called. You can
* then call webkit_web_view_run_javascript_from_gresource_finish() to get the result
* of the operation.
*/
void webkit_web_view_run_javascript_from_gresource(WebKitWebView* webView, const gchar* resource, GCancellable* cancellable, GAsyncReadyCallback callback, gpointer userData)
{
g_return_if_fail(WEBKIT_IS_WEB_VIEW(webView));
g_return_if_fail(resource);
GError* error = 0;
GRefPtr<GInputStream> inputStream = adoptGRef(g_resources_open_stream(resource, G_RESOURCE_LOOKUP_FLAGS_NONE, &error));
if (error) {
g_task_report_error(webView, callback, userData, 0, error);
return;
}
GTask* task = g_task_new(webView, cancellable, callback, userData);
GRefPtr<GOutputStream> outputStream = adoptGRef(g_memory_output_stream_new(0, 0, fastRealloc, fastFree));
g_output_stream_splice_async(outputStream.get(), inputStream.get(),
static_cast<GOutputStreamSpliceFlags>(G_OUTPUT_STREAM_SPLICE_CLOSE_SOURCE | G_OUTPUT_STREAM_SPLICE_CLOSE_TARGET),
G_PRIORITY_DEFAULT, cancellable, resourcesStreamReadCallback, task);
}
/**
* webkit_web_view_run_javascript_from_gresource_finish:
* @web_view: a #WebKitWebView
* @result: a #GAsyncResult
* @error: return location for error or %NULL to ignore
*
* Finish an asynchronous operation started with webkit_web_view_run_javascript_from_gresource().
*
* Check webkit_web_view_run_javascript_finish() for a usage example.
*
* Returns: (transfer full): a #WebKitJavascriptResult with the result of the last executed statement in @script
* or %NULL in case of error
*/
WebKitJavascriptResult* webkit_web_view_run_javascript_from_gresource_finish(WebKitWebView* webView, GAsyncResult* result, GError** error)
{
g_return_val_if_fail(WEBKIT_IS_WEB_VIEW(webView), 0);
g_return_val_if_fail(g_task_is_valid(result, webView), 0);
return static_cast<WebKitJavascriptResult*>(g_task_propagate_pointer(G_TASK(result), error));
}
/**
* webkit_web_view_get_main_resource:
* @web_view: a #WebKitWebView
*
* Return the main resource of @web_view.
*
* Returns: (transfer none): the main #WebKitWebResource of the view
* or %NULL if nothing has been loaded.
*/
WebKitWebResource* webkit_web_view_get_main_resource(WebKitWebView* webView)
{
g_return_val_if_fail(WEBKIT_IS_WEB_VIEW(webView), 0);
return webView->priv->mainResource.get();
}
/**
* webkit_web_view_get_inspector:
* @web_view: a #WebKitWebView
*
* Get the #WebKitWebInspector associated to @web_view
*
* Returns: (transfer none): the #WebKitWebInspector of @web_view
*/
WebKitWebInspector* webkit_web_view_get_inspector(WebKitWebView* webView)
{
g_return_val_if_fail(WEBKIT_IS_WEB_VIEW(webView), 0);
if (!webView->priv->inspector)
webView->priv->inspector = adoptGRef(webkitWebInspectorCreate(getPage(webView)->inspector()));
return webView->priv->inspector.get();
}
/**
* webkit_web_view_can_show_mime_type:
* @web_view: a #WebKitWebView
* @mime_type: a MIME type
*
* Whether or not a MIME type can be displayed in @web_view.
*
* Returns: %TRUE if the MIME type @mime_type can be displayed or %FALSE otherwise
*/
gboolean webkit_web_view_can_show_mime_type(WebKitWebView* webView, const char* mimeType)
{
g_return_val_if_fail(WEBKIT_IS_WEB_VIEW(webView), FALSE);
g_return_val_if_fail(mimeType, FALSE);
return getPage(webView)->canShowMIMEType(String::fromUTF8(mimeType));
}
struct ViewSaveAsyncData {
RefPtr<API::Data> webData;
GRefPtr<GFile> file;
};
WEBKIT_DEFINE_ASYNC_DATA_STRUCT(ViewSaveAsyncData)
static void fileReplaceContentsCallback(GObject* object, GAsyncResult* result, gpointer data)
{
GRefPtr<GTask> task = adoptGRef(G_TASK(data));
GError* error = 0;
if (!g_file_replace_contents_finish(G_FILE(object), result, 0, &error)) {
g_task_return_error(task.get(), error);
return;
}
g_task_return_boolean(task.get(), TRUE);
}
static void getContentsAsMHTMLDataCallback(API::Data* wkData, GTask* taskPtr)
{
GRefPtr<GTask> task = adoptGRef(taskPtr);
if (g_task_return_error_if_cancelled(task.get()))
return;
ViewSaveAsyncData* data = static_cast<ViewSaveAsyncData*>(g_task_get_task_data(task.get()));
// We need to retain the data until the asyncronous process
// initiated by the user has finished completely.
data->webData = wkData;
// If we are saving to a file we need to write the data on disk before finishing.
if (g_task_get_source_tag(task.get()) == webkit_web_view_save_to_file) {
ASSERT(G_IS_FILE(data->file.get()));
GCancellable* cancellable = g_task_get_cancellable(task.get());
g_file_replace_contents_async(data->file.get(), reinterpret_cast<const gchar*>(data->webData->bytes()), data->webData->size(),
0, FALSE, G_FILE_CREATE_REPLACE_DESTINATION, cancellable, fileReplaceContentsCallback, task.leakRef());
return;
}
g_task_return_boolean(task.get(), TRUE);
}
/**
* webkit_web_view_save:
* @web_view: a #WebKitWebView
* @save_mode: the #WebKitSaveMode specifying how the web page should be saved.
* @cancellable: (allow-none): a #GCancellable or %NULL to ignore
* @callback: (scope async): a #GAsyncReadyCallback to call when the request is satisfied
* @user_data: (closure): the data to pass to callback function
*
* Asynchronously save the current web page associated to the
* #WebKitWebView into a self-contained format using the mode
* specified in @save_mode.
*
* When the operation is finished, @callback will be called. You can
* then call webkit_web_view_save_finish() to get the result of the
* operation.
*/
void webkit_web_view_save(WebKitWebView* webView, WebKitSaveMode saveMode, GCancellable* cancellable, GAsyncReadyCallback callback, gpointer userData)
{
g_return_if_fail(WEBKIT_IS_WEB_VIEW(webView));
// We only support MHTML at the moment.
g_return_if_fail(saveMode == WEBKIT_SAVE_MODE_MHTML);
GTask* task = g_task_new(webView, cancellable, callback, userData);
g_task_set_source_tag(task, reinterpret_cast<gpointer>(webkit_web_view_save));
g_task_set_task_data(task, createViewSaveAsyncData(), reinterpret_cast<GDestroyNotify>(destroyViewSaveAsyncData));
getPage(webView)->getContentsAsMHTMLData([task](API::Data* data, CallbackBase::Error) {
getContentsAsMHTMLDataCallback(data, task);
}, false);
}
/**
* webkit_web_view_save_finish:
* @web_view: a #WebKitWebView
* @result: a #GAsyncResult
* @error: return location for error or %NULL to ignore
*
* Finish an asynchronous operation started with webkit_web_view_save().
*
* Returns: (transfer full): a #GInputStream with the result of saving
* the current web page or %NULL in case of error.
*/
GInputStream* webkit_web_view_save_finish(WebKitWebView* webView, GAsyncResult* result, GError** error)
{
g_return_val_if_fail(WEBKIT_IS_WEB_VIEW(webView), 0);
g_return_val_if_fail(g_task_is_valid(result, webView), 0);
GTask* task = G_TASK(result);
if (!g_task_propagate_boolean(task, error))
return 0;
GInputStream* dataStream = g_memory_input_stream_new();
ViewSaveAsyncData* data = static_cast<ViewSaveAsyncData*>(g_task_get_task_data(task));
gsize length = data->webData->size();
if (length)
g_memory_input_stream_add_data(G_MEMORY_INPUT_STREAM(dataStream), g_memdup(data->webData->bytes(), length), length, g_free);
return dataStream;
}
/**
* webkit_web_view_save_to_file:
* @web_view: a #WebKitWebView
* @file: the #GFile where the current web page should be saved to.
* @save_mode: the #WebKitSaveMode specifying how the web page should be saved.
* @cancellable: (allow-none): a #GCancellable or %NULL to ignore
* @callback: (scope async): a #GAsyncReadyCallback to call when the request is satisfied
* @user_data: (closure): the data to pass to callback function
*
* Asynchronously save the current web page associated to the
* #WebKitWebView into a self-contained format using the mode
* specified in @save_mode and writing it to @file.
*
* When the operation is finished, @callback will be called. You can
* then call webkit_web_view_save_to_file_finish() to get the result of the
* operation.
*/
void webkit_web_view_save_to_file(WebKitWebView* webView, GFile* file, WebKitSaveMode saveMode, GCancellable* cancellable, GAsyncReadyCallback callback, gpointer userData)
{
g_return_if_fail(WEBKIT_IS_WEB_VIEW(webView));
g_return_if_fail(G_IS_FILE(file));
// We only support MHTML at the moment.
g_return_if_fail(saveMode == WEBKIT_SAVE_MODE_MHTML);
GTask* task = g_task_new(webView, cancellable, callback, userData);
g_task_set_source_tag(task, reinterpret_cast<gpointer>(webkit_web_view_save_to_file));
ViewSaveAsyncData* data = createViewSaveAsyncData();
data->file = file;
g_task_set_task_data(task, data, reinterpret_cast<GDestroyNotify>(destroyViewSaveAsyncData));
getPage(webView)->getContentsAsMHTMLData([task](API::Data* data, CallbackBase::Error) {
getContentsAsMHTMLDataCallback(data, task);
}, false);
}
/**
* webkit_web_view_save_to_file_finish:
* @web_view: a #WebKitWebView
* @result: a #GAsyncResult
* @error: return location for error or %NULL to ignore
*
* Finish an asynchronous operation started with webkit_web_view_save_to_file().
*
* Returns: %TRUE if the web page was successfully saved to a file or %FALSE otherwise.
*/
gboolean webkit_web_view_save_to_file_finish(WebKitWebView* webView, GAsyncResult* result, GError** error)
{
g_return_val_if_fail(WEBKIT_IS_WEB_VIEW(webView), FALSE);
g_return_val_if_fail(g_task_is_valid(result, webView), FALSE);
return g_task_propagate_boolean(G_TASK(result), error);
}
/**
* webkit_web_view_download_uri:
* @web_view: a #WebKitWebView
* @uri: the URI to download
*
* Requests downloading of the specified URI string for @web_view.
*
* Returns: (transfer full): a new #WebKitDownload representing the
* the download operation.
*/
WebKitDownload* webkit_web_view_download_uri(WebKitWebView* webView, const char* uri)
{
g_return_val_if_fail(WEBKIT_IS_WEB_VIEW(webView), 0);
g_return_val_if_fail(uri, 0);
WebKitDownload* download = webkitWebContextStartDownload(webView->priv->context, uri, getPage(webView));
webkitDownloadSetWebView(download, webView);
return download;
}
/**
* webkit_web_view_get_tls_info:
* @web_view: a #WebKitWebView
* @certificate: (out) (transfer none): return location for a #GTlsCertificate
* @errors: (out): return location for a #GTlsCertificateFlags the verification status of @certificate
*
* Retrieves the #GTlsCertificate associated with the @web_view connection,
* and the #GTlsCertificateFlags showing what problems, if any, have been found
* with that certificate.
* If the connection is not HTTPS, this function returns %FALSE.
* This function should be called after a response has been received from the
* server, so you can connect to #WebKitWebView::load-changed and call this function
* when it's emitted with %WEBKIT_LOAD_COMMITTED event.
*
* Returns: %TRUE if the @web_view connection uses HTTPS and a response has been received
* from the server, or %FALSE otherwise.
*/
gboolean webkit_web_view_get_tls_info(WebKitWebView* webView, GTlsCertificate** certificate, GTlsCertificateFlags* errors)
{
g_return_val_if_fail(WEBKIT_IS_WEB_VIEW(webView), FALSE);
WebFrameProxy* mainFrame = getPage(webView)->mainFrame();
if (!mainFrame)
return FALSE;
const WebCore::CertificateInfo& certificateInfo = mainFrame->certificateInfo()->certificateInfo();
if (certificate)
*certificate = certificateInfo.certificate();
if (errors)
*errors = certificateInfo.tlsErrors();
return !!certificateInfo.certificate();
}
void webKitWebViewDidReceiveSnapshot(WebKitWebView* webView, uint64_t callbackID, WebImage* webImage)
{
GRefPtr<GTask> task = webView->priv->snapshotResultsMap.take(callbackID);
if (g_task_return_error_if_cancelled(task.get()))
return;
if (!webImage) {
g_task_return_new_error(task.get(), WEBKIT_SNAPSHOT_ERROR, WEBKIT_SNAPSHOT_ERROR_FAILED_TO_CREATE,
_("There was an error creating the snapshot"));
return;
}
if (RefPtr<ShareableBitmap> image = webImage->bitmap())
g_task_return_pointer(task.get(), image->createCairoSurface().leakRef(), reinterpret_cast<GDestroyNotify>(cairo_surface_destroy));
else
g_task_return_pointer(task.get(), 0, 0);
}
static inline unsigned webKitSnapshotOptionsToSnapshotOptions(WebKitSnapshotOptions options)
{
SnapshotOptions snapshotOptions = 0;
if (!(options & WEBKIT_SNAPSHOT_OPTIONS_INCLUDE_SELECTION_HIGHLIGHTING))
snapshotOptions |= SnapshotOptionsExcludeSelectionHighlighting;
return snapshotOptions;
}
static inline SnapshotRegion toSnapshotRegion(WebKitSnapshotRegion region)
{
switch (region) {
case WEBKIT_SNAPSHOT_REGION_VISIBLE:
return SnapshotRegionVisible;
case WEBKIT_SNAPSHOT_REGION_FULL_DOCUMENT:
return SnapshotRegionFullDocument;
default:
ASSERT_NOT_REACHED();
return SnapshotRegionVisible;
}
}
static inline uint64_t generateSnapshotCallbackID()
{
static uint64_t uniqueCallbackID = 1;
return uniqueCallbackID++;
}
/**
* webkit_web_view_get_snapshot:
* @web_view: a #WebKitWebView
* @options: #WebKitSnapshotOptions for the snapshot
* @region: the #WebKitSnapshotRegion for this snapshot
* @cancellable: (allow-none): a #GCancellable
* @callback: (scope async): a #GAsyncReadyCallback
* @user_data: (closure): user data
*
* Asynchronously retrieves a snapshot of @web_view for @region.
* @options specifies how the snapshot should be rendered.
*
* When the operation is finished, @callback will be called. You must
* call webkit_web_view_get_snapshot_finish() to get the result of the
* operation.
*/
void webkit_web_view_get_snapshot(WebKitWebView* webView, WebKitSnapshotRegion region, WebKitSnapshotOptions options, GCancellable* cancellable, GAsyncReadyCallback callback, gpointer userData)
{
g_return_if_fail(WEBKIT_IS_WEB_VIEW(webView));
ImmutableDictionary::MapType message;
uint64_t callbackID = generateSnapshotCallbackID();
message.set(String::fromUTF8("SnapshotOptions"), API::UInt64::create(static_cast<uint64_t>(webKitSnapshotOptionsToSnapshotOptions(options))));
message.set(String::fromUTF8("SnapshotRegion"), API::UInt64::create(static_cast<uint64_t>(toSnapshotRegion(region))));
message.set(String::fromUTF8("CallbackID"), API::UInt64::create(callbackID));
webView->priv->snapshotResultsMap.set(callbackID, adoptGRef(g_task_new(webView, cancellable, callback, userData)));
getPage(webView)->postMessageToInjectedBundle(String::fromUTF8("GetSnapshot"), ImmutableDictionary::create(WTF::move(message)).get());
}
/**
* webkit_web_view_get_snapshot_finish:
* @web_view: a #WebKitWebView
* @result: a #GAsyncResult
* @error: return location for error or %NULL to ignore
*
* Finishes an asynchronous operation started with webkit_web_view_get_snapshot().
*
* Returns: (transfer full): a #cairo_surface_t with the retrieved snapshot or %NULL in error.
*/
cairo_surface_t* webkit_web_view_get_snapshot_finish(WebKitWebView* webView, GAsyncResult* result, GError** error)
{
g_return_val_if_fail(WEBKIT_IS_WEB_VIEW(webView), 0);
g_return_val_if_fail(g_task_is_valid(result, webView), 0);
return static_cast<cairo_surface_t*>(g_task_propagate_pointer(G_TASK(result), error));
}
void webkitWebViewWebProcessCrashed(WebKitWebView* webView)
{
gboolean returnValue;
g_signal_emit(webView, signals[WEB_PROCESS_CRASHED], 0, &returnValue);
}