webkit6/auto/

web_view.rs

// This file was generated by gir (https://github.com/gtk-rs/gir)
// from gir-files (https://github.com/gtk-rs/gir-files)
// from webkit-gir-files
// DO NOT EDIT

use crate::{
    AuthenticationRequest, AutomationBrowsingContextPresentation, BackForwardList,
    BackForwardListItem, ColorChooserRequest, ContextMenu, Download, EditorState,
    FileChooserRequest, FindController, FormSubmissionRequest, HitTestResult, InputMethodContext,
    InsecureContentEvent, LoadEvent, MediaCaptureState, NavigationAction, NetworkSession,
    Notification, OptionMenu, PermissionRequest, PermissionStateQuery, PolicyDecision,
    PolicyDecisionType, PrintOperation, SaveMode, ScriptDialog, Settings, SnapshotOptions,
    SnapshotRegion, URIRequest, UserContentManager, UserMessage, WebContext, WebExtensionMode,
    WebInspector, WebProcessTerminationReason, WebResource, WebViewBase, WebViewSessionState,
    WebsitePolicies, WindowProperties, ffi,
};
use glib::{
    object::ObjectType as _,
    prelude::*,
    signal::{SignalHandlerId, connect_raw},
    translate::*,
};
use std::{boxed::Box as Box_, pin::Pin};

glib::wrapper! {
    /// The central class of the WPE WebKit and WebKitGTK APIs.
    ///
    /// [`WebView`][crate::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`][crate::WebView] or
    /// a data string. With [`Settings`][crate::Settings] you can control various aspects
    /// of the rendering and loading of the content.
    ///
    /// Note that in WebKitGTK, [`WebView`][crate::WebView] is scrollable by itself, so
    /// you don't need to embed it in a `GtkScrolledWindow`.
    ///
    /// ## Properties
    ///
    ///
    /// #### `automation-presentation-type`
    ///  The [`AutomationBrowsingContextPresentation`][crate::AutomationBrowsingContextPresentation] of [`WebView`][crate::WebView]. This should only be used when
    /// creating a new [`WebView`][crate::WebView] as a response to [`create-web-view`][struct@crate::AutomationSession#create-web-view]
    /// signal request. If the new WebView was added to a new tab of current browsing context window
    /// [`AutomationBrowsingContextPresentation::Tab`][crate::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`][crate::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`][crate::MediaCaptureState::None] or [`MediaCaptureState::Muted`][crate::MediaCaptureState::Muted].
    ///
    /// If the capture state of the device is set to [`MediaCaptureState::None`][crate::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`][crate::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].
    ///
    /// 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`][crate::MediaCaptureState::None] or [`MediaCaptureState::Muted`][crate::MediaCaptureState::Muted].
    ///
    /// If the capture state of the device is set to [`MediaCaptureState::None`][crate::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`][crate::WebView] are editable. For more
    /// information see [`WebViewExt::set_editable()`][crate::prelude::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`][crate::WebView].
    /// See [`WebViewExt::favicon()`][crate::prelude::WebViewExt::favicon()] for more details.
    ///
    /// Readable
    ///
    ///
    /// #### `is-controlled-by-automation`
    ///  Whether the [`WebView`][crate::WebView] is controlled by automation tools (e.g. WebDriver, Selenium). This is
    /// required for views returned as a response to [`create-web-view`][struct@crate::AutomationSession#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`][struct@crate::WebView#related-view] is also passed during construction, [`is-controlled-by-automation`][struct@crate::WebView#is-controlled-by-automation]
    /// ignores its own parameter and inherits directly from the related view [`is-controlled-by-automation`][struct@crate::WebView#is-controlled-by-automation]
    /// property. This is the recommended way when creating new views as a response to the [`create`][struct@crate::WebView#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`][crate::WebView] is in immersive mode.
    ///
    /// Readable
    ///
    ///
    /// #### `is-loading`
    ///  Whether the [`WebView`][crate::WebView] is currently loading a page. This property becomes
    /// [`true`] as soon as a new load operation is requested and before the
    /// [`load-changed`][struct@crate::WebView#load-changed] signal is emitted with [`LoadEvent::Started`][crate::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`][struct@crate::WebView#load-changed] is emitted with [`LoadEvent::Finished`][crate::LoadEvent::Finished].
    ///
    /// Readable
    ///
    ///
    /// #### `is-muted`
    ///  Whether the [`WebView`][crate::WebView] audio is muted. When [`true`], audio is silenced.
    /// It may still be playing, i.e. [`is-playing-audio`][struct@crate::WebView#is-playing-audio] may be [`true`].
    ///
    /// Readable | Writeable
    ///
    ///
    /// #### `is-playing-audio`
    ///  Whether the [`WebView`][crate::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`][crate::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`][crate::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`][crate::MediaCaptureState::None] or [`MediaCaptureState::Muted`][crate::MediaCaptureState::Muted].
    ///
    /// If the capture state of the device is set to [`MediaCaptureState::None`][crate::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`][crate::NetworkSession] of the view
    ///
    /// Readable | Writeable | Construct Only
    ///
    ///
    /// #### `page-id`
    ///  The identifier of the `WebKitWebPage` corresponding to the [`WebView`][crate::WebView].
    ///
    /// Readable
    ///
    ///
    /// #### `related-view`
    ///  The related [`WebView`][crate::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`][crate::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`][crate::WebView]. If
    /// the title has not been received yet, it will be [`None`].
    ///
    /// Readable
    ///
    ///
    /// #### `uri`
    ///  The current active URI of the [`WebView`][crate::WebView].
    /// See [`WebViewExt::uri()`][crate::prelude::WebViewExt::uri()] for more details.
    ///
    /// Readable
    ///
    ///
    /// #### `user-content-manager`
    ///  The [`UserContentManager`][crate::UserContentManager] of the view.
    ///
    /// Readable | Writeable | Construct Only
    ///
    ///
    /// #### `web-context`
    ///  The [`WebContext`][crate::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](https://developer.mozilla.org/en-US/docs/Mozilla/Add-ons/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](https://developer.chrome.com/docs/extensions/mv3/intro/mv3-migration/`content`-security-policy).
    ///
    /// Readable | Writeable | Construct Only
    ///
    ///
    /// #### `website-policies`
    ///  The [`WebsitePolicies`][crate::WebsitePolicies] for the view.
    ///
    /// Readable | Writeable | Construct Only
    ///
    ///
    /// #### `zoom-level`
    ///  The zoom level of the [`WebView`][crate::WebView] content.
    /// See [`WebViewExt::set_zoom_level()`][crate::prelude::WebViewExt::set_zoom_level()] for more details.
    ///
    /// Readable | Writeable
    /// <details><summary><h4>Widget</h4></summary>
    ///
    ///
    /// #### `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 [signal`Gtk`::query-tooltip]
    /// signal on `widget`.
    ///
    /// A true value indicates that `widget` can have a tooltip, in this case
    /// the widget will be queried using [signal`Gtk`::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 [class`Gtk`] 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 [method`Gtk`.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
    /// [method`Gtk`.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
    /// [method`Gtk`.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
    /// [method`Gtk`.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
    /// [method`Gtk`.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 [method`Gtk`.set_markup].
    ///
    /// This is a convenience property which will take care of getting the
    /// tooltip shown if the given string is not `NULL`:
    /// [property`Gtk`:has-tooltip] will automatically be set to true
    /// and there will be taken care of [signal`Gtk`::query-tooltip] in
    /// the default signal handler.
    ///
    /// Note that if both [property`Gtk`:tooltip-text] and
    /// [property`Gtk`:tooltip-markup] are set, the last one wins.
    ///
    /// Readable | Writeable
    ///
    ///
    /// #### `tooltip-text`
    ///  Sets the text of tooltip to be the given string.
    ///
    /// Also see [method`Gtk`.set_text].
    ///
    /// This is a convenience property which will take care of getting the
    /// tooltip shown if the given string is not `NULL`:
    /// [property`Gtk`:has-tooltip] will automatically be set to true
    /// and there will be taken care of [signal`Gtk`::query-tooltip] in
    /// the default signal handler.
    ///
    /// Note that if both [property`Gtk`:tooltip-text] and
    /// [property`Gtk`: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
    /// </details>
    /// <details><summary><h4>Accessible</h4></summary>
    ///
    ///
    /// #### `accessible-role`
    ///  The accessible role of the given [`gtk::Accessible`][crate::gtk::Accessible] implementation.
    ///
    /// The accessible role cannot be changed once set.
    ///
    /// Readable | Writeable
    /// </details>
    ///
    /// ## 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`][crate::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`][crate::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()`][crate::prelude::WebViewExt::try_close()].
    /// It is the owner's responsibility to handle this signal to hide or
    /// destroy the [`WebView`][crate::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()`][crate::ContextMenu::prepend()],
    ///  [`ContextMenu::append()`][crate::ContextMenu::append()] or [`ContextMenu::insert()`][crate::ContextMenu::insert()] to add new
    ///  [`ContextMenuItem`][crate::ContextMenuItem]<!-- -->s to `context_menu`, [`ContextMenu::move_item()`][crate::ContextMenu::move_item()]
    ///  to reorder existing items, or [`ContextMenu::remove()`][crate::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()`][crate::ContextMenu::remove_all()], add your own items and return [`false`] so
    ///  that the menu will be shown. You can also ignore the proposed [`ContextMenu`][crate::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`][crate::ContextMenu] passed in `context_menu` argument is only valid
    /// during the signal emission.
    ///
    ///
    ///
    ///
    /// #### `context-menu-dismissed`
    ///  Emitted after [`context-menu`][struct@crate::WebView#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`][crate::WebView] is requested.
    /// If this signal is handled the signal handler should return the
    /// newly created [`WebView`][crate::WebView].
    ///
    /// The [`NavigationAction`][crate::NavigationAction] parameter contains information about the
    /// navigation action that triggered this signal.
    ///
    /// The new [`WebView`][crate::WebView] must be related to `web_view`, see
    /// [`related-view`][struct@crate::WebView#related-view] for more details.
    ///
    /// The new [`WebView`][crate::WebView] should not be displayed to the user
    /// until the [`ready-to-show`][struct@crate::WebView#ready-to-show] signal is emitted.
    ///
    /// For creating views as response to automation tools requests, see the
    /// [`create-web-view`][struct@crate::AutomationSession#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`][crate::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 ⚠️**
    ///
    /// ```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`][crate::PolicyDecision] and no decision has been
    /// made explicitly, [`PolicyDecisionExt::use_()`][crate::prelude::PolicyDecisionExt::use_()] will be the default policy decision. The
    /// default signal handler will simply call [`PolicyDecisionExt::use_()`][crate::prelude::PolicyDecisionExt::use_()]. Only the first
    /// policy decision chosen for a given [`PolicyDecision`][crate::PolicyDecision] will have any affect.
    ///
    ///
    ///
    ///
    /// #### `enter-fullscreen`
    ///  Emitted when JavaScript code calls
    /// `<function>`element.webkitRequestFullScreen`</function>`. If the
    /// signal is not handled the [`WebView`][crate::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`][crate::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`][struct@crate::WebView#enter-fullscreen] stage for instance.
    ///
    ///
    ///
    ///
    /// #### `load-changed`
    ///  Emitted when a load operation in `web_view` changes.
    /// The signal is always emitted with [`LoadEvent::Started`][crate::LoadEvent::Started] when a
    /// new load request is made and [`LoadEvent::Finished`][crate::LoadEvent::Finished] when the load
    /// finishes successfully or due to an error. When the ongoing load
    /// operation fails [`load-failed`][struct@crate::WebView#load-failed] signal is emitted
    /// before [`load-changed`][struct@crate::WebView#load-changed] is emitted with
    /// [`LoadEvent::Finished`][crate::LoadEvent::Finished].
    /// If a redirection is received from the server, this signal is emitted
    /// with [`LoadEvent::Redirected`][crate::LoadEvent::Redirected] after the initial emission with
    /// [`LoadEvent::Started`][crate::LoadEvent::Started] and before [`LoadEvent::Committed`][crate::LoadEvent::Committed].
    /// When the page content starts arriving the signal is emitted with
    /// [`LoadEvent::Committed`][crate::LoadEvent::Committed] event.
    ///
    /// You can handle this signal and use a switch to track any ongoing
    /// load operation.
    ///
    /// **⚠️ The following code is in c ⚠️**
    ///
    /// ```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`][crate::LoadEvent::Started]. If it happened while
    /// loading a committed data source `load_event` will be [`LoadEvent::Committed`][crate::LoadEvent::Committed].
    /// Since a load error causes the load operation to finish, the signal
    /// WebKitWebView::load-changed will always be emitted with
    /// [`LoadEvent::Finished`][crate::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`][struct@crate::WebView#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 ⚠️**
    ///
    /// ```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`][crate::PermissionRequest] and the
    /// request has not been handled, [`PermissionRequestExt::deny()`][crate::prelude::PermissionRequestExt::deny()]
    /// will be the default action.
    ///
    /// If the signal is not handled, the `request` will be completed automatically
    /// by the specific [`PermissionRequest`][crate::PermissionRequest] that could allow or deny it. Check the
    /// documentation of classes implementing [`PermissionRequest`][crate::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()`][crate::PrintOperation::set_print_settings()] and
    /// [`PrintOperation::set_page_setup()`][crate::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](https://w3c.github.io/permissions/).
    /// You can reply to the query using [`PermissionStateQuery::finish()`][crate::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`][struct@crate::WebView#create] on the newly created [`WebView`][crate::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`][crate::WindowProperties]
    /// of `web_view`. See also [`WebViewExt::window_properties()`][crate::prelude::WebViewExt::window_properties()].
    ///
    ///
    ///
    ///
    /// #### `resource-load-started`
    ///  Emitted when a new resource is going to be loaded. The `request` parameter
    /// contains the [`URIRequest`][crate::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`][struct@crate::WebView#ready-to-show] on the newly
    /// created [`WebView`][crate::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`][crate::WebView] until the new dialog is closed.
    ///
    ///
    ///
    ///
    /// #### `run-color-chooser`
    ///  This signal is emitted when the user interacts with a <input
    /// type='color' /> 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`][crate::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 <input
    /// type='file' /> 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`][crate::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`][crate::ScriptDialogType::Alert]: message dialog with a single Close button.
    /// `</para>``</listitem>`
    /// `<listitem>``<para>`
    ///  [`ScriptDialogType::Confirm`][crate::ScriptDialogType::Confirm]: message dialog with OK and Cancel buttons.
    /// `</para>``</listitem>`
    /// `<listitem>``<para>`
    ///  [`ScriptDialogType::Prompt`][crate::ScriptDialogType::Prompt]: message dialog with OK and Cancel buttons and
    ///  a text entry with the default text.
    /// `</para>``</listitem>`
    /// `<listitem>``<para>`
    ///  [`ScriptDialogType::BeforeUnloadConfirm`][crate::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()`][crate::ScriptDialog::close()] when done.
    /// If the last reference is removed on a [`ScriptDialog`][crate::ScriptDialog] and the dialog has not been
    /// closed, [`ScriptDialog::close()`][crate::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`][crate::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()`][crate::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()`][crate::FormSubmissionRequest::submit()] when done to continue with the form submission.
    /// If the last reference is removed on a [`FormSubmissionRequest`][crate::FormSubmissionRequest] and the
    /// form has not been submitted, [`FormSubmissionRequest::submit()`][crate::FormSubmissionRequest::submit()] will be called.
    ///
    ///
    ///
    ///
    /// #### `user-message-received`
    ///  This signal is emitted when a [`UserMessage`][crate::UserMessage] is received from the
    /// `WebKitWebPage` corresponding to `web_view`. You can reply to the message
    /// using [`UserMessage::send_reply()`][crate::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`][crate::UserMessageError::Message].
    ///
    ///
    ///
    ///
    /// #### `web-process-terminated`
    ///  This signal is emitted when the web process terminates abnormally due
    /// to `reason`.
    ///
    ///
    /// <details><summary><h4>Widget</h4></summary>
    ///
    ///
    /// #### `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 [method`Gtk`.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
    /// [property`Gtk`: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 [signal`Gtk`::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](class.SignalAction.html).
    ///
    /// 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 [property`Gtk`: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 [method`Gtk`.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 [method`Gtk`.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 [method`Gtk`.unrealize] has been called
    /// or the widget has been unmapped (that is, it is going to be hidden).
    ///
    ///
    /// </details>
    ///
    /// # Implements
    ///
    /// [`WebViewExt`][trait@crate::prelude::WebViewExt], [`WebViewBaseExt`][trait@crate::prelude::WebViewBaseExt], [`trait@gtk::prelude::WidgetExt`], [`trait@gtk::prelude::AccessibleExt`], [`trait@gtk::prelude::BuildableExt`], [`trait@gtk::prelude::ConstraintTargetExt`]
    #[doc(alias = "WebKitWebView")]
    pub struct WebView(Object<ffi::WebKitWebView, ffi::WebKitWebViewClass>) @extends WebViewBase, gtk::Widget, @implements gtk::Accessible, gtk::Buildable, gtk::ConstraintTarget;

    match fn {
        type_ => || ffi::webkit_web_view_get_type(),
    }
}

impl WebView {
    pub const NONE: Option<&'static WebView> = None;

    /// Creates a new [`WebView`][crate::WebView] with the default [`WebContext`][crate::WebContext].
    ///
    /// Creates a new [`WebView`][crate::WebView] with the default [`WebContext`][crate::WebContext] and
    /// no [`UserContentManager`][crate::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()`.
    ///
    /// # Returns
    ///
    /// The newly created [`WebView`][crate::WebView] widget
    #[doc(alias = "webkit_web_view_new")]
    pub fn new() -> WebView {
        assert_initialized_main_thread!();
        unsafe { gtk::Widget::from_glib_none(ffi::webkit_web_view_new()).unsafe_cast() }
    }

    // rustdoc-stripper-ignore-next
    /// Creates a new builder-pattern struct instance to construct [`WebView`] objects.
    ///
    /// This method returns an instance of [`WebViewBuilder`](crate::builders::WebViewBuilder) which can be used to create [`WebView`] objects.
    pub fn builder() -> WebViewBuilder {
        WebViewBuilder::new()
    }
}

impl Default for WebView {
    fn default() -> Self {
        Self::new()
    }
}

// rustdoc-stripper-ignore-next
/// A [builder-pattern] type to construct [`WebView`] objects.
///
/// [builder-pattern]: https://doc.rust-lang.org/1.0.0/style/ownership/builders.html
#[must_use = "The builder must be built to be used"]
pub struct WebViewBuilder {
    builder: glib::object::ObjectBuilder<'static, WebView>,
}

impl WebViewBuilder {
    fn new() -> Self {
        Self {
            builder: glib::object::Object::builder(),
        }
    }

    /// The [`AutomationBrowsingContextPresentation`][crate::AutomationBrowsingContextPresentation] of [`WebView`][crate::WebView]. This should only be used when
    /// creating a new [`WebView`][crate::WebView] as a response to [`create-web-view`][struct@crate::AutomationSession#create-web-view]
    /// signal request. If the new WebView was added to a new tab of current browsing context window
    /// [`AutomationBrowsingContextPresentation::Tab`][crate::AutomationBrowsingContextPresentation::Tab] should be used.
    pub fn automation_presentation_type(
        self,
        automation_presentation_type: AutomationBrowsingContextPresentation,
    ) -> Self {
        Self {
            builder: self
                .builder
                .property("automation-presentation-type", automation_presentation_type),
        }
    }

    /// 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`][crate::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`][crate::MediaCaptureState::None] or [`MediaCaptureState::Muted`][crate::MediaCaptureState::Muted].
    ///
    /// If the capture state of the device is set to [`MediaCaptureState::None`][crate::MediaCaptureState::None] the web-page
    /// can still re-request the permission to the user. Permission desision caching is left to the
    /// application.
    pub fn camera_capture_state(self, camera_capture_state: MediaCaptureState) -> Self {
        Self {
            builder: self
                .builder
                .property("camera-capture-state", camera_capture_state),
        }
    }

    /// 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`][crate::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.
    pub fn default_content_security_policy(
        self,
        default_content_security_policy: impl Into<glib::GString>,
    ) -> Self {
        Self {
            builder: self.builder.property(
                "default-content-security-policy",
                default_content_security_policy.into(),
            ),
        }
    }

    /// 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].
    ///
    /// 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`][crate::MediaCaptureState::None] or [`MediaCaptureState::Muted`][crate::MediaCaptureState::Muted].
    ///
    /// If the capture state of the device is set to [`MediaCaptureState::None`][crate::MediaCaptureState::None] the web-page
    /// can still re-request the permission to the user. Permission desision caching is left to the
    /// application.
    pub fn display_capture_state(self, display_capture_state: MediaCaptureState) -> Self {
        Self {
            builder: self
                .builder
                .property("display-capture-state", display_capture_state),
        }
    }

    /// Whether the pages loaded inside [`WebView`][crate::WebView] are editable. For more
    /// information see [`WebViewExt::set_editable()`][crate::prelude::WebViewExt::set_editable()].
    pub fn editable(self, editable: bool) -> Self {
        Self {
            builder: self.builder.property("editable", editable),
        }
    }

    /// Whether the [`WebView`][crate::WebView] is controlled by automation tools (e.g. WebDriver, Selenium). This is
    /// required for views returned as a response to [`create-web-view`][struct@crate::AutomationSession#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`][struct@crate::WebView#related-view] is also passed during construction, [`is-controlled-by-automation`][struct@crate::WebView#is-controlled-by-automation]
    /// ignores its own parameter and inherits directly from the related view [`is-controlled-by-automation`][struct@crate::WebView#is-controlled-by-automation]
    /// property. This is the recommended way when creating new views as a response to the [`create`][struct@crate::WebView#create]
    /// signal. For example, as response to JavaScript ``window.open()`` calls during an automation session.
    pub fn is_controlled_by_automation(self, is_controlled_by_automation: bool) -> Self {
        Self {
            builder: self
                .builder
                .property("is-controlled-by-automation", is_controlled_by_automation),
        }
    }

    /// Whether the [`WebView`][crate::WebView] audio is muted. When [`true`], audio is silenced.
    /// It may still be playing, i.e. [`is-playing-audio`][struct@crate::WebView#is-playing-audio] may be [`true`].
    pub fn is_muted(self, is_muted: bool) -> Self {
        Self {
            builder: self.builder.property("is-muted", is_muted),
        }
    }

    /// 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`][crate::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`][crate::MediaCaptureState::None] or [`MediaCaptureState::Muted`][crate::MediaCaptureState::Muted].
    ///
    /// If the capture state of the device is set to [`MediaCaptureState::None`][crate::MediaCaptureState::None] the web-page
    /// can still re-request the permission to the user. Permission desision caching is left to the
    /// application.
    pub fn microphone_capture_state(self, microphone_capture_state: MediaCaptureState) -> Self {
        Self {
            builder: self
                .builder
                .property("microphone-capture-state", microphone_capture_state),
        }
    }

    /// The [`NetworkSession`][crate::NetworkSession] of the view
    pub fn network_session(self, network_session: &NetworkSession) -> Self {
        Self {
            builder: self
                .builder
                .property("network-session", network_session.clone()),
        }
    }

    /// The related [`WebView`][crate::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.
    pub fn related_view(self, related_view: &impl IsA<WebView>) -> Self {
        Self {
            builder: self
                .builder
                .property("related-view", related_view.clone().upcast()),
        }
    }

    /// The [`Settings`][crate::Settings] of the view.
    pub fn settings(self, settings: &Settings) -> Self {
        Self {
            builder: self.builder.property("settings", settings.clone()),
        }
    }

    /// The [`UserContentManager`][crate::UserContentManager] of the view.
    pub fn user_content_manager(self, user_content_manager: &UserContentManager) -> Self {
        Self {
            builder: self
                .builder
                .property("user-content-manager", user_content_manager.clone()),
        }
    }

    /// The [`WebContext`][crate::WebContext] of the view.
    pub fn web_context(self, web_context: &WebContext) -> Self {
        Self {
            builder: self.builder.property("web-context", web_context.clone()),
        }
    }

    /// This configures `web_view` to treat the content as a WebExtension.
    ///
    /// Note that this refers to the web standard [WebExtensions](https://developer.mozilla.org/en-US/docs/Mozilla/Add-ons/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](https://developer.chrome.com/docs/extensions/mv3/intro/mv3-migration/`content`-security-policy).
    pub fn web_extension_mode(self, web_extension_mode: WebExtensionMode) -> Self {
        Self {
            builder: self
                .builder
                .property("web-extension-mode", web_extension_mode),
        }
    }

    /// The [`WebsitePolicies`][crate::WebsitePolicies] for the view.
    pub fn website_policies(self, website_policies: &WebsitePolicies) -> Self {
        Self {
            builder: self
                .builder
                .property("website-policies", website_policies.clone()),
        }
    }

    /// The zoom level of the [`WebView`][crate::WebView] content.
    /// See [`WebViewExt::set_zoom_level()`][crate::prelude::WebViewExt::set_zoom_level()] for more details.
    pub fn zoom_level(self, zoom_level: f64) -> Self {
        Self {
            builder: self.builder.property("zoom-level", zoom_level),
        }
    }

    /// 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.
    pub fn can_focus(self, can_focus: bool) -> Self {
        Self {
            builder: self.builder.property("can-focus", can_focus),
        }
    }

    /// Whether the widget can receive pointer events.
    pub fn can_target(self, can_target: bool) -> Self {
        Self {
            builder: self.builder.property("can-target", can_target),
        }
    }

    /// A list of css classes applied to this widget.
    pub fn css_classes(self, css_classes: impl Into<glib::StrV>) -> Self {
        Self {
            builder: self.builder.property("css-classes", css_classes.into()),
        }
    }

    /// 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.
    pub fn css_name(self, css_name: impl Into<glib::GString>) -> Self {
        Self {
            builder: self.builder.property("css-name", css_name.into()),
        }
    }

    //pub fn cursor(self, cursor: /*Ignored*/&gdk::Cursor) -> Self {
    //    Self { builder: self.builder.property("cursor", cursor), }
    //}

    /// Whether the widget should grab focus when it is clicked with the mouse.
    ///
    /// This property is only relevant for widgets that can take focus.
    pub fn focus_on_click(self, focus_on_click: bool) -> Self {
        Self {
            builder: self.builder.property("focus-on-click", focus_on_click),
        }
    }

    /// Whether this widget itself will accept the input focus.
    pub fn focusable(self, focusable: bool) -> Self {
        Self {
            builder: self.builder.property("focusable", focusable),
        }
    }

    //pub fn halign(self, halign: /*Ignored*/gtk::Align) -> Self {
    //    Self { builder: self.builder.property("halign", halign), }
    //}

    /// Enables or disables the emission of the [signal`Gtk`::query-tooltip]
    /// signal on `widget`.
    ///
    /// A true value indicates that `widget` can have a tooltip, in this case
    /// the widget will be queried using [signal`Gtk`::query-tooltip] to
    /// determine whether it will provide a tooltip or not.
    pub fn has_tooltip(self, has_tooltip: bool) -> Self {
        Self {
            builder: self.builder.property("has-tooltip", has_tooltip),
        }
    }

    /// Overrides for height request of the widget.
    ///
    /// If this is -1, the natural request will be used.
    pub fn height_request(self, height_request: i32) -> Self {
        Self {
            builder: self.builder.property("height-request", height_request),
        }
    }

    /// Whether to expand horizontally.
    pub fn hexpand(self, hexpand: bool) -> Self {
        Self {
            builder: self.builder.property("hexpand", hexpand),
        }
    }

    /// Whether to use the `hexpand` property.
    pub fn hexpand_set(self, hexpand_set: bool) -> Self {
        Self {
            builder: self.builder.property("hexpand-set", hexpand_set),
        }
    }

    //pub fn layout_manager(self, layout_manager: &impl IsA</*Ignored*/gtk::LayoutManager>) -> Self {
    //    Self { builder: self.builder.property("layout-manager", layout_manager.clone().upcast()), }
    //}

    /// 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 [method`Gtk`.set_propagation_limit].
    #[cfg(feature = "gtk_v4_18")]
    #[cfg_attr(docsrs, doc(cfg(feature = "gtk_v4_18")))]
    pub fn limit_events(self, limit_events: bool) -> Self {
        Self {
            builder: self.builder.property("limit-events", limit_events),
        }
    }

    /// 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
    /// [method`Gtk`.set_size_request] for example.
    pub fn margin_bottom(self, margin_bottom: i32) -> Self {
        Self {
            builder: self.builder.property("margin-bottom", margin_bottom),
        }
    }

    /// 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
    /// [method`Gtk`.set_size_request] for example.
    pub fn margin_end(self, margin_end: i32) -> Self {
        Self {
            builder: self.builder.property("margin-end", margin_end),
        }
    }

    /// 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
    /// [method`Gtk`.set_size_request] for example.
    pub fn margin_start(self, margin_start: i32) -> Self {
        Self {
            builder: self.builder.property("margin-start", margin_start),
        }
    }

    /// 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
    /// [method`Gtk`.set_size_request] for example.
    pub fn margin_top(self, margin_top: i32) -> Self {
        Self {
            builder: self.builder.property("margin-top", margin_top),
        }
    }

    /// The name of the widget.
    pub fn name(self, name: impl Into<glib::GString>) -> Self {
        Self {
            builder: self.builder.property("name", name.into()),
        }
    }

    /// The requested opacity of the widget.
    pub fn opacity(self, opacity: f64) -> Self {
        Self {
            builder: self.builder.property("opacity", opacity),
        }
    }

    //pub fn overflow(self, overflow: /*Ignored*/gtk::Overflow) -> Self {
    //    Self { builder: self.builder.property("overflow", overflow), }
    //}

    /// Whether the widget will receive the default action when it is focused.
    pub fn receives_default(self, receives_default: bool) -> Self {
        Self {
            builder: self.builder.property("receives-default", receives_default),
        }
    }

    /// Whether the widget responds to input.
    pub fn sensitive(self, sensitive: bool) -> Self {
        Self {
            builder: self.builder.property("sensitive", sensitive),
        }
    }

    /// Sets the text of tooltip to be the given string, which is marked up
    /// with Pango markup.
    ///
    /// Also see [method`Gtk`.set_markup].
    ///
    /// This is a convenience property which will take care of getting the
    /// tooltip shown if the given string is not `NULL`:
    /// [property`Gtk`:has-tooltip] will automatically be set to true
    /// and there will be taken care of [signal`Gtk`::query-tooltip] in
    /// the default signal handler.
    ///
    /// Note that if both [property`Gtk`:tooltip-text] and
    /// [property`Gtk`:tooltip-markup] are set, the last one wins.
    pub fn tooltip_markup(self, tooltip_markup: impl Into<glib::GString>) -> Self {
        Self {
            builder: self
                .builder
                .property("tooltip-markup", tooltip_markup.into()),
        }
    }

    /// Sets the text of tooltip to be the given string.
    ///
    /// Also see [method`Gtk`.set_text].
    ///
    /// This is a convenience property which will take care of getting the
    /// tooltip shown if the given string is not `NULL`:
    /// [property`Gtk`:has-tooltip] will automatically be set to true
    /// and there will be taken care of [signal`Gtk`::query-tooltip] in
    /// the default signal handler.
    ///
    /// Note that if both [property`Gtk`:tooltip-text] and
    /// [property`Gtk`:tooltip-markup] are set, the last one wins.
    pub fn tooltip_text(self, tooltip_text: impl Into<glib::GString>) -> Self {
        Self {
            builder: self.builder.property("tooltip-text", tooltip_text.into()),
        }
    }

    //pub fn valign(self, valign: /*Ignored*/gtk::Align) -> Self {
    //    Self { builder: self.builder.property("valign", valign), }
    //}

    /// Whether to expand vertically.
    pub fn vexpand(self, vexpand: bool) -> Self {
        Self {
            builder: self.builder.property("vexpand", vexpand),
        }
    }

    /// Whether to use the `vexpand` property.
    pub fn vexpand_set(self, vexpand_set: bool) -> Self {
        Self {
            builder: self.builder.property("vexpand-set", vexpand_set),
        }
    }

    /// Whether the widget is visible.
    pub fn visible(self, visible: bool) -> Self {
        Self {
            builder: self.builder.property("visible", visible),
        }
    }

    /// Overrides for width request of the widget.
    ///
    /// If this is -1, the natural request will be used.
    pub fn width_request(self, width_request: i32) -> Self {
        Self {
            builder: self.builder.property("width-request", width_request),
        }
    }

    //pub fn accessible_role(self, accessible_role: /*Ignored*/gtk::AccessibleRole) -> Self {
    //    Self { builder: self.builder.property("accessible-role", accessible_role), }
    //}

    // rustdoc-stripper-ignore-next
    /// Build the [`WebView`].
    #[must_use = "Building the object from the builder is usually expensive and is not expected to have side effects"]
    pub fn build(self) -> WebView {
        assert_initialized_main_thread!();
        self.builder.build()
    }
}

/// Trait containing all [`struct@WebView`] methods.
///
/// # Implementors
///
/// [`WebView`][struct@crate::WebView]
pub trait WebViewExt: IsA<WebView> + 'static {
    /// Asynchronously call `body` with `arguments` in the script world with name `world_name` of the main frame current context in `self`.
    /// 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 `world_name` is [`None`], the default world is used. Any value that is not [`None`] is a distin ct world.
    /// The `source_uri` 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 [`enable-javascript`][struct@crate::Settings#enable-javascript] 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 [`enable-javascript-markup`][struct@crate::Settings#enable-javascript-markup].
    ///
    /// When the operation is finished, `callback` will be called. You can then call
    /// `webkit_web_view_call_async_javascript_function_finish()` 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:
    ///
    /// **⚠️ The following code is in c ⚠️**
    ///
    /// ```c
    /// 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");
    ///     }
    ///     g_object_unref (value);
    /// }
    ///
    /// 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);
    /// }
    /// ```
    /// ## `body`
    /// the function body
    /// ## `length`
    /// length of `body`, or -1 if `body` is a nul-terminated string
    /// ## `arguments`
    /// a [`glib::Variant`][struct@crate::glib::Variant] with format `a{sv}` storing the function arguments, or [`None`]
    /// ## `world_name`
    /// the name of a `WebKitScriptWorld` or [`None`] to use the default
    /// ## `source_uri`
    /// the source URI
    /// ## `cancellable`
    /// a [`gio::Cancellable`][crate::gio::Cancellable] or [`None`] to ignore
    /// ## `callback`
    /// a `GAsyncReadyCallback` to call when the script finished
    #[doc(alias = "webkit_web_view_call_async_javascript_function")]
    fn call_async_javascript_function<
        P: FnOnce(Result<javascriptcore::Value, glib::Error>) + 'static,
    >(
        &self,
        body: &str,
        arguments: Option<&glib::Variant>,
        world_name: Option<&str>,
        source_uri: Option<&str>,
        cancellable: Option<&impl IsA<gio::Cancellable>>,
        callback: P,
    ) {
        let length = body.len() as _;

        let main_context = glib::MainContext::ref_thread_default();
        let is_main_context_owner = main_context.is_owner();
        let has_acquired_main_context = (!is_main_context_owner)
            .then(|| main_context.acquire().ok())
            .flatten();
        assert!(
            is_main_context_owner || has_acquired_main_context.is_some(),
            "Async operations only allowed if the thread is owning the MainContext"
        );

        let user_data: Box_<glib::thread_guard::ThreadGuard<P>> =
            Box_::new(glib::thread_guard::ThreadGuard::new(callback));
        unsafe extern "C" fn call_async_javascript_function_trampoline<
            P: FnOnce(Result<javascriptcore::Value, glib::Error>) + 'static,
        >(
            _source_object: *mut glib::gobject_ffi::GObject,
            res: *mut gio::ffi::GAsyncResult,
            user_data: glib::ffi::gpointer,
        ) {
            unsafe {
                let mut error = std::ptr::null_mut();
                let ret = ffi::webkit_web_view_call_async_javascript_function_finish(
                    _source_object as *mut _,
                    res,
                    &mut error,
                );
                let result = if error.is_null() {
                    Ok(from_glib_full(ret))
                } else {
                    Err(from_glib_full(error))
                };
                let callback: Box_<glib::thread_guard::ThreadGuard<P>> =
                    Box_::from_raw(user_data as *mut _);
                let callback: P = callback.into_inner();
                callback(result);
            }
        }
        let callback = call_async_javascript_function_trampoline::<P>;
        unsafe {
            ffi::webkit_web_view_call_async_javascript_function(
                self.as_ref().to_glib_none().0,
                body.to_glib_none().0,
                length,
                arguments.to_glib_none().0,
                world_name.to_glib_none().0,
                source_uri.to_glib_none().0,
                cancellable.map(|p| p.as_ref()).to_glib_none().0,
                Some(callback),
                Box_::into_raw(user_data) as *mut _,
            );
        }
    }

    fn call_async_javascript_function_future(
        &self,
        body: &str,
        arguments: Option<&glib::Variant>,
        world_name: Option<&str>,
        source_uri: Option<&str>,
    ) -> Pin<
        Box_<
            dyn std::future::Future<Output = Result<javascriptcore::Value, glib::Error>> + 'static,
        >,
    > {
        let body = String::from(body);
        let arguments = arguments.map(ToOwned::to_owned);
        let world_name = world_name.map(ToOwned::to_owned);
        let source_uri = source_uri.map(ToOwned::to_owned);
        Box_::pin(gio::GioFuture::new(self, move |obj, cancellable, send| {
            obj.call_async_javascript_function(
                &body,
                arguments.as_ref().map(::std::borrow::Borrow::borrow),
                world_name.as_ref().map(::std::borrow::Borrow::borrow),
                source_uri.as_ref().map(::std::borrow::Borrow::borrow),
                Some(cancellable),
                move |res| {
                    send.resolve(res);
                },
            );
        }))
    }

    /// 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
    /// `webkit_web_view_can_execute_editing_command_finish()` to get the result of the operation.
    /// ## `command`
    /// the command to check
    /// ## `cancellable`
    /// a [`gio::Cancellable`][crate::gio::Cancellable] or [`None`] to ignore
    /// ## `callback`
    /// a `GAsyncReadyCallback` to call when the request is satisfied
    #[doc(alias = "webkit_web_view_can_execute_editing_command")]
    fn can_execute_editing_command<P: FnOnce(Result<(), glib::Error>) + 'static>(
        &self,
        command: &str,
        cancellable: Option<&impl IsA<gio::Cancellable>>,
        callback: P,
    ) {
        let main_context = glib::MainContext::ref_thread_default();
        let is_main_context_owner = main_context.is_owner();
        let has_acquired_main_context = (!is_main_context_owner)
            .then(|| main_context.acquire().ok())
            .flatten();
        assert!(
            is_main_context_owner || has_acquired_main_context.is_some(),
            "Async operations only allowed if the thread is owning the MainContext"
        );

        let user_data: Box_<glib::thread_guard::ThreadGuard<P>> =
            Box_::new(glib::thread_guard::ThreadGuard::new(callback));
        unsafe extern "C" fn can_execute_editing_command_trampoline<
            P: FnOnce(Result<(), glib::Error>) + 'static,
        >(
            _source_object: *mut glib::gobject_ffi::GObject,
            res: *mut gio::ffi::GAsyncResult,
            user_data: glib::ffi::gpointer,
        ) {
            unsafe {
                let mut error = std::ptr::null_mut();
                ffi::webkit_web_view_can_execute_editing_command_finish(
                    _source_object as *mut _,
                    res,
                    &mut error,
                );
                let result = if error.is_null() {
                    Ok(())
                } else {
                    Err(from_glib_full(error))
                };
                let callback: Box_<glib::thread_guard::ThreadGuard<P>> =
                    Box_::from_raw(user_data as *mut _);
                let callback: P = callback.into_inner();
                callback(result);
            }
        }
        let callback = can_execute_editing_command_trampoline::<P>;
        unsafe {
            ffi::webkit_web_view_can_execute_editing_command(
                self.as_ref().to_glib_none().0,
                command.to_glib_none().0,
                cancellable.map(|p| p.as_ref()).to_glib_none().0,
                Some(callback),
                Box_::into_raw(user_data) as *mut _,
            );
        }
    }

    fn can_execute_editing_command_future(
        &self,
        command: &str,
    ) -> Pin<Box_<dyn std::future::Future<Output = Result<(), glib::Error>> + 'static>> {
        let command = String::from(command);
        Box_::pin(gio::GioFuture::new(self, move |obj, cancellable, send| {
            obj.can_execute_editing_command(&command, Some(cancellable), move |res| {
                send.resolve(res);
            });
        }))
    }

    /// Determines whether `self` has a previous history item.
    ///
    /// # Returns
    ///
    /// [`true`] if able to move back or [`false`] otherwise.
    #[doc(alias = "webkit_web_view_can_go_back")]
    fn can_go_back(&self) -> bool {
        unsafe {
            from_glib(ffi::webkit_web_view_can_go_back(
                self.as_ref().to_glib_none().0,
            ))
        }
    }

    /// Determines whether `self` has a next history item.
    ///
    /// # Returns
    ///
    /// [`true`] if able to move forward or [`false`] otherwise.
    #[doc(alias = "webkit_web_view_can_go_forward")]
    fn can_go_forward(&self) -> bool {
        unsafe {
            from_glib(ffi::webkit_web_view_can_go_forward(
                self.as_ref().to_glib_none().0,
            ))
        }
    }

    /// Whether or not a MIME type can be displayed in `self`.
    /// ## `mime_type`
    /// a MIME type
    ///
    /// # Returns
    ///
    /// [`true`] if the MIME type `mime_type` can be displayed or [`false`] otherwise
    #[doc(alias = "webkit_web_view_can_show_mime_type")]
    fn can_show_mime_type(&self, mime_type: &str) -> bool {
        unsafe {
            from_glib(ffi::webkit_web_view_can_show_mime_type(
                self.as_ref().to_glib_none().0,
                mime_type.to_glib_none().0,
            ))
        }
    }

    /// Requests downloading of the specified URI string for `self`.
    /// ## `uri`
    /// the URI to download
    ///
    /// # Returns
    ///
    /// a new [`Download`][crate::Download] representing
    ///  the download operation.
    #[doc(alias = "webkit_web_view_download_uri")]
    fn download_uri(&self, uri: &str) -> Option<Download> {
        unsafe {
            from_glib_full(ffi::webkit_web_view_download_uri(
                self.as_ref().to_glib_none().0,
                uri.to_glib_none().0,
            ))
        }
    }

    /// Asynchronously evaluate `script` in the script world with name `world_name` of the main frame current context in `self`.
    /// If `world_name` is [`None`], the default world is used. Any value that is not [`None`] is a distinct world.
    /// The `source_uri` 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 [`enable-javascript`][struct@crate::Settings#enable-javascript] 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 [`enable-javascript-markup`][struct@crate::Settings#enable-javascript-markup].
    ///
    /// When the operation is finished, `callback` will be called. You can then call
    /// `webkit_web_view_evaluate_javascript_finish()` to get the result of the operation.
    ///
    /// This is an example of using [`evaluate_javascript()`][Self::evaluate_javascript()] with a script returning
    /// a string:
    ///
    /// **⚠️ The following code is in c ⚠️**
    ///
    /// ```c
    /// 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");
    ///     }
    ///     g_object_unref (value);
    /// }
    ///
    /// 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);
    /// }
    /// ```
    /// ## `script`
    /// the script to evaluate
    /// ## `length`
    /// length of `script`, or -1 if `script` is a nul-terminated string
    /// ## `world_name`
    /// the name of a `WebKitScriptWorld` or [`None`] to use the default
    /// ## `source_uri`
    /// the source URI
    /// ## `cancellable`
    /// a [`gio::Cancellable`][crate::gio::Cancellable] or [`None`] to ignore
    /// ## `callback`
    /// a `GAsyncReadyCallback` to call when the script finished
    #[doc(alias = "webkit_web_view_evaluate_javascript")]
    fn evaluate_javascript<P: FnOnce(Result<javascriptcore::Value, glib::Error>) + 'static>(
        &self,
        script: &str,
        world_name: Option<&str>,
        source_uri: Option<&str>,
        cancellable: Option<&impl IsA<gio::Cancellable>>,
        callback: P,
    ) {
        let length = script.len() as _;

        let main_context = glib::MainContext::ref_thread_default();
        let is_main_context_owner = main_context.is_owner();
        let has_acquired_main_context = (!is_main_context_owner)
            .then(|| main_context.acquire().ok())
            .flatten();
        assert!(
            is_main_context_owner || has_acquired_main_context.is_some(),
            "Async operations only allowed if the thread is owning the MainContext"
        );

        let user_data: Box_<glib::thread_guard::ThreadGuard<P>> =
            Box_::new(glib::thread_guard::ThreadGuard::new(callback));
        unsafe extern "C" fn evaluate_javascript_trampoline<
            P: FnOnce(Result<javascriptcore::Value, glib::Error>) + 'static,
        >(
            _source_object: *mut glib::gobject_ffi::GObject,
            res: *mut gio::ffi::GAsyncResult,
            user_data: glib::ffi::gpointer,
        ) {
            unsafe {
                let mut error = std::ptr::null_mut();
                let ret = ffi::webkit_web_view_evaluate_javascript_finish(
                    _source_object as *mut _,
                    res,
                    &mut error,
                );
                let result = if error.is_null() {
                    Ok(from_glib_full(ret))
                } else {
                    Err(from_glib_full(error))
                };
                let callback: Box_<glib::thread_guard::ThreadGuard<P>> =
                    Box_::from_raw(user_data as *mut _);
                let callback: P = callback.into_inner();
                callback(result);
            }
        }
        let callback = evaluate_javascript_trampoline::<P>;
        unsafe {
            ffi::webkit_web_view_evaluate_javascript(
                self.as_ref().to_glib_none().0,
                script.to_glib_none().0,
                length,
                world_name.to_glib_none().0,
                source_uri.to_glib_none().0,
                cancellable.map(|p| p.as_ref()).to_glib_none().0,
                Some(callback),
                Box_::into_raw(user_data) as *mut _,
            );
        }
    }

    fn evaluate_javascript_future(
        &self,
        script: &str,
        world_name: Option<&str>,
        source_uri: Option<&str>,
    ) -> Pin<
        Box_<
            dyn std::future::Future<Output = Result<javascriptcore::Value, glib::Error>> + 'static,
        >,
    > {
        let script = String::from(script);
        let world_name = world_name.map(ToOwned::to_owned);
        let source_uri = source_uri.map(ToOwned::to_owned);
        Box_::pin(gio::GioFuture::new(self, move |obj, cancellable, send| {
            obj.evaluate_javascript(
                &script,
                world_name.as_ref().map(::std::borrow::Borrow::borrow),
                source_uri.as_ref().map(::std::borrow::Borrow::borrow),
                Some(cancellable),
                move |res| {
                    send.resolve(res);
                },
            );
        }))
    }

    /// Request to execute the given `command` for `self`.
    ///
    /// You can use [`can_execute_editing_command()`][Self::can_execute_editing_command()] to check whether
    /// it's possible to execute the command.
    /// ## `command`
    /// the command to execute
    #[doc(alias = "webkit_web_view_execute_editing_command")]
    fn execute_editing_command(&self, command: &str) {
        unsafe {
            ffi::webkit_web_view_execute_editing_command(
                self.as_ref().to_glib_none().0,
                command.to_glib_none().0,
            );
        }
    }

    /// Request to execute the given `command` with `argument` for `self`.
    ///
    /// You can use
    /// [`can_execute_editing_command()`][Self::can_execute_editing_command()] to check whether
    /// it's possible to execute the command.
    /// ## `command`
    /// the command to execute
    /// ## `argument`
    /// the command argument
    #[doc(alias = "webkit_web_view_execute_editing_command_with_argument")]
    fn execute_editing_command_with_argument(&self, command: &str, argument: &str) {
        unsafe {
            ffi::webkit_web_view_execute_editing_command_with_argument(
                self.as_ref().to_glib_none().0,
                command.to_glib_none().0,
                argument.to_glib_none().0,
            );
        }
    }

    /// Get the presentation type of [`WebView`][crate::WebView] when created for automation.
    ///
    /// # Returns
    ///
    /// a [`AutomationBrowsingContextPresentation`][crate::AutomationBrowsingContextPresentation].
    #[doc(alias = "webkit_web_view_get_automation_presentation_type")]
    #[doc(alias = "get_automation_presentation_type")]
    #[doc(alias = "automation-presentation-type")]
    fn automation_presentation_type(&self) -> AutomationBrowsingContextPresentation {
        unsafe {
            from_glib(ffi::webkit_web_view_get_automation_presentation_type(
                self.as_ref().to_glib_none().0,
            ))
        }
    }

    /// Obtains the [`BackForwardList`][crate::BackForwardList] associated with the given [`WebView`][crate::WebView].
    ///
    /// The [`BackForwardList`][crate::BackForwardList] is owned by the [`WebView`][crate::WebView].
    ///
    /// # Returns
    ///
    /// the [`BackForwardList`][crate::BackForwardList]
    #[doc(alias = "webkit_web_view_get_back_forward_list")]
    #[doc(alias = "get_back_forward_list")]
    fn back_forward_list(&self) -> Option<BackForwardList> {
        unsafe {
            from_glib_none(ffi::webkit_web_view_get_back_forward_list(
                self.as_ref().to_glib_none().0,
            ))
        }
    }

    /// Gets the color that is used to draw the `self` background.
    ///
    /// Gets the color that is used to draw the `self` background before
    /// the actual contents are rendered.
    /// For more information see also [`set_background_color()`][Self::set_background_color()]
    ///
    /// # Returns
    ///
    ///
    /// ## `rgba`
    /// a [`gdk::RGBA`][crate::gdk::RGBA] to fill in with the background color
    #[doc(alias = "webkit_web_view_get_background_color")]
    #[doc(alias = "get_background_color")]
    fn background_color(&self) -> gdk::RGBA {
        unsafe {
            let mut rgba = gdk::RGBA::uninitialized();
            ffi::webkit_web_view_get_background_color(
                self.as_ref().to_glib_none().0,
                rgba.to_glib_none_mut().0,
            );
            rgba
        }
    }

    /// Get the camera capture state of a [`WebView`][crate::WebView].
    ///
    /// # Returns
    ///
    /// The [`MediaCaptureState`][crate::MediaCaptureState] of the camera device. If [`enable-mediastream`][struct@crate::Settings#enable-mediastream]
    /// is [`false`], this method will return [`MediaCaptureState::None`][crate::MediaCaptureState::None].
    #[doc(alias = "webkit_web_view_get_camera_capture_state")]
    #[doc(alias = "get_camera_capture_state")]
    #[doc(alias = "camera-capture-state")]
    fn camera_capture_state(&self) -> MediaCaptureState {
        unsafe {
            from_glib(ffi::webkit_web_view_get_camera_capture_state(
                self.as_ref().to_glib_none().0,
            ))
        }
    }

    /// Gets the web context of `self`.
    ///
    /// # Returns
    ///
    /// the [`WebContext`][crate::WebContext] of the view
    #[doc(alias = "webkit_web_view_get_context")]
    #[doc(alias = "get_context")]
    fn context(&self) -> Option<WebContext> {
        unsafe {
            from_glib_none(ffi::webkit_web_view_get_context(
                self.as_ref().to_glib_none().0,
            ))
        }
    }

    /// Returns the current custom character encoding name of `self`.
    ///
    /// # Returns
    ///
    /// the current custom character encoding name or [`None`] if no
    ///  custom character encoding has been set.
    #[doc(alias = "webkit_web_view_get_custom_charset")]
    #[doc(alias = "get_custom_charset")]
    fn custom_charset(&self) -> Option<glib::GString> {
        unsafe {
            from_glib_none(ffi::webkit_web_view_get_custom_charset(
                self.as_ref().to_glib_none().0,
            ))
        }
    }

    /// Gets the configured default Content-Security-Policy.
    ///
    /// # Returns
    ///
    /// The default policy or [`None`]
    #[doc(alias = "webkit_web_view_get_default_content_security_policy")]
    #[doc(alias = "get_default_content_security_policy")]
    #[doc(alias = "default-content-security-policy")]
    fn default_content_security_policy(&self) -> Option<glib::GString> {
        unsafe {
            from_glib_none(ffi::webkit_web_view_get_default_content_security_policy(
                self.as_ref().to_glib_none().0,
            ))
        }
    }

    /// Get the display capture state of a [`WebView`][crate::WebView].
    ///
    /// # Returns
    ///
    /// The [`MediaCaptureState`][crate::MediaCaptureState] of the display device. If [`enable-mediastream`][struct@crate::Settings#enable-mediastream]
    /// is [`false`], this method will return [`MediaCaptureState::None`][crate::MediaCaptureState::None].
    #[doc(alias = "webkit_web_view_get_display_capture_state")]
    #[doc(alias = "get_display_capture_state")]
    #[doc(alias = "display-capture-state")]
    fn display_capture_state(&self) -> MediaCaptureState {
        unsafe {
            from_glib(ffi::webkit_web_view_get_display_capture_state(
                self.as_ref().to_glib_none().0,
            ))
        }
    }

    /// Gets the web editor state of `self`.
    ///
    /// # Returns
    ///
    /// the [`EditorState`][crate::EditorState] of the view
    #[doc(alias = "webkit_web_view_get_editor_state")]
    #[doc(alias = "get_editor_state")]
    fn editor_state(&self) -> Option<EditorState> {
        unsafe {
            from_glib_none(ffi::webkit_web_view_get_editor_state(
                self.as_ref().to_glib_none().0,
            ))
        }
    }

    /// Gets the value of the [`estimated-load-progress`][struct@crate::WebView#estimated-load-progress] property.
    ///
    /// You can monitor the estimated progress of a load operation by
    /// connecting to the notify::estimated-load-progress signal of `self`.
    ///
    /// # Returns
    ///
    /// an estimate of the of the percent complete for a document
    ///  load as a range from 0.0 to 1.0.
    #[doc(alias = "webkit_web_view_get_estimated_load_progress")]
    #[doc(alias = "get_estimated_load_progress")]
    #[doc(alias = "estimated-load-progress")]
    fn estimated_load_progress(&self) -> f64 {
        unsafe { ffi::webkit_web_view_get_estimated_load_progress(self.as_ref().to_glib_none().0) }
    }

    /// Returns favicon currently associated to `self`.
    ///
    /// Returns favicon currently associated to `self`, if any. You can
    /// connect to notify::favicon signal of `self` to be notified when
    /// the favicon is available.
    ///
    /// # Returns
    ///
    /// the favicon image or [`None`] if there's no
    ///  icon associated with `self`.
    #[doc(alias = "webkit_web_view_get_favicon")]
    #[doc(alias = "get_favicon")]
    fn favicon(&self) -> Option<gdk::Texture> {
        unsafe {
            from_glib_none(ffi::webkit_web_view_get_favicon(
                self.as_ref().to_glib_none().0,
            ))
        }
    }

    /// Gets the [`FindController`][crate::FindController].
    ///
    /// Gets the [`FindController`][crate::FindController] that will allow the caller to query
    /// the [`WebView`][crate::WebView] for the text to look for.
    ///
    /// # Returns
    ///
    /// the [`FindController`][crate::FindController] associated to
    /// this particular [`WebView`][crate::WebView].
    #[doc(alias = "webkit_web_view_get_find_controller")]
    #[doc(alias = "get_find_controller")]
    fn find_controller(&self) -> Option<FindController> {
        unsafe {
            from_glib_none(ffi::webkit_web_view_get_find_controller(
                self.as_ref().to_glib_none().0,
            ))
        }
    }

    /// Get the [`InputMethodContext`][crate::InputMethodContext] currently in use by `self`.
    ///
    /// Get the [`InputMethodContext`][crate::InputMethodContext] currently in use by `self`, or [`None`] if no input method is being used.
    ///
    /// # Returns
    ///
    /// a [`InputMethodContext`][crate::InputMethodContext], or [`None`]
    #[doc(alias = "webkit_web_view_get_input_method_context")]
    #[doc(alias = "get_input_method_context")]
    fn input_method_context(&self) -> Option<InputMethodContext> {
        unsafe {
            from_glib_none(ffi::webkit_web_view_get_input_method_context(
                self.as_ref().to_glib_none().0,
            ))
        }
    }

    /// Get the [`WebInspector`][crate::WebInspector] associated to `self`
    ///
    /// # Returns
    ///
    /// the [`WebInspector`][crate::WebInspector] of `self`
    #[doc(alias = "webkit_web_view_get_inspector")]
    #[doc(alias = "get_inspector")]
    fn inspector(&self) -> Option<WebInspector> {
        unsafe {
            from_glib_none(ffi::webkit_web_view_get_inspector(
                self.as_ref().to_glib_none().0,
            ))
        }
    }

    /// Gets the mute state of `self`.
    ///
    /// # Returns
    ///
    /// [`true`] if `self` audio is muted or [`false`] is audio is not muted.
    #[doc(alias = "webkit_web_view_get_is_muted")]
    #[doc(alias = "get_is_muted")]
    #[doc(alias = "is-muted")]
    fn is_muted(&self) -> bool {
        unsafe {
            from_glib(ffi::webkit_web_view_get_is_muted(
                self.as_ref().to_glib_none().0,
            ))
        }
    }

    /// Get whether the current web process of a [`WebView`][crate::WebView] is responsive.
    ///
    /// # Returns
    ///
    /// [`true`] if the web process attached to `self` is responsive, or [`false`] otherwise.
    #[doc(alias = "webkit_web_view_get_is_web_process_responsive")]
    #[doc(alias = "get_is_web_process_responsive")]
    #[doc(alias = "is-web-process-responsive")]
    fn is_web_process_responsive(&self) -> bool {
        unsafe {
            from_glib(ffi::webkit_web_view_get_is_web_process_responsive(
                self.as_ref().to_glib_none().0,
            ))
        }
    }

    /// Return the main resource of `self`.
    ///
    /// # Returns
    ///
    /// the main [`WebResource`][crate::WebResource] of the view
    ///  or [`None`] if nothing has been loaded.
    #[doc(alias = "webkit_web_view_get_main_resource")]
    #[doc(alias = "get_main_resource")]
    fn main_resource(&self) -> Option<WebResource> {
        unsafe {
            from_glib_none(ffi::webkit_web_view_get_main_resource(
                self.as_ref().to_glib_none().0,
            ))
        }
    }

    /// Get the microphone capture state of a [`WebView`][crate::WebView].
    ///
    /// # Returns
    ///
    /// The [`MediaCaptureState`][crate::MediaCaptureState] of the microphone device. If [`enable-mediastream`][struct@crate::Settings#enable-mediastream]
    /// is [`false`], this method will return [`MediaCaptureState::None`][crate::MediaCaptureState::None].
    #[doc(alias = "webkit_web_view_get_microphone_capture_state")]
    #[doc(alias = "get_microphone_capture_state")]
    #[doc(alias = "microphone-capture-state")]
    fn microphone_capture_state(&self) -> MediaCaptureState {
        unsafe {
            from_glib(ffi::webkit_web_view_get_microphone_capture_state(
                self.as_ref().to_glib_none().0,
            ))
        }
    }

    /// Get the [`NetworkSession`][crate::NetworkSession] associated to `self`.
    ///
    /// # Returns
    ///
    /// a [`NetworkSession`][crate::NetworkSession]
    #[doc(alias = "webkit_web_view_get_network_session")]
    #[doc(alias = "get_network_session")]
    #[doc(alias = "network-session")]
    fn network_session(&self) -> Option<NetworkSession> {
        unsafe {
            from_glib_none(ffi::webkit_web_view_get_network_session(
                self.as_ref().to_glib_none().0,
            ))
        }
    }

    /// Get the identifier of the `WebKitWebPage` corresponding to
    /// the [`WebView`][crate::WebView]
    ///
    /// # Returns
    ///
    /// the page ID of `self`.
    #[doc(alias = "webkit_web_view_get_page_id")]
    #[doc(alias = "get_page_id")]
    #[doc(alias = "page-id")]
    fn page_id(&self) -> u64 {
        unsafe { ffi::webkit_web_view_get_page_id(self.as_ref().to_glib_none().0) }
    }

    /// Gets the current session state of `self`
    ///
    /// # Returns
    ///
    /// a [`WebViewSessionState`][crate::WebViewSessionState]
    #[doc(alias = "webkit_web_view_get_session_state")]
    #[doc(alias = "get_session_state")]
    fn session_state(&self) -> Option<WebViewSessionState> {
        unsafe {
            from_glib_full(ffi::webkit_web_view_get_session_state(
                self.as_ref().to_glib_none().0,
            ))
        }
    }

    /// Gets the [`Settings`][crate::Settings] currently applied to `self`.
    ///
    /// If no other [`Settings`][crate::Settings] have been explicitly applied to
    /// `self` with [`set_settings()`][Self::set_settings()], the default
    /// [`Settings`][crate::Settings] will be returned. This method always returns
    /// a valid [`Settings`][crate::Settings] object.
    /// To modify any of the `self` settings, you can either create
    /// a new [`Settings`][crate::Settings] object with [`Settings::new()`][crate::Settings::new()], setting
    /// the desired preferences, and then replace the existing `self`
    /// settings with [`set_settings()`][Self::set_settings()] or get the existing
    /// `self` settings and update it directly. [`Settings`][crate::Settings] objects
    /// can be shared by multiple [`WebView`][crate::WebView]<!-- -->s, so modifying
    /// the settings of a [`WebView`][crate::WebView] would affect other
    /// [`WebView`][crate::WebView]<!-- -->s using the same [`Settings`][crate::Settings].
    ///
    /// # Returns
    ///
    /// the [`Settings`][crate::Settings] attached to `self`
    #[doc(alias = "webkit_web_view_get_settings")]
    #[doc(alias = "get_settings")]
    fn settings(&self) -> Option<Settings> {
        unsafe {
            from_glib_none(ffi::webkit_web_view_get_settings(
                self.as_ref().to_glib_none().0,
            ))
        }
    }

    /// Asynchronously retrieves a snapshot of `self` 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.
    /// ## `region`
    /// the [`SnapshotRegion`][crate::SnapshotRegion] for this snapshot
    /// ## `options`
    /// [`SnapshotOptions`][crate::SnapshotOptions] for the snapshot
    /// ## `cancellable`
    /// a [`gio::Cancellable`][crate::gio::Cancellable]
    /// ## `callback`
    /// a `GAsyncReadyCallback`
    #[doc(alias = "webkit_web_view_get_snapshot")]
    #[doc(alias = "get_snapshot")]
    fn snapshot<P: FnOnce(Result<gdk::Texture, glib::Error>) + 'static>(
        &self,
        region: SnapshotRegion,
        options: SnapshotOptions,
        cancellable: Option<&impl IsA<gio::Cancellable>>,
        callback: P,
    ) {
        let main_context = glib::MainContext::ref_thread_default();
        let is_main_context_owner = main_context.is_owner();
        let has_acquired_main_context = (!is_main_context_owner)
            .then(|| main_context.acquire().ok())
            .flatten();
        assert!(
            is_main_context_owner || has_acquired_main_context.is_some(),
            "Async operations only allowed if the thread is owning the MainContext"
        );

        let user_data: Box_<glib::thread_guard::ThreadGuard<P>> =
            Box_::new(glib::thread_guard::ThreadGuard::new(callback));
        unsafe extern "C" fn snapshot_trampoline<
            P: FnOnce(Result<gdk::Texture, glib::Error>) + 'static,
        >(
            _source_object: *mut glib::gobject_ffi::GObject,
            res: *mut gio::ffi::GAsyncResult,
            user_data: glib::ffi::gpointer,
        ) {
            unsafe {
                let mut error = std::ptr::null_mut();
                let ret = ffi::webkit_web_view_get_snapshot_finish(
                    _source_object as *mut _,
                    res,
                    &mut error,
                );
                let result = if error.is_null() {
                    Ok(from_glib_full(ret))
                } else {
                    Err(from_glib_full(error))
                };
                let callback: Box_<glib::thread_guard::ThreadGuard<P>> =
                    Box_::from_raw(user_data as *mut _);
                let callback: P = callback.into_inner();
                callback(result);
            }
        }
        let callback = snapshot_trampoline::<P>;
        unsafe {
            ffi::webkit_web_view_get_snapshot(
                self.as_ref().to_glib_none().0,
                region.into_glib(),
                options.into_glib(),
                cancellable.map(|p| p.as_ref()).to_glib_none().0,
                Some(callback),
                Box_::into_raw(user_data) as *mut _,
            );
        }
    }

    fn snapshot_future(
        &self,
        region: SnapshotRegion,
        options: SnapshotOptions,
    ) -> Pin<Box_<dyn std::future::Future<Output = Result<gdk::Texture, glib::Error>> + 'static>>
    {
        Box_::pin(gio::GioFuture::new(self, move |obj, cancellable, send| {
            obj.snapshot(region, options, Some(cancellable), move |res| {
                send.resolve(res);
            });
        }))
    }

    /// Gets the theme color that is specified by the content in the `self`.
    /// If the `self` doesn't have a theme color it will fill the `rgba`
    /// with transparent black content.
    ///
    /// # Returns
    ///
    /// Whether the currently loaded page defines a theme color.
    ///
    /// ## `rgba`
    /// a [`gdk::RGBA`][crate::gdk::RGBA] to fill in with the theme color
    #[cfg(feature = "v2_50")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v2_50")))]
    #[doc(alias = "webkit_web_view_get_theme_color")]
    #[doc(alias = "get_theme_color")]
    #[doc(alias = "theme-color")]
    fn theme_color(&self) -> Option<gdk::RGBA> {
        unsafe {
            let mut rgba = gdk::RGBA::uninitialized();
            let ret = from_glib(ffi::webkit_web_view_get_theme_color(
                self.as_ref().to_glib_none().0,
                rgba.to_glib_none_mut().0,
            ));
            if ret { Some(rgba) } else { None }
        }
    }

    /// Gets the value of the [`title`][struct@crate::WebView#title] property.
    ///
    /// You can connect to notify::title signal of `self` to
    /// be notified when the title has been received.
    ///
    /// # Returns
    ///
    /// The main frame document title of `self`.
    #[doc(alias = "webkit_web_view_get_title")]
    #[doc(alias = "get_title")]
    fn title(&self) -> Option<glib::GString> {
        unsafe {
            from_glib_none(ffi::webkit_web_view_get_title(
                self.as_ref().to_glib_none().0,
            ))
        }
    }

    /// Retrieves the [`gio::TlsCertificate`][crate::gio::TlsCertificate] associated with the main resource of `self`.
    ///
    /// Retrieves the [`gio::TlsCertificate`][crate::gio::TlsCertificate] associated with the main resource of `self`,
    /// and the [`gio::TlsCertificateFlags`][crate::gio::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 [`load-changed`][struct@crate::WebView#load-changed] and call this function
    /// when it's emitted with [`LoadEvent::Committed`][crate::LoadEvent::Committed] event.
    ///
    /// Note that this function provides no information about the security of the web
    /// page if the current [`TLSErrorsPolicy`][crate::TLSErrorsPolicy] is [`TLSErrorsPolicy::Ignore`][crate::TLSErrorsPolicy::Ignore],
    /// 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`][crate::TLSErrorsPolicy] is [`TLSErrorsPolicy::Fail`][crate::TLSErrorsPolicy::Fail], in
    /// which case subresources that fail certificate verification will be blocked.
    ///
    /// # Returns
    ///
    /// [`true`] if the `self` connection uses HTTPS and a response has been received
    ///  from the server, or [`false`] otherwise.
    ///
    /// ## `certificate`
    /// return location for a [`gio::TlsCertificate`][crate::gio::TlsCertificate]
    ///
    /// ## `errors`
    /// return location for a [`gio::TlsCertificateFlags`][crate::gio::TlsCertificateFlags] the verification status of `certificate`
    #[doc(alias = "webkit_web_view_get_tls_info")]
    #[doc(alias = "get_tls_info")]
    fn tls_info(&self) -> Option<(gio::TlsCertificate, gio::TlsCertificateFlags)> {
        unsafe {
            let mut certificate = std::ptr::null_mut();
            let mut errors = std::mem::MaybeUninit::uninit();
            let ret = from_glib(ffi::webkit_web_view_get_tls_info(
                self.as_ref().to_glib_none().0,
                &mut certificate,
                errors.as_mut_ptr(),
            ));
            if ret {
                Some((from_glib_none(certificate), from_glib(errors.assume_init())))
            } else {
                None
            }
        }
    }

    /// Returns the current active URI of `self`.
    ///
    /// The active URI might change during
    /// a load operation:
    ///
    /// `<orderedlist>`
    /// `<listitem>``<para>`
    ///  When nothing has been loaded yet on `self` the active URI is [`None`].
    /// `</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 [`load_uri()`][Self::load_uri()],
    ///  the requested URI is the given one.
    ///  `</para>``</listitem>`
    ///  `<listitem>``<para>`
    ///  If the load operation was started by [`load_html()`][Self::load_html()],
    ///  the requested URI is "about:blank".
    ///  `</para>``</listitem>`
    ///  `<listitem>``<para>`
    ///  If the load operation was started by [`load_alternate_html()`][Self::load_alternate_html()],
    ///  the requested URI is content URI provided.
    ///  `</para>``</listitem>`
    ///  `<listitem>``<para>`
    ///  If the load operation was started by [`go_back()`][Self::go_back()] or
    ///  [`go_forward()`][Self::go_forward()], the requested URI is the original URI
    ///  of the previous/next item in the [`BackForwardList`][crate::BackForwardList] of `self`.
    ///  `</para>``</listitem>`
    ///  `<listitem>``<para>`
    ///  If the load operation was started by
    ///  [`go_to_back_forward_list_item()`][Self::go_to_back_forward_list_item()], the requested URI
    ///  is the opriginal URI of the given [`BackForwardListItem`][crate::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
    ///  [`load-changed`][struct@crate::WebView#load-changed] is emitted with [`LoadEvent::Redirected`][crate::LoadEvent::Redirected]
    ///  event, the active URI is already updated to the redirected URI.
    /// `</para>``</listitem>`
    /// `<listitem>``<para>`
    ///  When the signal [`load-changed`][struct@crate::WebView#load-changed] is emitted
    ///  with [`LoadEvent::Committed`][crate::LoadEvent::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 `self`.
    ///
    /// # Returns
    ///
    /// the current active URI of `self` or [`None`]
    ///  if nothing has been loaded yet.
    #[doc(alias = "webkit_web_view_get_uri")]
    #[doc(alias = "get_uri")]
    fn uri(&self) -> Option<glib::GString> {
        unsafe { from_glib_none(ffi::webkit_web_view_get_uri(self.as_ref().to_glib_none().0)) }
    }

    /// Gets the user content manager associated to `self`.
    ///
    /// # Returns
    ///
    /// the [`UserContentManager`][crate::UserContentManager] associated with the view
    #[doc(alias = "webkit_web_view_get_user_content_manager")]
    #[doc(alias = "get_user_content_manager")]
    #[doc(alias = "user-content-manager")]
    fn user_content_manager(&self) -> Option<UserContentManager> {
        unsafe {
            from_glib_none(ffi::webkit_web_view_get_user_content_manager(
                self.as_ref().to_glib_none().0,
            ))
        }
    }

    /// Get the view's [`WebExtensionMode`][crate::WebExtensionMode].
    ///
    /// # Returns
    ///
    /// the [`WebExtensionMode`][crate::WebExtensionMode]
    #[doc(alias = "webkit_web_view_get_web_extension_mode")]
    #[doc(alias = "get_web_extension_mode")]
    #[doc(alias = "web-extension-mode")]
    fn web_extension_mode(&self) -> WebExtensionMode {
        unsafe {
            from_glib(ffi::webkit_web_view_get_web_extension_mode(
                self.as_ref().to_glib_none().0,
            ))
        }
    }

    /// Gets the default website policies.
    ///
    /// Gets the default website policies set on construction in the
    /// `self`. These can be overridden on a per-origin basis via the
    /// [`decide-policy`][struct@crate::WebView#decide-policy] signal handler.
    ///
    /// See also [`PolicyDecisionExt::use_with_policies()`][crate::prelude::PolicyDecisionExt::use_with_policies()].
    ///
    /// # Returns
    ///
    /// the default [`WebsitePolicies`][crate::WebsitePolicies]
    ///  associated with the view.
    #[doc(alias = "webkit_web_view_get_website_policies")]
    #[doc(alias = "get_website_policies")]
    #[doc(alias = "website-policies")]
    fn website_policies(&self) -> Option<WebsitePolicies> {
        unsafe {
            from_glib_none(ffi::webkit_web_view_get_website_policies(
                self.as_ref().to_glib_none().0,
            ))
        }
    }

    /// Get the [`WindowProperties`][crate::WindowProperties] object.
    ///
    /// Get the [`WindowProperties`][crate::WindowProperties] object containing the properties
    /// that the window containing `self` should have.
    ///
    /// # Returns
    ///
    /// the [`WindowProperties`][crate::WindowProperties] of `self`
    #[doc(alias = "webkit_web_view_get_window_properties")]
    #[doc(alias = "get_window_properties")]
    fn window_properties(&self) -> Option<WindowProperties> {
        unsafe {
            from_glib_none(ffi::webkit_web_view_get_window_properties(
                self.as_ref().to_glib_none().0,
            ))
        }
    }

    /// Set the zoom level of `self`.
    ///
    /// Get the zoom level of `self`, i.e. the factor by which the
    /// view contents are scaled with respect to their original size.
    ///
    /// # Returns
    ///
    /// the current zoom level of `self`
    #[doc(alias = "webkit_web_view_get_zoom_level")]
    #[doc(alias = "get_zoom_level")]
    #[doc(alias = "zoom-level")]
    fn zoom_level(&self) -> f64 {
        unsafe { ffi::webkit_web_view_get_zoom_level(self.as_ref().to_glib_none().0) }
    }

    /// Loads the previous history item.
    ///
    /// You can monitor the load operation by connecting to
    /// [`load-changed`][struct@crate::WebView#load-changed] signal.
    #[doc(alias = "webkit_web_view_go_back")]
    fn go_back(&self) {
        unsafe {
            ffi::webkit_web_view_go_back(self.as_ref().to_glib_none().0);
        }
    }

    /// Loads the next history item.
    ///
    /// You can monitor the load operation by connecting to
    /// [`load-changed`][struct@crate::WebView#load-changed] signal.
    #[doc(alias = "webkit_web_view_go_forward")]
    fn go_forward(&self) {
        unsafe {
            ffi::webkit_web_view_go_forward(self.as_ref().to_glib_none().0);
        }
    }

    /// Loads the specific history item `list_item`.
    ///
    /// You can monitor the load operation by connecting to
    /// [`load-changed`][struct@crate::WebView#load-changed] signal.
    /// ## `list_item`
    /// a [`BackForwardListItem`][crate::BackForwardListItem]
    #[doc(alias = "webkit_web_view_go_to_back_forward_list_item")]
    fn go_to_back_forward_list_item(&self, list_item: &BackForwardListItem) {
        unsafe {
            ffi::webkit_web_view_go_to_back_forward_list_item(
                self.as_ref().to_glib_none().0,
                list_item.to_glib_none().0,
            );
        }
    }

    /// Get whether a [`WebView`][crate::WebView] was created with [`is-controlled-by-automation`][struct@crate::WebView#is-controlled-by-automation]
    /// property enabled.
    ///
    /// Only [`WebView`][crate::WebView]<!-- -->s controlled by automation can be used in an
    /// automation session.
    ///
    /// # Returns
    ///
    /// [`true`] if `self` is controlled by automation, or [`false`] otherwise.
    #[doc(alias = "webkit_web_view_is_controlled_by_automation")]
    fn is_controlled_by_automation(&self) -> bool {
        unsafe {
            from_glib(ffi::webkit_web_view_is_controlled_by_automation(
                self.as_ref().to_glib_none().0,
            ))
        }
    }

    /// Gets whether the user is allowed to edit the HTML document.
    ///
    /// When `self` 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`][crate::WebView] is not editable.
    ///
    /// # Returns
    ///
    /// [`true`] if the user is allowed to edit the HTML document, or [`false`] otherwise.
    #[doc(alias = "webkit_web_view_is_editable")]
    #[doc(alias = "editable")]
    fn is_editable(&self) -> bool {
        unsafe {
            from_glib(ffi::webkit_web_view_is_editable(
                self.as_ref().to_glib_none().0,
            ))
        }
    }

    /// Gets whether `self` is in immersive mode.
    ///
    /// An immersive session is a mode in which the user is presented with a fully immersive XR experience
    /// (such as VR or AR), typically rendered via a headset.
    ///
    /// Note that if WebXR is disabled or OPENXR is not used, this API always returns [`false`].
    ///
    /// # Returns
    ///
    /// [`true`] if the `self` is in immersive mode, or [`false`] otherwise.
    #[cfg(feature = "v2_52")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v2_52")))]
    #[doc(alias = "webkit_web_view_is_immersive_mode_enabled")]
    #[doc(alias = "is-immersive-mode-enabled")]
    fn is_immersive_mode_enabled(&self) -> bool {
        unsafe {
            from_glib(ffi::webkit_web_view_is_immersive_mode_enabled(
                self.as_ref().to_glib_none().0,
            ))
        }
    }

    /// Gets the value of the [`is-loading`][struct@crate::WebView#is-loading] property.
    ///
    /// You can monitor when a [`WebView`][crate::WebView] is loading a page by connecting to
    /// notify::is-loading signal of `self`. 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.
    ///
    /// # Returns
    ///
    /// [`true`] if `self` is loading a page or [`false`] otherwise.
    #[doc(alias = "webkit_web_view_is_loading")]
    #[doc(alias = "is-loading")]
    fn is_loading(&self) -> bool {
        unsafe {
            from_glib(ffi::webkit_web_view_is_loading(
                self.as_ref().to_glib_none().0,
            ))
        }
    }

    /// Gets the value of the [`is-playing-audio`][struct@crate::WebView#is-playing-audio] property.
    ///
    /// You can monitor when a page in a [`WebView`][crate::WebView] is playing audio by
    /// connecting to the notify::is-playing-audio signal of `self`. This
    /// is useful when the application wants to provide visual feedback when a
    /// page is producing sound.
    ///
    /// # Returns
    ///
    /// [`true`] if a page in `self` is playing audio or [`false`] otherwise.
    #[doc(alias = "webkit_web_view_is_playing_audio")]
    #[doc(alias = "is-playing-audio")]
    fn is_playing_audio(&self) -> bool {
        unsafe {
            from_glib(ffi::webkit_web_view_is_playing_audio(
                self.as_ref().to_glib_none().0,
            ))
        }
    }

    /// Requests to leave the immersive mode this [`WebView`][crate::WebView] is in.
    ///
    /// Users interact with web content to start XR sessions, and can typically
    /// end the sessions themselves, but applications might need to end a session on their
    /// own based on application or platform logic.
    ///
    /// Note that if WebXR is disabled, or if it is enabled but the `self` is not in
    /// immersive mode, this API does nothing. See also [`is_immersive_mode_enabled()`][Self::is_immersive_mode_enabled()].
    #[cfg(feature = "v2_52")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v2_52")))]
    #[doc(alias = "webkit_web_view_leave_immersive_mode")]
    fn leave_immersive_mode(&self) {
        unsafe {
            ffi::webkit_web_view_leave_immersive_mode(self.as_ref().to_glib_none().0);
        }
    }

    /// Load the given `content` string for the URI `content_uri`.
    ///
    /// This allows clients to display page-loading errors in the [`WebView`][crate::WebView] itself.
    /// When this method is called from [`load-failed`][struct@crate::WebView#load-failed] signal to show an
    /// error page, then the back-forward list is maintained appropriately.
    /// For everything else this method works the same way as [`load_html()`][Self::load_html()].
    /// ## `content`
    /// the new content to display as the main page of the `self`
    /// ## `content_uri`
    /// the URI for the alternate page content
    /// ## `base_uri`
    /// the base URI for relative locations or [`None`]
    #[doc(alias = "webkit_web_view_load_alternate_html")]
    fn load_alternate_html(&self, content: &str, content_uri: &str, base_uri: Option<&str>) {
        unsafe {
            ffi::webkit_web_view_load_alternate_html(
                self.as_ref().to_glib_none().0,
                content.to_glib_none().0,
                content_uri.to_glib_none().0,
                base_uri.to_glib_none().0,
            );
        }
    }

    /// Load the specified `bytes` into `self` using the given `mime_type` and `encoding`.
    ///
    /// When `mime_type` is [`None`], it defaults to "text/html".
    /// When `encoding` is [`None`], it defaults to "UTF-8".
    /// When `base_uri` is [`None`], it defaults to "about:blank".
    /// You can monitor the load operation by connecting to [`load-changed`][struct@crate::WebView#load-changed] signal.
    /// ## `bytes`
    /// input data to load
    /// ## `mime_type`
    /// the MIME type of `bytes`, or [`None`]
    /// ## `encoding`
    /// the character encoding of `bytes`, or [`None`]
    /// ## `base_uri`
    /// the base URI for relative locations or [`None`]
    #[doc(alias = "webkit_web_view_load_bytes")]
    fn load_bytes(
        &self,
        bytes: &glib::Bytes,
        mime_type: Option<&str>,
        encoding: Option<&str>,
        base_uri: Option<&str>,
    ) {
        unsafe {
            ffi::webkit_web_view_load_bytes(
                self.as_ref().to_glib_none().0,
                bytes.to_glib_none().0,
                mime_type.to_glib_none().0,
                encoding.to_glib_none().0,
                base_uri.to_glib_none().0,
            );
        }
    }

    /// Load the given `content` string with the specified `base_uri`.
    ///
    /// If `base_uri` is not [`None`], 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 [`None`],
    /// it defaults to "about:blank". The mime type of the document will be "text/html".
    /// You can monitor the load operation by connecting to [`load-changed`][struct@crate::WebView#load-changed] signal.
    /// ## `content`
    /// The HTML string to load
    /// ## `base_uri`
    /// The base URI for relative locations or [`None`]
    #[doc(alias = "webkit_web_view_load_html")]
    fn load_html(&self, content: &str, base_uri: Option<&str>) {
        unsafe {
            ffi::webkit_web_view_load_html(
                self.as_ref().to_glib_none().0,
                content.to_glib_none().0,
                base_uri.to_glib_none().0,
            );
        }
    }

    /// Load the specified `plain_text` string into `self`.
    ///
    /// The mime type of document will be "text/plain". You can monitor the load
    /// operation by connecting to [`load-changed`][struct@crate::WebView#load-changed] signal.
    /// ## `plain_text`
    /// The plain text to load
    #[doc(alias = "webkit_web_view_load_plain_text")]
    fn load_plain_text(&self, plain_text: &str) {
        unsafe {
            ffi::webkit_web_view_load_plain_text(
                self.as_ref().to_glib_none().0,
                plain_text.to_glib_none().0,
            );
        }
    }

    /// Requests loading of the specified [`URIRequest`][crate::URIRequest].
    ///
    /// You can monitor the load operation by connecting to
    /// [`load-changed`][struct@crate::WebView#load-changed] signal.
    /// ## `request`
    /// a [`URIRequest`][crate::URIRequest] to load
    #[doc(alias = "webkit_web_view_load_request")]
    fn load_request(&self, request: &URIRequest) {
        unsafe {
            ffi::webkit_web_view_load_request(
                self.as_ref().to_glib_none().0,
                request.to_glib_none().0,
            );
        }
    }

    /// Requests loading of the specified URI string.
    ///
    /// You can monitor the load operation by connecting to
    /// [`load-changed`][struct@crate::WebView#load-changed] signal.
    /// ## `uri`
    /// an URI string
    #[doc(alias = "webkit_web_view_load_uri")]
    fn load_uri(&self, uri: &str) {
        unsafe {
            ffi::webkit_web_view_load_uri(self.as_ref().to_glib_none().0, uri.to_glib_none().0);
        }
    }

    /// Reloads the current contents of `self`.
    ///
    /// See also [`reload_bypass_cache()`][Self::reload_bypass_cache()].
    #[doc(alias = "webkit_web_view_reload")]
    fn reload(&self) {
        unsafe {
            ffi::webkit_web_view_reload(self.as_ref().to_glib_none().0);
        }
    }

    /// Reloads the current contents of `self` without
    /// using any cached data.
    #[doc(alias = "webkit_web_view_reload_bypass_cache")]
    fn reload_bypass_cache(&self) {
        unsafe {
            ffi::webkit_web_view_reload_bypass_cache(self.as_ref().to_glib_none().0);
        }
    }

    /// Restore the `self` session state from `state`
    /// ## `state`
    /// a [`WebViewSessionState`][crate::WebViewSessionState]
    #[doc(alias = "webkit_web_view_restore_session_state")]
    fn restore_session_state(&self, state: &WebViewSessionState) {
        unsafe {
            ffi::webkit_web_view_restore_session_state(
                self.as_ref().to_glib_none().0,
                state.to_glib_none().0,
            );
        }
    }

    /// Asynchronously save the current web page.
    ///
    /// Asynchronously save the current web page associated to the
    /// [`WebView`][crate::WebView] 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.
    /// ## `save_mode`
    /// the [`SaveMode`][crate::SaveMode] specifying how the web page should be saved.
    /// ## `cancellable`
    /// a [`gio::Cancellable`][crate::gio::Cancellable] or [`None`] to ignore
    /// ## `callback`
    /// a `GAsyncReadyCallback` to call when the request is satisfied
    #[doc(alias = "webkit_web_view_save")]
    fn save<P: FnOnce(Result<gio::InputStream, glib::Error>) + 'static>(
        &self,
        save_mode: SaveMode,
        cancellable: Option<&impl IsA<gio::Cancellable>>,
        callback: P,
    ) {
        let main_context = glib::MainContext::ref_thread_default();
        let is_main_context_owner = main_context.is_owner();
        let has_acquired_main_context = (!is_main_context_owner)
            .then(|| main_context.acquire().ok())
            .flatten();
        assert!(
            is_main_context_owner || has_acquired_main_context.is_some(),
            "Async operations only allowed if the thread is owning the MainContext"
        );

        let user_data: Box_<glib::thread_guard::ThreadGuard<P>> =
            Box_::new(glib::thread_guard::ThreadGuard::new(callback));
        unsafe extern "C" fn save_trampoline<
            P: FnOnce(Result<gio::InputStream, glib::Error>) + 'static,
        >(
            _source_object: *mut glib::gobject_ffi::GObject,
            res: *mut gio::ffi::GAsyncResult,
            user_data: glib::ffi::gpointer,
        ) {
            unsafe {
                let mut error = std::ptr::null_mut();
                let ret =
                    ffi::webkit_web_view_save_finish(_source_object as *mut _, res, &mut error);
                let result = if error.is_null() {
                    Ok(from_glib_full(ret))
                } else {
                    Err(from_glib_full(error))
                };
                let callback: Box_<glib::thread_guard::ThreadGuard<P>> =
                    Box_::from_raw(user_data as *mut _);
                let callback: P = callback.into_inner();
                callback(result);
            }
        }
        let callback = save_trampoline::<P>;
        unsafe {
            ffi::webkit_web_view_save(
                self.as_ref().to_glib_none().0,
                save_mode.into_glib(),
                cancellable.map(|p| p.as_ref()).to_glib_none().0,
                Some(callback),
                Box_::into_raw(user_data) as *mut _,
            );
        }
    }

    fn save_future(
        &self,
        save_mode: SaveMode,
    ) -> Pin<Box_<dyn std::future::Future<Output = Result<gio::InputStream, glib::Error>> + 'static>>
    {
        Box_::pin(gio::GioFuture::new(self, move |obj, cancellable, send| {
            obj.save(save_mode, Some(cancellable), move |res| {
                send.resolve(res);
            });
        }))
    }

    /// Asynchronously save the current web page.
    ///
    /// Asynchronously save the current web page associated to the
    /// [`WebView`][crate::WebView] 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.
    /// ## `file`
    /// the [`gio::File`][crate::gio::File] where the current web page should be saved to.
    /// ## `save_mode`
    /// the [`SaveMode`][crate::SaveMode] specifying how the web page should be saved.
    /// ## `cancellable`
    /// a [`gio::Cancellable`][crate::gio::Cancellable] or [`None`] to ignore
    /// ## `callback`
    /// a `GAsyncReadyCallback` to call when the request is satisfied
    #[doc(alias = "webkit_web_view_save_to_file")]
    fn save_to_file<P: FnOnce(Result<(), glib::Error>) + 'static>(
        &self,
        file: &impl IsA<gio::File>,
        save_mode: SaveMode,
        cancellable: Option<&impl IsA<gio::Cancellable>>,
        callback: P,
    ) {
        let main_context = glib::MainContext::ref_thread_default();
        let is_main_context_owner = main_context.is_owner();
        let has_acquired_main_context = (!is_main_context_owner)
            .then(|| main_context.acquire().ok())
            .flatten();
        assert!(
            is_main_context_owner || has_acquired_main_context.is_some(),
            "Async operations only allowed if the thread is owning the MainContext"
        );

        let user_data: Box_<glib::thread_guard::ThreadGuard<P>> =
            Box_::new(glib::thread_guard::ThreadGuard::new(callback));
        unsafe extern "C" fn save_to_file_trampoline<
            P: FnOnce(Result<(), glib::Error>) + 'static,
        >(
            _source_object: *mut glib::gobject_ffi::GObject,
            res: *mut gio::ffi::GAsyncResult,
            user_data: glib::ffi::gpointer,
        ) {
            unsafe {
                let mut error = std::ptr::null_mut();
                ffi::webkit_web_view_save_to_file_finish(_source_object as *mut _, res, &mut error);
                let result = if error.is_null() {
                    Ok(())
                } else {
                    Err(from_glib_full(error))
                };
                let callback: Box_<glib::thread_guard::ThreadGuard<P>> =
                    Box_::from_raw(user_data as *mut _);
                let callback: P = callback.into_inner();
                callback(result);
            }
        }
        let callback = save_to_file_trampoline::<P>;
        unsafe {
            ffi::webkit_web_view_save_to_file(
                self.as_ref().to_glib_none().0,
                file.as_ref().to_glib_none().0,
                save_mode.into_glib(),
                cancellable.map(|p| p.as_ref()).to_glib_none().0,
                Some(callback),
                Box_::into_raw(user_data) as *mut _,
            );
        }
    }

    fn save_to_file_future(
        &self,
        file: &(impl IsA<gio::File> + Clone + 'static),
        save_mode: SaveMode,
    ) -> Pin<Box_<dyn std::future::Future<Output = Result<(), glib::Error>> + 'static>> {
        let file = file.clone();
        Box_::pin(gio::GioFuture::new(self, move |obj, cancellable, send| {
            obj.save_to_file(&file, save_mode, Some(cancellable), move |res| {
                send.resolve(res);
            });
        }))
    }

    /// Send `message` to the `WebKitWebPage` corresponding to `self`.
    ///
    /// If `message` is floating, it's consumed.
    /// If you don't expect any reply, or you simply want to ignore it, you can pass [`None`] as `callback`.
    /// When the operation is finished, `callback` will be called. You can then call
    /// `webkit_web_view_send_message_to_page_finish()` to get the message reply.
    /// ## `message`
    /// a [`UserMessage`][crate::UserMessage]
    /// ## `cancellable`
    /// a [`gio::Cancellable`][crate::gio::Cancellable] or [`None`] to ignore
    /// ## `callback`
    /// (nullable): A `GAsyncReadyCallback` to call when the request is satisfied or [`None`]
    #[doc(alias = "webkit_web_view_send_message_to_page")]
    fn send_message_to_page<P: FnOnce(Result<UserMessage, glib::Error>) + 'static>(
        &self,
        message: &UserMessage,
        cancellable: Option<&impl IsA<gio::Cancellable>>,
        callback: P,
    ) {
        let main_context = glib::MainContext::ref_thread_default();
        let is_main_context_owner = main_context.is_owner();
        let has_acquired_main_context = (!is_main_context_owner)
            .then(|| main_context.acquire().ok())
            .flatten();
        assert!(
            is_main_context_owner || has_acquired_main_context.is_some(),
            "Async operations only allowed if the thread is owning the MainContext"
        );

        let user_data: Box_<glib::thread_guard::ThreadGuard<P>> =
            Box_::new(glib::thread_guard::ThreadGuard::new(callback));
        unsafe extern "C" fn send_message_to_page_trampoline<
            P: FnOnce(Result<UserMessage, glib::Error>) + 'static,
        >(
            _source_object: *mut glib::gobject_ffi::GObject,
            res: *mut gio::ffi::GAsyncResult,
            user_data: glib::ffi::gpointer,
        ) {
            unsafe {
                let mut error = std::ptr::null_mut();
                let ret = ffi::webkit_web_view_send_message_to_page_finish(
                    _source_object as *mut _,
                    res,
                    &mut error,
                );
                let result = if error.is_null() {
                    Ok(from_glib_full(ret))
                } else {
                    Err(from_glib_full(error))
                };
                let callback: Box_<glib::thread_guard::ThreadGuard<P>> =
                    Box_::from_raw(user_data as *mut _);
                let callback: P = callback.into_inner();
                callback(result);
            }
        }
        let callback = send_message_to_page_trampoline::<P>;
        unsafe {
            ffi::webkit_web_view_send_message_to_page(
                self.as_ref().to_glib_none().0,
                message.to_glib_none().0,
                cancellable.map(|p| p.as_ref()).to_glib_none().0,
                Some(callback),
                Box_::into_raw(user_data) as *mut _,
            );
        }
    }

    fn send_message_to_page_future(
        &self,
        message: &UserMessage,
    ) -> Pin<Box_<dyn std::future::Future<Output = Result<UserMessage, glib::Error>> + 'static>>
    {
        let message = message.clone();
        Box_::pin(gio::GioFuture::new(self, move |obj, cancellable, send| {
            obj.send_message_to_page(&message, Some(cancellable), move |res| {
                send.resolve(res);
            });
        }))
    }

    /// Sets the color that will be used to draw the `self` background.
    ///
    /// Sets the color that will be used to draw the `self` background before
    /// the actual contents are rendered. Note that if the web page loaded in `self`
    /// specifies a background color, it will take precedence over the `rgba` color.
    /// By default the `self` background color is opaque white.
    /// ## `rgba`
    /// a [`gdk::RGBA`][crate::gdk::RGBA]
    #[doc(alias = "webkit_web_view_set_background_color")]
    fn set_background_color(&self, rgba: &gdk::RGBA) {
        unsafe {
            ffi::webkit_web_view_set_background_color(
                self.as_ref().to_glib_none().0,
                rgba.to_glib_none().0,
            );
        }
    }

    /// Set the camera capture state of a [`WebView`][crate::WebView].
    ///
    /// If [`enable-mediastream`][struct@crate::Settings#enable-mediastream] is [`false`], this method will have no visible effect. Once the
    /// state of the device has been set to [`MediaCaptureState::None`][crate::MediaCaptureState::None] it cannot be changed
    /// anymore. The page can however request capture again using the mediaDevices API.
    /// ## `state`
    /// a [`MediaCaptureState`][crate::MediaCaptureState]
    #[doc(alias = "webkit_web_view_set_camera_capture_state")]
    #[doc(alias = "camera-capture-state")]
    fn set_camera_capture_state(&self, state: MediaCaptureState) {
        unsafe {
            ffi::webkit_web_view_set_camera_capture_state(
                self.as_ref().to_glib_none().0,
                state.into_glib(),
            );
        }
    }

    /// Sets the `allowlist` for CORS.
    ///
    /// Sets the `allowlist` for which
    /// [Cross-Origin Resource Sharing](https://developer.mozilla.org/en-US/docs/Web/HTTP/CORS)
    /// checks are disabled in `self`. 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.
    /// ## `allowlist`
    /// an allowlist of URI patterns, or [`None`]
    #[doc(alias = "webkit_web_view_set_cors_allowlist")]
    fn set_cors_allowlist(&self, allowlist: &[&str]) {
        unsafe {
            ffi::webkit_web_view_set_cors_allowlist(
                self.as_ref().to_glib_none().0,
                allowlist.to_glib_none().0,
            );
        }
    }

    /// Sets the current custom character encoding override of `self`.
    ///
    /// 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 [`None`] removes the character
    /// encoding override.
    /// ## `charset`
    /// a character encoding name or [`None`]
    #[doc(alias = "webkit_web_view_set_custom_charset")]
    fn set_custom_charset(&self, charset: Option<&str>) {
        unsafe {
            ffi::webkit_web_view_set_custom_charset(
                self.as_ref().to_glib_none().0,
                charset.to_glib_none().0,
            );
        }
    }

    /// Set the display capture state of a [`WebView`][crate::WebView].
    ///
    /// If [`enable-mediastream`][struct@crate::Settings#enable-mediastream] is [`false`], this method will have no visible effect. Once the
    /// state of the device has been set to [`MediaCaptureState::None`][crate::MediaCaptureState::None] it cannot be changed
    /// anymore. The page can however request capture again using the mediaDevices API.
    /// ## `state`
    /// a [`MediaCaptureState`][crate::MediaCaptureState]
    #[doc(alias = "webkit_web_view_set_display_capture_state")]
    #[doc(alias = "display-capture-state")]
    fn set_display_capture_state(&self, state: MediaCaptureState) {
        unsafe {
            ffi::webkit_web_view_set_display_capture_state(
                self.as_ref().to_glib_none().0,
                state.into_glib(),
            );
        }
    }

    /// Sets whether the user is allowed to edit the HTML document.
    ///
    /// If `editable` is [`true`], `self` allows the user to edit the HTML document. If
    /// `editable` is [`false`], an element in `self`'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`][crate::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`][crate::WebView] editable without altering the document or DOM structure.
    /// ## `editable`
    /// a `gboolean` indicating the editable state
    #[doc(alias = "webkit_web_view_set_editable")]
    #[doc(alias = "editable")]
    fn set_editable(&self, editable: bool) {
        unsafe {
            ffi::webkit_web_view_set_editable(self.as_ref().to_glib_none().0, editable.into_glib());
        }
    }

    /// Set the [`InputMethodContext`][crate::InputMethodContext] to be used by `self`.
    ///
    /// Set the [`InputMethodContext`][crate::InputMethodContext] to be used by `self`, or [`None`] to not use any input method.
    /// Note that the same [`InputMethodContext`][crate::InputMethodContext] can't be set on more than one [`WebView`][crate::WebView] at the same time.
    /// ## `context`
    /// the [`InputMethodContext`][crate::InputMethodContext] to set, or [`None`]
    #[doc(alias = "webkit_web_view_set_input_method_context")]
    fn set_input_method_context(&self, context: Option<&impl IsA<InputMethodContext>>) {
        unsafe {
            ffi::webkit_web_view_set_input_method_context(
                self.as_ref().to_glib_none().0,
                context.map(|p| p.as_ref()).to_glib_none().0,
            );
        }
    }

    /// Sets the mute state of `self`.
    /// ## `muted`
    /// mute flag
    #[doc(alias = "webkit_web_view_set_is_muted")]
    #[doc(alias = "is-muted")]
    fn set_is_muted(&self, muted: bool) {
        unsafe {
            ffi::webkit_web_view_set_is_muted(self.as_ref().to_glib_none().0, muted.into_glib());
        }
    }

    /// Set the microphone capture state of a [`WebView`][crate::WebView].
    ///
    /// If [`enable-mediastream`][struct@crate::Settings#enable-mediastream] is [`false`], this method will have no visible effect. Once the
    /// state of the device has been set to [`MediaCaptureState::None`][crate::MediaCaptureState::None] it cannot be changed
    /// anymore. The page can however request capture again using the mediaDevices API.
    /// ## `state`
    /// a [`MediaCaptureState`][crate::MediaCaptureState]
    #[doc(alias = "webkit_web_view_set_microphone_capture_state")]
    #[doc(alias = "microphone-capture-state")]
    fn set_microphone_capture_state(&self, state: MediaCaptureState) {
        unsafe {
            ffi::webkit_web_view_set_microphone_capture_state(
                self.as_ref().to_glib_none().0,
                state.into_glib(),
            );
        }
    }

    /// Sets the [`Settings`][crate::Settings] to be applied to `self`.
    ///
    /// The
    /// existing [`Settings`][crate::Settings] of `self` will be replaced by
    /// `settings`. New settings are applied immediately on `self`.
    /// The same [`Settings`][crate::Settings] object can be shared
    /// by multiple [`WebView`][crate::WebView]<!-- -->s.
    /// ## `settings`
    /// a [`Settings`][crate::Settings]
    #[doc(alias = "webkit_web_view_set_settings")]
    #[doc(alias = "settings")]
    fn set_settings(&self, settings: &Settings) {
        unsafe {
            ffi::webkit_web_view_set_settings(
                self.as_ref().to_glib_none().0,
                settings.to_glib_none().0,
            );
        }
    }

    /// Set the zoom level of `self`.
    ///
    /// Set the zoom level of `self`, i.e. the factor by which the
    /// view contents are scaled with respect to their original size.
    /// ## `zoom_level`
    /// the zoom level
    #[doc(alias = "webkit_web_view_set_zoom_level")]
    #[doc(alias = "zoom-level")]
    fn set_zoom_level(&self, zoom_level: f64) {
        unsafe {
            ffi::webkit_web_view_set_zoom_level(self.as_ref().to_glib_none().0, zoom_level);
        }
    }

    /// Stops any ongoing loading operation in `self`.
    ///
    /// This method does nothing if no content is being loaded.
    /// If there is a loading operation in progress, it will be cancelled and
    /// [`load-failed`][struct@crate::WebView#load-failed] signal will be emitted with
    /// [`NetworkError::Cancelled`][crate::NetworkError::Cancelled] error.
    #[doc(alias = "webkit_web_view_stop_loading")]
    fn stop_loading(&self) {
        unsafe {
            ffi::webkit_web_view_stop_loading(self.as_ref().to_glib_none().0);
        }
    }

    /// Terminates the web process associated to `self`.
    ///
    /// When the web process gets terminated
    /// using this method, the [`web-process-terminated`][struct@crate::WebView#web-process-terminated] signal is emitted with
    /// [`WebProcessTerminationReason::TerminatedByApi`][crate::WebProcessTerminationReason::TerminatedByApi] as the reason for termination.
    #[doc(alias = "webkit_web_view_terminate_web_process")]
    fn terminate_web_process(&self) {
        unsafe {
            ffi::webkit_web_view_terminate_web_process(self.as_ref().to_glib_none().0);
        }
    }

    /// Tries to close the `self`.
    ///
    /// 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 [`close`][struct@crate::WebView#close] signal is emitted, otherwise nothing happens.
    #[doc(alias = "webkit_web_view_try_close")]
    fn try_close(&self) {
        unsafe {
            ffi::webkit_web_view_try_close(self.as_ref().to_glib_none().0);
        }
    }

    /// The [`WebContext`][crate::WebContext] of the view.
    #[doc(alias = "web-context")]
    fn web_context(&self) -> Option<WebContext> {
        ObjectExt::property(self.as_ref(), "web-context")
    }

    /// 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`][crate::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.
    /// ## `request`
    /// a [`AuthenticationRequest`][crate::AuthenticationRequest]
    ///
    /// # Returns
    ///
    /// [`true`] to stop other handlers from being invoked for the event.
    ///  [`false`] to propagate the event further.
    #[doc(alias = "authenticate")]
    fn connect_authenticate<F: Fn(&Self, &AuthenticationRequest) -> bool + 'static>(
        &self,
        f: F,
    ) -> SignalHandlerId {
        unsafe extern "C" fn authenticate_trampoline<
            P: IsA<WebView>,
            F: Fn(&P, &AuthenticationRequest) -> bool + 'static,
        >(
            this: *mut ffi::WebKitWebView,
            request: *mut ffi::WebKitAuthenticationRequest,
            f: glib::ffi::gpointer,
        ) -> glib::ffi::gboolean {
            unsafe {
                let f: &F = &*(f as *const F);
                f(
                    WebView::from_glib_borrow(this).unsafe_cast_ref(),
                    &from_glib_borrow(request),
                )
                .into_glib()
            }
        }
        unsafe {
            let f: Box_<F> = Box_::new(f);
            connect_raw(
                self.as_ptr() as *mut _,
                c"authenticate".as_ptr(),
                Some(std::mem::transmute::<*const (), unsafe extern "C" fn()>(
                    authenticate_trampoline::<Self, F> as *const (),
                )),
                Box_::into_raw(f),
            )
        }
    }

    /// Emitted when closing a [`WebView`][crate::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 [`try_close()`][Self::try_close()].
    /// It is the owner's responsibility to handle this signal to hide or
    /// destroy the [`WebView`][crate::WebView], if necessary.
    #[doc(alias = "close")]
    fn connect_close<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId {
        unsafe extern "C" fn close_trampoline<P: IsA<WebView>, F: Fn(&P) + 'static>(
            this: *mut ffi::WebKitWebView,
            f: glib::ffi::gpointer,
        ) {
            unsafe {
                let f: &F = &*(f as *const F);
                f(WebView::from_glib_borrow(this).unsafe_cast_ref())
            }
        }
        unsafe {
            let f: Box_<F> = Box_::new(f);
            connect_raw(
                self.as_ptr() as *mut _,
                c"close".as_ptr(),
                Some(std::mem::transmute::<*const (), unsafe extern "C" fn()>(
                    close_trampoline::<Self, F> as *const (),
                )),
                Box_::into_raw(f),
            )
        }
    }

    /// 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()`][crate::ContextMenu::prepend()],
    ///  [`ContextMenu::append()`][crate::ContextMenu::append()] or [`ContextMenu::insert()`][crate::ContextMenu::insert()] to add new
    ///  [`ContextMenuItem`][crate::ContextMenuItem]<!-- -->s to `context_menu`, [`ContextMenu::move_item()`][crate::ContextMenu::move_item()]
    ///  to reorder existing items, or [`ContextMenu::remove()`][crate::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()`][crate::ContextMenu::remove_all()], add your own items and return [`false`] so
    ///  that the menu will be shown. You can also ignore the proposed [`ContextMenu`][crate::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`][crate::ContextMenu] passed in `context_menu` argument is only valid
    /// during the signal emission.
    /// ## `context_menu`
    /// the proposed [`ContextMenu`][crate::ContextMenu]
    /// ## `hit_test_result`
    /// a [`HitTestResult`][crate::HitTestResult]
    ///
    /// # Returns
    ///
    /// [`true`] to stop other handlers from being invoked for the event.
    ///  [`false`] to propagate the event further.
    #[doc(alias = "context-menu")]
    fn connect_context_menu<F: Fn(&Self, &ContextMenu, &HitTestResult) -> bool + 'static>(
        &self,
        f: F,
    ) -> SignalHandlerId {
        unsafe extern "C" fn context_menu_trampoline<
            P: IsA<WebView>,
            F: Fn(&P, &ContextMenu, &HitTestResult) -> bool + 'static,
        >(
            this: *mut ffi::WebKitWebView,
            context_menu: *mut ffi::WebKitContextMenu,
            hit_test_result: *mut ffi::WebKitHitTestResult,
            f: glib::ffi::gpointer,
        ) -> glib::ffi::gboolean {
            unsafe {
                let f: &F = &*(f as *const F);
                f(
                    WebView::from_glib_borrow(this).unsafe_cast_ref(),
                    &from_glib_borrow(context_menu),
                    &from_glib_borrow(hit_test_result),
                )
                .into_glib()
            }
        }
        unsafe {
            let f: Box_<F> = Box_::new(f);
            connect_raw(
                self.as_ptr() as *mut _,
                c"context-menu".as_ptr(),
                Some(std::mem::transmute::<*const (), unsafe extern "C" fn()>(
                    context_menu_trampoline::<Self, F> as *const (),
                )),
                Box_::into_raw(f),
            )
        }
    }

    /// Emitted after [`context-menu`][struct@crate::WebView#context-menu] signal, if the context menu is shown,
    /// to notify that the context menu is dismissed.
    #[doc(alias = "context-menu-dismissed")]
    fn connect_context_menu_dismissed<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId {
        unsafe extern "C" fn context_menu_dismissed_trampoline<
            P: IsA<WebView>,
            F: Fn(&P) + 'static,
        >(
            this: *mut ffi::WebKitWebView,
            f: glib::ffi::gpointer,
        ) {
            unsafe {
                let f: &F = &*(f as *const F);
                f(WebView::from_glib_borrow(this).unsafe_cast_ref())
            }
        }
        unsafe {
            let f: Box_<F> = Box_::new(f);
            connect_raw(
                self.as_ptr() as *mut _,
                c"context-menu-dismissed".as_ptr(),
                Some(std::mem::transmute::<*const (), unsafe extern "C" fn()>(
                    context_menu_dismissed_trampoline::<Self, F> as *const (),
                )),
                Box_::into_raw(f),
            )
        }
    }

    /// Emitted when the creation of a new [`WebView`][crate::WebView] is requested.
    /// If this signal is handled the signal handler should return the
    /// newly created [`WebView`][crate::WebView].
    ///
    /// The [`NavigationAction`][crate::NavigationAction] parameter contains information about the
    /// navigation action that triggered this signal.
    ///
    /// The new [`WebView`][crate::WebView] must be related to `web_view`, see
    /// [`related-view`][struct@crate::WebView#related-view] for more details.
    ///
    /// The new [`WebView`][crate::WebView] should not be displayed to the user
    /// until the [`ready-to-show`][struct@crate::WebView#ready-to-show] signal is emitted.
    ///
    /// For creating views as response to automation tools requests, see the
    /// [`create-web-view`][struct@crate::AutomationSession#create-web-view] signal.
    /// ## `navigation_action`
    /// a [`NavigationAction`][crate::NavigationAction]
    ///
    /// # Returns
    ///
    /// a newly allocated [`WebView`][crate::WebView] widget
    ///  or [`None`] to propagate the event further.
    #[doc(alias = "create")]
    fn connect_create<F: Fn(&Self, &NavigationAction) -> Option<gtk::Widget> + 'static>(
        &self,
        f: F,
    ) -> SignalHandlerId {
        unsafe extern "C" fn create_trampoline<
            P: IsA<WebView>,
            F: Fn(&P, &NavigationAction) -> Option<gtk::Widget> + 'static,
        >(
            this: *mut ffi::WebKitWebView,
            navigation_action: *mut ffi::WebKitNavigationAction,
            f: glib::ffi::gpointer,
        ) -> *mut gtk::ffi::GtkWidget {
            unsafe {
                let f: &F = &*(f as *const F);
                f(
                    WebView::from_glib_borrow(this).unsafe_cast_ref(),
                    &from_glib_borrow(navigation_action),
                )
                .to_glib_full()
            }
        }
        unsafe {
            let f: Box_<F> = Box_::new(f);
            connect_raw(
                self.as_ptr() as *mut _,
                c"create".as_ptr(),
                Some(std::mem::transmute::<*const (), unsafe extern "C" fn()>(
                    create_trampoline::<Self, F> as *const (),
                )),
                Box_::into_raw(f),
            )
        }
    }

    /// 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`][crate::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 ⚠️**
    ///
    /// ```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`][crate::PolicyDecision] and no decision has been
    /// made explicitly, [`PolicyDecisionExt::use_()`][crate::prelude::PolicyDecisionExt::use_()] will be the default policy decision. The
    /// default signal handler will simply call [`PolicyDecisionExt::use_()`][crate::prelude::PolicyDecisionExt::use_()]. Only the first
    /// policy decision chosen for a given [`PolicyDecision`][crate::PolicyDecision] will have any affect.
    /// ## `decision`
    /// the [`PolicyDecision`][crate::PolicyDecision]
    /// ## `decision_type`
    /// a [`PolicyDecisionType`][crate::PolicyDecisionType] denoting the type of `decision`
    ///
    /// # Returns
    ///
    /// [`true`] to stop other handlers from being invoked for the event.
    ///  [`false`] to propagate the event further.
    #[doc(alias = "decide-policy")]
    fn connect_decide_policy<
        F: Fn(&Self, &PolicyDecision, PolicyDecisionType) -> bool + 'static,
    >(
        &self,
        f: F,
    ) -> SignalHandlerId {
        unsafe extern "C" fn decide_policy_trampoline<
            P: IsA<WebView>,
            F: Fn(&P, &PolicyDecision, PolicyDecisionType) -> bool + 'static,
        >(
            this: *mut ffi::WebKitWebView,
            decision: *mut ffi::WebKitPolicyDecision,
            decision_type: ffi::WebKitPolicyDecisionType,
            f: glib::ffi::gpointer,
        ) -> glib::ffi::gboolean {
            unsafe {
                let f: &F = &*(f as *const F);
                f(
                    WebView::from_glib_borrow(this).unsafe_cast_ref(),
                    &from_glib_borrow(decision),
                    from_glib(decision_type),
                )
                .into_glib()
            }
        }
        unsafe {
            let f: Box_<F> = Box_::new(f);
            connect_raw(
                self.as_ptr() as *mut _,
                c"decide-policy".as_ptr(),
                Some(std::mem::transmute::<*const (), unsafe extern "C" fn()>(
                    decide_policy_trampoline::<Self, F> as *const (),
                )),
                Box_::into_raw(f),
            )
        }
    }

    /// Emitted when JavaScript code calls
    /// `<function>`element.webkitRequestFullScreen`</function>`. If the
    /// signal is not handled the [`WebView`][crate::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).
    ///
    /// # Returns
    ///
    /// [`true`] to stop other handlers from being invoked for the event.
    ///  [`false`] to continue emission of the event.
    #[doc(alias = "enter-fullscreen")]
    fn connect_enter_fullscreen<F: Fn(&Self) -> bool + 'static>(&self, f: F) -> SignalHandlerId {
        unsafe extern "C" fn enter_fullscreen_trampoline<
            P: IsA<WebView>,
            F: Fn(&P) -> bool + 'static,
        >(
            this: *mut ffi::WebKitWebView,
            f: glib::ffi::gpointer,
        ) -> glib::ffi::gboolean {
            unsafe {
                let f: &F = &*(f as *const F);
                f(WebView::from_glib_borrow(this).unsafe_cast_ref()).into_glib()
            }
        }
        unsafe {
            let f: Box_<F> = Box_::new(f);
            connect_raw(
                self.as_ptr() as *mut _,
                c"enter-fullscreen".as_ptr(),
                Some(std::mem::transmute::<*const (), unsafe extern "C" fn()>(
                    enter_fullscreen_trampoline::<Self, F> as *const (),
                )),
                Box_::into_raw(f),
            )
        }
    }

    /// 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.
    ///
    /// # Deprecated since 2.46
    ///
    /// ## `event`
    /// the [`InsecureContentEvent`][crate::InsecureContentEvent]
    #[cfg_attr(feature = "v2_46", deprecated = "Since 2.46")]
    #[doc(alias = "insecure-content-detected")]
    fn connect_insecure_content_detected<F: Fn(&Self, InsecureContentEvent) + 'static>(
        &self,
        f: F,
    ) -> SignalHandlerId {
        unsafe extern "C" fn insecure_content_detected_trampoline<
            P: IsA<WebView>,
            F: Fn(&P, InsecureContentEvent) + 'static,
        >(
            this: *mut ffi::WebKitWebView,
            event: ffi::WebKitInsecureContentEvent,
            f: glib::ffi::gpointer,
        ) {
            unsafe {
                let f: &F = &*(f as *const F);
                f(
                    WebView::from_glib_borrow(this).unsafe_cast_ref(),
                    from_glib(event),
                )
            }
        }
        unsafe {
            let f: Box_<F> = Box_::new(f);
            connect_raw(
                self.as_ptr() as *mut _,
                c"insecure-content-detected".as_ptr(),
                Some(std::mem::transmute::<*const (), unsafe extern "C" fn()>(
                    insecure_content_detected_trampoline::<Self, F> as *const (),
                )),
                Box_::into_raw(f),
            )
        }
    }

    /// Emitted when the [`WebView`][crate::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`][struct@crate::WebView#enter-fullscreen] stage for instance.
    ///
    /// # Returns
    ///
    /// [`true`] to stop other handlers from being invoked for the event.
    ///  [`false`] to continue emission of the event.
    #[doc(alias = "leave-fullscreen")]
    fn connect_leave_fullscreen<F: Fn(&Self) -> bool + 'static>(&self, f: F) -> SignalHandlerId {
        unsafe extern "C" fn leave_fullscreen_trampoline<
            P: IsA<WebView>,
            F: Fn(&P) -> bool + 'static,
        >(
            this: *mut ffi::WebKitWebView,
            f: glib::ffi::gpointer,
        ) -> glib::ffi::gboolean {
            unsafe {
                let f: &F = &*(f as *const F);
                f(WebView::from_glib_borrow(this).unsafe_cast_ref()).into_glib()
            }
        }
        unsafe {
            let f: Box_<F> = Box_::new(f);
            connect_raw(
                self.as_ptr() as *mut _,
                c"leave-fullscreen".as_ptr(),
                Some(std::mem::transmute::<*const (), unsafe extern "C" fn()>(
                    leave_fullscreen_trampoline::<Self, F> as *const (),
                )),
                Box_::into_raw(f),
            )
        }
    }

    /// Emitted when a load operation in `web_view` changes.
    /// The signal is always emitted with [`LoadEvent::Started`][crate::LoadEvent::Started] when a
    /// new load request is made and [`LoadEvent::Finished`][crate::LoadEvent::Finished] when the load
    /// finishes successfully or due to an error. When the ongoing load
    /// operation fails [`load-failed`][struct@crate::WebView#load-failed] signal is emitted
    /// before [`load-changed`][struct@crate::WebView#load-changed] is emitted with
    /// [`LoadEvent::Finished`][crate::LoadEvent::Finished].
    /// If a redirection is received from the server, this signal is emitted
    /// with [`LoadEvent::Redirected`][crate::LoadEvent::Redirected] after the initial emission with
    /// [`LoadEvent::Started`][crate::LoadEvent::Started] and before [`LoadEvent::Committed`][crate::LoadEvent::Committed].
    /// When the page content starts arriving the signal is emitted with
    /// [`LoadEvent::Committed`][crate::LoadEvent::Committed] event.
    ///
    /// You can handle this signal and use a switch to track any ongoing
    /// load operation.
    ///
    /// **⚠️ The following code is in c ⚠️**
    ///
    /// ```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_event`
    /// the [`LoadEvent`][crate::LoadEvent]
    #[doc(alias = "load-changed")]
    fn connect_load_changed<F: Fn(&Self, LoadEvent) + 'static>(&self, f: F) -> SignalHandlerId {
        unsafe extern "C" fn load_changed_trampoline<
            P: IsA<WebView>,
            F: Fn(&P, LoadEvent) + 'static,
        >(
            this: *mut ffi::WebKitWebView,
            load_event: ffi::WebKitLoadEvent,
            f: glib::ffi::gpointer,
        ) {
            unsafe {
                let f: &F = &*(f as *const F);
                f(
                    WebView::from_glib_borrow(this).unsafe_cast_ref(),
                    from_glib(load_event),
                )
            }
        }
        unsafe {
            let f: Box_<F> = Box_::new(f);
            connect_raw(
                self.as_ptr() as *mut _,
                c"load-changed".as_ptr(),
                Some(std::mem::transmute::<*const (), unsafe extern "C" fn()>(
                    load_changed_trampoline::<Self, F> as *const (),
                )),
                Box_::into_raw(f),
            )
        }
    }

    /// 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`][crate::LoadEvent::Started]. If it happened while
    /// loading a committed data source `load_event` will be [`LoadEvent::Committed`][crate::LoadEvent::Committed].
    /// Since a load error causes the load operation to finish, the signal
    /// WebKitWebView::load-changed will always be emitted with
    /// [`LoadEvent::Finished`][crate::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_event`
    /// the [`LoadEvent`][crate::LoadEvent] of the load operation
    /// ## `failing_uri`
    /// the URI that failed to load
    /// ## `error`
    /// the [`glib::Error`][crate::glib::Error] that was triggered
    ///
    /// # Returns
    ///
    /// [`true`] to stop other handlers from being invoked for the event.
    ///  [`false`] to propagate the event further.
    #[doc(alias = "load-failed")]
    fn connect_load_failed<F: Fn(&Self, LoadEvent, &str, &glib::Error) -> bool + 'static>(
        &self,
        f: F,
    ) -> SignalHandlerId {
        unsafe extern "C" fn load_failed_trampoline<
            P: IsA<WebView>,
            F: Fn(&P, LoadEvent, &str, &glib::Error) -> bool + 'static,
        >(
            this: *mut ffi::WebKitWebView,
            load_event: ffi::WebKitLoadEvent,
            failing_uri: *mut std::ffi::c_char,
            error: *mut glib::ffi::GError,
            f: glib::ffi::gpointer,
        ) -> glib::ffi::gboolean {
            unsafe {
                let f: &F = &*(f as *const F);
                f(
                    WebView::from_glib_borrow(this).unsafe_cast_ref(),
                    from_glib(load_event),
                    &glib::GString::from_glib_borrow(failing_uri),
                    &from_glib_borrow(error),
                )
                .into_glib()
            }
        }
        unsafe {
            let f: Box_<F> = Box_::new(f);
            connect_raw(
                self.as_ptr() as *mut _,
                c"load-failed".as_ptr(),
                Some(std::mem::transmute::<*const (), unsafe extern "C" fn()>(
                    load_failed_trampoline::<Self, F> as *const (),
                )),
                Box_::into_raw(f),
            )
        }
    }

    /// 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`][struct@crate::WebView#load-failed] will be emitted. The load
    /// will finish regardless of the returned value.
    /// ## `failing_uri`
    /// the URI that failed to load
    /// ## `certificate`
    /// a [`gio::TlsCertificate`][crate::gio::TlsCertificate]
    /// ## `errors`
    /// a [`gio::TlsCertificateFlags`][crate::gio::TlsCertificateFlags] with the verification status of `certificate`
    ///
    /// # Returns
    ///
    /// [`true`] to stop other handlers from being invoked for the event.
    ///  [`false`] to propagate the event further.
    #[doc(alias = "load-failed-with-tls-errors")]
    fn connect_load_failed_with_tls_errors<
        F: Fn(&Self, &str, &gio::TlsCertificate, gio::TlsCertificateFlags) -> bool + 'static,
    >(
        &self,
        f: F,
    ) -> SignalHandlerId {
        unsafe extern "C" fn load_failed_with_tls_errors_trampoline<
            P: IsA<WebView>,
            F: Fn(&P, &str, &gio::TlsCertificate, gio::TlsCertificateFlags) -> bool + 'static,
        >(
            this: *mut ffi::WebKitWebView,
            failing_uri: *mut std::ffi::c_char,
            certificate: *mut gio::ffi::GTlsCertificate,
            errors: gio::ffi::GTlsCertificateFlags,
            f: glib::ffi::gpointer,
        ) -> glib::ffi::gboolean {
            unsafe {
                let f: &F = &*(f as *const F);
                f(
                    WebView::from_glib_borrow(this).unsafe_cast_ref(),
                    &glib::GString::from_glib_borrow(failing_uri),
                    &from_glib_borrow(certificate),
                    from_glib(errors),
                )
                .into_glib()
            }
        }
        unsafe {
            let f: Box_<F> = Box_::new(f);
            connect_raw(
                self.as_ptr() as *mut _,
                c"load-failed-with-tls-errors".as_ptr(),
                Some(std::mem::transmute::<*const (), unsafe extern "C" fn()>(
                    load_failed_with_tls_errors_trampoline::<Self, F> as *const (),
                )),
                Box_::into_raw(f),
            )
        }
    }

    /// 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`.
    /// ## `hit_test_result`
    /// a [`HitTestResult`][crate::HitTestResult]
    /// ## `modifiers`
    /// a bitmask of `GdkModifierType`
    #[doc(alias = "mouse-target-changed")]
    fn connect_mouse_target_changed<F: Fn(&Self, &HitTestResult, u32) + 'static>(
        &self,
        f: F,
    ) -> SignalHandlerId {
        unsafe extern "C" fn mouse_target_changed_trampoline<
            P: IsA<WebView>,
            F: Fn(&P, &HitTestResult, u32) + 'static,
        >(
            this: *mut ffi::WebKitWebView,
            hit_test_result: *mut ffi::WebKitHitTestResult,
            modifiers: std::ffi::c_uint,
            f: glib::ffi::gpointer,
        ) {
            unsafe {
                let f: &F = &*(f as *const F);
                f(
                    WebView::from_glib_borrow(this).unsafe_cast_ref(),
                    &from_glib_borrow(hit_test_result),
                    modifiers,
                )
            }
        }
        unsafe {
            let f: Box_<F> = Box_::new(f);
            connect_raw(
                self.as_ptr() as *mut _,
                c"mouse-target-changed".as_ptr(),
                Some(std::mem::transmute::<*const (), unsafe extern "C" fn()>(
                    mouse_target_changed_trampoline::<Self, F> as *const (),
                )),
                Box_::into_raw(f),
            )
        }
    }

    /// 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 ⚠️**
    ///
    /// ```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`][crate::PermissionRequest] and the
    /// request has not been handled, [`PermissionRequestExt::deny()`][crate::prelude::PermissionRequestExt::deny()]
    /// will be the default action.
    ///
    /// If the signal is not handled, the `request` will be completed automatically
    /// by the specific [`PermissionRequest`][crate::PermissionRequest] that could allow or deny it. Check the
    /// documentation of classes implementing [`PermissionRequest`][crate::PermissionRequest] interface to know
    /// their default action.
    /// ## `request`
    /// the [`PermissionRequest`][crate::PermissionRequest]
    ///
    /// # Returns
    ///
    /// [`true`] to stop other handlers from being invoked for the event.
    ///  [`false`] to propagate the event further.
    #[doc(alias = "permission-request")]
    fn connect_permission_request<F: Fn(&Self, &PermissionRequest) -> bool + 'static>(
        &self,
        f: F,
    ) -> SignalHandlerId {
        unsafe extern "C" fn permission_request_trampoline<
            P: IsA<WebView>,
            F: Fn(&P, &PermissionRequest) -> bool + 'static,
        >(
            this: *mut ffi::WebKitWebView,
            request: *mut ffi::WebKitPermissionRequest,
            f: glib::ffi::gpointer,
        ) -> glib::ffi::gboolean {
            unsafe {
                let f: &F = &*(f as *const F);
                f(
                    WebView::from_glib_borrow(this).unsafe_cast_ref(),
                    &from_glib_borrow(request),
                )
                .into_glib()
            }
        }
        unsafe {
            let f: Box_<F> = Box_::new(f);
            connect_raw(
                self.as_ptr() as *mut _,
                c"permission-request".as_ptr(),
                Some(std::mem::transmute::<*const (), unsafe extern "C" fn()>(
                    permission_request_trampoline::<Self, F> as *const (),
                )),
                Box_::into_raw(f),
            )
        }
    }

    /// 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()`][crate::PrintOperation::set_print_settings()] and
    /// [`PrintOperation::set_page_setup()`][crate::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.
    /// ## `print_operation`
    /// the [`PrintOperation`][crate::PrintOperation] that will handle the print request
    ///
    /// # Returns
    ///
    /// [`true`] to stop other handlers from being invoked for the event.
    ///  [`false`] to propagate the event further.
    #[doc(alias = "print")]
    fn connect_print<F: Fn(&Self, &PrintOperation) -> bool + 'static>(
        &self,
        f: F,
    ) -> SignalHandlerId {
        unsafe extern "C" fn print_trampoline<
            P: IsA<WebView>,
            F: Fn(&P, &PrintOperation) -> bool + 'static,
        >(
            this: *mut ffi::WebKitWebView,
            print_operation: *mut ffi::WebKitPrintOperation,
            f: glib::ffi::gpointer,
        ) -> glib::ffi::gboolean {
            unsafe {
                let f: &F = &*(f as *const F);
                f(
                    WebView::from_glib_borrow(this).unsafe_cast_ref(),
                    &from_glib_borrow(print_operation),
                )
                .into_glib()
            }
        }
        unsafe {
            let f: Box_<F> = Box_::new(f);
            connect_raw(
                self.as_ptr() as *mut _,
                c"print".as_ptr(),
                Some(std::mem::transmute::<*const (), unsafe extern "C" fn()>(
                    print_trampoline::<Self, F> as *const (),
                )),
                Box_::into_raw(f),
            )
        }
    }

    /// This signal allows the User-Agent to respond to permission requests for powerful features, as
    /// specified by the [Permissions W3C Specification](https://w3c.github.io/permissions/).
    /// You can reply to the query using [`PermissionStateQuery::finish()`][crate::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`.
    /// ## `query`
    /// the [`PermissionStateQuery`][crate::PermissionStateQuery]
    ///
    /// # Returns
    ///
    /// [`true`] if the message was handled, or [`false`] otherwise.
    #[doc(alias = "query-permission-state")]
    fn connect_query_permission_state<F: Fn(&Self, &PermissionStateQuery) -> bool + 'static>(
        &self,
        f: F,
    ) -> SignalHandlerId {
        unsafe extern "C" fn query_permission_state_trampoline<
            P: IsA<WebView>,
            F: Fn(&P, &PermissionStateQuery) -> bool + 'static,
        >(
            this: *mut ffi::WebKitWebView,
            query: *mut ffi::WebKitPermissionStateQuery,
            f: glib::ffi::gpointer,
        ) -> glib::ffi::gboolean {
            unsafe {
                let f: &F = &*(f as *const F);
                f(
                    WebView::from_glib_borrow(this).unsafe_cast_ref(),
                    &from_glib_borrow(query),
                )
                .into_glib()
            }
        }
        unsafe {
            let f: Box_<F> = Box_::new(f);
            connect_raw(
                self.as_ptr() as *mut _,
                c"query-permission-state".as_ptr(),
                Some(std::mem::transmute::<*const (), unsafe extern "C" fn()>(
                    query_permission_state_trampoline::<Self, F> as *const (),
                )),
                Box_::into_raw(f),
            )
        }
    }

    /// Emitted after [`create`][struct@crate::WebView#create] on the newly created [`WebView`][crate::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`][crate::WindowProperties]
    /// of `web_view`. See also [`window_properties()`][Self::window_properties()].
    #[doc(alias = "ready-to-show")]
    fn connect_ready_to_show<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId {
        unsafe extern "C" fn ready_to_show_trampoline<P: IsA<WebView>, F: Fn(&P) + 'static>(
            this: *mut ffi::WebKitWebView,
            f: glib::ffi::gpointer,
        ) {
            unsafe {
                let f: &F = &*(f as *const F);
                f(WebView::from_glib_borrow(this).unsafe_cast_ref())
            }
        }
        unsafe {
            let f: Box_<F> = Box_::new(f);
            connect_raw(
                self.as_ptr() as *mut _,
                c"ready-to-show".as_ptr(),
                Some(std::mem::transmute::<*const (), unsafe extern "C" fn()>(
                    ready_to_show_trampoline::<Self, F> as *const (),
                )),
                Box_::into_raw(f),
            )
        }
    }

    /// Emitted when a new resource is going to be loaded. The `request` parameter
    /// contains the [`URIRequest`][crate::URIRequest] that will be sent to the server.
    /// You can monitor the load operation by connecting to the different signals
    /// of `resource`.
    /// ## `resource`
    /// a [`WebResource`][crate::WebResource]
    /// ## `request`
    /// a [`URIRequest`][crate::URIRequest]
    #[doc(alias = "resource-load-started")]
    fn connect_resource_load_started<F: Fn(&Self, &WebResource, &URIRequest) + 'static>(
        &self,
        f: F,
    ) -> SignalHandlerId {
        unsafe extern "C" fn resource_load_started_trampoline<
            P: IsA<WebView>,
            F: Fn(&P, &WebResource, &URIRequest) + 'static,
        >(
            this: *mut ffi::WebKitWebView,
            resource: *mut ffi::WebKitWebResource,
            request: *mut ffi::WebKitURIRequest,
            f: glib::ffi::gpointer,
        ) {
            unsafe {
                let f: &F = &*(f as *const F);
                f(
                    WebView::from_glib_borrow(this).unsafe_cast_ref(),
                    &from_glib_borrow(resource),
                    &from_glib_borrow(request),
                )
            }
        }
        unsafe {
            let f: Box_<F> = Box_::new(f);
            connect_raw(
                self.as_ptr() as *mut _,
                c"resource-load-started".as_ptr(),
                Some(std::mem::transmute::<*const (), unsafe extern "C" fn()>(
                    resource_load_started_trampoline::<Self, F> as *const (),
                )),
                Box_::into_raw(f),
            )
        }
    }

    /// Emitted after [`ready-to-show`][struct@crate::WebView#ready-to-show] on the newly
    /// created [`WebView`][crate::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`][crate::WebView] until the new dialog is closed.
    #[doc(alias = "run-as-modal")]
    fn connect_run_as_modal<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId {
        unsafe extern "C" fn run_as_modal_trampoline<P: IsA<WebView>, F: Fn(&P) + 'static>(
            this: *mut ffi::WebKitWebView,
            f: glib::ffi::gpointer,
        ) {
            unsafe {
                let f: &F = &*(f as *const F);
                f(WebView::from_glib_borrow(this).unsafe_cast_ref())
            }
        }
        unsafe {
            let f: Box_<F> = Box_::new(f);
            connect_raw(
                self.as_ptr() as *mut _,
                c"run-as-modal".as_ptr(),
                Some(std::mem::transmute::<*const (), unsafe extern "C" fn()>(
                    run_as_modal_trampoline::<Self, F> as *const (),
                )),
                Box_::into_raw(f),
            )
        }
    }

    /// This signal is emitted when the user interacts with a <input
    /// type='color' /> 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`][crate::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.
    /// ## `request`
    /// a [`ColorChooserRequest`][crate::ColorChooserRequest]
    ///
    /// # Returns
    ///
    /// [`true`] to stop other handlers from being invoked for the event.
    ///  [`false`] to propagate the event further.
    #[doc(alias = "run-color-chooser")]
    fn connect_run_color_chooser<F: Fn(&Self, &ColorChooserRequest) -> bool + 'static>(
        &self,
        f: F,
    ) -> SignalHandlerId {
        unsafe extern "C" fn run_color_chooser_trampoline<
            P: IsA<WebView>,
            F: Fn(&P, &ColorChooserRequest) -> bool + 'static,
        >(
            this: *mut ffi::WebKitWebView,
            request: *mut ffi::WebKitColorChooserRequest,
            f: glib::ffi::gpointer,
        ) -> glib::ffi::gboolean {
            unsafe {
                let f: &F = &*(f as *const F);
                f(
                    WebView::from_glib_borrow(this).unsafe_cast_ref(),
                    &from_glib_borrow(request),
                )
                .into_glib()
            }
        }
        unsafe {
            let f: Box_<F> = Box_::new(f);
            connect_raw(
                self.as_ptr() as *mut _,
                c"run-color-chooser".as_ptr(),
                Some(std::mem::transmute::<*const (), unsafe extern "C" fn()>(
                    run_color_chooser_trampoline::<Self, F> as *const (),
                )),
                Box_::into_raw(f),
            )
        }
    }

    /// This signal is emitted when the user interacts with a <input
    /// type='file' /> 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`][crate::FileChooserRequest] in the `request`
    /// argument.
    ///
    /// The default signal handler will asynchronously run a regular
    /// `GtkFileChooserDialog` for the user to interact with.
    /// ## `request`
    /// a [`FileChooserRequest`][crate::FileChooserRequest]
    ///
    /// # Returns
    ///
    /// [`true`] to stop other handlers from being invoked for the event.
    ///  [`false`] to propagate the event further.
    #[doc(alias = "run-file-chooser")]
    fn connect_run_file_chooser<F: Fn(&Self, &FileChooserRequest) -> bool + 'static>(
        &self,
        f: F,
    ) -> SignalHandlerId {
        unsafe extern "C" fn run_file_chooser_trampoline<
            P: IsA<WebView>,
            F: Fn(&P, &FileChooserRequest) -> bool + 'static,
        >(
            this: *mut ffi::WebKitWebView,
            request: *mut ffi::WebKitFileChooserRequest,
            f: glib::ffi::gpointer,
        ) -> glib::ffi::gboolean {
            unsafe {
                let f: &F = &*(f as *const F);
                f(
                    WebView::from_glib_borrow(this).unsafe_cast_ref(),
                    &from_glib_borrow(request),
                )
                .into_glib()
            }
        }
        unsafe {
            let f: Box_<F> = Box_::new(f);
            connect_raw(
                self.as_ptr() as *mut _,
                c"run-file-chooser".as_ptr(),
                Some(std::mem::transmute::<*const (), unsafe extern "C" fn()>(
                    run_file_chooser_trampoline::<Self, F> as *const (),
                )),
                Box_::into_raw(f),
            )
        }
    }

    /// 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`][crate::ScriptDialogType::Alert]: message dialog with a single Close button.
    /// `</para>``</listitem>`
    /// `<listitem>``<para>`
    ///  [`ScriptDialogType::Confirm`][crate::ScriptDialogType::Confirm]: message dialog with OK and Cancel buttons.
    /// `</para>``</listitem>`
    /// `<listitem>``<para>`
    ///  [`ScriptDialogType::Prompt`][crate::ScriptDialogType::Prompt]: message dialog with OK and Cancel buttons and
    ///  a text entry with the default text.
    /// `</para>``</listitem>`
    /// `<listitem>``<para>`
    ///  [`ScriptDialogType::BeforeUnloadConfirm`][crate::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()`][crate::ScriptDialog::close()] when done.
    /// If the last reference is removed on a [`ScriptDialog`][crate::ScriptDialog] and the dialog has not been
    /// closed, [`ScriptDialog::close()`][crate::ScriptDialog::close()] will be called.
    /// ## `dialog`
    /// the [`ScriptDialog`][crate::ScriptDialog] to show
    ///
    /// # Returns
    ///
    /// [`true`] to stop other handlers from being invoked for the event.
    ///  [`false`] to propagate the event further.
    #[doc(alias = "script-dialog")]
    fn connect_script_dialog<F: Fn(&Self, &ScriptDialog) -> bool + 'static>(
        &self,
        f: F,
    ) -> SignalHandlerId {
        unsafe extern "C" fn script_dialog_trampoline<
            P: IsA<WebView>,
            F: Fn(&P, &ScriptDialog) -> bool + 'static,
        >(
            this: *mut ffi::WebKitWebView,
            dialog: *mut ffi::WebKitScriptDialog,
            f: glib::ffi::gpointer,
        ) -> glib::ffi::gboolean {
            unsafe {
                let f: &F = &*(f as *const F);
                f(
                    WebView::from_glib_borrow(this).unsafe_cast_ref(),
                    &from_glib_borrow(dialog),
                )
                .into_glib()
            }
        }
        unsafe {
            let f: Box_<F> = Box_::new(f);
            connect_raw(
                self.as_ptr() as *mut _,
                c"script-dialog".as_ptr(),
                Some(std::mem::transmute::<*const (), unsafe extern "C" fn()>(
                    script_dialog_trampoline::<Self, F> as *const (),
                )),
                Box_::into_raw(f),
            )
        }
    }

    /// 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.
    /// ## `notification`
    /// a [`Notification`][crate::Notification]
    ///
    /// # Returns
    ///
    /// [`true`] to stop other handlers from being invoked. [`false`] otherwise.
    #[doc(alias = "show-notification")]
    fn connect_show_notification<F: Fn(&Self, &Notification) -> bool + 'static>(
        &self,
        f: F,
    ) -> SignalHandlerId {
        unsafe extern "C" fn show_notification_trampoline<
            P: IsA<WebView>,
            F: Fn(&P, &Notification) -> bool + 'static,
        >(
            this: *mut ffi::WebKitWebView,
            notification: *mut ffi::WebKitNotification,
            f: glib::ffi::gpointer,
        ) -> glib::ffi::gboolean {
            unsafe {
                let f: &F = &*(f as *const F);
                f(
                    WebView::from_glib_borrow(this).unsafe_cast_ref(),
                    &from_glib_borrow(notification),
                )
                .into_glib()
            }
        }
        unsafe {
            let f: Box_<F> = Box_::new(f);
            connect_raw(
                self.as_ptr() as *mut _,
                c"show-notification".as_ptr(),
                Some(std::mem::transmute::<*const (), unsafe extern "C" fn()>(
                    show_notification_trampoline::<Self, F> as *const (),
                )),
                Box_::into_raw(f),
            )
        }
    }

    /// 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`][crate::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`.
    /// ## `menu`
    /// the [`OptionMenu`][crate::OptionMenu]
    /// ## `rectangle`
    /// the option element area
    ///
    /// # Returns
    ///
    /// [`true`] to stop other handlers from being invoked for the event.
    ///  [`false`] to propagate the event further.
    #[doc(alias = "show-option-menu")]
    fn connect_show_option_menu<F: Fn(&Self, &OptionMenu, &gdk::Rectangle) -> bool + 'static>(
        &self,
        f: F,
    ) -> SignalHandlerId {
        unsafe extern "C" fn show_option_menu_trampoline<
            P: IsA<WebView>,
            F: Fn(&P, &OptionMenu, &gdk::Rectangle) -> bool + 'static,
        >(
            this: *mut ffi::WebKitWebView,
            menu: *mut ffi::WebKitOptionMenu,
            rectangle: *mut gdk::ffi::GdkRectangle,
            f: glib::ffi::gpointer,
        ) -> glib::ffi::gboolean {
            unsafe {
                let f: &F = &*(f as *const F);
                f(
                    WebView::from_glib_borrow(this).unsafe_cast_ref(),
                    &from_glib_borrow(menu),
                    &from_glib_borrow(rectangle),
                )
                .into_glib()
            }
        }
        unsafe {
            let f: Box_<F> = Box_::new(f);
            connect_raw(
                self.as_ptr() as *mut _,
                c"show-option-menu".as_ptr(),
                Some(std::mem::transmute::<*const (), unsafe extern "C" fn()>(
                    show_option_menu_trampoline::<Self, F> as *const (),
                )),
                Box_::into_raw(f),
            )
        }
    }

    /// 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()`][crate::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()`][crate::FormSubmissionRequest::submit()] when done to continue with the form submission.
    /// If the last reference is removed on a [`FormSubmissionRequest`][crate::FormSubmissionRequest] and the
    /// form has not been submitted, [`FormSubmissionRequest::submit()`][crate::FormSubmissionRequest::submit()] will be called.
    /// ## `request`
    /// a [`FormSubmissionRequest`][crate::FormSubmissionRequest]
    #[doc(alias = "submit-form")]
    fn connect_submit_form<F: Fn(&Self, &FormSubmissionRequest) + 'static>(
        &self,
        f: F,
    ) -> SignalHandlerId {
        unsafe extern "C" fn submit_form_trampoline<
            P: IsA<WebView>,
            F: Fn(&P, &FormSubmissionRequest) + 'static,
        >(
            this: *mut ffi::WebKitWebView,
            request: *mut ffi::WebKitFormSubmissionRequest,
            f: glib::ffi::gpointer,
        ) {
            unsafe {
                let f: &F = &*(f as *const F);
                f(
                    WebView::from_glib_borrow(this).unsafe_cast_ref(),
                    &from_glib_borrow(request),
                )
            }
        }
        unsafe {
            let f: Box_<F> = Box_::new(f);
            connect_raw(
                self.as_ptr() as *mut _,
                c"submit-form".as_ptr(),
                Some(std::mem::transmute::<*const (), unsafe extern "C" fn()>(
                    submit_form_trampoline::<Self, F> as *const (),
                )),
                Box_::into_raw(f),
            )
        }
    }

    /// This signal is emitted when a [`UserMessage`][crate::UserMessage] is received from the
    /// `WebKitWebPage` corresponding to `web_view`. You can reply to the message
    /// using [`UserMessage::send_reply()`][crate::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`][crate::UserMessageError::Message].
    /// ## `message`
    /// the [`UserMessage`][crate::UserMessage] received
    ///
    /// # Returns
    ///
    /// [`true`] if the message was handled, or [`false`] otherwise.
    #[doc(alias = "user-message-received")]
    fn connect_user_message_received<F: Fn(&Self, &UserMessage) -> bool + 'static>(
        &self,
        f: F,
    ) -> SignalHandlerId {
        unsafe extern "C" fn user_message_received_trampoline<
            P: IsA<WebView>,
            F: Fn(&P, &UserMessage) -> bool + 'static,
        >(
            this: *mut ffi::WebKitWebView,
            message: *mut ffi::WebKitUserMessage,
            f: glib::ffi::gpointer,
        ) -> glib::ffi::gboolean {
            unsafe {
                let f: &F = &*(f as *const F);
                f(
                    WebView::from_glib_borrow(this).unsafe_cast_ref(),
                    &from_glib_borrow(message),
                )
                .into_glib()
            }
        }
        unsafe {
            let f: Box_<F> = Box_::new(f);
            connect_raw(
                self.as_ptr() as *mut _,
                c"user-message-received".as_ptr(),
                Some(std::mem::transmute::<*const (), unsafe extern "C" fn()>(
                    user_message_received_trampoline::<Self, F> as *const (),
                )),
                Box_::into_raw(f),
            )
        }
    }

    /// This signal is emitted when the web process terminates abnormally due
    /// to `reason`.
    /// ## `reason`
    /// the a [`WebProcessTerminationReason`][crate::WebProcessTerminationReason]
    #[doc(alias = "web-process-terminated")]
    fn connect_web_process_terminated<F: Fn(&Self, WebProcessTerminationReason) + 'static>(
        &self,
        f: F,
    ) -> SignalHandlerId {
        unsafe extern "C" fn web_process_terminated_trampoline<
            P: IsA<WebView>,
            F: Fn(&P, WebProcessTerminationReason) + 'static,
        >(
            this: *mut ffi::WebKitWebView,
            reason: ffi::WebKitWebProcessTerminationReason,
            f: glib::ffi::gpointer,
        ) {
            unsafe {
                let f: &F = &*(f as *const F);
                f(
                    WebView::from_glib_borrow(this).unsafe_cast_ref(),
                    from_glib(reason),
                )
            }
        }
        unsafe {
            let f: Box_<F> = Box_::new(f);
            connect_raw(
                self.as_ptr() as *mut _,
                c"web-process-terminated".as_ptr(),
                Some(std::mem::transmute::<*const (), unsafe extern "C" fn()>(
                    web_process_terminated_trampoline::<Self, F> as *const (),
                )),
                Box_::into_raw(f),
            )
        }
    }

    #[doc(alias = "camera-capture-state")]
    fn connect_camera_capture_state_notify<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId {
        unsafe extern "C" fn notify_camera_capture_state_trampoline<
            P: IsA<WebView>,
            F: Fn(&P) + 'static,
        >(
            this: *mut ffi::WebKitWebView,
            _param_spec: glib::ffi::gpointer,
            f: glib::ffi::gpointer,
        ) {
            unsafe {
                let f: &F = &*(f as *const F);
                f(WebView::from_glib_borrow(this).unsafe_cast_ref())
            }
        }
        unsafe {
            let f: Box_<F> = Box_::new(f);
            connect_raw(
                self.as_ptr() as *mut _,
                c"notify::camera-capture-state".as_ptr(),
                Some(std::mem::transmute::<*const (), unsafe extern "C" fn()>(
                    notify_camera_capture_state_trampoline::<Self, F> as *const (),
                )),
                Box_::into_raw(f),
            )
        }
    }

    #[doc(alias = "display-capture-state")]
    fn connect_display_capture_state_notify<F: Fn(&Self) + 'static>(
        &self,
        f: F,
    ) -> SignalHandlerId {
        unsafe extern "C" fn notify_display_capture_state_trampoline<
            P: IsA<WebView>,
            F: Fn(&P) + 'static,
        >(
            this: *mut ffi::WebKitWebView,
            _param_spec: glib::ffi::gpointer,
            f: glib::ffi::gpointer,
        ) {
            unsafe {
                let f: &F = &*(f as *const F);
                f(WebView::from_glib_borrow(this).unsafe_cast_ref())
            }
        }
        unsafe {
            let f: Box_<F> = Box_::new(f);
            connect_raw(
                self.as_ptr() as *mut _,
                c"notify::display-capture-state".as_ptr(),
                Some(std::mem::transmute::<*const (), unsafe extern "C" fn()>(
                    notify_display_capture_state_trampoline::<Self, F> as *const (),
                )),
                Box_::into_raw(f),
            )
        }
    }

    #[doc(alias = "editable")]
    fn connect_editable_notify<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId {
        unsafe extern "C" fn notify_editable_trampoline<P: IsA<WebView>, F: Fn(&P) + 'static>(
            this: *mut ffi::WebKitWebView,
            _param_spec: glib::ffi::gpointer,
            f: glib::ffi::gpointer,
        ) {
            unsafe {
                let f: &F = &*(f as *const F);
                f(WebView::from_glib_borrow(this).unsafe_cast_ref())
            }
        }
        unsafe {
            let f: Box_<F> = Box_::new(f);
            connect_raw(
                self.as_ptr() as *mut _,
                c"notify::editable".as_ptr(),
                Some(std::mem::transmute::<*const (), unsafe extern "C" fn()>(
                    notify_editable_trampoline::<Self, F> as *const (),
                )),
                Box_::into_raw(f),
            )
        }
    }

    #[doc(alias = "estimated-load-progress")]
    fn connect_estimated_load_progress_notify<F: Fn(&Self) + 'static>(
        &self,
        f: F,
    ) -> SignalHandlerId {
        unsafe extern "C" fn notify_estimated_load_progress_trampoline<
            P: IsA<WebView>,
            F: Fn(&P) + 'static,
        >(
            this: *mut ffi::WebKitWebView,
            _param_spec: glib::ffi::gpointer,
            f: glib::ffi::gpointer,
        ) {
            unsafe {
                let f: &F = &*(f as *const F);
                f(WebView::from_glib_borrow(this).unsafe_cast_ref())
            }
        }
        unsafe {
            let f: Box_<F> = Box_::new(f);
            connect_raw(
                self.as_ptr() as *mut _,
                c"notify::estimated-load-progress".as_ptr(),
                Some(std::mem::transmute::<*const (), unsafe extern "C" fn()>(
                    notify_estimated_load_progress_trampoline::<Self, F> as *const (),
                )),
                Box_::into_raw(f),
            )
        }
    }

    #[doc(alias = "favicon")]
    fn connect_favicon_notify<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId {
        unsafe extern "C" fn notify_favicon_trampoline<P: IsA<WebView>, F: Fn(&P) + 'static>(
            this: *mut ffi::WebKitWebView,
            _param_spec: glib::ffi::gpointer,
            f: glib::ffi::gpointer,
        ) {
            unsafe {
                let f: &F = &*(f as *const F);
                f(WebView::from_glib_borrow(this).unsafe_cast_ref())
            }
        }
        unsafe {
            let f: Box_<F> = Box_::new(f);
            connect_raw(
                self.as_ptr() as *mut _,
                c"notify::favicon".as_ptr(),
                Some(std::mem::transmute::<*const (), unsafe extern "C" fn()>(
                    notify_favicon_trampoline::<Self, F> as *const (),
                )),
                Box_::into_raw(f),
            )
        }
    }

    #[cfg(feature = "v2_52")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v2_52")))]
    #[doc(alias = "is-immersive-mode-enabled")]
    fn connect_is_immersive_mode_enabled_notify<F: Fn(&Self) + 'static>(
        &self,
        f: F,
    ) -> SignalHandlerId {
        unsafe extern "C" fn notify_is_immersive_mode_enabled_trampoline<
            P: IsA<WebView>,
            F: Fn(&P) + 'static,
        >(
            this: *mut ffi::WebKitWebView,
            _param_spec: glib::ffi::gpointer,
            f: glib::ffi::gpointer,
        ) {
            unsafe {
                let f: &F = &*(f as *const F);
                f(WebView::from_glib_borrow(this).unsafe_cast_ref())
            }
        }
        unsafe {
            let f: Box_<F> = Box_::new(f);
            connect_raw(
                self.as_ptr() as *mut _,
                c"notify::is-immersive-mode-enabled".as_ptr(),
                Some(std::mem::transmute::<*const (), unsafe extern "C" fn()>(
                    notify_is_immersive_mode_enabled_trampoline::<Self, F> as *const (),
                )),
                Box_::into_raw(f),
            )
        }
    }

    #[doc(alias = "is-loading")]
    fn connect_is_loading_notify<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId {
        unsafe extern "C" fn notify_is_loading_trampoline<P: IsA<WebView>, F: Fn(&P) + 'static>(
            this: *mut ffi::WebKitWebView,
            _param_spec: glib::ffi::gpointer,
            f: glib::ffi::gpointer,
        ) {
            unsafe {
                let f: &F = &*(f as *const F);
                f(WebView::from_glib_borrow(this).unsafe_cast_ref())
            }
        }
        unsafe {
            let f: Box_<F> = Box_::new(f);
            connect_raw(
                self.as_ptr() as *mut _,
                c"notify::is-loading".as_ptr(),
                Some(std::mem::transmute::<*const (), unsafe extern "C" fn()>(
                    notify_is_loading_trampoline::<Self, F> as *const (),
                )),
                Box_::into_raw(f),
            )
        }
    }

    #[doc(alias = "is-muted")]
    fn connect_is_muted_notify<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId {
        unsafe extern "C" fn notify_is_muted_trampoline<P: IsA<WebView>, F: Fn(&P) + 'static>(
            this: *mut ffi::WebKitWebView,
            _param_spec: glib::ffi::gpointer,
            f: glib::ffi::gpointer,
        ) {
            unsafe {
                let f: &F = &*(f as *const F);
                f(WebView::from_glib_borrow(this).unsafe_cast_ref())
            }
        }
        unsafe {
            let f: Box_<F> = Box_::new(f);
            connect_raw(
                self.as_ptr() as *mut _,
                c"notify::is-muted".as_ptr(),
                Some(std::mem::transmute::<*const (), unsafe extern "C" fn()>(
                    notify_is_muted_trampoline::<Self, F> as *const (),
                )),
                Box_::into_raw(f),
            )
        }
    }

    #[doc(alias = "is-playing-audio")]
    fn connect_is_playing_audio_notify<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId {
        unsafe extern "C" fn notify_is_playing_audio_trampoline<
            P: IsA<WebView>,
            F: Fn(&P) + 'static,
        >(
            this: *mut ffi::WebKitWebView,
            _param_spec: glib::ffi::gpointer,
            f: glib::ffi::gpointer,
        ) {
            unsafe {
                let f: &F = &*(f as *const F);
                f(WebView::from_glib_borrow(this).unsafe_cast_ref())
            }
        }
        unsafe {
            let f: Box_<F> = Box_::new(f);
            connect_raw(
                self.as_ptr() as *mut _,
                c"notify::is-playing-audio".as_ptr(),
                Some(std::mem::transmute::<*const (), unsafe extern "C" fn()>(
                    notify_is_playing_audio_trampoline::<Self, F> as *const (),
                )),
                Box_::into_raw(f),
            )
        }
    }

    #[doc(alias = "is-web-process-responsive")]
    fn connect_is_web_process_responsive_notify<F: Fn(&Self) + 'static>(
        &self,
        f: F,
    ) -> SignalHandlerId {
        unsafe extern "C" fn notify_is_web_process_responsive_trampoline<
            P: IsA<WebView>,
            F: Fn(&P) + 'static,
        >(
            this: *mut ffi::WebKitWebView,
            _param_spec: glib::ffi::gpointer,
            f: glib::ffi::gpointer,
        ) {
            unsafe {
                let f: &F = &*(f as *const F);
                f(WebView::from_glib_borrow(this).unsafe_cast_ref())
            }
        }
        unsafe {
            let f: Box_<F> = Box_::new(f);
            connect_raw(
                self.as_ptr() as *mut _,
                c"notify::is-web-process-responsive".as_ptr(),
                Some(std::mem::transmute::<*const (), unsafe extern "C" fn()>(
                    notify_is_web_process_responsive_trampoline::<Self, F> as *const (),
                )),
                Box_::into_raw(f),
            )
        }
    }

    #[doc(alias = "microphone-capture-state")]
    fn connect_microphone_capture_state_notify<F: Fn(&Self) + 'static>(
        &self,
        f: F,
    ) -> SignalHandlerId {
        unsafe extern "C" fn notify_microphone_capture_state_trampoline<
            P: IsA<WebView>,
            F: Fn(&P) + 'static,
        >(
            this: *mut ffi::WebKitWebView,
            _param_spec: glib::ffi::gpointer,
            f: glib::ffi::gpointer,
        ) {
            unsafe {
                let f: &F = &*(f as *const F);
                f(WebView::from_glib_borrow(this).unsafe_cast_ref())
            }
        }
        unsafe {
            let f: Box_<F> = Box_::new(f);
            connect_raw(
                self.as_ptr() as *mut _,
                c"notify::microphone-capture-state".as_ptr(),
                Some(std::mem::transmute::<*const (), unsafe extern "C" fn()>(
                    notify_microphone_capture_state_trampoline::<Self, F> as *const (),
                )),
                Box_::into_raw(f),
            )
        }
    }

    #[doc(alias = "page-id")]
    fn connect_page_id_notify<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId {
        unsafe extern "C" fn notify_page_id_trampoline<P: IsA<WebView>, F: Fn(&P) + 'static>(
            this: *mut ffi::WebKitWebView,
            _param_spec: glib::ffi::gpointer,
            f: glib::ffi::gpointer,
        ) {
            unsafe {
                let f: &F = &*(f as *const F);
                f(WebView::from_glib_borrow(this).unsafe_cast_ref())
            }
        }
        unsafe {
            let f: Box_<F> = Box_::new(f);
            connect_raw(
                self.as_ptr() as *mut _,
                c"notify::page-id".as_ptr(),
                Some(std::mem::transmute::<*const (), unsafe extern "C" fn()>(
                    notify_page_id_trampoline::<Self, F> as *const (),
                )),
                Box_::into_raw(f),
            )
        }
    }

    #[doc(alias = "settings")]
    fn connect_settings_notify<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId {
        unsafe extern "C" fn notify_settings_trampoline<P: IsA<WebView>, F: Fn(&P) + 'static>(
            this: *mut ffi::WebKitWebView,
            _param_spec: glib::ffi::gpointer,
            f: glib::ffi::gpointer,
        ) {
            unsafe {
                let f: &F = &*(f as *const F);
                f(WebView::from_glib_borrow(this).unsafe_cast_ref())
            }
        }
        unsafe {
            let f: Box_<F> = Box_::new(f);
            connect_raw(
                self.as_ptr() as *mut _,
                c"notify::settings".as_ptr(),
                Some(std::mem::transmute::<*const (), unsafe extern "C" fn()>(
                    notify_settings_trampoline::<Self, F> as *const (),
                )),
                Box_::into_raw(f),
            )
        }
    }

    #[cfg(feature = "v2_50")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v2_50")))]
    #[doc(alias = "theme-color")]
    fn connect_theme_color_notify<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId {
        unsafe extern "C" fn notify_theme_color_trampoline<P: IsA<WebView>, F: Fn(&P) + 'static>(
            this: *mut ffi::WebKitWebView,
            _param_spec: glib::ffi::gpointer,
            f: glib::ffi::gpointer,
        ) {
            unsafe {
                let f: &F = &*(f as *const F);
                f(WebView::from_glib_borrow(this).unsafe_cast_ref())
            }
        }
        unsafe {
            let f: Box_<F> = Box_::new(f);
            connect_raw(
                self.as_ptr() as *mut _,
                c"notify::theme-color".as_ptr(),
                Some(std::mem::transmute::<*const (), unsafe extern "C" fn()>(
                    notify_theme_color_trampoline::<Self, F> as *const (),
                )),
                Box_::into_raw(f),
            )
        }
    }

    #[doc(alias = "title")]
    fn connect_title_notify<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId {
        unsafe extern "C" fn notify_title_trampoline<P: IsA<WebView>, F: Fn(&P) + 'static>(
            this: *mut ffi::WebKitWebView,
            _param_spec: glib::ffi::gpointer,
            f: glib::ffi::gpointer,
        ) {
            unsafe {
                let f: &F = &*(f as *const F);
                f(WebView::from_glib_borrow(this).unsafe_cast_ref())
            }
        }
        unsafe {
            let f: Box_<F> = Box_::new(f);
            connect_raw(
                self.as_ptr() as *mut _,
                c"notify::title".as_ptr(),
                Some(std::mem::transmute::<*const (), unsafe extern "C" fn()>(
                    notify_title_trampoline::<Self, F> as *const (),
                )),
                Box_::into_raw(f),
            )
        }
    }

    #[doc(alias = "uri")]
    fn connect_uri_notify<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId {
        unsafe extern "C" fn notify_uri_trampoline<P: IsA<WebView>, F: Fn(&P) + 'static>(
            this: *mut ffi::WebKitWebView,
            _param_spec: glib::ffi::gpointer,
            f: glib::ffi::gpointer,
        ) {
            unsafe {
                let f: &F = &*(f as *const F);
                f(WebView::from_glib_borrow(this).unsafe_cast_ref())
            }
        }
        unsafe {
            let f: Box_<F> = Box_::new(f);
            connect_raw(
                self.as_ptr() as *mut _,
                c"notify::uri".as_ptr(),
                Some(std::mem::transmute::<*const (), unsafe extern "C" fn()>(
                    notify_uri_trampoline::<Self, F> as *const (),
                )),
                Box_::into_raw(f),
            )
        }
    }

    #[doc(alias = "zoom-level")]
    fn connect_zoom_level_notify<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId {
        unsafe extern "C" fn notify_zoom_level_trampoline<P: IsA<WebView>, F: Fn(&P) + 'static>(
            this: *mut ffi::WebKitWebView,
            _param_spec: glib::ffi::gpointer,
            f: glib::ffi::gpointer,
        ) {
            unsafe {
                let f: &F = &*(f as *const F);
                f(WebView::from_glib_borrow(this).unsafe_cast_ref())
            }
        }
        unsafe {
            let f: Box_<F> = Box_::new(f);
            connect_raw(
                self.as_ptr() as *mut _,
                c"notify::zoom-level".as_ptr(),
                Some(std::mem::transmute::<*const (), unsafe extern "C" fn()>(
                    notify_zoom_level_trampoline::<Self, F> as *const (),
                )),
                Box_::into_raw(f),
            )
        }
    }
}

impl<O: IsA<WebView>> WebViewExt for O {}