// 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::{
    ffi, 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,
};
use glib::{
    prelude::*,
    signal::{connect_raw, SignalHandlerId},
    translate::*,
};
use std::{boxed::Box as Box_, pin::Pin};

glib::wrapper! {
    /// The central class of the WPE WebKit and WebKitGTK APIs.
    ///
    /// #WebKitWebView 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 #WebKitWebView or
    /// a data string. With #WebKitSettings you can control various aspects
    /// of the rendering and loading of the content.
    ///
    /// Note that in WebKitGTK, #WebKitWebView is scrollable by itself, so
    /// you don't need to embed it in a #GtkScrolledWindow.
    ///
    /// ## Properties
    ///
    ///
    /// #### `automation-presentation-type`
    ///  The #WebKitAutomationBrowsingContextPresentation of #WebKitWebView. This should only be used when
    /// creating a new #WebKitWebView as a response to #WebKitAutomationSession::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 #WebKitUserContentManager 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 #WebKitWebView are editable. For more
    /// information see webkit_web_view_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 #WebKitWebView.
    /// See webkit_web_view_get_favicon() for more details.
    ///
    /// Readable
    ///
    ///
    /// #### `is-controlled-by-automation`
    ///  Whether the #WebKitWebView is controlled by automation. This should only be used when
    /// creating a new #WebKitWebView as a response to #WebKitAutomationSession::create-web-view
    /// signal request.
    ///
    /// Readable | Writeable | Construct Only
    ///
    ///
    /// #### `is-loading`
    ///  Whether the #WebKitWebView is currently loading a page. This property becomes
    /// [`true`] as soon as a new load operation is requested and before the
    /// #WebKitWebView::load-changed signal is emitted with [`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
    /// #WebKitWebView::load-changed is emitted with [`LoadEvent::Finished`][crate::LoadEvent::Finished].
    ///
    /// Readable
    ///
    ///
    /// #### `is-muted`
    ///  Whether the #WebKitWebView audio is muted. When [`true`], audio is silenced.
    /// It may still be playing, i.e. #WebKitWebView:is-playing-audio may be [`true`].
    ///
    /// Readable | Writeable
    ///
    ///
    /// #### `is-playing-audio`
    ///  Whether the #WebKitWebView 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 #WebKitWebView 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 #WebKitNetworkSession of the view
    ///
    /// Readable | Writeable | Construct Only
    ///
    ///
    /// #### `page-id`
    ///  The identifier of the #WebKitWebPage corresponding to the #WebKitWebView.
    ///
    /// Readable
    ///
    ///
    /// #### `related-view`
    ///  The related #WebKitWebView 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 #WebKitSettings of the view.
    ///
    /// Writeable | Construct
    ///
    ///
    /// #### `title`
    ///  The main frame document title of this #WebKitWebView. If
    /// the title has not been received yet, it will be [`None`].
    ///
    /// Readable
    ///
    ///
    /// #### `uri`
    ///  The current active URI of the #WebKitWebView.
    /// See webkit_web_view_get_uri() for more details.
    ///
    /// Readable
    ///
    ///
    /// #### `user-content-manager`
    ///  The #WebKitUserContentManager of the view.
    ///
    /// Readable | Writeable | Construct Only
    ///
    ///
    /// #### `web-context`
    ///  The #WebKitWebContext 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 #WebKitWebsitePolicies for the view.
    ///
    /// Readable | Writeable | Construct Only
    ///
    ///
    /// #### `zoom-level`
    ///  The zoom level of the #WebKitWebView content.
    /// See webkit_web_view_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 ::query-tooltip signal on @widget.
    ///
    /// A value of [`true`] indicates that @widget can have a tooltip, in this case
    /// the widget will be queried using [`query-tooltip`][struct@crate::gtk::Widget#query-tooltip] to
    /// determine whether it will provide a tooltip or not.
    ///
    /// Readable | Writeable
    ///
    ///
    /// #### `height-request`
    ///  Override 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 `GtkLayoutManager` 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
    ///
    ///
    /// #### `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
    /// [`WidgetExtManual::set_size_request()`][crate::gtk::prelude::WidgetExtManual::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
    /// [`WidgetExtManual::set_size_request()`][crate::gtk::prelude::WidgetExtManual::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
    /// [`WidgetExtManual::set_size_request()`][crate::gtk::prelude::WidgetExtManual::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
    /// [`WidgetExtManual::set_size_request()`][crate::gtk::prelude::WidgetExtManual::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 [`None`] 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 `Gtk::Tooltip::set_markup()`.
    ///
    /// This is a convenience property which will take care of getting the
    /// tooltip shown if the given string is not [`None`]:
    /// [`has-tooltip`][struct@crate::gtk::Widget#has-tooltip] will automatically be set to [`true`]
    /// and there will be taken care of [`query-tooltip`][struct@crate::gtk::Widget#query-tooltip] in
    /// the default signal handler.
    ///
    /// Note that if both [`tooltip-text`][struct@crate::gtk::Widget#tooltip-text] and
    /// [`tooltip-markup`][struct@crate::gtk::Widget#tooltip-markup] are set, the last one wins.
    ///
    /// Readable | Writeable
    ///
    ///
    /// #### `tooltip-text`
    ///  Sets the text of tooltip to be the given string.
    ///
    /// Also see `Gtk::Tooltip::set_text()`.
    ///
    /// This is a convenience property which will take care of getting the
    /// tooltip shown if the given string is not [`None`]:
    /// [`has-tooltip`][struct@crate::gtk::Widget#has-tooltip] will automatically be set to [`true`]
    /// and there will be taken care of [`query-tooltip`][struct@crate::gtk::Widget#query-tooltip] in
    /// the default signal handler.
    ///
    /// Note that if both [`tooltip-text`][struct@crate::gtk::Widget#tooltip-text] and
    /// [`tooltip-markup`][struct@crate::gtk::Widget#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`
    ///  Override 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
    /// #WebKitAuthenticationRequest in the @request argument.
    /// To handle this signal asynchronously you should keep a ref
    /// of the request and return [`true`]. To disable HTTP authentication
    /// entirely, connect to this signal and simply return [`true`].
    ///
    /// The default signal handler will run a default authentication
    /// dialog asynchronously for the user to interact with.
    ///
    ///
    ///
    ///
    /// #### `close`
    ///  Emitted when closing a #WebKitWebView 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 webkit_web_view_try_close().
    /// It is the owner's responsibility to handle this signal to hide or
    /// destroy the #WebKitWebView, 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 webkit_context_menu_prepend(),
    ///  webkit_context_menu_append() or webkit_context_menu_insert() to add new
    ///  #WebKitContextMenuItem<!-- -->s to @context_menu, webkit_context_menu_move_item()
    ///  to reorder existing items, or webkit_context_menu_remove() to remove an
    ///  existing item. The signal handler should return [`false`], and the menu represented
    ///  by @context_menu will be shown.
    /// </para></listitem>
    /// <listitem><para>
    ///  To prevent the menu from being displayed you can just connect to this signal
    ///  and return [`true`] so that the proposed menu will not be shown.
    /// </para></listitem>
    /// <listitem><para>
    ///  To build your own menu, you can remove all items from the proposed menu with
    ///  webkit_context_menu_remove_all(), add your own items and return [`false`] so
    ///  that the menu will be shown. You can also ignore the proposed #WebKitContextMenu,
    ///  build your own #GtkMenu and return [`true`] to prevent the proposed menu from being shown.
    /// </para></listitem>
    /// <listitem><para>
    ///  If you just want the default menu to be shown always, simply don't connect to this
    ///  signal because showing the proposed context menu is the default behaviour.
    /// </para></listitem>
    /// </itemizedlist>
    ///
    /// If the signal handler returns [`false`] the context menu represented by @context_menu
    /// will be shown, if it return [`true`] the context menu will not be shown.
    ///
    /// The proposed #WebKitContextMenu passed in @context_menu argument is only valid
    /// during the signal emission.
    ///
    ///
    ///
    ///
    /// #### `context-menu-dismissed`
    ///  Emitted after #WebKitWebView::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 #WebKitWebView is requested.
    /// If this signal is handled the signal handler should return the
    /// newly created #WebKitWebView.
    ///
    /// The #WebKitNavigationAction parameter contains information about the
    /// navigation action that triggered this signal.
    ///
    /// The new #WebKitWebView must be related to @web_view, see
    /// #WebKitWebView:related-view for more details.
    ///
    /// The new #WebKitWebView should not be displayed to the user
    /// until the #WebKitWebView::ready-to-show signal is emitted.
    ///
    ///
    ///
    ///
    /// #### `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 #WebKitNavigationPolicyDecision passed in the
    /// @decision argument is a generic type, but should be casted to a more
    /// specific type when making the decision. For example:
    ///
    /// **⚠️ 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 #WebKitPolicyDecision and no decision has been
    /// made explicitly, webkit_policy_decision_use() will be the default policy decision. The
    /// default signal handler will simply call webkit_policy_decision_use(). Only the first
    /// policy decision chosen for a given #WebKitPolicyDecision will have any affect.
    ///
    ///
    ///
    ///
    /// #### `enter-fullscreen`
    ///  Emitted when JavaScript code calls
    /// <function>element.webkitRequestFullScreen</function>. If the
    /// signal is not handled the #WebKitWebView will proceed to full screen
    /// its top level window. This signal can be used by client code to
    /// request permission to the user prior doing the full screen
    /// transition and eventually prepare the top-level window
    /// (e.g. hide some widgets that would otherwise be part of the
    /// full screen window).
    ///
    ///
    ///
    ///
    /// #### `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 #WebKitWebView is about to restore its top level
    /// window out of its full screen state. This signal can be used by
    /// client code to restore widgets hidden during the
    /// #WebKitWebView::enter-fullscreen stage for instance.
    ///
    ///
    ///
    ///
    /// #### `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 #WebKitWebView::load-failed signal is emitted
    /// before #WebKitWebView::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, #WebKitWebView::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 #WebKitPermissionRequest and the
    /// request has not been handled, webkit_permission_request_deny()
    /// will be the default action.
    ///
    /// If the signal is not handled, the @request will be completed automatically
    /// by the specific #WebKitPermissionRequest that could allow or deny it. Check the
    /// documentation of classes implementing #WebKitPermissionRequest 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 webkit_print_operation_set_print_settings() and
    /// webkit_print_operation_set_page_setup() and then return [`false`] to propagate the
    /// event so that the print dialog is shown.
    ///
    /// You can connect to this signal and return [`true`] to cancel the print operation
    /// or implement your own print dialog.
    ///
    ///
    ///
    ///
    /// #### `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 webkit_permission_state_query_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 #WebKitWebView::create on the newly created #WebKitWebView
    /// when it should be displayed to the user. When this signal is emitted
    /// all the information about how the window should look, including
    /// size, position, whether the location, status and scrollbars
    /// should be displayed, is already set on the #WebKitWindowProperties
    /// of @web_view. See also webkit_web_view_get_window_properties().
    ///
    ///
    ///
    ///
    /// #### `resource-load-started`
    ///  Emitted when a new resource is going to be loaded. The @request parameter
    /// contains the #WebKitURIRequest that will be sent to the server.
    /// You can monitor the load operation by connecting to the different signals
    /// of @resource.
    ///
    ///
    ///
    ///
    /// #### `run-as-modal`
    ///  Emitted after #WebKitWebView::ready-to-show on the newly
    /// created #WebKitWebView when JavaScript code calls
    /// <function>window.showModalDialog</function>. The purpose of
    /// this signal is to allow the client application to prepare the
    /// new view to behave as modal. Once the signal is emitted a new
    /// main loop will be run to block user interaction in the parent
    /// #WebKitWebView 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 #WebKitColorChooserRequest 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 #WebKitFileChooserRequest 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
    /// webkit_script_dialog_close() when done.
    /// If the last reference is removed on a #WebKitScriptDialog and the dialog has not been
    /// closed, webkit_script_dialog_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
    /// #WebKitWebView 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 webkit_form_submission_request_submit() is called.
    ///
    /// It is possible to handle the form submission request asynchronously, by
    /// simply calling g_object_ref() on the @request argument and calling
    /// webkit_form_submission_request_submit() when done to continue with the form submission.
    /// If the last reference is removed on a #WebKitFormSubmissionRequest and the
    /// form has not been submitted, webkit_form_submission_request_submit() will be called.
    ///
    ///
    ///
    ///
    /// #### `user-message-received`
    ///  This signal is emitted when a #WebKitUserMessage is received from the
    /// #WebKitWebPage corresponding to @web_view. You can reply to the message
    /// using webkit_user_message_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 [`WidgetExtManual::keynav_failed()`][crate::gtk::prelude::WidgetExtManual::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
    /// [`visible`][struct@crate::gtk::Widget#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 [`unmap`][struct@crate::gtk::Widget#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 [`has-tooltip`][struct@crate::gtk::Widget#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 [`WidgetExtManual::realize()`][crate::gtk::prelude::WidgetExtManual::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 [`WidgetExtManual::state_flags()`][crate::gtk::prelude::WidgetExtManual::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 [`WidgetExtManual::unrealize()`][crate::gtk::prelude::WidgetExtManual::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 #WebKitWebView with the default #WebKitWebContext.
    ///
    /// Creates a new #WebKitWebView with the default #WebKitWebContext and
    /// no #WebKitUserContentManager 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 #WebKitWebView 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 #WebKitAutomationBrowsingContextPresentation of #WebKitWebView. This should only be used when
    /// creating a new #WebKitWebView as a response to #WebKitAutomationSession::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 #WebKitUserContentManager 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 #WebKitWebView are editable. For more
    /// information see webkit_web_view_set_editable().
    pub fn editable(self, editable: bool) -> Self {
        Self {
            builder: self.builder.property("editable", editable),
        }
    }

    /// Whether the #WebKitWebView is controlled by automation. This should only be used when
    /// creating a new #WebKitWebView as a response to #WebKitAutomationSession::create-web-view
    /// signal request.
    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 #WebKitWebView audio is muted. When [`true`], audio is silenced.
    /// It may still be playing, i.e. #WebKitWebView: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 #WebKitNetworkSession of the view
    pub fn network_session(self, network_session: &NetworkSession) -> Self {
        Self {
            builder: self
                .builder
                .property("network-session", network_session.clone()),
        }
    }

    /// The related #WebKitWebView 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 #WebKitSettings of the view.
    pub fn settings(self, settings: &Settings) -> Self {
        Self {
            builder: self.builder.property("settings", settings.clone()),
        }
    }

    /// The #WebKitUserContentManager 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 #WebKitWebContext 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 #WebKitWebsitePolicies 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 #WebKitWebView content.
    /// See webkit_web_view_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 ::query-tooltip signal on @widget.
    ///
    /// A value of [`true`] indicates that @widget can have a tooltip, in this case
    /// the widget will be queried using [`query-tooltip`][struct@crate::gtk::Widget#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),
        }
    }

    /// Override 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()), }
    //}

    /// 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
    /// [`WidgetExtManual::set_size_request()`][crate::gtk::prelude::WidgetExtManual::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
    /// [`WidgetExtManual::set_size_request()`][crate::gtk::prelude::WidgetExtManual::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
    /// [`WidgetExtManual::set_size_request()`][crate::gtk::prelude::WidgetExtManual::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
    /// [`WidgetExtManual::set_size_request()`][crate::gtk::prelude::WidgetExtManual::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 `Gtk::Tooltip::set_markup()`.
    ///
    /// This is a convenience property which will take care of getting the
    /// tooltip shown if the given string is not [`None`]:
    /// [`has-tooltip`][struct@crate::gtk::Widget#has-tooltip] will automatically be set to [`true`]
    /// and there will be taken care of [`query-tooltip`][struct@crate::gtk::Widget#query-tooltip] in
    /// the default signal handler.
    ///
    /// Note that if both [`tooltip-text`][struct@crate::gtk::Widget#tooltip-text] and
    /// [`tooltip-markup`][struct@crate::gtk::Widget#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 `Gtk::Tooltip::set_text()`.
    ///
    /// This is a convenience property which will take care of getting the
    /// tooltip shown if the given string is not [`None`]:
    /// [`has-tooltip`][struct@crate::gtk::Widget#has-tooltip] will automatically be set to [`true`]
    /// and there will be taken care of [`query-tooltip`][struct@crate::gtk::Widget#query-tooltip] in
    /// the default signal handler.
    ///
    /// Note that if both [`tooltip-text`][struct@crate::gtk::Widget#tooltip-text] and
    /// [`tooltip-markup`][struct@crate::gtk::Widget#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),
        }
    }

    /// Override 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 {
        self.builder.build()
    }
}

mod sealed {
    pub trait Sealed {}
    impl<T: super::IsA<super::WebView>> Sealed for T {}
}

/// Trait containing all [`struct@WebView`] methods.
///
/// # Implementors
///
/// [`WebView`][struct@crate::WebView]
pub trait WebViewExt: IsA<WebView> + sealed::Sealed + '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 #WebKitSettings: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 #WebKitSettings: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 #GVariant 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 #GCancellable 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,
        ) {
            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 #GCancellable 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,
        ) {
            let mut error = std::ptr::null_mut();
            let _ = 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 #WebKitDownload 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 #WebKitSettings: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 #WebKitSettings: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 webkit_web_view_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 #GCancellable 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,
        ) {
            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 webkit_web_view_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
    /// webkit_web_view_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 #WebKitWebView when created for automation.
    ///
    /// # Returns
    ///
    /// a #WebKitAutomationBrowsingContextPresentation.
    #[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 #WebKitBackForwardList associated with the given #WebKitWebView.
    ///
    /// The #WebKitBackForwardList is owned by the #WebKitWebView.
    ///
    /// # Returns
    ///
    /// the #WebKitBackForwardList
    #[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 webkit_web_view_set_background_color()
    ///
    /// # Returns
    ///
    ///
    /// ## `rgba`
    /// a #GdkRGBA 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 #WebKitWebView.
    ///
    /// # Returns
    ///
    /// The #WebKitMediaCaptureState of the camera device. If #WebKitSettings: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 #WebKitWebContext 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 #WebKitWebView.
    ///
    /// # Returns
    ///
    /// The #WebKitMediaCaptureState of the display device. If #WebKitSettings: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 #WebKitEditorState 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 #WebKitWebView:estimated-load-progress property.
    ///
    /// You can monitor the estimated progress of a load operation by
    /// connecting to the notify::estimated-load-progress signal of @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 #WebKitFindController.
    ///
    /// Gets the #WebKitFindController that will allow the caller to query
    /// the #WebKitWebView for the text to look for.
    ///
    /// # Returns
    ///
    /// the #WebKitFindController associated to
    /// this particular #WebKitWebView.
    #[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 #WebKitInputMethodContext currently in use by @self.
    ///
    /// Get the #WebKitInputMethodContext currently in use by @self, or [`None`] if no input method is being used.
    ///
    /// # Returns
    ///
    /// a #WebKitInputMethodContext, 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 #WebKitWebInspector associated to @self
    ///
    /// # Returns
    ///
    /// the #WebKitWebInspector 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 #WebKitWebView 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 #WebKitWebResource 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 #WebKitWebView.
    ///
    /// # Returns
    ///
    /// The #WebKitMediaCaptureState of the microphone device. If #WebKitSettings: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 #WebKitNetworkSession associated to @self.
    ///
    /// # Returns
    ///
    /// a #WebKitNetworkSession
    #[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 #WebKitWebView
    ///
    /// # 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 #WebKitWebViewSessionState
    #[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 #WebKitSettings currently applied to @self.
    ///
    /// If no other #WebKitSettings have been explicitly applied to
    /// @self with webkit_web_view_set_settings(), the default
    /// #WebKitSettings will be returned. This method always returns
    /// a valid #WebKitSettings object.
    /// To modify any of the @self settings, you can either create
    /// a new #WebKitSettings object with webkit_settings_new(), setting
    /// the desired preferences, and then replace the existing @self
    /// settings with webkit_web_view_set_settings() or get the existing
    /// @self settings and update it directly. #WebKitSettings objects
    /// can be shared by multiple #WebKitWebView<!-- -->s, so modifying
    /// the settings of a #WebKitWebView would affect other
    /// #WebKitWebView<!-- -->s using the same #WebKitSettings.
    ///
    /// # Returns
    ///
    /// the #WebKitSettings 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 #WebKitSnapshotRegion for this snapshot
    /// ## `options`
    /// #WebKitSnapshotOptions for the snapshot
    /// ## `cancellable`
    /// a #GCancellable
    /// ## `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,
        ) {
            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 value of the #WebKitWebView: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 #GTlsCertificate associated with the main resource of @self.
    ///
    /// Retrieves the #GTlsCertificate associated with the main resource of @self,
    /// and the #GTlsCertificateFlags showing what problems, if any, have been found
    /// with that certificate.
    /// If the connection is not HTTPS, this function returns [`false`].
    /// This function should be called after a response has been received from the
    /// server, so you can connect to #WebKitWebView::load-changed and call this function
    /// when it's emitted with [`LoadEvent::Committed`][crate::LoadEvent::Committed] event.
    ///
    /// Note that this function provides no information about the security of the web
    /// page if the current #WebKitTLSErrorsPolicy 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 #WebKitTLSErrorsPolicy 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 #GTlsCertificate
    ///
    /// ## `errors`
    /// return location for a #GTlsCertificateFlags 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 webkit_web_view_load_uri(),
    ///     the requested URI is the given one.
    ///   </para></listitem>
    ///   <listitem><para>
    ///     If the load operation was started by webkit_web_view_load_html(),
    ///     the requested URI is "about:blank".
    ///   </para></listitem>
    ///   <listitem><para>
    ///     If the load operation was started by webkit_web_view_load_alternate_html(),
    ///     the requested URI is content URI provided.
    ///   </para></listitem>
    ///   <listitem><para>
    ///     If the load operation was started by webkit_web_view_go_back() or
    ///     webkit_web_view_go_forward(), the requested URI is the original URI
    ///     of the previous/next item in the #WebKitBackForwardList of @self.
    ///   </para></listitem>
    ///   <listitem><para>
    ///     If the load operation was started by
    ///     webkit_web_view_go_to_back_forward_list_item(), the requested URI
    ///     is the opriginal URI of the given #WebKitBackForwardListItem.
    ///   </para></listitem>
    ///   </itemizedlist>
    /// </para></listitem>
    /// <listitem><para>
    ///   If there is a server redirection during the load operation,
    ///   the active URI is the redirected URI. When the signal
    ///   #WebKitWebView::load-changed is emitted with [`LoadEvent::Redirected`][crate::LoadEvent::Redirected]
    ///   event, the active URI is already updated to the redirected URI.
    /// </para></listitem>
    /// <listitem><para>
    ///   When the signal #WebKitWebView::load-changed is emitted
    ///   with [`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 #WebKitUserContentManager 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 #WebKitWebExtensionMode.
    ///
    /// # Returns
    ///
    /// the #WebKitWebExtensionMode
    #[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
    /// #WebKitWebView::decide-policy signal handler.
    ///
    /// See also webkit_policy_decision_use_with_policies().
    ///
    /// # Returns
    ///
    /// the default #WebKitWebsitePolicies
    ///     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 #WebKitWindowProperties object.
    ///
    /// Get the #WebKitWindowProperties object containing the properties
    /// that the window containing @self should have.
    ///
    /// # Returns
    ///
    /// the #WebKitWindowProperties 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
    /// #WebKitWebView::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
    /// #WebKitWebView::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
    /// #WebKitWebView::load-changed signal.
    /// ## `list_item`
    /// a #WebKitBackForwardListItem
    #[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 #WebKitWebView was created with #WebKitWebView:is-controlled-by-automation
    /// property enabled.
    ///
    /// Only #WebKitWebView<!-- -->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 #WebKitWebView 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 the value of the #WebKitWebView:is-loading property.
    ///
    /// You can monitor when a #WebKitWebView is loading a page by connecting to
    /// notify::is-loading signal of @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 #WebKitWebView:is-playing-audio property.
    ///
    /// You can monitor when a page in a #WebKitWebView 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,
            ))
        }
    }

    /// Load the given @content string for the URI @content_uri.
    ///
    /// This allows clients to display page-loading errors in the #WebKitWebView itself.
    /// When this method is called from #WebKitWebView::load-failed signal to show an
    /// error page, then the back-forward list is maintained appropriately.
    /// For everything else this method works the same way as webkit_web_view_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 #WebKitWebView::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 #WebKitWebView::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 #WebKitWebView::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 #WebKitURIRequest.
    ///
    /// You can monitor the load operation by connecting to
    /// #WebKitWebView::load-changed signal.
    /// ## `request`
    /// a #WebKitURIRequest 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
    /// #WebKitWebView::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 webkit_web_view_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 #WebKitWebViewSessionState
    #[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
    /// #WebKitWebView into a self-contained format using the mode
    /// specified in @save_mode.
    ///
    /// When the operation is finished, @callback will be called. You can
    /// then call webkit_web_view_save_finish() to get the result of the
    /// operation.
    /// ## `save_mode`
    /// the #WebKitSaveMode specifying how the web page should be saved.
    /// ## `cancellable`
    /// a #GCancellable 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,
        ) {
            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
    /// #WebKitWebView into a self-contained format using the mode
    /// specified in @save_mode and writing it to @file.
    ///
    /// When the operation is finished, @callback will be called. You can
    /// then call webkit_web_view_save_to_file_finish() to get the result of the
    /// operation.
    /// ## `file`
    /// the #GFile where the current web page should be saved to.
    /// ## `save_mode`
    /// the #WebKitSaveMode specifying how the web page should be saved.
    /// ## `cancellable`
    /// a #GCancellable 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,
        ) {
            let mut error = std::ptr::null_mut();
            let _ =
                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 #WebKitUserMessage
    /// ## `cancellable`
    /// a #GCancellable 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,
        ) {
            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 #GdkRGBA
    #[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 #WebKitWebView.
    ///
    /// If #WebKitSettings: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 #WebKitMediaCaptureState
    #[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 #WebKitWebView.
    ///
    /// If #WebKitSettings: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 #WebKitMediaCaptureState
    #[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 #WebKitWebView 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 #WebKitWebView 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 #WebKitInputMethodContext to be used by @self.
    ///
    /// Set the #WebKitInputMethodContext to be used by @self, or [`None`] to not use any input method.
    /// Note that the same #WebKitInputMethodContext can't be set on more than one #WebKitWebView at the same time.
    /// ## `context`
    /// the #WebKitInputMethodContext 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 #WebKitWebView.
    ///
    /// If #WebKitSettings: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 #WebKitMediaCaptureState
    #[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 #WebKitSettings to be applied to @self.
    ///
    /// The
    /// existing #WebKitSettings of @self will be replaced by
    /// @settings. New settings are applied immediately on @self.
    /// The same #WebKitSettings object can be shared
    /// by multiple #WebKitWebView<!-- -->s.
    /// ## `settings`
    /// a #WebKitSettings
    #[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
    /// #WebKitWebView::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 #WebKitWebView::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 #WebKitWebView::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 #WebKitWebContext 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
    /// #WebKitAuthenticationRequest in the @request argument.
    /// To handle this signal asynchronously you should keep a ref
    /// of the request and return [`true`]. To disable HTTP authentication
    /// entirely, connect to this signal and simply return [`true`].
    ///
    /// The default signal handler will run a default authentication
    /// dialog asynchronously for the user to interact with.
    /// ## `request`
    /// a #WebKitAuthenticationRequest
    ///
    /// # 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 {
            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 _,
                b"authenticate\0".as_ptr() as *const _,
                Some(std::mem::transmute::<*const (), unsafe extern "C" fn()>(
                    authenticate_trampoline::<Self, F> as *const (),
                )),
                Box_::into_raw(f),
            )
        }
    }

    /// Emitted when closing a #WebKitWebView 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 webkit_web_view_try_close().
    /// It is the owner's responsibility to handle this signal to hide or
    /// destroy the #WebKitWebView, 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,
        ) {
            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 _,
                b"close\0".as_ptr() as *const _,
                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 webkit_context_menu_prepend(),
    ///  webkit_context_menu_append() or webkit_context_menu_insert() to add new
    ///  #WebKitContextMenuItem<!-- -->s to @context_menu, webkit_context_menu_move_item()
    ///  to reorder existing items, or webkit_context_menu_remove() to remove an
    ///  existing item. The signal handler should return [`false`], and the menu represented
    ///  by @context_menu will be shown.
    /// </para></listitem>
    /// <listitem><para>
    ///  To prevent the menu from being displayed you can just connect to this signal
    ///  and return [`true`] so that the proposed menu will not be shown.
    /// </para></listitem>
    /// <listitem><para>
    ///  To build your own menu, you can remove all items from the proposed menu with
    ///  webkit_context_menu_remove_all(), add your own items and return [`false`] so
    ///  that the menu will be shown. You can also ignore the proposed #WebKitContextMenu,
    ///  build your own #GtkMenu and return [`true`] to prevent the proposed menu from being shown.
    /// </para></listitem>
    /// <listitem><para>
    ///  If you just want the default menu to be shown always, simply don't connect to this
    ///  signal because showing the proposed context menu is the default behaviour.
    /// </para></listitem>
    /// </itemizedlist>
    ///
    /// If the signal handler returns [`false`] the context menu represented by @context_menu
    /// will be shown, if it return [`true`] the context menu will not be shown.
    ///
    /// The proposed #WebKitContextMenu passed in @context_menu argument is only valid
    /// during the signal emission.
    /// ## `context_menu`
    /// the proposed #WebKitContextMenu
    /// ## `hit_test_result`
    /// a #WebKitHitTestResult
    ///
    /// # 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 {
            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 _,
                b"context-menu\0".as_ptr() as *const _,
                Some(std::mem::transmute::<*const (), unsafe extern "C" fn()>(
                    context_menu_trampoline::<Self, F> as *const (),
                )),
                Box_::into_raw(f),
            )
        }
    }

    /// Emitted after #WebKitWebView::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,
        ) {
            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 _,
                b"context-menu-dismissed\0".as_ptr() as *const _,
                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 #WebKitWebView is requested.
    /// If this signal is handled the signal handler should return the
    /// newly created #WebKitWebView.
    ///
    /// The #WebKitNavigationAction parameter contains information about the
    /// navigation action that triggered this signal.
    ///
    /// The new #WebKitWebView must be related to @web_view, see
    /// #WebKitWebView:related-view for more details.
    ///
    /// The new #WebKitWebView should not be displayed to the user
    /// until the #WebKitWebView::ready-to-show signal is emitted.
    /// ## `navigation_action`
    /// a #WebKitNavigationAction
    ///
    /// # Returns
    ///
    /// a newly allocated #WebKitWebView widget
    ///    or [`None`] to propagate the event further.
    #[doc(alias = "create")]
    fn connect_create<F: Fn(&Self, &NavigationAction) -> gtk::Widget + 'static>(
        &self,
        f: F,
    ) -> SignalHandlerId {
        unsafe extern "C" fn create_trampoline<
            P: IsA<WebView>,
            F: Fn(&P, &NavigationAction) -> gtk::Widget + 'static,
        >(
            this: *mut ffi::WebKitWebView,
            navigation_action: *mut ffi::WebKitNavigationAction,
            f: glib::ffi::gpointer,
        ) -> *mut gtk::ffi::GtkWidget {
            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 _,
                b"create\0".as_ptr() as *const _,
                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 #WebKitNavigationPolicyDecision passed in the
    /// @decision argument is a generic type, but should be casted to a more
    /// specific type when making the decision. For example:
    ///
    /// **⚠️ 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 #WebKitPolicyDecision and no decision has been
    /// made explicitly, webkit_policy_decision_use() will be the default policy decision. The
    /// default signal handler will simply call webkit_policy_decision_use(). Only the first
    /// policy decision chosen for a given #WebKitPolicyDecision will have any affect.
    /// ## `decision`
    /// the #WebKitPolicyDecision
    /// ## `decision_type`
    /// a #WebKitPolicyDecisionType 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 {
            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 _,
                b"decide-policy\0".as_ptr() as *const _,
                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 #WebKitWebView will proceed to full screen
    /// its top level window. This signal can be used by client code to
    /// request permission to the user prior doing the full screen
    /// transition and eventually prepare the top-level window
    /// (e.g. hide some widgets that would otherwise be part of the
    /// full screen window).
    ///
    /// # Returns
    ///
    /// [`true`] to stop other handlers from being invoked for the event.
    ///    [`false`] to continue emission of the event.
    #[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 {
            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 _,
                b"enter-fullscreen\0".as_ptr() as *const _,
                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 #WebKitInsecureContentEvent
    #[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,
        ) {
            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 _,
                b"insecure-content-detected\0".as_ptr() as *const _,
                Some(std::mem::transmute::<*const (), unsafe extern "C" fn()>(
                    insecure_content_detected_trampoline::<Self, F> as *const (),
                )),
                Box_::into_raw(f),
            )
        }
    }

    /// Emitted when the #WebKitWebView is about to restore its top level
    /// window out of its full screen state. This signal can be used by
    /// client code to restore widgets hidden during the
    /// #WebKitWebView::enter-fullscreen stage for instance.
    ///
    /// # Returns
    ///
    /// [`true`] to stop other handlers from being invoked for the event.
    ///    [`false`] to continue emission of the event.
    #[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 {
            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 _,
                b"leave-fullscreen\0".as_ptr() as *const _,
                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 #WebKitWebView::load-failed signal is emitted
    /// before #WebKitWebView::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 #WebKitLoadEvent
    #[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,
        ) {
            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 _,
                b"load-changed\0".as_ptr() as *const _,
                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 #WebKitLoadEvent of the load operation
    /// ## `failing_uri`
    /// the URI that failed to load
    /// ## `error`
    /// the #GError 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 libc::c_char,
            error: *mut glib::ffi::GError,
            f: glib::ffi::gpointer,
        ) -> glib::ffi::gboolean {
            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 _,
                b"load-failed\0".as_ptr() as *const _,
                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, #WebKitWebView::load-failed will be emitted. The load
    /// will finish regardless of the returned value.
    /// ## `failing_uri`
    /// the URI that failed to load
    /// ## `certificate`
    /// a #GTlsCertificate
    /// ## `errors`
    /// a #GTlsCertificateFlags 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 libc::c_char,
            certificate: *mut gio::ffi::GTlsCertificate,
            errors: gio::ffi::GTlsCertificateFlags,
            f: glib::ffi::gpointer,
        ) -> glib::ffi::gboolean {
            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 _,
                b"load-failed-with-tls-errors\0".as_ptr() as *const _,
                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 #WebKitHitTestResult
    /// ## `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: libc::c_uint,
            f: glib::ffi::gpointer,
        ) {
            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 _,
                b"mouse-target-changed\0".as_ptr() as *const _,
                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 #WebKitPermissionRequest and the
    /// request has not been handled, webkit_permission_request_deny()
    /// will be the default action.
    ///
    /// If the signal is not handled, the @request will be completed automatically
    /// by the specific #WebKitPermissionRequest that could allow or deny it. Check the
    /// documentation of classes implementing #WebKitPermissionRequest interface to know
    /// their default action.
    /// ## `request`
    /// the #WebKitPermissionRequest
    ///
    /// # 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 {
            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 _,
                b"permission-request\0".as_ptr() as *const _,
                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 webkit_print_operation_set_print_settings() and
    /// webkit_print_operation_set_page_setup() and then return [`false`] to propagate the
    /// event so that the print dialog is shown.
    ///
    /// You can connect to this signal and return [`true`] to cancel the print operation
    /// or implement your own print dialog.
    /// ## `print_operation`
    /// the #WebKitPrintOperation 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 {
            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 _,
                b"print\0".as_ptr() as *const _,
                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 webkit_permission_state_query_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 #WebKitPermissionStateQuery
    ///
    /// # 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 {
            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 _,
                b"query-permission-state\0".as_ptr() as *const _,
                Some(std::mem::transmute::<*const (), unsafe extern "C" fn()>(
                    query_permission_state_trampoline::<Self, F> as *const (),
                )),
                Box_::into_raw(f),
            )
        }
    }

    /// Emitted after #WebKitWebView::create on the newly created #WebKitWebView
    /// when it should be displayed to the user. When this signal is emitted
    /// all the information about how the window should look, including
    /// size, position, whether the location, status and scrollbars
    /// should be displayed, is already set on the #WebKitWindowProperties
    /// of @web_view. See also webkit_web_view_get_window_properties().
    #[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,
        ) {
            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 _,
                b"ready-to-show\0".as_ptr() as *const _,
                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 #WebKitURIRequest that will be sent to the server.
    /// You can monitor the load operation by connecting to the different signals
    /// of @resource.
    /// ## `resource`
    /// a #WebKitWebResource
    /// ## `request`
    /// a #WebKitURIRequest
    #[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,
        ) {
            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 _,
                b"resource-load-started\0".as_ptr() as *const _,
                Some(std::mem::transmute::<*const (), unsafe extern "C" fn()>(
                    resource_load_started_trampoline::<Self, F> as *const (),
                )),
                Box_::into_raw(f),
            )
        }
    }

    /// Emitted after #WebKitWebView::ready-to-show on the newly
    /// created #WebKitWebView when JavaScript code calls
    /// <function>window.showModalDialog</function>. The purpose of
    /// this signal is to allow the client application to prepare the
    /// new view to behave as modal. Once the signal is emitted a new
    /// main loop will be run to block user interaction in the parent
    /// #WebKitWebView 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,
        ) {
            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 _,
                b"run-as-modal\0".as_ptr() as *const _,
                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 #WebKitColorChooserRequest 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 #WebKitColorChooserRequest
    ///
    /// # 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 {
            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 _,
                b"run-color-chooser\0".as_ptr() as *const _,
                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 #WebKitFileChooserRequest in the @request
    /// argument.
    ///
    /// The default signal handler will asynchronously run a regular
    /// #GtkFileChooserDialog for the user to interact with.
    /// ## `request`
    /// a #WebKitFileChooserRequest
    ///
    /// # 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 {
            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 _,
                b"run-file-chooser\0".as_ptr() as *const _,
                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
    /// webkit_script_dialog_close() when done.
    /// If the last reference is removed on a #WebKitScriptDialog and the dialog has not been
    /// closed, webkit_script_dialog_close() will be called.
    /// ## `dialog`
    /// the #WebKitScriptDialog 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 {
            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 _,
                b"script-dialog\0".as_ptr() as *const _,
                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 #WebKitNotification
    ///
    /// # 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 {
            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 _,
                b"show-notification\0".as_ptr() as *const _,
                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
    /// #WebKitWebView 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 #WebKitOptionMenu
    /// ## `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 {
            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 _,
                b"show-option-menu\0".as_ptr() as *const _,
                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 webkit_form_submission_request_submit() is called.
    ///
    /// It is possible to handle the form submission request asynchronously, by
    /// simply calling g_object_ref() on the @request argument and calling
    /// webkit_form_submission_request_submit() when done to continue with the form submission.
    /// If the last reference is removed on a #WebKitFormSubmissionRequest and the
    /// form has not been submitted, webkit_form_submission_request_submit() will be called.
    /// ## `request`
    /// a #WebKitFormSubmissionRequest
    #[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,
        ) {
            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 _,
                b"submit-form\0".as_ptr() as *const _,
                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 #WebKitUserMessage is received from the
    /// #WebKitWebPage corresponding to @web_view. You can reply to the message
    /// using webkit_user_message_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 #WebKitUserMessage 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 {
            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 _,
                b"user-message-received\0".as_ptr() as *const _,
                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 #WebKitWebProcessTerminationReason
    #[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,
        ) {
            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 _,
                b"web-process-terminated\0".as_ptr() as *const _,
                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,
        ) {
            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 _,
                b"notify::camera-capture-state\0".as_ptr() as *const _,
                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,
        ) {
            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 _,
                b"notify::display-capture-state\0".as_ptr() as *const _,
                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,
        ) {
            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 _,
                b"notify::editable\0".as_ptr() as *const _,
                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,
        ) {
            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 _,
                b"notify::estimated-load-progress\0".as_ptr() as *const _,
                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,
        ) {
            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 _,
                b"notify::favicon\0".as_ptr() as *const _,
                Some(std::mem::transmute::<*const (), unsafe extern "C" fn()>(
                    notify_favicon_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,
        ) {
            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 _,
                b"notify::is-loading\0".as_ptr() as *const _,
                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,
        ) {
            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 _,
                b"notify::is-muted\0".as_ptr() as *const _,
                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,
        ) {
            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 _,
                b"notify::is-playing-audio\0".as_ptr() as *const _,
                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,
        ) {
            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 _,
                b"notify::is-web-process-responsive\0".as_ptr() as *const _,
                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,
        ) {
            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 _,
                b"notify::microphone-capture-state\0".as_ptr() as *const _,
                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,
        ) {
            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 _,
                b"notify::page-id\0".as_ptr() as *const _,
                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,
        ) {
            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 _,
                b"notify::settings\0".as_ptr() as *const _,
                Some(std::mem::transmute::<*const (), unsafe extern "C" fn()>(
                    notify_settings_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,
        ) {
            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 _,
                b"notify::title\0".as_ptr() as *const _,
                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,
        ) {
            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 _,
                b"notify::uri\0".as_ptr() as *const _,
                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,
        ) {
            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 _,
                b"notify::zoom-level\0".as_ptr() as *const _,
                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 {}