Memory-managed wrapper type.

Type class for types which can be safely cast to WebView, for instance with toWebView.

Cast to WebView, for types for which this is known to be safe. For general casts, use castTo.

Asynchronously call body with arguments in the script world with name worldName of the main frame current context in webView. The arguments values must be one of the following types, or contain only the following GVariant types: number, string and dictionary. The result of the operation can be a Promise that will be properly passed to the callback. If worldName is Nothing, the default world is used. Any value that is not Nothing is a distin ct world. The sourceUri will be shown in exceptions and doesn't affect the behavior of the script. When not provided, the document URL is used.

Note that if Settings:enableJavascript is False, this method will do nothing. If you want to use this method but still prevent web content from executing its own JavaScript, then use Settings:enableJavascriptMarkup.

When the operation is finished, callback will be called. You can then call webViewCallAsyncJavascriptFunctionFinish to get the result of the operation.

This is an example that shows how to pass arguments to a JS function that returns a Promise that resolves with the passed argument:

c code

static void
web_view_javascript_finished (GObject      *object,
                              GAsyncResult *result,
                              gpointer      user_data)
{
    JSCValue               *value;
    GError                 *error = NULL;

    value = webkit_web_view_call_async_javascript_function_finish (WEBKIT_WEB_VIEW (object), result, &error);
    if (!value) {
        g_warning ("Error running javascript: %s", error->message);
        g_error_free (error);
        return;
    }

    if (jsc_value_is_number (value)) {
        gint32        int_value = jsc_value_to_string (value);
        JSCException *exception = jsc_context_get_exception (jsc_value_get_context (value));
        if (exception)
            g_warning ("Error running javascript: %s", jsc_exception_get_message (exception));
        else
            g_print ("Script result: %d\n", int_value);
        g_free (str_value);
    } else {
        g_warning ("Error running javascript: unexpected return value");
    }
    webkit_javascript_result_unref (js_result);
}

static void
web_view_evaluate_promise (WebKitWebView *web_view)
{
    GVariantDict dict;
    g_variant_dict_init (&dict, NULL);
    g_variant_dict_insert (&dict, "count", "u", 42);
    GVariant *args = g_variant_dict_end (&dict);
    const gchar *body = "return new Promise((resolve) => { resolve(count); });";
    webkit_web_view_call_async_javascript_function (web_view, body, -1, arguments, NULL, NULL, NULL, web_view_javascript_finished, NULL);
}

Since: 2.40

Finish an asynchronous operation started with webViewCallAsyncJavascriptFunction.

Since: 2.40

Asynchronously check if it is possible to execute the given editing command.

When the operation is finished, callback will be called. You can then call webViewCanExecuteEditingCommandFinish to get the result of the operation.

Finish an asynchronous operation started with webViewCanExecuteEditingCommand.

Determines whether webView has a previous history item.

Determines whether webView has a next history item.

Whether or not a MIME type can be displayed in webView.

Requests downloading of the specified URI string for webView.

Asynchronously evaluate script in the script world with name worldName of the main frame current context in webView. If worldName is Nothing, the default world is used. Any value that is not Nothing is a distinct world. The sourceUri will be shown in exceptions and doesn't affect the behavior of the script. When not provided, the document URL is used.

Note that if Settings:enableJavascript is False, this method will do nothing. If you want to use this method but still prevent web content from executing its own JavaScript, then use Settings:enableJavascriptMarkup.

When the operation is finished, callback will be called. You can then call webViewEvaluateJavascriptFinish to get the result of the operation.

This is an example of using webViewEvaluateJavascript with a script returning a string:

c code

static void
web_view_javascript_finished (GObject      *object,
                              GAsyncResult *result,
                              gpointer      user_data)
{
    JSCValue               *value;
    GError                 *error = NULL;

    value = webkit_web_view_evaluate_javascript_finish (WEBKIT_WEB_VIEW (object), result, &error);
    if (!value) {
        g_warning ("Error running javascript: %s", error->message);
        g_error_free (error);
        return;
    }

    if (jsc_value_is_string (value)) {
        gchar        *str_value = jsc_value_to_string (value);
        JSCException *exception = jsc_context_get_exception (jsc_value_get_context (value));
        if (exception)
            g_warning ("Error running javascript: %s", jsc_exception_get_message (exception));
        else
            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 = g_strdup_printf ("window.document.getElementById('%s').href;", link_id);
    webkit_web_view_evaluate_javascript (web_view, script, -1, NULL, NULL, NULL, web_view_javascript_finished, NULL);
    g_free (script);
}

Since: 2.40

Finish an asynchronous operation started with webViewEvaluateJavascript.

Since: 2.40

Request to execute the given command for webView.

You can use webViewCanExecuteEditingCommand to check whether it's possible to execute the command.

Request to execute the given command with argument for webView.

You can use webViewCanExecuteEditingCommand to check whether it's possible to execute the command.

Since: 2.10

Get the presentation type of WebView when created for automation.

Since: 2.28

Obtains the BackForwardList associated with the given WebView.

The BackForwardList is owned by the WebView.

Gets the color that is used to draw the webView background.

Gets the color that is used to draw the webView background before the actual contents are rendered. For more information see also webViewSetBackgroundColor

Since: 2.8

Get the camera capture state of a WebView.

Since: 2.34

Gets the web context of webView.

Returns the current custom character encoding name of webView.

Gets the configured default Content-Security-Policy.

Since: 2.38

Get the display capture state of a WebView.

Since: 2.34

Gets the web editor state of webView.

Since: 2.10

Gets the value of the WebView:estimatedLoadProgress property.

You can monitor the estimated progress of a load operation by connecting to the notifyestimatedLoadProgress signal of webView.

Returns favicon currently associated to webView.

Returns favicon currently associated to webView, if any. You can connect to notifyfavicon signal of webView to be notified when the favicon is available.

Gets the FindController.

Gets the FindController that will allow the caller to query the WebView for the text to look for.

Get the InputMethodContext currently in use by webView.

Get the InputMethodContext currently in use by webView, or Nothing if no input method is being used.

Since: 2.28

Get the WebInspector associated to webView

Gets the mute state of webView.

Since: 2.30

Get whether the current web process of a WebView is responsive.

Since: 2.34

Return the main resource of webView.

Get the microphone capture state of a WebView.

Since: 2.34

Get the NetworkSession associated to webView.

Since: 2.40

Get the identifier of the WebKitWebPage corresponding to the WebView

Gets the current session state of webView

Since: 2.12

Gets the Settings currently applied to webView.

If no other Settings have been explicitly applied to webView with webViewSetSettings, the default Settings will be returned. This method always returns a valid Settings object. To modify any of the webView settings, you can either create a new Settings object with settingsNew, setting the desired preferences, and then replace the existing webView settings with webViewSetSettings or get the existing webView settings and update it directly. Settings objects can be shared by multiple WebViews, so modifying the settings of a WebView would affect other WebViews using the same Settings.

Asynchronously retrieves a snapshot of webView for region.

options specifies how the snapshot should be rendered.

When the operation is finished, callback will be called. You must call webViewGetSnapshotFinish to get the result of the operation.

Finishes an asynchronous operation started with webViewGetSnapshot.

Gets the value of the WebView:title property.

You can connect to notifytitle signal of webView to be notified when the title has been received.

Retrieves the TlsCertificate associated with the main resource of webView.

Retrieves the TlsCertificate associated with the main resource of webView, and the TlsCertificateFlags 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 WebView::loadChanged and call this function when it's emitted with LoadEventCommitted event.

Note that this function provides no information about the security of the web page if the current TLSErrorsPolicy is TLSErrorsPolicyIgnore, as subresources of the page may be controlled by an attacker. This function may safely be used to determine the security status of the current page only if the current TLSErrorsPolicy is TLSErrorsPolicyFail, in which case subresources that fail certificate verification will be blocked.

Returns the current active URI of webView.

The active URI might change during a load operation:

<orderedlist> <listitem><para> When nothing has been loaded yet on webView the active URI is Nothing. </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 webViewLoadUri, the requested URI is the given one. </para></listitem> <listitem><para> If the load operation was started by webViewLoadHtml, the requested URI is "about:blank". </para></listitem> <listitem><para> If the load operation was started by webViewLoadAlternateHtml, the requested URI is content URI provided. </para></listitem> <listitem><para> If the load operation was started by webViewGoBack or webViewGoForward, the requested URI is the original URI of the previous/next item in the BackForwardList of webView. </para></listitem> <listitem><para> If the load operation was started by webViewGoToBackForwardListItem, the requested URI is the opriginal URI of the given BackForwardListItem. </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 WebView::loadChanged is emitted with LoadEventRedirected event, the active URI is already updated to the redirected URI. </para></listitem> <listitem><para> When the signal WebView::loadChanged is emitted with LoadEventCommitted 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 notifyuri signal of webView.

Gets the user content manager associated to webView.

Since: 2.6

Get the view's WebExtensionMode.

Since: 2.38

Gets the default website policies.

Gets the default website policies set on construction in the webView. These can be overridden on a per-origin basis via the WebView::decidePolicy signal handler.

See also policyDecisionUseWithPolicies.

Since: 2.30

Get the WindowProperties object.

Get the WindowProperties object containing the properties that the window containing webView should have.

Set the zoom level of webView.

Get the zoom level of webView, i.e. the factor by which the view contents are scaled with respect to their original size.

Loads the previous history item.

You can monitor the load operation by connecting to WebView::loadChanged signal.

Loads the next history item.

You can monitor the load operation by connecting to WebView::loadChanged signal.

Loads the specific history item listItem.

You can monitor the load operation by connecting to WebView::loadChanged signal.

Get whether a WebView was created with WebView:isControlledByAutomation property enabled.

Only WebViews controlled by automation can be used in an automation session.

Since: 2.18

Gets whether the user is allowed to edit the HTML document.

When webView is not editable an element in the HTML document can only be edited if the CONTENTEDITABLE attribute has been set on the element or one of its parent elements. By default a WebView is not editable.

Since: 2.8

Gets the value of the WebView:isLoading property.

You can monitor when a WebView is loading a page by connecting to notifyisLoading signal of webView. This is useful when you are interesting in knowing when the view is loading 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.

Gets the value of the WebView:isPlayingAudio property.

You can monitor when a page in a WebView is playing audio by connecting to the notifyisPlayingAudio signal of webView. This is useful when the application wants to provide visual feedback when a page is producing sound.

Since: 2.8

Load the given content string for the URI contentUri.

This allows clients to display page-loading errors in the WebView itself. When this method is called from WebView::loadFailed signal to show an error page, then the back-forward list is maintained appropriately. For everything else this method works the same way as webViewLoadHtml.

Load the specified bytes into webView using the given mimeType and encoding.

When mimeType is Nothing, it defaults to "text/html". When encoding is Nothing, it defaults to "UTF-8". When baseUri is Nothing, it defaults to "about:blank". You can monitor the load operation by connecting to WebView::loadChanged signal.

Since: 2.6

Load the given content string with the specified baseUri.

If baseUri is not Nothing, relative URLs in the content will be resolved against baseUri and absolute local paths must be children of the baseUri. For security reasons absolute local paths that are not children of baseUri will cause the web process to terminate. If you need to include URLs in content that are local paths in a different directory than baseUri you can build a data URI for them. When baseUri is Nothing, it defaults to "about:blank". The mime type of the document will be "text/html". You can monitor the load operation by connecting to WebView::loadChanged signal.

Load the specified plainText string into webView.

The mime type of document will be "text/plain". You can monitor the load operation by connecting to WebView::loadChanged signal.

Requests loading of the specified URIRequest.

You can monitor the load operation by connecting to WebView::loadChanged signal.

Requests loading of the specified URI string.

You can monitor the load operation by connecting to WebView::loadChanged signal.

Creates a new WebView with the default WebContext.

Creates a new WebView with the default WebContext and no UserContentManager associated with it. See also webkit_web_view_new_with_context(), webkit_web_view_new_with_user_content_manager(), and webkit_web_view_new_with_settings().

Reloads the current contents of webView.

See also webViewReloadBypassCache.

Reloads the current contents of webView without using any cached data.

Restore the webView session state from state

Since: 2.12

Asynchronously save the current web page.

Asynchronously save the current web page associated to the WebView into a self-contained format using the mode specified in saveMode.

When the operation is finished, callback will be called. You can then call webViewSaveFinish to get the result of the operation.

Finish an asynchronous operation started with webViewSave.

Asynchronously save the current web page.

Asynchronously save the current web page associated to the WebView into a self-contained format using the mode specified in saveMode and writing it to file.

When the operation is finished, callback will be called. You can then call webViewSaveToFileFinish to get the result of the operation.

Finish an asynchronous operation started with webViewSaveToFile.

Send message to the WebKitWebPage corresponding to webView.

If message is floating, it's consumed. If you don't expect any reply, or you simply want to ignore it, you can pass Nothing as callback. When the operation is finished, callback will be called. You can then call webViewSendMessageToPageFinish to get the message reply.

Since: 2.28

Finish an asynchronous operation started with webViewSendMessageToPage.

Since: 2.28

Sets the color that will be used to draw the webView background.

Sets the color that will be used to draw the webView background before the actual contents are rendered. Note that if the web page loaded in webView specifies a background color, it will take precedence over the rgba color. By default the webView background color is opaque white. Note that the parent window must have a RGBA visual and Widget:app-paintable property set to True for backgrounds colors to work.

c code

static void browser_window_set_background_color (BrowserWindow *window,
                                                 const GdkRGBA *rgba)
{
    WebKitWebView *web_view;
    GdkScreen *screen = gtk_window_get_screen (GTK_WINDOW (window));
    GdkVisual *rgba_visual = gdk_screen_get_rgba_visual (screen);

    if (!rgba_visual)
         return;

    gtk_widget_set_visual (GTK_WIDGET (window), rgba_visual);
    gtk_widget_set_app_paintable (GTK_WIDGET (window), TRUE);

    web_view = browser_window_get_web_view (window);
    webkit_web_view_set_background_color (web_view, rgba);
}

Since: 2.8

Set the camera capture state of a WebView.

If Settings:enable-mediastream is False, this method will have no visible effect. Once the state of the device has been set to MediaCaptureStateNone it cannot be changed anymore. The page can however request capture again using the mediaDevices API.

Since: 2.34

Sets the allowlist for CORS.

Sets the allowlist for which Cross-Origin Resource Sharing checks are disabled in webView. URI patterns must be of the form [protocol]://[host]/[path], each component may contain the wildcard character (*) to represent zero or more other characters. All three components are required and must not be omitted from the URI patterns.

Disabling CORS checks permits resources from other origins to load allowlisted resources. It does not permit the allowlisted resources to load resources from other origins.

If this function is called multiple times, only the allowlist set by the most recent call will be effective.

Since: 2.34

Sets the current custom character encoding override of webView.

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 Nothing removes the character encoding override.

Set the display capture state of a WebView.

If Settings:enable-mediastream is False, this method will have no visible effect. Once the state of the device has been set to MediaCaptureStateNone it cannot be changed anymore. The page can however request capture again using the mediaDevices API.

Since: 2.34

Sets whether the user is allowed to edit the HTML document.

If editable is True, webView allows the user to edit the HTML document. If editable is False, an element in webView's document can only be edited if the CONTENTEDITABLE attribute has been set on the element or one of its parent elements. By default a WebView is not editable.

Normally, a HTML document is not editable unless the elements within the document are editable. This function provides a way to make the contents of a WebView editable without altering the document or DOM structure.

Since: 2.8

Set the InputMethodContext to be used by webView.

Set the InputMethodContext to be used by webView, or Nothing to not use any input method. Note that the same InputMethodContext can't be set on more than one WebView at the same time.

Since: 2.28

Sets the mute state of webView.

Since: 2.30

Set the microphone capture state of a WebView.

If Settings:enable-mediastream is False, this method will have no visible effect. Once the state of the device has been set to MediaCaptureStateNone it cannot be changed anymore. The page can however request capture again using the mediaDevices API.

Since: 2.34

Sets the Settings to be applied to webView.

The existing Settings of webView will be replaced by settings. New settings are applied immediately on webView. The same Settings object can be shared by multiple WebViews.

Set the zoom level of webView.

Set the zoom level of webView, i.e. the factor by which the view contents are scaled with respect to their original size.

Stops any ongoing loading operation in webView.

This method does nothing if no content is being loaded. If there is a loading operation in progress, it will be cancelled and WebView::loadFailed signal will be emitted with NetworkErrorCancelled error.

Terminates the web process associated to webView.

When the web process gets terminated using this method, the WebView::webProcessTerminated signal is emitted with WebProcessTerminationReasonTerminatedByApi as the reason for termination.

Since: 2.34

Tries to close the webView.

This will fire the onbeforeunload event to ask the user for confirmation to close the page. If there isn't an onbeforeunload event handler or the user confirms to close the page, the WebView::close signal is emitted, otherwise nothing happens.

Since: 2.12

Construct a GValueConstruct with valid value for the “automation-presentation-type” property. This is rarely needed directly, but it is used by new.

Get the value of the “automation-presentation-type” property. When overloading is enabled, this is equivalent to

get webView #automationPresentationType

Construct a GValueConstruct with valid value for the “camera-capture-state” property. This is rarely needed directly, but it is used by new.

Get the value of the “camera-capture-state” property. When overloading is enabled, this is equivalent to

get webView #cameraCaptureState

Set the value of the “camera-capture-state” property. When overloading is enabled, this is equivalent to

set webView [ #cameraCaptureState := value ]

Construct a GValueConstruct with valid value for the “default-content-security-policy” property. This is rarely needed directly, but it is used by new.

Get the value of the “default-content-security-policy” property. When overloading is enabled, this is equivalent to

get webView #defaultContentSecurityPolicy

Construct a GValueConstruct with valid value for the “display-capture-state” property. This is rarely needed directly, but it is used by new.

Get the value of the “display-capture-state” property. When overloading is enabled, this is equivalent to

get webView #displayCaptureState

Set the value of the “display-capture-state” property. When overloading is enabled, this is equivalent to

set webView [ #displayCaptureState := value ]

Construct a GValueConstruct with valid value for the “editable” property. This is rarely needed directly, but it is used by new.

Get the value of the “editable” property. When overloading is enabled, this is equivalent to

get webView #editable

Set the value of the “editable” property. When overloading is enabled, this is equivalent to

set webView [ #editable := value ]

Get the value of the “estimated-load-progress” property. When overloading is enabled, this is equivalent to

get webView #estimatedLoadProgress

Get the value of the “favicon” property. When overloading is enabled, this is equivalent to

get webView #favicon

Construct a GValueConstruct with valid value for the “is-controlled-by-automation” property. This is rarely needed directly, but it is used by new.

Get the value of the “is-controlled-by-automation” property. When overloading is enabled, this is equivalent to

get webView #isControlledByAutomation

Get the value of the “is-loading” property. When overloading is enabled, this is equivalent to

get webView #isLoading

Construct a GValueConstruct with valid value for the “is-muted” property. This is rarely needed directly, but it is used by new.

Get the value of the “is-muted” property. When overloading is enabled, this is equivalent to

get webView #isMuted

Set the value of the “is-muted” property. When overloading is enabled, this is equivalent to

set webView [ #isMuted := value ]

Get the value of the “is-playing-audio” property. When overloading is enabled, this is equivalent to

get webView #isPlayingAudio

Get the value of the “is-web-process-responsive” property. When overloading is enabled, this is equivalent to

get webView #isWebProcessResponsive

Construct a GValueConstruct with valid value for the “microphone-capture-state” property. This is rarely needed directly, but it is used by new.

Get the value of the “microphone-capture-state” property. When overloading is enabled, this is equivalent to

get webView #microphoneCaptureState

Set the value of the “microphone-capture-state” property. When overloading is enabled, this is equivalent to

set webView [ #microphoneCaptureState := value ]

Construct a GValueConstruct with valid value for the “network-session” property. This is rarely needed directly, but it is used by new.

Get the value of the “network-session” property. When overloading is enabled, this is equivalent to

get webView #networkSession

Get the value of the “page-id” property. When overloading is enabled, this is equivalent to

get webView #pageId

Construct a GValueConstruct with valid value for the “related-view” property. This is rarely needed directly, but it is used by new.

Construct a GValueConstruct with valid value for the “settings” property. This is rarely needed directly, but it is used by new.

Set the value of the “settings” property. When overloading is enabled, this is equivalent to

set webView [ #settings := value ]

Get the value of the “title” property. When overloading is enabled, this is equivalent to

get webView #title

Get the value of the “uri” property. When overloading is enabled, this is equivalent to

get webView #uri

Construct a GValueConstruct with valid value for the “user-content-manager” property. This is rarely needed directly, but it is used by new.

Get the value of the “user-content-manager” property. When overloading is enabled, this is equivalent to

get webView #userContentManager

Construct a GValueConstruct with valid value for the “web-context” property. This is rarely needed directly, but it is used by new.

Get the value of the “web-context” property. When overloading is enabled, this is equivalent to

get webView #webContext

Construct a GValueConstruct with valid value for the “web-extension-mode” property. This is rarely needed directly, but it is used by new.

Get the value of the “web-extension-mode” property. When overloading is enabled, this is equivalent to

get webView #webExtensionMode

Construct a GValueConstruct with valid value for the “website-policies” property. This is rarely needed directly, but it is used by new.

Get the value of the “website-policies” property. When overloading is enabled, this is equivalent to

get webView #websitePolicies

Construct a GValueConstruct with valid value for the “zoom-level” property. This is rarely needed directly, but it is used by new.

Get the value of the “zoom-level” property. When overloading is enabled, this is equivalent to

get webView #zoomLevel

Set the value of the “zoom-level” property. When overloading is enabled, this is equivalent to

set webView [ #zoomLevel := value ]

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 AuthenticationRequest 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.

Since: 2.2

Connect a signal handler for the authenticate signal, to be run after the default handler. When overloading is enabled, this is equivalent to

after webView #authenticate callback

By default the object invoking the signal is not passed to the callback. If you need to access it, you can use the implit ?self parameter. Note that this requires activating the ImplicitParams GHC extension.

Connect a signal handler for the authenticate signal, to be run before the default handler. When overloading is enabled, this is equivalent to

on webView #authenticate callback

Emitted when closing a WebView is requested. This occurs when a call is made from JavaScript's <function>window.close</function> function or after trying to close the webView with webViewTryClose. It is the owner's responsibility to handle this signal to hide or destroy the WebView, if necessary.

Connect a signal handler for the close signal, to be run after the default handler. When overloading is enabled, this is equivalent to

after webView #close callback

By default the object invoking the signal is not passed to the callback. If you need to access it, you can use the implit ?self parameter. Note that this requires activating the ImplicitParams GHC extension.

Connect a signal handler for the close signal, to be run before the default handler. When overloading is enabled, this is equivalent to

on webView #close callback

Emitted 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 contextMenuPrepend, contextMenuAppend or contextMenuInsert to add new ContextMenuItems to contextMenu, contextMenuMoveItem to reorder existing items, or contextMenuRemove to remove an existing item. The signal handler should return False, and the menu represented by contextMenu 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 contextMenuRemoveAll, add your own items and return False so that the menu will be shown. You can also ignore the proposed ContextMenu, 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 contextMenu will be shown, if it return True the context menu will not be shown.

The proposed ContextMenu passed in contextMenu argument is only valid during the signal emission.

Connect a signal handler for the contextMenu signal, to be run after the default handler. When overloading is enabled, this is equivalent to

after webView #contextMenu callback

By default the object invoking the signal is not passed to the callback. If you need to access it, you can use the implit ?self parameter. Note that this requires activating the ImplicitParams GHC extension.

Connect a signal handler for the contextMenu signal, to be run before the default handler. When overloading is enabled, this is equivalent to

on webView #contextMenu callback

Emitted after WebView::contextMenu signal, if the context menu is shown, to notify that the context menu is dismissed.

Connect a signal handler for the contextMenuDismissed signal, to be run after the default handler. When overloading is enabled, this is equivalent to

after webView #contextMenuDismissed callback

By default the object invoking the signal is not passed to the callback. If you need to access it, you can use the implit ?self parameter. Note that this requires activating the ImplicitParams GHC extension.

Connect a signal handler for the contextMenuDismissed signal, to be run before the default handler. When overloading is enabled, this is equivalent to

on webView #contextMenuDismissed callback

Emitted when the creation of a new WebView is requested. If this signal is handled the signal handler should return the newly created WebView.

The NavigationAction parameter contains information about the navigation action that triggered this signal.

The new WebView must be related to webView, see WebView:relatedView for more details.

The new WebView should not be displayed to the user until the WebView::readyToShow signal is emitted.

Connect a signal handler for the create signal, to be run after the default handler. When overloading is enabled, this is equivalent to

after webView #create callback

By default the object invoking the signal is not passed to the callback. If you need to access it, you can use the implit ?self parameter. Note that this requires activating the ImplicitParams GHC extension.

Connect a signal handler for the create signal, to be run before the default handler. When overloading is enabled, this is equivalent to

on webView #create callback

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 NavigationPolicyDecision passed in the decision argument is a generic type, but should be casted to a more specific type when making the decision. For example:

c code

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;
}

It is possible to make policy decision asynchronously, by simply calling objectRef on the decision argument and returning True to block the default signal handler. If the last reference is removed on a PolicyDecision and no decision has been made explicitly, policyDecisionUse will be the default policy decision. The default signal handler will simply call policyDecisionUse. Only the first policy decision chosen for a given PolicyDecision will have any affect.

Connect a signal handler for the decidePolicy signal, to be run after the default handler. When overloading is enabled, this is equivalent to

after webView #decidePolicy callback

By default the object invoking the signal is not passed to the callback. If you need to access it, you can use the implit ?self parameter. Note that this requires activating the ImplicitParams GHC extension.

Connect a signal handler for the decidePolicy signal, to be run before the default handler. When overloading is enabled, this is equivalent to

on webView #decidePolicy callback

Emitted when JavaScript code calls <function>element.webkitRequestFullScreen</function>. If the signal is not handled the WebView 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).

Connect a signal handler for the enterFullscreen signal, to be run after the default handler. When overloading is enabled, this is equivalent to

after webView #enterFullscreen callback

By default the object invoking the signal is not passed to the callback. If you need to access it, you can use the implit ?self parameter. Note that this requires activating the ImplicitParams GHC extension.

Connect a signal handler for the enterFullscreen signal, to be run before the default handler. When overloading is enabled, this is equivalent to

on webView #enterFullscreen callback

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 InsecureContentEvent).

Connect a signal handler for the insecureContentDetected signal, to be run after the default handler. When overloading is enabled, this is equivalent to

after webView #insecureContentDetected callback

By default the object invoking the signal is not passed to the callback. If you need to access it, you can use the implit ?self parameter. Note that this requires activating the ImplicitParams GHC extension.

Connect a signal handler for the insecureContentDetected signal, to be run before the default handler. When overloading is enabled, this is equivalent to

on webView #insecureContentDetected callback

Emitted when the WebView 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 WebView::enterFullscreen stage for instance.

Connect a signal handler for the leaveFullscreen signal, to be run after the default handler. When overloading is enabled, this is equivalent to

after webView #leaveFullscreen callback

By default the object invoking the signal is not passed to the callback. If you need to access it, you can use the implit ?self parameter. Note that this requires activating the ImplicitParams GHC extension.

Connect a signal handler for the leaveFullscreen signal, to be run before the default handler. When overloading is enabled, this is equivalent to

on webView #leaveFullscreen callback

Emitted when a load operation in webView changes. The signal is always emitted with LoadEventStarted when a new load request is made and LoadEventFinished when the load finishes successfully or due to an error. When the ongoing load operation fails WebView::loadFailed signal is emitted before WebView::loadChanged is emitted with LoadEventFinished. If a redirection is received from the server, this signal is emitted with LoadEventRedirected after the initial emission with LoadEventStarted and before LoadEventCommitted. When the page content starts arriving the signal is emitted with LoadEventCommitted event.

You can handle this signal and use a switch to track any ongoing load operation.

c code

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;
    }
}

Connect a signal handler for the loadChanged signal, to be run after the default handler. When overloading is enabled, this is equivalent to

after webView #loadChanged callback

By default the object invoking the signal is not passed to the callback. If you need to access it, you can use the implit ?self parameter. Note that this requires activating the ImplicitParams GHC extension.

Connect a signal handler for the loadChanged signal, to be run before the default handler. When overloading is enabled, this is equivalent to

on webView #loadChanged callback

Emitted when an error occurs during a load operation. If the error happened when starting to load data for a page loadEvent will be LoadEventStarted. If it happened while loading a committed data source loadEvent will be LoadEventCommitted. Since a load error causes the load operation to finish, the signal WebKitWebViewloadChanged will always be emitted with LoadEventFinished 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.

Connect a signal handler for the loadFailed signal, to be run after the default handler. When overloading is enabled, this is equivalent to

after webView #loadFailed callback

By default the object invoking the signal is not passed to the callback. If you need to access it, you can use the implit ?self parameter. Note that this requires activating the ImplicitParams GHC extension.

Connect a signal handler for the loadFailed signal, to be run before the default handler. When overloading is enabled, this is equivalent to

on webView #loadFailed callback

Emitted when a TLS error occurs during a load operation. To allow an exception for this certificate and the host of failingUri use webkit_web_context_allow_tls_certificate_for_host().

To handle this signal asynchronously you should call objectRef on certificate and return True.

If False is returned, WebView::loadFailed will be emitted. The load will finish regardless of the returned value.

Since: 2.6

Connect a signal handler for the loadFailedWithTlsErrors signal, to be run after the default handler. When overloading is enabled, this is equivalent to

after webView #loadFailedWithTlsErrors callback

By default the object invoking the signal is not passed to the callback. If you need to access it, you can use the implit ?self parameter. Note that this requires activating the ImplicitParams GHC extension.

Connect a signal handler for the loadFailedWithTlsErrors signal, to be run before the default handler. When overloading is enabled, this is equivalent to

on webView #loadFailedWithTlsErrors callback

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 hitTestResult argument. The modifiers argument is a bitmask of ModifierType 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 hitTestResult.

Connect a signal handler for the mouseTargetChanged signal, to be run after the default handler. When overloading is enabled, this is equivalent to

after webView #mouseTargetChanged callback

By default the object invoking the signal is not passed to the callback. If you need to access it, you can use the implit ?self parameter. Note that this requires activating the ImplicitParams GHC extension.