Struct WebView

Source

pub struct WebView { /* private fields */ }

Expand description

The central class of the WPE WebKit and WebKitGTK APIs.

WebView is the central class of the WPE WebKit and WebKitGTK APIs. It is responsible for managing the drawing of the content and forwarding of events. You can load any URI into the WebView or a data string. With Settings you can control various aspects of the rendering and loading of the content.

Note that in WebKitGTK, WebView is scrollable by itself, so you don’t need to embed it in a GtkScrolledWindow.

§Properties

§`automation-presentation-type`

The AutomationBrowsingContextPresentation of WebView. This should only be used when creating a new WebView as a response to create-web-view signal request. If the new WebView was added to a new tab of current browsing context window AutomationBrowsingContextPresentation::Tab should be used.

Readable | Writeable | Construct Only

§`camera-capture-state`

Capture state of the camera device. Whenever the user grants a media-request sent by the web page, requesting video capture capabilities (navigator.mediaDevices.getUserMedia({video: true})) this property will be set to MediaCaptureState::Active.

The application can monitor this property and provide a visual indicator allowing to optionally deactivate or mute the capture device by setting this property respectively to MediaCaptureState::None or MediaCaptureState::Muted.

If the capture state of the device is set to MediaCaptureState::None the web-page can still re-request the permission to the user. Permission desision caching is left to the application.

Readable | Writeable

§`default-content-security-policy`

The default Content-Security-Policy used by the webview as if it were set by an HTTP header.

This applies to all content loaded including through navigation or via the various webkit_web_view_load_* APIs. However do note that many WebKit APIs bypass Content-Security-Policy in general such as UserContentManager and webkit_web_view_run_javascript().

Policies are additive so if a website sets its own policy it still applies on top of the policy set here.

Readable | Writeable | Construct Only

§`display-capture-state`

Capture state of the display device. Whenever the user grants a media-request sent by the web page, requesting screencasting capabilities (navigator.mediaDevices.getDisplayMedia() this property will be set to [MediaCaptureState::Active`]crate::MediaCaptureState::Active.

If the capture state of the device is set to MediaCaptureState::None the web-page can still re-request the permission to the user. Permission desision caching is left to the application.

Readable | Writeable

§`editable`

Whether the pages loaded inside WebView are editable. For more information see WebViewExt::set_editable().

Readable | Writeable

§`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.

Readable

§`favicon`

The favicon currently associated to the WebView. See WebViewExt::favicon() for more details.

Readable

§`is-controlled-by-automation`

Whether the WebView is controlled by automation tools (e.g. WebDriver, Selenium). This is required for views returned as a response to create-web-view signal, alongside any view you want to control during an automation session.

As a G_PARAM_CONSTRUCT_ONLY, you need to set it during construction and it can’t be modified.

If related-view is also passed during construction, is-controlled-by-automation ignores its own parameter and inherits directly from the related view is-controlled-by-automation property. This is the recommended way when creating new views as a response to the create signal. For example, as response to JavaScript window.open() calls during an automation session.

Readable | Writeable | Construct Only

§`is-immersive-mode-enabled`

Whether the WebView is in immersive mode.

Readable

§`is-loading`

Whether the WebView is currently loading a page. This property becomes true as soon as a new load operation is requested and before the load-changed signal is emitted with LoadEvent::Started and at that point the active URI is the requested one. When the load operation finishes the property is set to false before load-changed is emitted with LoadEvent::Finished.

Readable

§`is-muted`

Whether the WebView audio is muted. When true, audio is silenced. It may still be playing, i.e. is-playing-audio may be true.

Readable | Writeable

§`is-playing-audio`

Whether the WebView is currently playing audio from a page. This property becomes true as soon as web content starts playing any kind of audio. When a page is no longer playing any kind of sound, the property is set back to false.

Readable

§`is-web-process-responsive`

Whether the web process currently associated to the WebView is responsive.

Readable

§`microphone-capture-state`

Capture state of the microphone device. Whenever the user grants a media-request sent by the web page, requesting audio capture capabilities (navigator.mediaDevices.getUserMedia({audio: true})) this property will be set to MediaCaptureState::Active.

If the capture state of the device is set to MediaCaptureState::None the web-page can still re-request the permission to the user. Permission desision caching is left to the application.

Readable | Writeable

§`network-session`

The NetworkSession of the view

Readable | Writeable | Construct Only

§`page-id`

The identifier of the WebKitWebPage corresponding to the WebView.

Readable

§`related-view`

The related WebView used when creating the view to share the same web process and network session. This property is not readable because the related web view is only valid during the object construction.

Writeable | Construct Only

§`settings`

The Settings of the view.

Writeable | Construct

§`theme-color`

The theme color of the WebView’s current page.

Readable

§`title`

The main frame document title of this WebView. If the title has not been received yet, it will be None.

Readable

§`uri`

The current active URI of the WebView. See WebViewExt::uri() for more details.

Readable

§`user-content-manager`

The UserContentManager of the view.

Readable | Writeable | Construct Only

§`web-context`

The WebContext of the view.

Readable | Writeable | Construct Only

§`web-extension-mode`

This configures web_view to treat the content as a WebExtension.

Note that this refers to the web standard WebExtensions and not WebKitWebExtensions.

In practice this limits the Content-Security-Policies that are allowed to be set. Some details can be found in Chrome’s documentation.

Readable | Writeable | Construct Only

§`website-policies`

The WebsitePolicies for the view.

Readable | Writeable | Construct Only

§`zoom-level`

The zoom level of the WebView content. See WebViewExt::set_zoom_level() for more details.

Readable | Writeable

Widget

§`can-focus`

Whether the widget or any of its descendents can accept the input focus.

This property is meant to be set by widget implementations, typically in their instance init function.

Readable | Writeable

§`can-target`

Whether the widget can receive pointer events.

Readable | Writeable

§`css-classes`

A list of css classes applied to this widget.

Readable | Writeable

§`css-name`

The name of this widget in the CSS tree.

This property is meant to be set by widget implementations, typically in their instance init function.

Readable | Writeable | Construct Only

§`cursor`

The cursor used by widget.

Readable | Writeable

§`focus-on-click`

Whether the widget should grab focus when it is clicked with the mouse.

This property is only relevant for widgets that can take focus.

Readable | Writeable

§`focusable`

Whether this widget itself will accept the input focus.

Readable | Writeable

§`halign`

How to distribute horizontal space if widget gets extra space.

Readable | Writeable

§`has-default`

Whether the widget is the default widget.

Readable

§`has-focus`

Whether the widget has the input focus.

Readable

§`has-tooltip`

Enables or disables the emission of the [signalGtk::query-tooltip] signal on widget.

A true value indicates that widget can have a tooltip, in this case the widget will be queried using [signalGtk::query-tooltip] to determine whether it will provide a tooltip or not.

Readable | Writeable

§`height-request`

Overrides for height request of the widget.

If this is -1, the natural request will be used.

Readable | Writeable

§`hexpand`

Whether to expand horizontally.

Readable | Writeable

§`hexpand-set`

Whether to use the hexpand property.

Readable | Writeable

§`layout-manager`

The [classGtk] instance to use to compute the preferred size of the widget, and allocate its children.

This property is meant to be set by widget implementations, typically in their instance init function.

Readable | Writeable

§`limit-events`

Makes this widget act like a modal dialog, with respect to event delivery.

Global event controllers will not handle events with targets inside the widget, unless they are set up to ignore propagation limits. See [methodGtk.set_propagation_limit].

Readable | Writeable

§`margin-bottom`

Margin on bottom side of widget.

This property adds margin outside of the widget’s normal size request, the margin will be added in addition to the size from [methodGtk.set_size_request] for example.

Readable | Writeable

§`margin-end`

Margin on end of widget, horizontally.

This property supports left-to-right and right-to-left text directions.

This property adds margin outside of the widget’s normal size request, the margin will be added in addition to the size from [methodGtk.set_size_request] for example.

Readable | Writeable

§`margin-start`

Margin on start of widget, horizontally.

This property supports left-to-right and right-to-left text directions.

This property adds margin outside of the widget’s normal size request, the margin will be added in addition to the size from [methodGtk.set_size_request] for example.

Readable | Writeable

§`margin-top`

Margin on top side of widget.

This property adds margin outside of the widget’s normal size request, the margin will be added in addition to the size from [methodGtk.set_size_request] for example.

Readable | Writeable

§`name`

The name of the widget.

Readable | Writeable

§`opacity`

The requested opacity of the widget.

Readable | Writeable

§`overflow`

How content outside the widget’s content area is treated.

This property is meant to be set by widget implementations, typically in their instance init function.

Readable | Writeable

§`parent`

The parent widget of this widget.

Readable

§`receives-default`

Whether the widget will receive the default action when it is focused.

Readable | Writeable

§`root`

The GtkRoot widget of the widget tree containing this widget.

This will be NULL if the widget is not contained in a root widget.

Readable

§`scale-factor`

The scale factor of the widget.

Readable

§`sensitive`

Whether the widget responds to input.

Readable | Writeable

§`tooltip-markup`

Sets the text of tooltip to be the given string, which is marked up with Pango markup.

Also see [methodGtk.set_markup].

This is a convenience property which will take care of getting the tooltip shown if the given string is not NULL: [propertyGtk:has-tooltip] will automatically be set to true and there will be taken care of [signalGtk::query-tooltip] in the default signal handler.

Note that if both [propertyGtk:tooltip-text] and [propertyGtk:tooltip-markup] are set, the last one wins.

Readable | Writeable

§`tooltip-text`

Sets the text of tooltip to be the given string.

Also see [methodGtk.set_text].

Note that if both [propertyGtk:tooltip-text] and [propertyGtk:tooltip-markup] are set, the last one wins.

Readable | Writeable

§`valign`

How to distribute vertical space if widget gets extra space.

Readable | Writeable

§`vexpand`

Whether to expand vertically.

Readable | Writeable

§`vexpand-set`

Whether to use the vexpand property.

Readable | Writeable

§`visible`

Whether the widget is visible.

Readable | Writeable

§`width-request`

Overrides for width request of the widget.

If this is -1, the natural request will be used.

Readable | Writeable

Accessible

§`accessible-role`

The accessible role of the given gtk::Accessible implementation.

The accessible role cannot be changed once set.

Readable | Writeable

§Signals

§`authenticate`

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.

§`close`

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 web_view with WebViewExt::try_close(). It is the owner’s responsibility to handle this signal to hide or destroy the WebView, if necessary.

§`context-menu`

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 ContextMenu::prepend(), ContextMenu::append() or ContextMenu::insert() to add new ContextMenuItems to context_menu, ContextMenu::move_item() to reorder existing items, or ContextMenu::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 ContextMenu::remove_all(), 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 context_menu will be shown, if it return true the context menu will not be shown.

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

§`context-menu-dismissed`

Emitted after context-menu signal, if the context menu is shown, to notify that the context menu is dismissed.

§`create`

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 web_view, see related-view for more details.

The new WebView should not be displayed to the user until the ready-to-show signal is emitted.

For creating views as response to automation tools requests, see the create-web-view signal.

§`decide-policy`

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:

⚠️ The following code is in c ⚠️

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 g_object_ref() 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, PolicyDecisionExt::use_() will be the default policy decision. The default signal handler will simply call PolicyDecisionExt::use_(). Only the first policy decision chosen for a given PolicyDecision will have any affect.

§`enter-fullscreen`

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

§`insecure-content-detected`

Prior to 2.46, this signal was emitted when insecure content was loaded in a secure content. Since 2.46, this signal is generally no longer emitted.

§`leave-fullscreen`

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 enter-fullscreen stage for instance.

§`load-changed`

Emitted when a load operation in web_view changes. The signal is always emitted with LoadEvent::Started when a new load request is made and LoadEvent::Finished when the load finishes successfully or due to an error. When the ongoing load operation fails load-failed signal is emitted before load-changed is emitted with LoadEvent::Finished. If a redirection is received from the server, this signal is emitted with LoadEvent::Redirected after the initial emission with LoadEvent::Started and before LoadEvent::Committed. When the page content starts arriving the signal is emitted with LoadEvent::Committed event.

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

⚠️ The following code is in c ⚠️

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

§`load-failed`

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 LoadEvent::Started. If it happened while loading a committed data source load_event will be LoadEvent::Committed. Since a load error causes the load operation to finish, the signal WebKitWebView::load-changed will always be emitted with LoadEvent::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.

§`load-failed-with-tls-errors`

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

To handle this signal asynchronously you should call g_object_ref() on certificate and return true.

If false is returned, load-failed will be emitted. The load will finish regardless of the returned value.

§`mouse-target-changed`

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.

§`permission-request`

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:

⚠️ The following code is in c ⚠️

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

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 PermissionRequest and the request has not been handled, PermissionRequestExt::deny() will be the default action.

If the signal is not handled, the request will be completed automatically by the specific PermissionRequest that could allow or deny it. Check the documentation of classes implementing PermissionRequest interface to know their default action.

§`print`

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 PrintOperation::set_print_settings() and PrintOperation::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.

§`query-permission-state`

This signal allows the User-Agent to respond to permission requests for powerful features, as specified by the Permissions W3C Specification. You can reply to the query using PermissionStateQuery::finish().

You can handle the query asynchronously by calling webkit_permission_state_query_ref() on query and returning true. If the last reference of query is removed and the query has not been handled, the query result will be set to WEBKIT_QUERY_PERMISSION_PROMPT.

§`ready-to-show`

Emitted after create on the newly created WebView 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 WindowProperties of web_view. See also WebViewExt::window_properties().

§`resource-load-started`

Emitted when a new resource is going to be loaded. The request parameter contains the URIRequest that will be sent to the server. You can monitor the load operation by connecting to the different signals of resource.

§`run-as-modal`

Emitted after ready-to-show on the newly created WebView 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 main loop will be run to block user interaction in the parent WebView until the new dialog is closed.

§`run-color-chooser`

This signal is emitted when the user interacts with a HTML element, requesting from WebKit to show a dialog to select a color. To let the application know the details of the color chooser, as well as to allow the client application to either cancel the request or perform an actual color selection, the signal will pass an instance of the ColorChooserRequest in the request argument.

It is possible to handle this request asynchronously by increasing the reference count of the request.

The default signal handler will asynchronously run a regular GtkColorChooser for the user to interact with.

§`run-file-chooser`

This signal is emitted when the user interacts with a 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 FileChooserRequest in the request argument.

The default signal handler will asynchronously run a regular GtkFileChooserDialog for the user to interact with.

§`script-dialog`

Emitted when JavaScript code calls <function>window.alert</function>, <function>window.confirm</function> or <function>window.prompt</function>, or when <function>onbeforeunload</function> event is fired. 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> ScriptDialogType::Alert: message dialog with a single Close button. </para>``</listitem> <listitem>``<para> ScriptDialogType::Confirm: message dialog with OK and Cancel buttons. </para>``</listitem> <listitem>``<para> ScriptDialogType::Prompt: message dialog with OK and Cancel buttons and a text entry with the default text. </para>``</listitem> <listitem>``<para> ScriptDialogType::BeforeUnloadConfirm: message dialog with Stay and Leave buttons. </para>``</listitem> </itemizedlist>

It is possible to handle the script dialog request asynchronously, by simply caling webkit_script_dialog_ref() on the dialog argument and calling ScriptDialog::close() when done. If the last reference is removed on a ScriptDialog and the dialog has not been closed, ScriptDialog::close() will be called.

§`show-notification`

This signal is emitted when a notification should be presented to the user. The notification is kept alive until either: 1) the web page cancels it or 2) a navigation happens.

The default handler will emit a notification using libnotify, if built with support for it.

§`show-option-menu`

This signal is emitted when a select element in web_view needs to display a dropdown menu. This signal can be used to show a custom menu, using menu to get the details of all items that should be displayed. The area of the element in the WebView is given as rectangle parameter, it can be used to position the menu. To handle this signal asynchronously you should keep a ref of the menu.

The default signal handler will pop up a GtkMenu.

§`submit-form`

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 FormSubmissionRequest::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 FormSubmissionRequest::submit() when done to continue with the form submission. If the last reference is removed on a FormSubmissionRequest and the form has not been submitted, FormSubmissionRequest::submit() will be called.

§`user-message-received`

This signal is emitted when a UserMessage is received from the WebKitWebPage corresponding to web_view. You can reply to the message using UserMessage::send_reply().

You can handle the user message asynchronously by calling g_object_ref() on message and returning true. If the last reference of message is removed and the message has not been replied to, the operation in the WebKitWebPage will finish with error UserMessageError::Message.

§`web-process-terminated`

This signal is emitted when the web process terminates abnormally due to reason.

Widget

§`destroy`

Signals that all holders of a reference to the widget should release the reference that they hold.

May result in finalization of the widget if all references are released.

This signal is not suitable for saving widget state.

§`direction-changed`

Emitted when the text direction of a widget changes.

§`hide`

Emitted when widget is hidden.

§`keynav-failed`

Emitted if keyboard navigation fails.

See [methodGtk.keynav_failed] for details.

§`map`

Emitted when widget is going to be mapped.

A widget is mapped when the widget is visible (which is controlled with [propertyGtk:visible]) and all its parents up to the toplevel widget are also visible.

The ::map signal can be used to determine whether a widget will be drawn, for instance it can resume an animation that was stopped during the emission of [signalGtk::unmap].

§`mnemonic-activate`

Emitted when a widget is activated via a mnemonic.

The default handler for this signal activates widget if group_cycling is false, or just makes widget grab focus if group_cycling is true.

§`move-focus`

Emitted when the focus is moved.

The ::move-focus signal is a keybinding signal.

The default bindings for this signal are <kbd>Tab</kbd> to move forward, and <kbd>Shift</kbd>+<kbd>Tab</kbd> to move backward.

Action

§`query-tooltip`

Emitted when the widget’s tooltip is about to be shown.

This happens when the [propertyGtk:has-tooltip] property is true and the hover timeout has expired with the cursor hovering above widget; or emitted when widget got focus in keyboard mode.

Using the given coordinates, the signal handler should determine whether a tooltip should be shown for widget. If this is the case true should be returned, false otherwise. Note that if keyboard_mode is true, the values of x and y are undefined and should not be used.

The signal handler is free to manipulate tooltip with the therefore destined function calls.

§`realize`

Emitted when widget is associated with a GdkSurface.

This means that [methodGtk.realize] has been called or the widget has been mapped (that is, it is going to be drawn).

§`show`

Emitted when widget is shown.

§`state-flags-changed`

Emitted when the widget state changes.

See [methodGtk.get_state_flags].

§`unmap`

Emitted when widget is going to be unmapped.

A widget is unmapped when either it or any of its parents up to the toplevel widget have been set as hidden.

As ::unmap indicates that a widget will not be shown any longer, it can be used to, for example, stop an animation on the widget.

§`unrealize`

Emitted when the GdkSurface associated with widget is destroyed.

This means that [methodGtk.unrealize] has been called or the widget has been unmapped (that is, it is going to be hidden).

§Implements

WebViewExt, [WebViewBaseExt][trait@crate::prelude::WebViewBaseExt], gtk::prelude::WidgetExt, gtk::prelude::AccessibleExt, gtk::prelude::BuildableExt, gtk::prelude::ConstraintTargetExt

GLib type: GObject with reference counted clone semantics.

Struct WebView Copy item path

§Properties

§automation-presentation-type

§camera-capture-state

§default-content-security-policy

§display-capture-state

§editable

§estimated-load-progress

§favicon

§is-controlled-by-automation

§is-immersive-mode-enabled

§is-loading

§is-muted

§is-playing-audio

§is-web-process-responsive

§microphone-capture-state

§network-session

§page-id

§related-view

§settings

§theme-color

§title

§uri

§user-content-manager

§web-context

§web-extension-mode

§website-policies

§zoom-level

Widget

§can-focus

§can-target

§css-classes

§css-name

§cursor

§focus-on-click

§focusable

§halign

§has-default

§has-focus

§has-tooltip

§height-request

§hexpand

§hexpand-set

§layout-manager

§limit-events

§margin-bottom

§margin-end

§margin-start

§margin-top

§name

§opacity

§overflow

§parent

§receives-default

§root

§scale-factor

§sensitive

§tooltip-markup

§tooltip-text

§valign

§vexpand

§vexpand-set

§visible

§width-request

Accessible

§accessible-role

§Signals

§authenticate

§close

§context-menu

§context-menu-dismissed

§create

§decide-policy

§enter-fullscreen

§insecure-content-detected

§leave-fullscreen

§load-changed

§load-failed

§load-failed-with-tls-errors

§mouse-target-changed

Struct WebView

§`automation-presentation-type`

§`camera-capture-state`

§`default-content-security-policy`

§`display-capture-state`

§`editable`

§`estimated-load-progress`

§`favicon`

§`is-controlled-by-automation`

§`is-immersive-mode-enabled`

§`is-loading`

§`is-muted`

§`is-playing-audio`

§`is-web-process-responsive`

§`microphone-capture-state`

§`network-session`

§`page-id`

§`related-view`

§`settings`

§`theme-color`

§`title`

§`uri`

§`user-content-manager`

§`web-context`

§`web-extension-mode`

§`website-policies`

§`zoom-level`

§`can-focus`

§`can-target`

§`css-classes`

§`css-name`

§`cursor`

§`focus-on-click`

§`focusable`

§`halign`

§`has-default`

§`has-focus`

§`has-tooltip`

§`height-request`

§`hexpand`

§`hexpand-set`

§`layout-manager`

§`limit-events`

§`margin-bottom`

§`margin-end`

§`margin-start`

§`margin-top`

§`name`

§`opacity`

§`overflow`

§`parent`

§`receives-default`

§`root`

§`scale-factor`

§`sensitive`

§`tooltip-markup`

§`tooltip-text`

§`valign`

§`vexpand`

§`vexpand-set`

§`visible`

§`width-request`

§`accessible-role`

§`authenticate`

§`close`

§`context-menu`

§`context-menu-dismissed`

§`create`

§`decide-policy`

§`enter-fullscreen`

§`insecure-content-detected`

§`leave-fullscreen`

§`load-changed`

§`load-failed`

§`load-failed-with-tls-errors`

§`mouse-target-changed`

§`permission-request`

§`print`

§`query-permission-state`

§`ready-to-show`