webkit6/auto/

settings.rs

// This file was generated by gir (https://github.com/gtk-rs/gir)
// from gir-files (https://github.com/gtk-rs/gir-files)
// from webkit-gir-files
// DO NOT EDIT
#![allow(deprecated)]

#[cfg(feature = "v2_42")]
#[cfg_attr(docsrs, doc(cfg(feature = "v2_42")))]
use crate::{Feature, FeatureList};
use crate::{HardwareAccelerationPolicy, ffi};
use glib::{
    prelude::*,
    signal::{SignalHandlerId, connect_raw},
    translate::*,
};
use std::boxed::Box as Box_;

glib::wrapper! {
    /// Control the behaviour of a [`WebView`][crate::WebView].
    ///
    /// [`Settings`][crate::Settings] can be applied to a [`WebView`][crate::WebView] to control text charset,
    /// color, font sizes, printing mode, script support, loading of images and various
    /// other things on a [`WebView`][crate::WebView]. After creation, a [`Settings`][crate::Settings] object
    /// contains default settings.
    ///
    /// **⚠️ The following code is in c ⚠️**
    ///
    /// ```c
    /// // Disable JavaScript
    /// WebKitSettings *settings = webkit_web_view_group_get_settings (my_view_group);
    /// webkit_settings_set_enable_javascript (settings, FALSE);
    /// ```
    ///
    /// ## Properties
    ///
    ///
    /// #### `allow-file-access-from-file-urls`
    ///  Whether file access is allowed from file URLs. By default, when
    /// something is loaded in a [`WebView`][crate::WebView] using a file URI, cross
    /// origin requests to other file resources are not allowed. This
    /// setting allows you to change that behaviour, so that it would be
    /// possible to do a XMLHttpRequest of a local file, for example.
    ///
    /// Readable | Writeable | Construct
    ///
    ///
    /// #### `allow-modal-dialogs`
    ///  Determine whether it's allowed to create and run modal dialogs
    /// from a [`WebView`][crate::WebView] through JavaScript with
    /// `<function>`window.showModalDialog`</function>`. If it's set to
    /// [`false`], the associated [`WebView`][crate::WebView] won't be able to create
    /// new modal dialogs, so not even the [`create`][struct@crate::WebView#create]
    /// signal will be emitted.
    ///
    /// Readable | Writeable | Construct
    ///
    ///
    /// #### `allow-top-navigation-to-data-urls`
    ///  Whether or not the top frame is allowed to navigate to data URLs. It is disabled by default
    /// due to the risk it poses when loading untrusted URLs, with data URLs being used in scamming
    /// and phishing attacks. In contrast, a scenario where it could be enabled could be an app that
    /// embeds a WebView and you have control of the pages being show instead of a generic browser.
    ///
    /// Readable | Writeable | Construct
    ///
    ///
    /// #### `allow-universal-access-from-file-urls`
    ///  Whether or not JavaScript running in the context of a file scheme URL
    /// should be allowed to access content from any origin. By default, when
    /// something is loaded in a [`WebView`][crate::WebView] using a file scheme URL,
    /// access to the local file system and arbitrary local storage is not
    /// allowed. This setting allows you to change that behaviour, so that
    /// it would be possible to use local storage, for example.
    ///
    /// Readable | Writeable | Construct
    ///
    ///
    /// #### `auto-load-images`
    ///  Determines whether images should be automatically loaded or not.
    /// On devices where network bandwidth is of concern, it might be
    /// useful to turn this property off.
    ///
    /// Readable | Writeable | Construct
    ///
    ///
    /// #### `cursive-font-family`
    ///  The font family used as the default for content using a cursive font.
    ///
    /// Readable | Writeable | Construct
    ///
    ///
    /// #### `default-charset`
    ///  The default text charset used when interpreting content with an unspecified charset.
    ///
    /// Readable | Writeable | Construct
    ///
    ///
    /// #### `default-font-family`
    ///  The font family to use as the default for content that does not specify a font.
    ///
    /// Readable | Writeable | Construct
    ///
    ///
    /// #### `default-font-size`
    ///  The default font size in pixels to use for content displayed if
    /// no font size is specified.
    ///
    /// Readable | Writeable | Construct
    ///
    ///
    /// #### `default-monospace-font-size`
    ///  The default font size in pixels to use for content displayed in
    /// monospace font if no font size is specified.
    ///
    /// Readable | Writeable | Construct
    ///
    ///
    /// #### `disable-web-security`
    ///  Enable or disable support for Web Security on pages.
    ///
    /// This setting disables the same-origin policy, allowing every website full control over
    /// all other websites. This is for use in special environments where you wish to disable
    /// all security and allow websites to hack each other. It is impossible to use this setting
    /// securely.
    ///
    /// Readable | Writeable | Construct
    ///
    ///
    /// #### `draw-compositing-indicators`
    ///  Whether to draw compositing borders and repaint counters on layers drawn
    /// with accelerated compositing. This is useful for debugging issues related
    /// to web content that is composited with the GPU.
    ///
    /// Readable | Writeable | Construct
    ///
    ///
    /// #### `enable-2d-canvas-acceleration`
    ///  Enable or disable 2D canvas acceleration.
    /// If this setting is enabled, the 2D canvas will be accelerated even if Skia CPU
    /// is used for rendering. However, the canvas can be unaccelerated even when this setting
    /// is enabled, for other reasons like its size or when willReadFrequently property is used.
    ///
    /// Readable | Writeable | Construct
    ///
    ///
    /// #### `enable-back-forward-navigation-gestures`
    ///  Enable or disable horizontal swipe gesture for back-forward navigation.
    ///
    /// Readable | Writeable | Construct
    ///
    ///
    /// #### `enable-caret-browsing`
    ///  Whether to enable accessibility enhanced keyboard navigation.
    ///
    /// Readable | Writeable | Construct
    ///
    ///
    /// #### `enable-developer-extras`
    ///  Determines whether or not developer tools, such as the Web Inspector, are enabled.
    ///
    /// Readable | Writeable | Construct
    ///
    ///
    /// #### `enable-dns-prefetching`
    ///  Determines whether or not to prefetch domain names. DNS prefetching attempts
    /// to resolve domain names before a user tries to follow a link.
    ///
    /// Readable | Writeable | Construct
    ///
    ///
    /// #### `enable-encrypted-media`
    ///  Enable or disable support for Encrypted Media API on pages.
    /// EncryptedMedia is an experimental JavaScript API for playing encrypted media in HTML.
    /// This property will only work as intended if the EncryptedMedia feature is enabled at build time
    /// with the ENABLE_ENCRYPTED_MEDIA flag.
    ///
    /// See https://www.w3.org/TR/encrypted-media/
    ///
    /// Readable | Writeable | Construct
    ///
    ///
    /// #### `enable-fullscreen`
    ///  Whether to enable the Javascript Fullscreen API. The API
    /// allows any HTML element to request fullscreen display. See also
    /// the current draft of the spec:
    /// http://www.w3.org/TR/fullscreen/
    ///
    /// Readable | Writeable | Construct
    ///
    ///
    /// #### `enable-html5-database`
    ///  Whether to enable HTML5 client-side SQL database support (IndexedDB).
    ///
    /// Readable | Writeable | Construct
    ///
    ///
    /// #### `enable-html5-local-storage`
    ///  Whether to enable HTML5 local storage support. Local storage provides
    /// simple synchronous storage access.
    ///
    /// HTML5 local storage specification is available at
    /// http://dev.w3.org/html5/webstorage/.
    ///
    /// Readable | Writeable | Construct
    ///
    ///
    /// #### `enable-hyperlink-auditing`
    ///  Determines whether or not hyperlink auditing is enabled.
    ///
    /// The hyperlink auditing specification is available at
    /// http://www.whatwg.org/specs/web-apps/current-work/multipage/links.html`hyperlink`-auditing.
    ///
    /// Readable | Writeable | Construct
    ///
    ///
    /// #### `enable-javascript`
    ///  Determines whether or not JavaScript executes within a page.
    ///
    /// Readable | Writeable | Construct
    ///
    ///
    /// #### `enable-javascript-markup`
    ///  Determines whether or not JavaScript markup is allowed in document. When this setting is disabled,
    /// all JavaScript-related elements and attributes are removed from the document during parsing. Note that
    /// executing JavaScript is still allowed if [`enable-javascript`][struct@crate::Settings#enable-javascript] is [`true`].
    ///
    /// Readable | Writeable | Construct
    ///
    ///
    /// #### `enable-media`
    ///  Enable or disable support for media playback on pages. This setting is enabled by
    /// default. Disabling it means ``<audio>``, ``<track>`` and ``<video>`` elements will have
    /// playback support disabled.
    ///
    /// Readable | Writeable | Construct
    ///
    ///
    /// #### `enable-media-capabilities`
    ///  Enable or disable support for MediaCapabilities on pages. This
    /// specification intends to provide APIs to allow websites to make an optimal
    /// decision when picking media content for the user. The APIs will expose
    /// information about the decoding and encoding capabilities for a given format
    /// but also output capabilities to find the best match based on the device’s
    /// display.
    ///
    /// See also https://wicg.github.io/media-capabilities/
    ///
    /// Readable | Writeable | Construct
    ///
    ///
    /// #### `enable-media-stream`
    ///  Enable or disable support for MediaStream on pages. MediaStream
    /// is an experimental proposal for allowing web pages to access
    /// audio and video devices for capture.
    ///
    /// See also http://dev.w3.org/2011/webrtc/editor/getusermedia.html
    ///
    /// Readable | Writeable | Construct
    ///
    ///
    /// #### `enable-mediasource`
    ///  Enable or disable support for MediaSource on pages. MediaSource
    /// extends HTMLMediaElement to allow JavaScript to generate media
    /// streams for playback.
    ///
    /// See also http://www.w3.org/TR/media-source/
    ///
    /// Readable | Writeable | Construct
    ///
    ///
    /// #### `enable-mock-capture-devices`
    ///  Enable or disable the Mock Capture Devices. Those are fake
    /// Microphone and Camera devices to be used as MediaStream
    /// sources.
    ///
    /// Readable | Writeable | Construct
    ///
    ///
    /// #### `enable-offline-web-application-cache`
    ///  Unsupported setting. This property does nothing.
    ///
    /// Readable | Writeable | Construct
    ///
    ///
    /// #### `enable-page-cache`
    ///  Enable or disable the page cache. Disabling the page cache is
    /// generally only useful for special circumstances like low-memory
    /// scenarios or special purpose applications like static HTML
    /// viewers. This setting only controls the Page Cache, this cache
    /// is different than the disk-based or memory-based traditional
    /// resource caches, its point is to make going back and forth
    /// between pages much faster. For details about the different types
    /// of caches and their purposes see:
    /// http://webkit.org/blog/427/webkit-page-cache-i-the-basics/
    ///
    /// Readable | Writeable | Construct
    ///
    ///
    /// #### `enable-resizable-text-areas`
    ///  Determines whether or not text areas can be resized.
    ///
    /// Readable | Writeable | Construct
    ///
    ///
    /// #### `enable-site-specific-quirks`
    ///  Whether to turn on site-specific quirks. Turning this on will
    /// tell WebKit to use some site-specific workarounds for
    /// better web compatibility. For example, older versions of
    /// MediaWiki will incorrectly send to WebKit a CSS file with KHTML
    /// workarounds. By turning on site-specific quirks, WebKit will
    /// special-case this and other cases to make some specific sites work.
    ///
    /// Readable | Writeable | Construct
    ///
    ///
    /// #### `enable-smooth-scrolling`
    ///  Enable or disable smooth scrolling.
    ///
    /// Readable | Writeable | Construct
    ///
    ///
    /// #### `enable-spatial-navigation`
    ///  Whether to enable Spatial Navigation. This feature consists in the ability
    /// to navigate between focusable elements in a Web page, such as hyperlinks
    /// and form controls, by using Left, Right, Up and Down arrow keys.
    /// For example, if an user presses the Right key, heuristics determine whether
    /// there is an element they might be trying to reach towards the right, and if
    /// there are multiple elements, which element they probably wants.
    ///
    /// Readable | Writeable | Construct
    ///
    ///
    /// #### `enable-tabs-to-links`
    ///  Determines whether the tab key cycles through the elements on the page.
    /// When this setting is enabled, users will be able to focus the next element
    /// in the page by pressing the tab key. If the selected element is editable,
    /// then pressing tab key will insert the tab character.
    ///
    /// Readable | Writeable | Construct
    ///
    ///
    /// #### `enable-webaudio`
    ///  Enable or disable support for WebAudio on pages. WebAudio is an
    /// API for processing and synthesizing audio in web applications
    ///
    /// See also https://webaudio.github.io/web-audio-api
    ///
    /// Readable | Writeable | Construct
    ///
    ///
    /// #### `enable-webgl`
    ///  Enable or disable support for WebGL on pages. WebGL enables web
    /// content to use an API based on OpenGL ES 2.0.
    ///
    /// Readable | Writeable | Construct
    ///
    ///
    /// #### `enable-webrtc`
    ///  Enable WebRTC support for loaded pages.
    ///
    /// Enabling this setting implies that [property`Settings`]
    /// will be enabled as well.
    ///
    /// See also https://www.w3.org/TR/webrtc/
    ///
    /// Readable | Writeable | Construct
    ///
    ///
    /// #### `enable-write-console-messages-to-stdout`
    ///  Enable or disable writing console messages to stdout. These are messages
    /// sent to the console with console.log and related methods.
    ///
    /// Readable | Writeable | Construct
    ///
    ///
    /// #### `fantasy-font-family`
    ///  The font family used as the default for content using a fantasy font.
    ///
    /// Readable | Writeable | Construct
    ///
    ///
    /// #### `hardware-acceleration-policy`
    ///  The [`HardwareAccelerationPolicy`][crate::HardwareAccelerationPolicy] to decide how to enable and disable
    /// hardware acceleration. Disabling hardware acceleration might
    /// cause some websites to not render correctly or consume more CPU.
    ///
    /// Note that changing this setting might not be possible if hardware acceleration is not
    /// supported by the hardware or the system. In that case, you can get the value to know the
    /// actual policy being used, but changing the setting will not have any effect.
    ///
    /// Readable | Writeable | Construct
    ///
    ///
    /// #### `javascript-can-access-clipboard`
    ///  Whether JavaScript can access the clipboard. The default value is [`false`]. If
    /// set to [`true`], document.execCommand() allows cut, copy and paste commands.
    ///
    /// Readable | Writeable | Construct
    ///
    ///
    /// #### `javascript-can-open-windows-automatically`
    ///  Whether JavaScript can open popup windows automatically without user
    /// intervention.
    ///
    /// Readable | Writeable | Construct
    ///
    ///
    /// #### `load-icons-ignoring-image-load-setting`
    ///  Unsupported setting. This property does nothing.
    ///
    /// Readable | Writeable | Construct
    ///
    ///
    /// #### `math-font-family`
    ///  The font family used as the default for content using a math font.
    ///
    /// Readable | Writeable | Construct
    ///
    ///
    /// #### `media-content-types-requiring-hardware-support`
    ///  List of media content types requiring hardware support, split by semicolons (:).
    /// For example: 'video/webm; codecs="vp*":video/mp4; codecs="avc*":video/&ast; codecs="av1*"'.
    ///
    /// Readable | Writeable | Construct
    ///
    ///
    /// #### `media-playback-allows-inline`
    ///  Whether media playback is full-screen only or inline playback is allowed.
    /// This is [`true`] by default, so media playback can be inline. Setting it to
    /// [`false`] allows specifying that media playback should be always fullscreen.
    ///
    /// Readable | Writeable | Construct
    ///
    ///
    /// #### `media-playback-requires-user-gesture`
    ///  Whether a user gesture (such as clicking the play button)
    /// would be required to start media playback or load media. This is off
    /// by default, so media playback could start automatically.
    /// Setting it on requires a gesture by the user to start playback, or to
    /// load the media.
    ///
    /// Readable | Writeable | Construct
    ///
    ///
    /// #### `minimum-font-size`
    ///  The minimum font size in pixels used to display text. This setting
    /// controls the absolute smallest size. Values other than 0 can
    /// potentially break page layouts.
    ///
    /// Readable | Writeable | Construct
    ///
    ///
    /// #### `monospace-font-family`
    ///  The font family used as the default for content using a monospace font.
    ///
    /// Readable | Writeable | Construct
    ///
    ///
    /// #### `pictograph-font-family`
    ///  The font family used as the default for content using a pictograph font.
    ///
    /// Readable | Writeable | Construct
    ///
    ///
    /// #### `print-backgrounds`
    ///  Whether background images should be drawn during printing.
    ///
    /// Readable | Writeable | Construct
    ///
    ///
    /// #### `sans-serif-font-family`
    ///  The font family used as the default for content using a sans-serif font.
    ///
    /// Readable | Writeable | Construct
    ///
    ///
    /// #### `serif-font-family`
    ///  The font family used as the default for content using a serif font.
    ///
    /// Readable | Writeable | Construct
    ///
    ///
    /// #### `user-agent`
    ///  The user-agent string used by WebKit. Unusual user-agent strings may cause web
    /// content to render incorrectly or fail to run, as many web pages are written to
    /// parse the user-agent strings of only the most popular browsers. Therefore, it's
    /// typically better to not completely override the standard user-agent, but to use
    /// [`Settings::set_user_agent_with_application_details()`][crate::Settings::set_user_agent_with_application_details()] instead.
    ///
    /// If this property is set to the empty string or [`None`], it will revert to the standard
    /// user-agent.
    ///
    /// Readable | Writeable | Construct
    ///
    ///
    /// #### `webrtc-udp-ports-range`
    ///  Allow customization of the WebRTC UDP ports range.
    ///
    /// In some constrained environments where a firewall blocks UDP network traffic excepted on a
    /// specific port range, this settings can be used to give hints to the WebRTC backend regarding
    /// which ports to allocate. The format is min-port:max-port, so for instance 20000:30000. The
    /// default empty string value means the OS will use no hints from the WebRTC backend. Using 0
    /// for one of the values is allowed and means the value is unspecified.
    ///
    /// Readable | Writeable | Construct
    ///
    ///
    /// #### `zoom-text-only`
    ///  Whether [`zoom-level`][struct@crate::WebView#zoom-level] affects only the
    /// text of the page or all the contents. Other contents containing text
    /// like form controls will be also affected by zoom factor when
    /// this property is enabled.
    ///
    /// Readable | Writeable | Construct
    #[doc(alias = "WebKitSettings")]
    pub struct Settings(Object<ffi::WebKitSettings, ffi::WebKitSettingsClass>);

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

impl Settings {
    /// Creates a new [`Settings`][crate::Settings] instance with default values.
    ///
    /// It must be manually attached to a [`WebView`][crate::WebView].
    /// See also `webkit_settings_new_with_settings()`.
    ///
    /// # Returns
    ///
    /// a new [`Settings`][crate::Settings] instance.
    #[doc(alias = "webkit_settings_new")]
    pub fn new() -> Settings {
        assert_initialized_main_thread!();
        unsafe { from_glib_full(ffi::webkit_settings_new()) }
    }

    //#[doc(alias = "webkit_settings_new_with_settings")]
    //#[doc(alias = "new_with_settings")]
    //pub fn with_settings(first_setting_name: &str, : /*Unknown conversion*//*Unimplemented*/Basic: VarArgs) -> Settings {
    //    unsafe { TODO: call ffi:webkit_settings_new_with_settings() }
    //}

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

    /// Reads the contents of the given `group_name` from the given `key_file` and apply the value of
    /// each key/value to the corresponding property on the `self`.
    ///
    /// Value types have to match with the corresponding setting property type and the group keys have to
    /// match existing setting property names. If those conditions are not met, the function will return
    /// [`false`].
    ///
    /// Supported value types are strings (unquoted), booleans (0, 1, true, false) and unsigned integers.
    /// ## `key_file`
    /// a [`glib::KeyFile`][crate::glib::KeyFile]
    /// ## `group_name`
    /// Name of the group to read from `key_file`
    ///
    /// # Returns
    ///
    /// [`true`] if the settings were correctly applied or [`false`] on error.
    #[cfg(feature = "v2_46")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v2_46")))]
    #[doc(alias = "webkit_settings_apply_from_key_file")]
    pub fn apply_from_key_file(
        &self,
        key_file: &glib::KeyFile,
        group_name: &str,
    ) -> Result<(), glib::Error> {
        unsafe {
            let mut error = std::ptr::null_mut();
            let is_ok = ffi::webkit_settings_apply_from_key_file(
                self.to_glib_none().0,
                key_file.to_glib_none().0,
                group_name.to_glib_none().0,
                &mut error,
            );
            debug_assert_eq!(is_ok == glib::ffi::GFALSE, !error.is_null());
            if error.is_null() {
                Ok(())
            } else {
                Err(from_glib_full(error))
            }
        }
    }

    /// Get the [`allow-file-access-from-file-urls`][struct@crate::Settings#allow-file-access-from-file-urls] property.
    ///
    /// # Returns
    ///
    /// [`true`] If file access from file URLs is allowed or [`false`] otherwise.
    #[doc(alias = "webkit_settings_get_allow_file_access_from_file_urls")]
    #[doc(alias = "get_allow_file_access_from_file_urls")]
    #[doc(alias = "allow-file-access-from-file-urls")]
    pub fn allows_file_access_from_file_urls(&self) -> bool {
        unsafe {
            from_glib(ffi::webkit_settings_get_allow_file_access_from_file_urls(
                self.to_glib_none().0,
            ))
        }
    }

    /// Get the [`allow-modal-dialogs`][struct@crate::Settings#allow-modal-dialogs] property.
    ///
    /// # Returns
    ///
    /// [`true`] if it's allowed to create and run modal dialogs or [`false`] otherwise.
    #[doc(alias = "webkit_settings_get_allow_modal_dialogs")]
    #[doc(alias = "get_allow_modal_dialogs")]
    #[doc(alias = "allow-modal-dialogs")]
    pub fn allows_modal_dialogs(&self) -> bool {
        unsafe {
            from_glib(ffi::webkit_settings_get_allow_modal_dialogs(
                self.to_glib_none().0,
            ))
        }
    }

    /// Get the [`allow-top-navigation-to-data-urls`][struct@crate::Settings#allow-top-navigation-to-data-urls] property.
    ///
    /// # Returns
    ///
    /// [`true`] If navigation to data URLs from the top frame is allowed or [`false`]\
    /// otherwise.
    #[doc(alias = "webkit_settings_get_allow_top_navigation_to_data_urls")]
    #[doc(alias = "get_allow_top_navigation_to_data_urls")]
    #[doc(alias = "allow-top-navigation-to-data-urls")]
    pub fn allows_top_navigation_to_data_urls(&self) -> bool {
        unsafe {
            from_glib(ffi::webkit_settings_get_allow_top_navigation_to_data_urls(
                self.to_glib_none().0,
            ))
        }
    }

    /// Get the [`allow-universal-access-from-file-urls`][struct@crate::Settings#allow-universal-access-from-file-urls] property.
    ///
    /// # Returns
    ///
    /// [`true`] If universal access from file URLs is allowed or [`false`] otherwise.
    #[doc(alias = "webkit_settings_get_allow_universal_access_from_file_urls")]
    #[doc(alias = "get_allow_universal_access_from_file_urls")]
    #[doc(alias = "allow-universal-access-from-file-urls")]
    pub fn allows_universal_access_from_file_urls(&self) -> bool {
        unsafe {
            from_glib(
                ffi::webkit_settings_get_allow_universal_access_from_file_urls(
                    self.to_glib_none().0,
                ),
            )
        }
    }

    /// Get the [`auto-load-images`][struct@crate::Settings#auto-load-images] property.
    ///
    /// # Returns
    ///
    /// [`true`] If auto loading of images is enabled or [`false`] otherwise.
    #[doc(alias = "webkit_settings_get_auto_load_images")]
    #[doc(alias = "get_auto_load_images")]
    #[doc(alias = "auto-load-images")]
    pub fn is_auto_load_images(&self) -> bool {
        unsafe {
            from_glib(ffi::webkit_settings_get_auto_load_images(
                self.to_glib_none().0,
            ))
        }
    }

    /// Gets the [`cursive-font-family`][struct@crate::Settings#cursive-font-family] property.
    ///
    /// # Returns
    ///
    /// The default font family used to display content marked with cursive font.
    #[doc(alias = "webkit_settings_get_cursive_font_family")]
    #[doc(alias = "get_cursive_font_family")]
    #[doc(alias = "cursive-font-family")]
    pub fn cursive_font_family(&self) -> Option<glib::GString> {
        unsafe {
            from_glib_none(ffi::webkit_settings_get_cursive_font_family(
                self.to_glib_none().0,
            ))
        }
    }

    /// Gets the [`default-charset`][struct@crate::Settings#default-charset] property.
    ///
    /// # Returns
    ///
    /// Default charset.
    #[doc(alias = "webkit_settings_get_default_charset")]
    #[doc(alias = "get_default_charset")]
    #[doc(alias = "default-charset")]
    pub fn default_charset(&self) -> Option<glib::GString> {
        unsafe {
            from_glib_none(ffi::webkit_settings_get_default_charset(
                self.to_glib_none().0,
            ))
        }
    }

    /// Gets the [`default-font-family`][struct@crate::Settings#default-font-family] property.
    ///
    /// # Returns
    ///
    /// The default font family used to display content that does not specify a font.
    #[doc(alias = "webkit_settings_get_default_font_family")]
    #[doc(alias = "get_default_font_family")]
    #[doc(alias = "default-font-family")]
    pub fn default_font_family(&self) -> Option<glib::GString> {
        unsafe {
            from_glib_none(ffi::webkit_settings_get_default_font_family(
                self.to_glib_none().0,
            ))
        }
    }

    /// Gets the [`default-font-size`][struct@crate::Settings#default-font-size] property.
    ///
    /// # Returns
    ///
    /// The default font size, in pixels.
    #[doc(alias = "webkit_settings_get_default_font_size")]
    #[doc(alias = "get_default_font_size")]
    #[doc(alias = "default-font-size")]
    pub fn default_font_size(&self) -> u32 {
        unsafe { ffi::webkit_settings_get_default_font_size(self.to_glib_none().0) }
    }

    /// Gets the [`default-monospace-font-size`][struct@crate::Settings#default-monospace-font-size] property.
    ///
    /// # Returns
    ///
    /// Default monospace font size, in pixels.
    #[doc(alias = "webkit_settings_get_default_monospace_font_size")]
    #[doc(alias = "get_default_monospace_font_size")]
    #[doc(alias = "default-monospace-font-size")]
    pub fn default_monospace_font_size(&self) -> u32 {
        unsafe { ffi::webkit_settings_get_default_monospace_font_size(self.to_glib_none().0) }
    }

    /// Get the [`disable-web-security`][struct@crate::Settings#disable-web-security] property.
    ///
    /// # Returns
    ///
    /// [`true`] If web security support is disabled or [`false`] otherwise.
    #[doc(alias = "webkit_settings_get_disable_web_security")]
    #[doc(alias = "get_disable_web_security")]
    #[doc(alias = "disable-web-security")]
    pub fn is_disable_web_security(&self) -> bool {
        unsafe {
            from_glib(ffi::webkit_settings_get_disable_web_security(
                self.to_glib_none().0,
            ))
        }
    }

    /// Get the [`draw-compositing-indicators`][struct@crate::Settings#draw-compositing-indicators] property.
    ///
    /// # Returns
    ///
    /// [`true`] If compositing borders are drawn or [`false`] otherwise.
    #[doc(alias = "webkit_settings_get_draw_compositing_indicators")]
    #[doc(alias = "get_draw_compositing_indicators")]
    #[doc(alias = "draw-compositing-indicators")]
    pub fn draws_compositing_indicators(&self) -> bool {
        unsafe {
            from_glib(ffi::webkit_settings_get_draw_compositing_indicators(
                self.to_glib_none().0,
            ))
        }
    }

    /// Get the [`enable-2d-canvas-acceleration`][struct@crate::Settings#enable-2d-canvas-acceleration] property.
    ///
    /// # Returns
    ///
    /// [`true`] if 2D canvas acceleration is enabled or [`false`] otherwise.
    #[cfg(feature = "v2_46")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v2_46")))]
    #[doc(alias = "webkit_settings_get_enable_2d_canvas_acceleration")]
    #[doc(alias = "get_enable_2d_canvas_acceleration")]
    #[doc(alias = "enable-2d-canvas-acceleration")]
    pub fn enables_2d_canvas_acceleration(&self) -> bool {
        unsafe {
            from_glib(ffi::webkit_settings_get_enable_2d_canvas_acceleration(
                self.to_glib_none().0,
            ))
        }
    }

    /// Get the [`enable-back-forward-navigation-gestures`][struct@crate::Settings#enable-back-forward-navigation-gestures] property.
    ///
    /// # Returns
    ///
    /// [`true`] if horizontal swipe gesture will trigger back-forward navigaiton or [`false`] otherwise.
    #[doc(alias = "webkit_settings_get_enable_back_forward_navigation_gestures")]
    #[doc(alias = "get_enable_back_forward_navigation_gestures")]
    #[doc(alias = "enable-back-forward-navigation-gestures")]
    pub fn enables_back_forward_navigation_gestures(&self) -> bool {
        unsafe {
            from_glib(
                ffi::webkit_settings_get_enable_back_forward_navigation_gestures(
                    self.to_glib_none().0,
                ),
            )
        }
    }

    /// Get the [`enable-caret-browsing`][struct@crate::Settings#enable-caret-browsing] property.
    ///
    /// # Returns
    ///
    /// [`true`] If caret browsing is enabled or [`false`] otherwise.
    #[doc(alias = "webkit_settings_get_enable_caret_browsing")]
    #[doc(alias = "get_enable_caret_browsing")]
    #[doc(alias = "enable-caret-browsing")]
    pub fn enables_caret_browsing(&self) -> bool {
        unsafe {
            from_glib(ffi::webkit_settings_get_enable_caret_browsing(
                self.to_glib_none().0,
            ))
        }
    }

    /// Get the [`enable-developer-extras`][struct@crate::Settings#enable-developer-extras] property.
    ///
    /// # Returns
    ///
    /// [`true`] If developer extras is enabled or [`false`] otherwise.
    #[doc(alias = "webkit_settings_get_enable_developer_extras")]
    #[doc(alias = "get_enable_developer_extras")]
    #[doc(alias = "enable-developer-extras")]
    pub fn enables_developer_extras(&self) -> bool {
        unsafe {
            from_glib(ffi::webkit_settings_get_enable_developer_extras(
                self.to_glib_none().0,
            ))
        }
    }

    /// Get the [`enable-dns-prefetching`][struct@crate::Settings#enable-dns-prefetching] property.
    ///
    /// # Deprecated since 2.48
    ///
    ///
    /// # Returns
    ///
    /// [`true`] If DNS prefetching is enabled or [`false`] otherwise.
    #[cfg_attr(feature = "v2_48", deprecated = "Since 2.48")]
    #[allow(deprecated)]
    #[doc(alias = "webkit_settings_get_enable_dns_prefetching")]
    #[doc(alias = "get_enable_dns_prefetching")]
    #[doc(alias = "enable-dns-prefetching")]
    pub fn enables_dns_prefetching(&self) -> bool {
        unsafe {
            from_glib(ffi::webkit_settings_get_enable_dns_prefetching(
                self.to_glib_none().0,
            ))
        }
    }

    /// Get the [`enable-encrypted-media`][struct@crate::Settings#enable-encrypted-media] property.
    ///
    /// # Returns
    ///
    /// [`true`] if EncryptedMedia support is enabled or [`false`] otherwise.
    #[doc(alias = "webkit_settings_get_enable_encrypted_media")]
    #[doc(alias = "get_enable_encrypted_media")]
    #[doc(alias = "enable-encrypted-media")]
    pub fn enables_encrypted_media(&self) -> bool {
        unsafe {
            from_glib(ffi::webkit_settings_get_enable_encrypted_media(
                self.to_glib_none().0,
            ))
        }
    }

    /// Get the [`enable-fullscreen`][struct@crate::Settings#enable-fullscreen] property.
    ///
    /// # Returns
    ///
    /// [`true`] If fullscreen support is enabled or [`false`] otherwise.
    #[doc(alias = "webkit_settings_get_enable_fullscreen")]
    #[doc(alias = "get_enable_fullscreen")]
    #[doc(alias = "enable-fullscreen")]
    pub fn enables_fullscreen(&self) -> bool {
        unsafe {
            from_glib(ffi::webkit_settings_get_enable_fullscreen(
                self.to_glib_none().0,
            ))
        }
    }

    /// Get the [`enable-html5-database`][struct@crate::Settings#enable-html5-database] property.
    ///
    /// # Returns
    ///
    /// [`true`] if IndexedDB support is enabled or [`false`] otherwise.
    #[doc(alias = "webkit_settings_get_enable_html5_database")]
    #[doc(alias = "get_enable_html5_database")]
    #[doc(alias = "enable-html5-database")]
    pub fn enables_html5_database(&self) -> bool {
        unsafe {
            from_glib(ffi::webkit_settings_get_enable_html5_database(
                self.to_glib_none().0,
            ))
        }
    }

    /// Get the [`enable-html5-local-storage`][struct@crate::Settings#enable-html5-local-storage] property.
    ///
    /// # Returns
    ///
    /// [`true`] If HTML5 local storage support is enabled or [`false`] otherwise.
    #[doc(alias = "webkit_settings_get_enable_html5_local_storage")]
    #[doc(alias = "get_enable_html5_local_storage")]
    #[doc(alias = "enable-html5-local-storage")]
    pub fn enables_html5_local_storage(&self) -> bool {
        unsafe {
            from_glib(ffi::webkit_settings_get_enable_html5_local_storage(
                self.to_glib_none().0,
            ))
        }
    }

    /// Get the [`enable-hyperlink-auditing`][struct@crate::Settings#enable-hyperlink-auditing] property.
    ///
    /// # Deprecated since 2.50
    ///
    ///
    /// # Returns
    ///
    /// [`true`] If hyper link auditing is enabled or [`false`] otherwise.
    #[cfg_attr(feature = "v2_50", deprecated = "Since 2.50")]
    #[allow(deprecated)]
    #[doc(alias = "webkit_settings_get_enable_hyperlink_auditing")]
    #[doc(alias = "get_enable_hyperlink_auditing")]
    #[doc(alias = "enable-hyperlink-auditing")]
    pub fn enables_hyperlink_auditing(&self) -> bool {
        unsafe {
            from_glib(ffi::webkit_settings_get_enable_hyperlink_auditing(
                self.to_glib_none().0,
            ))
        }
    }

    /// Get the [`enable-javascript`][struct@crate::Settings#enable-javascript] property.
    ///
    /// # Returns
    ///
    /// [`true`] If JavaScript is enabled or [`false`] otherwise.
    #[doc(alias = "webkit_settings_get_enable_javascript")]
    #[doc(alias = "get_enable_javascript")]
    #[doc(alias = "enable-javascript")]
    pub fn enables_javascript(&self) -> bool {
        unsafe {
            from_glib(ffi::webkit_settings_get_enable_javascript(
                self.to_glib_none().0,
            ))
        }
    }

    /// Get the [`enable-javascript-markup`][struct@crate::Settings#enable-javascript-markup] property.
    ///
    /// # Returns
    ///
    /// [`true`] if JavaScript markup is enabled or [`false`] otherwise.
    #[doc(alias = "webkit_settings_get_enable_javascript_markup")]
    #[doc(alias = "get_enable_javascript_markup")]
    #[doc(alias = "enable-javascript-markup")]
    pub fn enables_javascript_markup(&self) -> bool {
        unsafe {
            from_glib(ffi::webkit_settings_get_enable_javascript_markup(
                self.to_glib_none().0,
            ))
        }
    }

    /// Get the [`enable-media`][struct@crate::Settings#enable-media] property.
    ///
    /// # Returns
    ///
    /// [`true`] if media support is enabled or [`false`] otherwise.
    #[doc(alias = "webkit_settings_get_enable_media")]
    #[doc(alias = "get_enable_media")]
    #[doc(alias = "enable-media")]
    pub fn enables_media(&self) -> bool {
        unsafe { from_glib(ffi::webkit_settings_get_enable_media(self.to_glib_none().0)) }
    }

    /// Get the [`enable-media-capabilities`][struct@crate::Settings#enable-media-capabilities] property.
    ///
    /// # Returns
    ///
    /// [`true`] if MediaCapabilities support is enabled or [`false`] otherwise.
    #[doc(alias = "webkit_settings_get_enable_media_capabilities")]
    #[doc(alias = "get_enable_media_capabilities")]
    #[doc(alias = "enable-media-capabilities")]
    pub fn enables_media_capabilities(&self) -> bool {
        unsafe {
            from_glib(ffi::webkit_settings_get_enable_media_capabilities(
                self.to_glib_none().0,
            ))
        }
    }

    /// Get the [`enable-media-stream`][struct@crate::Settings#enable-media-stream] property.
    ///
    /// # Returns
    ///
    /// [`true`] If mediastream support is enabled or [`false`] otherwise.
    #[doc(alias = "webkit_settings_get_enable_media_stream")]
    #[doc(alias = "get_enable_media_stream")]
    #[doc(alias = "enable-media-stream")]
    pub fn enables_media_stream(&self) -> bool {
        unsafe {
            from_glib(ffi::webkit_settings_get_enable_media_stream(
                self.to_glib_none().0,
            ))
        }
    }

    /// Get the [`enable-mediasource`][struct@crate::Settings#enable-mediasource] property.
    ///
    /// # Returns
    ///
    /// [`true`] If MediaSource support is enabled or [`false`] otherwise.
    #[doc(alias = "webkit_settings_get_enable_mediasource")]
    #[doc(alias = "get_enable_mediasource")]
    #[doc(alias = "enable-mediasource")]
    pub fn enables_mediasource(&self) -> bool {
        unsafe {
            from_glib(ffi::webkit_settings_get_enable_mediasource(
                self.to_glib_none().0,
            ))
        }
    }

    /// Get the [`enable-mock-capture-devices`][struct@crate::Settings#enable-mock-capture-devices] property.
    ///
    /// # Returns
    ///
    /// [`true`] If mock capture devices is enabled or [`false`] otherwise.
    #[doc(alias = "webkit_settings_get_enable_mock_capture_devices")]
    #[doc(alias = "get_enable_mock_capture_devices")]
    #[doc(alias = "enable-mock-capture-devices")]
    pub fn enables_mock_capture_devices(&self) -> bool {
        unsafe {
            from_glib(ffi::webkit_settings_get_enable_mock_capture_devices(
                self.to_glib_none().0,
            ))
        }
    }

    /// Get the [`enable-offline-web-application-cache`][struct@crate::Settings#enable-offline-web-application-cache] property.
    ///
    /// # Deprecated since 2.44
    ///
    ///
    /// # Returns
    ///
    /// [`false`].
    #[cfg_attr(feature = "v2_44", deprecated = "Since 2.44")]
    #[allow(deprecated)]
    #[doc(alias = "webkit_settings_get_enable_offline_web_application_cache")]
    #[doc(alias = "get_enable_offline_web_application_cache")]
    #[doc(alias = "enable-offline-web-application-cache")]
    pub fn enables_offline_web_application_cache(&self) -> bool {
        unsafe {
            from_glib(
                ffi::webkit_settings_get_enable_offline_web_application_cache(
                    self.to_glib_none().0,
                ),
            )
        }
    }

    /// Get the [`enable-page-cache`][struct@crate::Settings#enable-page-cache] property.
    ///
    /// # Returns
    ///
    /// [`true`] if page cache enabled or [`false`] otherwise.
    #[doc(alias = "webkit_settings_get_enable_page_cache")]
    #[doc(alias = "get_enable_page_cache")]
    #[doc(alias = "enable-page-cache")]
    pub fn enables_page_cache(&self) -> bool {
        unsafe {
            from_glib(ffi::webkit_settings_get_enable_page_cache(
                self.to_glib_none().0,
            ))
        }
    }

    /// Get the [`enable-resizable-text-areas`][struct@crate::Settings#enable-resizable-text-areas] property.
    ///
    /// # Returns
    ///
    /// [`true`] If text areas can be resized or [`false`] otherwise.
    #[doc(alias = "webkit_settings_get_enable_resizable_text_areas")]
    #[doc(alias = "get_enable_resizable_text_areas")]
    #[doc(alias = "enable-resizable-text-areas")]
    pub fn enables_resizable_text_areas(&self) -> bool {
        unsafe {
            from_glib(ffi::webkit_settings_get_enable_resizable_text_areas(
                self.to_glib_none().0,
            ))
        }
    }

    /// Get the [`enable-site-specific-quirks`][struct@crate::Settings#enable-site-specific-quirks] property.
    ///
    /// # Returns
    ///
    /// [`true`] if site specific quirks are enabled or [`false`] otherwise.
    #[doc(alias = "webkit_settings_get_enable_site_specific_quirks")]
    #[doc(alias = "get_enable_site_specific_quirks")]
    #[doc(alias = "enable-site-specific-quirks")]
    pub fn enables_site_specific_quirks(&self) -> bool {
        unsafe {
            from_glib(ffi::webkit_settings_get_enable_site_specific_quirks(
                self.to_glib_none().0,
            ))
        }
    }

    /// Get the [`enable-smooth-scrolling`][struct@crate::Settings#enable-smooth-scrolling] property.
    ///
    /// # Returns
    ///
    /// [`true`] if smooth scrolling is enabled or [`false`] otherwise.
    #[doc(alias = "webkit_settings_get_enable_smooth_scrolling")]
    #[doc(alias = "get_enable_smooth_scrolling")]
    #[doc(alias = "enable-smooth-scrolling")]
    pub fn enables_smooth_scrolling(&self) -> bool {
        unsafe {
            from_glib(ffi::webkit_settings_get_enable_smooth_scrolling(
                self.to_glib_none().0,
            ))
        }
    }

    /// Get the [`enable-spatial-navigation`][struct@crate::Settings#enable-spatial-navigation] property.
    ///
    /// # Returns
    ///
    /// [`true`] If HTML5 spatial navigation support is enabled or [`false`] otherwise.
    #[doc(alias = "webkit_settings_get_enable_spatial_navigation")]
    #[doc(alias = "get_enable_spatial_navigation")]
    #[doc(alias = "enable-spatial-navigation")]
    pub fn enables_spatial_navigation(&self) -> bool {
        unsafe {
            from_glib(ffi::webkit_settings_get_enable_spatial_navigation(
                self.to_glib_none().0,
            ))
        }
    }

    /// Get the [`enable-tabs-to-links`][struct@crate::Settings#enable-tabs-to-links] property.
    ///
    /// # Returns
    ///
    /// [`true`] If tabs to link is enabled or [`false`] otherwise.
    #[doc(alias = "webkit_settings_get_enable_tabs_to_links")]
    #[doc(alias = "get_enable_tabs_to_links")]
    #[doc(alias = "enable-tabs-to-links")]
    pub fn enables_tabs_to_links(&self) -> bool {
        unsafe {
            from_glib(ffi::webkit_settings_get_enable_tabs_to_links(
                self.to_glib_none().0,
            ))
        }
    }

    /// Get the [`enable-webaudio`][struct@crate::Settings#enable-webaudio] property.
    ///
    /// # Returns
    ///
    /// [`true`] If webaudio support is enabled or [`false`] otherwise.
    #[doc(alias = "webkit_settings_get_enable_webaudio")]
    #[doc(alias = "get_enable_webaudio")]
    #[doc(alias = "enable-webaudio")]
    pub fn enables_webaudio(&self) -> bool {
        unsafe {
            from_glib(ffi::webkit_settings_get_enable_webaudio(
                self.to_glib_none().0,
            ))
        }
    }

    /// Get the [`enable-webgl`][struct@crate::Settings#enable-webgl] property.
    ///
    /// # Returns
    ///
    /// [`true`] If WebGL support is enabled or [`false`] otherwise.
    #[doc(alias = "webkit_settings_get_enable_webgl")]
    #[doc(alias = "get_enable_webgl")]
    #[doc(alias = "enable-webgl")]
    pub fn enables_webgl(&self) -> bool {
        unsafe { from_glib(ffi::webkit_settings_get_enable_webgl(self.to_glib_none().0)) }
    }

    /// Get the [property`Settings`] property.
    ///
    /// # Returns
    ///
    /// [`true`] If WebRTC support is enabled or [`false`] otherwise.
    #[doc(alias = "webkit_settings_get_enable_webrtc")]
    #[doc(alias = "get_enable_webrtc")]
    #[doc(alias = "enable-webrtc")]
    pub fn enables_webrtc(&self) -> bool {
        unsafe {
            from_glib(ffi::webkit_settings_get_enable_webrtc(
                self.to_glib_none().0,
            ))
        }
    }

    /// Get the [`enable-write-console-messages-to-stdout`][struct@crate::Settings#enable-write-console-messages-to-stdout] property.
    ///
    /// # Returns
    ///
    /// [`true`] if writing console messages to stdout is enabled or [`false`]
    /// otherwise.
    #[doc(alias = "webkit_settings_get_enable_write_console_messages_to_stdout")]
    #[doc(alias = "get_enable_write_console_messages_to_stdout")]
    #[doc(alias = "enable-write-console-messages-to-stdout")]
    pub fn enables_write_console_messages_to_stdout(&self) -> bool {
        unsafe {
            from_glib(
                ffi::webkit_settings_get_enable_write_console_messages_to_stdout(
                    self.to_glib_none().0,
                ),
            )
        }
    }

    /// Gets the [`fantasy-font-family`][struct@crate::Settings#fantasy-font-family] property.
    ///
    /// # Returns
    ///
    /// The default font family used to display content marked with fantasy font.
    #[doc(alias = "webkit_settings_get_fantasy_font_family")]
    #[doc(alias = "get_fantasy_font_family")]
    #[doc(alias = "fantasy-font-family")]
    pub fn fantasy_font_family(&self) -> Option<glib::GString> {
        unsafe {
            from_glib_none(ffi::webkit_settings_get_fantasy_font_family(
                self.to_glib_none().0,
            ))
        }
    }

    /// Gets whether a feature is enabled.
    /// ## `feature`
    /// the feature to toggle.
    ///
    /// # Returns
    ///
    /// Whether the feature is enabled.
    #[cfg(feature = "v2_42")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v2_42")))]
    #[doc(alias = "webkit_settings_get_feature_enabled")]
    #[doc(alias = "get_feature_enabled")]
    pub fn is_feature_enabled(&self, feature: &Feature) -> bool {
        unsafe {
            from_glib(ffi::webkit_settings_get_feature_enabled(
                self.to_glib_none().0,
                feature.to_glib_none().0,
            ))
        }
    }

    /// Get the [`hardware-acceleration-policy`][struct@crate::Settings#hardware-acceleration-policy] property.
    ///
    /// # Returns
    ///
    /// a [`HardwareAccelerationPolicy`][crate::HardwareAccelerationPolicy]
    #[doc(alias = "webkit_settings_get_hardware_acceleration_policy")]
    #[doc(alias = "get_hardware_acceleration_policy")]
    #[doc(alias = "hardware-acceleration-policy")]
    pub fn hardware_acceleration_policy(&self) -> HardwareAccelerationPolicy {
        unsafe {
            from_glib(ffi::webkit_settings_get_hardware_acceleration_policy(
                self.to_glib_none().0,
            ))
        }
    }

    /// Get the [`javascript-can-access-clipboard`][struct@crate::Settings#javascript-can-access-clipboard] property.
    ///
    /// # Returns
    ///
    /// [`true`] If javascript-can-access-clipboard is enabled or [`false`] otherwise.
    #[doc(alias = "webkit_settings_get_javascript_can_access_clipboard")]
    #[doc(alias = "get_javascript_can_access_clipboard")]
    #[doc(alias = "javascript-can-access-clipboard")]
    pub fn is_javascript_can_access_clipboard(&self) -> bool {
        unsafe {
            from_glib(ffi::webkit_settings_get_javascript_can_access_clipboard(
                self.to_glib_none().0,
            ))
        }
    }

    /// Get the [`javascript-can-open-windows-automatically`][struct@crate::Settings#javascript-can-open-windows-automatically] property.
    ///
    /// # Returns
    ///
    /// [`true`] If JavaScript can open window automatically or [`false`] otherwise.
    #[doc(alias = "webkit_settings_get_javascript_can_open_windows_automatically")]
    #[doc(alias = "get_javascript_can_open_windows_automatically")]
    #[doc(alias = "javascript-can-open-windows-automatically")]
    pub fn is_javascript_can_open_windows_automatically(&self) -> bool {
        unsafe {
            from_glib(
                ffi::webkit_settings_get_javascript_can_open_windows_automatically(
                    self.to_glib_none().0,
                ),
            )
        }
    }

    /// Setting no longer supported. This function returns [`false`].
    ///
    /// # Deprecated since 2.42
    ///
    ///
    /// # Returns
    ///
    /// [`false`]
    #[cfg_attr(feature = "v2_42", deprecated = "Since 2.42")]
    #[allow(deprecated)]
    #[doc(alias = "webkit_settings_get_load_icons_ignoring_image_load_setting")]
    #[doc(alias = "get_load_icons_ignoring_image_load_setting")]
    #[doc(alias = "load-icons-ignoring-image-load-setting")]
    pub fn is_load_icons_ignoring_image_load_setting(&self) -> bool {
        unsafe {
            from_glib(
                ffi::webkit_settings_get_load_icons_ignoring_image_load_setting(
                    self.to_glib_none().0,
                ),
            )
        }
    }

    /// Gets the [`math-font-family`][struct@crate::Settings#math-font-family] property.
    ///
    /// # Returns
    ///
    /// The default font family used to display content marked with math font.
    ///
    /// Since 2.52
    #[doc(alias = "webkit_settings_get_math_font_family")]
    #[doc(alias = "get_math_font_family")]
    #[doc(alias = "math-font-family")]
    pub fn math_font_family(&self) -> Option<glib::GString> {
        unsafe {
            from_glib_none(ffi::webkit_settings_get_math_font_family(
                self.to_glib_none().0,
            ))
        }
    }

    /// Gets the [`media-content-types-requiring-hardware-support`][struct@crate::Settings#media-content-types-requiring-hardware-support] property.
    ///
    /// # Returns
    ///
    /// Media content types requiring hardware support, or [`None`].
    #[doc(alias = "webkit_settings_get_media_content_types_requiring_hardware_support")]
    #[doc(alias = "get_media_content_types_requiring_hardware_support")]
    #[doc(alias = "media-content-types-requiring-hardware-support")]
    pub fn media_content_types_requiring_hardware_support(&self) -> Option<glib::GString> {
        unsafe {
            from_glib_none(
                ffi::webkit_settings_get_media_content_types_requiring_hardware_support(
                    self.to_glib_none().0,
                ),
            )
        }
    }

    /// Get the [`media-playback-allows-inline`][struct@crate::Settings#media-playback-allows-inline] property.
    ///
    /// # Returns
    ///
    /// [`true`] If inline playback is allowed for media
    ///  or [`false`] if only fullscreen playback is allowed.
    #[doc(alias = "webkit_settings_get_media_playback_allows_inline")]
    #[doc(alias = "get_media_playback_allows_inline")]
    #[doc(alias = "media-playback-allows-inline")]
    pub fn is_media_playback_allows_inline(&self) -> bool {
        unsafe {
            from_glib(ffi::webkit_settings_get_media_playback_allows_inline(
                self.to_glib_none().0,
            ))
        }
    }

    /// Get the [`media-playback-requires-user-gesture`][struct@crate::Settings#media-playback-requires-user-gesture] property.
    ///
    /// # Returns
    ///
    /// [`true`] If an user gesture is needed to play or load media
    ///  or [`false`] if no user gesture is needed.
    #[doc(alias = "webkit_settings_get_media_playback_requires_user_gesture")]
    #[doc(alias = "get_media_playback_requires_user_gesture")]
    #[doc(alias = "media-playback-requires-user-gesture")]
    pub fn is_media_playback_requires_user_gesture(&self) -> bool {
        unsafe {
            from_glib(
                ffi::webkit_settings_get_media_playback_requires_user_gesture(
                    self.to_glib_none().0,
                ),
            )
        }
    }

    /// Gets the [`minimum-font-size`][struct@crate::Settings#minimum-font-size] property.
    ///
    /// # Returns
    ///
    /// Minimum font size, in pixels.
    #[doc(alias = "webkit_settings_get_minimum_font_size")]
    #[doc(alias = "get_minimum_font_size")]
    #[doc(alias = "minimum-font-size")]
    pub fn minimum_font_size(&self) -> u32 {
        unsafe { ffi::webkit_settings_get_minimum_font_size(self.to_glib_none().0) }
    }

    /// Gets the [`monospace-font-family`][struct@crate::Settings#monospace-font-family] property.
    ///
    /// # Returns
    ///
    /// Default font family used to display content marked with monospace font.
    #[doc(alias = "webkit_settings_get_monospace_font_family")]
    #[doc(alias = "get_monospace_font_family")]
    #[doc(alias = "monospace-font-family")]
    pub fn monospace_font_family(&self) -> Option<glib::GString> {
        unsafe {
            from_glib_none(ffi::webkit_settings_get_monospace_font_family(
                self.to_glib_none().0,
            ))
        }
    }

    /// Gets the [`pictograph-font-family`][struct@crate::Settings#pictograph-font-family] property.
    ///
    /// # Returns
    ///
    /// The default font family used to display content marked with pictograph font.
    #[doc(alias = "webkit_settings_get_pictograph_font_family")]
    #[doc(alias = "get_pictograph_font_family")]
    #[doc(alias = "pictograph-font-family")]
    pub fn pictograph_font_family(&self) -> Option<glib::GString> {
        unsafe {
            from_glib_none(ffi::webkit_settings_get_pictograph_font_family(
                self.to_glib_none().0,
            ))
        }
    }

    /// Get the [`print-backgrounds`][struct@crate::Settings#print-backgrounds] property.
    ///
    /// # Returns
    ///
    /// [`true`] If background images should be printed or [`false`] otherwise.
    #[doc(alias = "webkit_settings_get_print_backgrounds")]
    #[doc(alias = "get_print_backgrounds")]
    #[doc(alias = "print-backgrounds")]
    pub fn is_print_backgrounds(&self) -> bool {
        unsafe {
            from_glib(ffi::webkit_settings_get_print_backgrounds(
                self.to_glib_none().0,
            ))
        }
    }

    /// Gets the [`sans-serif-font-family`][struct@crate::Settings#sans-serif-font-family] property.
    ///
    /// # Returns
    ///
    /// The default font family used to display content marked with sans-serif font.
    #[doc(alias = "webkit_settings_get_sans_serif_font_family")]
    #[doc(alias = "get_sans_serif_font_family")]
    #[doc(alias = "sans-serif-font-family")]
    pub fn sans_serif_font_family(&self) -> Option<glib::GString> {
        unsafe {
            from_glib_none(ffi::webkit_settings_get_sans_serif_font_family(
                self.to_glib_none().0,
            ))
        }
    }

    /// Gets the [`serif-font-family`][struct@crate::Settings#serif-font-family] property.
    ///
    /// # Returns
    ///
    /// The default font family used to display content marked with serif font.
    #[doc(alias = "webkit_settings_get_serif_font_family")]
    #[doc(alias = "get_serif_font_family")]
    #[doc(alias = "serif-font-family")]
    pub fn serif_font_family(&self) -> Option<glib::GString> {
        unsafe {
            from_glib_none(ffi::webkit_settings_get_serif_font_family(
                self.to_glib_none().0,
            ))
        }
    }

    /// Get the [`user-agent`][struct@crate::Settings#user-agent] property.
    ///
    /// # Returns
    ///
    /// The current value of the user-agent property.
    #[doc(alias = "webkit_settings_get_user_agent")]
    #[doc(alias = "get_user_agent")]
    #[doc(alias = "user-agent")]
    pub fn user_agent(&self) -> Option<glib::GString> {
        unsafe { from_glib_none(ffi::webkit_settings_get_user_agent(self.to_glib_none().0)) }
    }

    /// Get the [property`Settings`] property.
    ///
    /// # Returns
    ///
    /// The WebRTC UDP ports range, or [`None`] if un-set.
    #[cfg(feature = "v2_48")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v2_48")))]
    #[doc(alias = "webkit_settings_get_webrtc_udp_ports_range")]
    #[doc(alias = "get_webrtc_udp_ports_range")]
    #[doc(alias = "webrtc-udp-ports-range")]
    pub fn webrtc_udp_ports_range(&self) -> Option<glib::GString> {
        unsafe {
            from_glib_none(ffi::webkit_settings_get_webrtc_udp_ports_range(
                self.to_glib_none().0,
            ))
        }
    }

    /// Get the [`zoom-text-only`][struct@crate::Settings#zoom-text-only] property.
    ///
    /// # Returns
    ///
    /// [`true`] If zoom level of the view should only affect the text
    ///  or [`false`] if all view contents should be scaled.
    #[doc(alias = "webkit_settings_get_zoom_text_only")]
    #[doc(alias = "get_zoom_text_only")]
    #[doc(alias = "zoom-text-only")]
    pub fn is_zoom_text_only(&self) -> bool {
        unsafe {
            from_glib(ffi::webkit_settings_get_zoom_text_only(
                self.to_glib_none().0,
            ))
        }
    }

    /// Set the [`allow-file-access-from-file-urls`][struct@crate::Settings#allow-file-access-from-file-urls] property.
    /// ## `allowed`
    /// Value to be set
    #[doc(alias = "webkit_settings_set_allow_file_access_from_file_urls")]
    #[doc(alias = "allow-file-access-from-file-urls")]
    pub fn set_allow_file_access_from_file_urls(&self, allowed: bool) {
        unsafe {
            ffi::webkit_settings_set_allow_file_access_from_file_urls(
                self.to_glib_none().0,
                allowed.into_glib(),
            );
        }
    }

    /// Set the [`allow-modal-dialogs`][struct@crate::Settings#allow-modal-dialogs] property.
    /// ## `allowed`
    /// Value to be set
    #[doc(alias = "webkit_settings_set_allow_modal_dialogs")]
    #[doc(alias = "allow-modal-dialogs")]
    pub fn set_allow_modal_dialogs(&self, allowed: bool) {
        unsafe {
            ffi::webkit_settings_set_allow_modal_dialogs(
                self.to_glib_none().0,
                allowed.into_glib(),
            );
        }
    }

    /// Set the [`allow-top-navigation-to-data-urls`][struct@crate::Settings#allow-top-navigation-to-data-urls] property.
    /// ## `allowed`
    /// Value to be set
    #[doc(alias = "webkit_settings_set_allow_top_navigation_to_data_urls")]
    #[doc(alias = "allow-top-navigation-to-data-urls")]
    pub fn set_allow_top_navigation_to_data_urls(&self, allowed: bool) {
        unsafe {
            ffi::webkit_settings_set_allow_top_navigation_to_data_urls(
                self.to_glib_none().0,
                allowed.into_glib(),
            );
        }
    }

    /// Set the [`allow-universal-access-from-file-urls`][struct@crate::Settings#allow-universal-access-from-file-urls] property.
    /// ## `allowed`
    /// Value to be set
    #[doc(alias = "webkit_settings_set_allow_universal_access_from_file_urls")]
    #[doc(alias = "allow-universal-access-from-file-urls")]
    pub fn set_allow_universal_access_from_file_urls(&self, allowed: bool) {
        unsafe {
            ffi::webkit_settings_set_allow_universal_access_from_file_urls(
                self.to_glib_none().0,
                allowed.into_glib(),
            );
        }
    }

    /// Set the [`auto-load-images`][struct@crate::Settings#auto-load-images] property.
    /// ## `enabled`
    /// Value to be set
    #[doc(alias = "webkit_settings_set_auto_load_images")]
    #[doc(alias = "auto-load-images")]
    pub fn set_auto_load_images(&self, enabled: bool) {
        unsafe {
            ffi::webkit_settings_set_auto_load_images(self.to_glib_none().0, enabled.into_glib());
        }
    }

    /// Set the [`cursive-font-family`][struct@crate::Settings#cursive-font-family] property.
    /// ## `cursive_font_family`
    /// the new default cursive font family
    #[doc(alias = "webkit_settings_set_cursive_font_family")]
    #[doc(alias = "cursive-font-family")]
    pub fn set_cursive_font_family(&self, cursive_font_family: &str) {
        unsafe {
            ffi::webkit_settings_set_cursive_font_family(
                self.to_glib_none().0,
                cursive_font_family.to_glib_none().0,
            );
        }
    }

    /// Set the [`default-charset`][struct@crate::Settings#default-charset] property.
    /// ## `default_charset`
    /// default charset to be set
    #[doc(alias = "webkit_settings_set_default_charset")]
    #[doc(alias = "default-charset")]
    pub fn set_default_charset(&self, default_charset: &str) {
        unsafe {
            ffi::webkit_settings_set_default_charset(
                self.to_glib_none().0,
                default_charset.to_glib_none().0,
            );
        }
    }

    /// Set the [`default-font-family`][struct@crate::Settings#default-font-family] property.
    /// ## `default_font_family`
    /// the new default font family
    #[doc(alias = "webkit_settings_set_default_font_family")]
    #[doc(alias = "default-font-family")]
    pub fn set_default_font_family(&self, default_font_family: &str) {
        unsafe {
            ffi::webkit_settings_set_default_font_family(
                self.to_glib_none().0,
                default_font_family.to_glib_none().0,
            );
        }
    }

    /// Set the [`default-font-size`][struct@crate::Settings#default-font-size] property.
    /// ## `font_size`
    /// default font size to be set in pixels
    #[doc(alias = "webkit_settings_set_default_font_size")]
    #[doc(alias = "default-font-size")]
    pub fn set_default_font_size(&self, font_size: u32) {
        unsafe {
            ffi::webkit_settings_set_default_font_size(self.to_glib_none().0, font_size);
        }
    }

    /// Set the [`default-monospace-font-size`][struct@crate::Settings#default-monospace-font-size] property.
    /// ## `font_size`
    /// default monospace font size to be set in pixels
    #[doc(alias = "webkit_settings_set_default_monospace_font_size")]
    #[doc(alias = "default-monospace-font-size")]
    pub fn set_default_monospace_font_size(&self, font_size: u32) {
        unsafe {
            ffi::webkit_settings_set_default_monospace_font_size(self.to_glib_none().0, font_size);
        }
    }

    /// Set the [`disable-web-security`][struct@crate::Settings#disable-web-security] property.
    /// ## `disabled`
    /// Value to be set
    #[doc(alias = "webkit_settings_set_disable_web_security")]
    #[doc(alias = "disable-web-security")]
    pub fn set_disable_web_security(&self, disabled: bool) {
        unsafe {
            ffi::webkit_settings_set_disable_web_security(
                self.to_glib_none().0,
                disabled.into_glib(),
            );
        }
    }

    /// Set the [`draw-compositing-indicators`][struct@crate::Settings#draw-compositing-indicators] property.
    /// ## `enabled`
    /// Value to be set
    #[doc(alias = "webkit_settings_set_draw_compositing_indicators")]
    #[doc(alias = "draw-compositing-indicators")]
    pub fn set_draw_compositing_indicators(&self, enabled: bool) {
        unsafe {
            ffi::webkit_settings_set_draw_compositing_indicators(
                self.to_glib_none().0,
                enabled.into_glib(),
            );
        }
    }

    /// Set the [`enable-2d-canvas-acceleration`][struct@crate::Settings#enable-2d-canvas-acceleration] property.
    /// ## `enabled`
    /// Value to be set
    #[cfg(feature = "v2_46")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v2_46")))]
    #[doc(alias = "webkit_settings_set_enable_2d_canvas_acceleration")]
    #[doc(alias = "enable-2d-canvas-acceleration")]
    pub fn set_enable_2d_canvas_acceleration(&self, enabled: bool) {
        unsafe {
            ffi::webkit_settings_set_enable_2d_canvas_acceleration(
                self.to_glib_none().0,
                enabled.into_glib(),
            );
        }
    }

    /// Set the [`enable-back-forward-navigation-gestures`][struct@crate::Settings#enable-back-forward-navigation-gestures] property.
    /// ## `enabled`
    /// value to be set
    #[doc(alias = "webkit_settings_set_enable_back_forward_navigation_gestures")]
    #[doc(alias = "enable-back-forward-navigation-gestures")]
    pub fn set_enable_back_forward_navigation_gestures(&self, enabled: bool) {
        unsafe {
            ffi::webkit_settings_set_enable_back_forward_navigation_gestures(
                self.to_glib_none().0,
                enabled.into_glib(),
            );
        }
    }

    /// Set the [`enable-caret-browsing`][struct@crate::Settings#enable-caret-browsing] property.
    /// ## `enabled`
    /// Value to be set
    #[doc(alias = "webkit_settings_set_enable_caret_browsing")]
    #[doc(alias = "enable-caret-browsing")]
    pub fn set_enable_caret_browsing(&self, enabled: bool) {
        unsafe {
            ffi::webkit_settings_set_enable_caret_browsing(
                self.to_glib_none().0,
                enabled.into_glib(),
            );
        }
    }

    /// Set the [`enable-developer-extras`][struct@crate::Settings#enable-developer-extras] property.
    /// ## `enabled`
    /// Value to be set
    #[doc(alias = "webkit_settings_set_enable_developer_extras")]
    #[doc(alias = "enable-developer-extras")]
    pub fn set_enable_developer_extras(&self, enabled: bool) {
        unsafe {
            ffi::webkit_settings_set_enable_developer_extras(
                self.to_glib_none().0,
                enabled.into_glib(),
            );
        }
    }

    /// Set the [`enable-dns-prefetching`][struct@crate::Settings#enable-dns-prefetching] property.
    ///
    /// # Deprecated since 2.48
    ///
    /// ## `enabled`
    /// Value to be set
    #[cfg_attr(feature = "v2_48", deprecated = "Since 2.48")]
    #[allow(deprecated)]
    #[doc(alias = "webkit_settings_set_enable_dns_prefetching")]
    #[doc(alias = "enable-dns-prefetching")]
    pub fn set_enable_dns_prefetching(&self, enabled: bool) {
        unsafe {
            ffi::webkit_settings_set_enable_dns_prefetching(
                self.to_glib_none().0,
                enabled.into_glib(),
            );
        }
    }

    /// Set the [`enable-encrypted-media`][struct@crate::Settings#enable-encrypted-media] property.
    /// ## `enabled`
    /// Value to be set
    #[doc(alias = "webkit_settings_set_enable_encrypted_media")]
    #[doc(alias = "enable-encrypted-media")]
    pub fn set_enable_encrypted_media(&self, enabled: bool) {
        unsafe {
            ffi::webkit_settings_set_enable_encrypted_media(
                self.to_glib_none().0,
                enabled.into_glib(),
            );
        }
    }

    /// Set the [`enable-fullscreen`][struct@crate::Settings#enable-fullscreen] property.
    /// ## `enabled`
    /// Value to be set
    #[doc(alias = "webkit_settings_set_enable_fullscreen")]
    #[doc(alias = "enable-fullscreen")]
    pub fn set_enable_fullscreen(&self, enabled: bool) {
        unsafe {
            ffi::webkit_settings_set_enable_fullscreen(self.to_glib_none().0, enabled.into_glib());
        }
    }

    /// Set the [`enable-html5-database`][struct@crate::Settings#enable-html5-database] property.
    /// ## `enabled`
    /// Value to be set
    #[doc(alias = "webkit_settings_set_enable_html5_database")]
    #[doc(alias = "enable-html5-database")]
    pub fn set_enable_html5_database(&self, enabled: bool) {
        unsafe {
            ffi::webkit_settings_set_enable_html5_database(
                self.to_glib_none().0,
                enabled.into_glib(),
            );
        }
    }

    /// Set the [`enable-html5-local-storage`][struct@crate::Settings#enable-html5-local-storage] property.
    /// ## `enabled`
    /// Value to be set
    #[doc(alias = "webkit_settings_set_enable_html5_local_storage")]
    #[doc(alias = "enable-html5-local-storage")]
    pub fn set_enable_html5_local_storage(&self, enabled: bool) {
        unsafe {
            ffi::webkit_settings_set_enable_html5_local_storage(
                self.to_glib_none().0,
                enabled.into_glib(),
            );
        }
    }

    /// Set the [`enable-hyperlink-auditing`][struct@crate::Settings#enable-hyperlink-auditing] property.
    ///
    /// # Deprecated since 2.50
    ///
    /// ## `enabled`
    /// Value to be set
    #[cfg_attr(feature = "v2_50", deprecated = "Since 2.50")]
    #[allow(deprecated)]
    #[doc(alias = "webkit_settings_set_enable_hyperlink_auditing")]
    #[doc(alias = "enable-hyperlink-auditing")]
    pub fn set_enable_hyperlink_auditing(&self, enabled: bool) {
        unsafe {
            ffi::webkit_settings_set_enable_hyperlink_auditing(
                self.to_glib_none().0,
                enabled.into_glib(),
            );
        }
    }

    /// Set the [`enable-javascript`][struct@crate::Settings#enable-javascript] property.
    /// ## `enabled`
    /// Value to be set
    #[doc(alias = "webkit_settings_set_enable_javascript")]
    #[doc(alias = "enable-javascript")]
    pub fn set_enable_javascript(&self, enabled: bool) {
        unsafe {
            ffi::webkit_settings_set_enable_javascript(self.to_glib_none().0, enabled.into_glib());
        }
    }

    /// Set the [`enable-javascript-markup`][struct@crate::Settings#enable-javascript-markup] property.
    /// ## `enabled`
    /// Value to be set
    #[doc(alias = "webkit_settings_set_enable_javascript_markup")]
    #[doc(alias = "enable-javascript-markup")]
    pub fn set_enable_javascript_markup(&self, enabled: bool) {
        unsafe {
            ffi::webkit_settings_set_enable_javascript_markup(
                self.to_glib_none().0,
                enabled.into_glib(),
            );
        }
    }

    /// Set the [`enable-media`][struct@crate::Settings#enable-media] property.
    /// ## `enabled`
    /// Value to be set
    #[doc(alias = "webkit_settings_set_enable_media")]
    #[doc(alias = "enable-media")]
    pub fn set_enable_media(&self, enabled: bool) {
        unsafe {
            ffi::webkit_settings_set_enable_media(self.to_glib_none().0, enabled.into_glib());
        }
    }

    /// Set the [`enable-media-capabilities`][struct@crate::Settings#enable-media-capabilities] property.
    /// ## `enabled`
    /// Value to be set
    #[doc(alias = "webkit_settings_set_enable_media_capabilities")]
    #[doc(alias = "enable-media-capabilities")]
    pub fn set_enable_media_capabilities(&self, enabled: bool) {
        unsafe {
            ffi::webkit_settings_set_enable_media_capabilities(
                self.to_glib_none().0,
                enabled.into_glib(),
            );
        }
    }

    /// Set the [`enable-media-stream`][struct@crate::Settings#enable-media-stream] property.
    /// ## `enabled`
    /// Value to be set
    #[doc(alias = "webkit_settings_set_enable_media_stream")]
    #[doc(alias = "enable-media-stream")]
    pub fn set_enable_media_stream(&self, enabled: bool) {
        unsafe {
            ffi::webkit_settings_set_enable_media_stream(
                self.to_glib_none().0,
                enabled.into_glib(),
            );
        }
    }

    /// Set the [`enable-mediasource`][struct@crate::Settings#enable-mediasource] property.
    /// ## `enabled`
    /// Value to be set
    #[doc(alias = "webkit_settings_set_enable_mediasource")]
    #[doc(alias = "enable-mediasource")]
    pub fn set_enable_mediasource(&self, enabled: bool) {
        unsafe {
            ffi::webkit_settings_set_enable_mediasource(self.to_glib_none().0, enabled.into_glib());
        }
    }

    /// Set the [`enable-mock-capture-devices`][struct@crate::Settings#enable-mock-capture-devices] property.
    /// ## `enabled`
    /// Value to be set
    #[doc(alias = "webkit_settings_set_enable_mock_capture_devices")]
    #[doc(alias = "enable-mock-capture-devices")]
    pub fn set_enable_mock_capture_devices(&self, enabled: bool) {
        unsafe {
            ffi::webkit_settings_set_enable_mock_capture_devices(
                self.to_glib_none().0,
                enabled.into_glib(),
            );
        }
    }

    /// Setting no longer supported. This function does nothing.
    ///
    /// # Deprecated since 2.44
    ///
    /// ## `enabled`
    /// Value to be set
    #[cfg_attr(feature = "v2_44", deprecated = "Since 2.44")]
    #[allow(deprecated)]
    #[doc(alias = "webkit_settings_set_enable_offline_web_application_cache")]
    #[doc(alias = "enable-offline-web-application-cache")]
    pub fn set_enable_offline_web_application_cache(&self, enabled: bool) {
        unsafe {
            ffi::webkit_settings_set_enable_offline_web_application_cache(
                self.to_glib_none().0,
                enabled.into_glib(),
            );
        }
    }

    /// Set the [`enable-page-cache`][struct@crate::Settings#enable-page-cache] property.
    /// ## `enabled`
    /// Value to be set
    #[doc(alias = "webkit_settings_set_enable_page_cache")]
    #[doc(alias = "enable-page-cache")]
    pub fn set_enable_page_cache(&self, enabled: bool) {
        unsafe {
            ffi::webkit_settings_set_enable_page_cache(self.to_glib_none().0, enabled.into_glib());
        }
    }

    /// Set the [`enable-resizable-text-areas`][struct@crate::Settings#enable-resizable-text-areas] property.
    /// ## `enabled`
    /// Value to be set
    #[doc(alias = "webkit_settings_set_enable_resizable_text_areas")]
    #[doc(alias = "enable-resizable-text-areas")]
    pub fn set_enable_resizable_text_areas(&self, enabled: bool) {
        unsafe {
            ffi::webkit_settings_set_enable_resizable_text_areas(
                self.to_glib_none().0,
                enabled.into_glib(),
            );
        }
    }

    /// Set the [`enable-site-specific-quirks`][struct@crate::Settings#enable-site-specific-quirks] property.
    /// ## `enabled`
    /// Value to be set
    #[doc(alias = "webkit_settings_set_enable_site_specific_quirks")]
    #[doc(alias = "enable-site-specific-quirks")]
    pub fn set_enable_site_specific_quirks(&self, enabled: bool) {
        unsafe {
            ffi::webkit_settings_set_enable_site_specific_quirks(
                self.to_glib_none().0,
                enabled.into_glib(),
            );
        }
    }

    /// Set the [`enable-smooth-scrolling`][struct@crate::Settings#enable-smooth-scrolling] property.
    /// ## `enabled`
    /// Value to be set
    #[doc(alias = "webkit_settings_set_enable_smooth_scrolling")]
    #[doc(alias = "enable-smooth-scrolling")]
    pub fn set_enable_smooth_scrolling(&self, enabled: bool) {
        unsafe {
            ffi::webkit_settings_set_enable_smooth_scrolling(
                self.to_glib_none().0,
                enabled.into_glib(),
            );
        }
    }

    /// Set the [`enable-spatial-navigation`][struct@crate::Settings#enable-spatial-navigation] property.
    /// ## `enabled`
    /// Value to be set
    #[doc(alias = "webkit_settings_set_enable_spatial_navigation")]
    #[doc(alias = "enable-spatial-navigation")]
    pub fn set_enable_spatial_navigation(&self, enabled: bool) {
        unsafe {
            ffi::webkit_settings_set_enable_spatial_navigation(
                self.to_glib_none().0,
                enabled.into_glib(),
            );
        }
    }

    /// Set the [`enable-tabs-to-links`][struct@crate::Settings#enable-tabs-to-links] property.
    /// ## `enabled`
    /// Value to be set
    #[doc(alias = "webkit_settings_set_enable_tabs_to_links")]
    #[doc(alias = "enable-tabs-to-links")]
    pub fn set_enable_tabs_to_links(&self, enabled: bool) {
        unsafe {
            ffi::webkit_settings_set_enable_tabs_to_links(
                self.to_glib_none().0,
                enabled.into_glib(),
            );
        }
    }

    /// Set the [`enable-webaudio`][struct@crate::Settings#enable-webaudio] property.
    /// ## `enabled`
    /// Value to be set
    #[doc(alias = "webkit_settings_set_enable_webaudio")]
    #[doc(alias = "enable-webaudio")]
    pub fn set_enable_webaudio(&self, enabled: bool) {
        unsafe {
            ffi::webkit_settings_set_enable_webaudio(self.to_glib_none().0, enabled.into_glib());
        }
    }

    /// Set the [`enable-webgl`][struct@crate::Settings#enable-webgl] property.
    /// ## `enabled`
    /// Value to be set
    #[doc(alias = "webkit_settings_set_enable_webgl")]
    #[doc(alias = "enable-webgl")]
    pub fn set_enable_webgl(&self, enabled: bool) {
        unsafe {
            ffi::webkit_settings_set_enable_webgl(self.to_glib_none().0, enabled.into_glib());
        }
    }

    /// Set the [property`Settings`] property.
    ///
    /// Setting this property to [`true`] implies the media-stream web-setting will also be enabled.
    /// ## `enabled`
    /// Value to be set
    #[doc(alias = "webkit_settings_set_enable_webrtc")]
    #[doc(alias = "enable-webrtc")]
    pub fn set_enable_webrtc(&self, enabled: bool) {
        unsafe {
            ffi::webkit_settings_set_enable_webrtc(self.to_glib_none().0, enabled.into_glib());
        }
    }

    /// Set the [`enable-write-console-messages-to-stdout`][struct@crate::Settings#enable-write-console-messages-to-stdout] property.
    /// ## `enabled`
    /// Value to be set
    #[doc(alias = "webkit_settings_set_enable_write_console_messages_to_stdout")]
    #[doc(alias = "enable-write-console-messages-to-stdout")]
    pub fn set_enable_write_console_messages_to_stdout(&self, enabled: bool) {
        unsafe {
            ffi::webkit_settings_set_enable_write_console_messages_to_stdout(
                self.to_glib_none().0,
                enabled.into_glib(),
            );
        }
    }

    /// Set the [`fantasy-font-family`][struct@crate::Settings#fantasy-font-family] property.
    /// ## `fantasy_font_family`
    /// the new default fantasy font family
    #[doc(alias = "webkit_settings_set_fantasy_font_family")]
    #[doc(alias = "fantasy-font-family")]
    pub fn set_fantasy_font_family(&self, fantasy_font_family: &str) {
        unsafe {
            ffi::webkit_settings_set_fantasy_font_family(
                self.to_glib_none().0,
                fantasy_font_family.to_glib_none().0,
            );
        }
    }

    /// Enables or disables a feature.
    ///
    /// The current status of the feature can be determined with
    /// [id[`is_feature_enabled()`][Self::is_feature_enabled()]]. To reset a feature to its
    /// initial status, pass the value returned by
    /// [id[`Feature::is_default_value()`][crate::Feature::is_default_value()]] as the `enabled` parameter.
    /// ## `feature`
    /// the feature to toggle.
    /// ## `enabled`
    /// whether the feature will be enabled.
    #[cfg(feature = "v2_42")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v2_42")))]
    #[doc(alias = "webkit_settings_set_feature_enabled")]
    pub fn set_feature_enabled(&self, feature: &Feature, enabled: bool) {
        unsafe {
            ffi::webkit_settings_set_feature_enabled(
                self.to_glib_none().0,
                feature.to_glib_none().0,
                enabled.into_glib(),
            );
        }
    }

    /// Set the [`hardware-acceleration-policy`][struct@crate::Settings#hardware-acceleration-policy] property.
    /// ## `policy`
    /// a [`HardwareAccelerationPolicy`][crate::HardwareAccelerationPolicy]
    #[doc(alias = "webkit_settings_set_hardware_acceleration_policy")]
    #[doc(alias = "hardware-acceleration-policy")]
    pub fn set_hardware_acceleration_policy(&self, policy: HardwareAccelerationPolicy) {
        unsafe {
            ffi::webkit_settings_set_hardware_acceleration_policy(
                self.to_glib_none().0,
                policy.into_glib(),
            );
        }
    }

    /// Set the [`javascript-can-access-clipboard`][struct@crate::Settings#javascript-can-access-clipboard] property.
    /// ## `enabled`
    /// Value to be set
    #[doc(alias = "webkit_settings_set_javascript_can_access_clipboard")]
    #[doc(alias = "javascript-can-access-clipboard")]
    pub fn set_javascript_can_access_clipboard(&self, enabled: bool) {
        unsafe {
            ffi::webkit_settings_set_javascript_can_access_clipboard(
                self.to_glib_none().0,
                enabled.into_glib(),
            );
        }
    }

    /// Set the [`javascript-can-open-windows-automatically`][struct@crate::Settings#javascript-can-open-windows-automatically] property.
    /// ## `enabled`
    /// Value to be set
    #[doc(alias = "webkit_settings_set_javascript_can_open_windows_automatically")]
    #[doc(alias = "javascript-can-open-windows-automatically")]
    pub fn set_javascript_can_open_windows_automatically(&self, enabled: bool) {
        unsafe {
            ffi::webkit_settings_set_javascript_can_open_windows_automatically(
                self.to_glib_none().0,
                enabled.into_glib(),
            );
        }
    }

    /// Setting no longer supported. This function does nothing.
    ///
    /// # Deprecated since 2.42
    ///
    /// ## `enabled`
    /// Value to be set
    #[cfg_attr(feature = "v2_42", deprecated = "Since 2.42")]
    #[allow(deprecated)]
    #[doc(alias = "webkit_settings_set_load_icons_ignoring_image_load_setting")]
    #[doc(alias = "load-icons-ignoring-image-load-setting")]
    pub fn set_load_icons_ignoring_image_load_setting(&self, enabled: bool) {
        unsafe {
            ffi::webkit_settings_set_load_icons_ignoring_image_load_setting(
                self.to_glib_none().0,
                enabled.into_glib(),
            );
        }
    }

    /// Set the [`math-font-family`][struct@crate::Settings#math-font-family] property.
    ///
    /// Since 2.52
    /// ## `math_font_family`
    /// the new default math font family
    #[doc(alias = "webkit_settings_set_math_font_family")]
    #[doc(alias = "math-font-family")]
    pub fn set_math_font_family(&self, math_font_family: Option<&str>) {
        unsafe {
            ffi::webkit_settings_set_math_font_family(
                self.to_glib_none().0,
                math_font_family.to_glib_none().0,
            );
        }
    }

    /// Set the [`media-content-types-requiring-hardware-support`][struct@crate::Settings#media-content-types-requiring-hardware-support] property.
    /// ## `content_types`
    /// list of media content types requiring hardware support split by semicolons (:) or [`None`] to use the default value.
    #[doc(alias = "webkit_settings_set_media_content_types_requiring_hardware_support")]
    #[doc(alias = "media-content-types-requiring-hardware-support")]
    pub fn set_media_content_types_requiring_hardware_support(&self, content_types: Option<&str>) {
        unsafe {
            ffi::webkit_settings_set_media_content_types_requiring_hardware_support(
                self.to_glib_none().0,
                content_types.to_glib_none().0,
            );
        }
    }

    /// Set the [`media-playback-allows-inline`][struct@crate::Settings#media-playback-allows-inline] property.
    /// ## `enabled`
    /// Value to be set
    #[doc(alias = "webkit_settings_set_media_playback_allows_inline")]
    #[doc(alias = "media-playback-allows-inline")]
    pub fn set_media_playback_allows_inline(&self, enabled: bool) {
        unsafe {
            ffi::webkit_settings_set_media_playback_allows_inline(
                self.to_glib_none().0,
                enabled.into_glib(),
            );
        }
    }

    /// Set the [`media-playback-requires-user-gesture`][struct@crate::Settings#media-playback-requires-user-gesture] property.
    /// ## `enabled`
    /// Value to be set
    #[doc(alias = "webkit_settings_set_media_playback_requires_user_gesture")]
    #[doc(alias = "media-playback-requires-user-gesture")]
    pub fn set_media_playback_requires_user_gesture(&self, enabled: bool) {
        unsafe {
            ffi::webkit_settings_set_media_playback_requires_user_gesture(
                self.to_glib_none().0,
                enabled.into_glib(),
            );
        }
    }

    /// Set the [`minimum-font-size`][struct@crate::Settings#minimum-font-size] property.
    /// ## `font_size`
    /// minimum font size to be set in pixels
    #[doc(alias = "webkit_settings_set_minimum_font_size")]
    #[doc(alias = "minimum-font-size")]
    pub fn set_minimum_font_size(&self, font_size: u32) {
        unsafe {
            ffi::webkit_settings_set_minimum_font_size(self.to_glib_none().0, font_size);
        }
    }

    /// Set the [`monospace-font-family`][struct@crate::Settings#monospace-font-family] property.
    /// ## `monospace_font_family`
    /// the new default monospace font family
    #[doc(alias = "webkit_settings_set_monospace_font_family")]
    #[doc(alias = "monospace-font-family")]
    pub fn set_monospace_font_family(&self, monospace_font_family: &str) {
        unsafe {
            ffi::webkit_settings_set_monospace_font_family(
                self.to_glib_none().0,
                monospace_font_family.to_glib_none().0,
            );
        }
    }

    /// Set the [`pictograph-font-family`][struct@crate::Settings#pictograph-font-family] property.
    /// ## `pictograph_font_family`
    /// the new default pictograph font family
    #[doc(alias = "webkit_settings_set_pictograph_font_family")]
    #[doc(alias = "pictograph-font-family")]
    pub fn set_pictograph_font_family(&self, pictograph_font_family: &str) {
        unsafe {
            ffi::webkit_settings_set_pictograph_font_family(
                self.to_glib_none().0,
                pictograph_font_family.to_glib_none().0,
            );
        }
    }

    /// Set the [`print-backgrounds`][struct@crate::Settings#print-backgrounds] property.
    /// ## `print_backgrounds`
    /// Value to be set
    #[doc(alias = "webkit_settings_set_print_backgrounds")]
    #[doc(alias = "print-backgrounds")]
    pub fn set_print_backgrounds(&self, print_backgrounds: bool) {
        unsafe {
            ffi::webkit_settings_set_print_backgrounds(
                self.to_glib_none().0,
                print_backgrounds.into_glib(),
            );
        }
    }

    /// Set the [`sans-serif-font-family`][struct@crate::Settings#sans-serif-font-family] property.
    /// ## `sans_serif_font_family`
    /// the new default sans-serif font family
    #[doc(alias = "webkit_settings_set_sans_serif_font_family")]
    #[doc(alias = "sans-serif-font-family")]
    pub fn set_sans_serif_font_family(&self, sans_serif_font_family: &str) {
        unsafe {
            ffi::webkit_settings_set_sans_serif_font_family(
                self.to_glib_none().0,
                sans_serif_font_family.to_glib_none().0,
            );
        }
    }

    /// Set the [`serif-font-family`][struct@crate::Settings#serif-font-family] property.
    /// ## `serif_font_family`
    /// the new default serif font family
    #[doc(alias = "webkit_settings_set_serif_font_family")]
    #[doc(alias = "serif-font-family")]
    pub fn set_serif_font_family(&self, serif_font_family: &str) {
        unsafe {
            ffi::webkit_settings_set_serif_font_family(
                self.to_glib_none().0,
                serif_font_family.to_glib_none().0,
            );
        }
    }

    /// Set the [`user-agent`][struct@crate::Settings#user-agent] property.
    /// ## `user_agent`
    /// The new custom user agent string or [`None`] to use the default user agent
    #[doc(alias = "webkit_settings_set_user_agent")]
    #[doc(alias = "user-agent")]
    pub fn set_user_agent(&self, user_agent: Option<&str>) {
        unsafe {
            ffi::webkit_settings_set_user_agent(self.to_glib_none().0, user_agent.to_glib_none().0);
        }
    }

    /// Set the [`user-agent`][struct@crate::Settings#user-agent] property by appending the application details.
    ///
    /// Set the [`user-agent`][struct@crate::Settings#user-agent] property by appending the application details to the default user
    /// agent. If no application name or version is given, the default user agent used will be used. If only
    /// the version is given, the default engine version is used with the given application name.
    /// ## `application_name`
    /// The application name used for the user agent or [`None`] to use the default user agent.
    /// ## `application_version`
    /// The application version for the user agent or [`None`] to user the default version.
    #[doc(alias = "webkit_settings_set_user_agent_with_application_details")]
    pub fn set_user_agent_with_application_details(
        &self,
        application_name: Option<&str>,
        application_version: Option<&str>,
    ) {
        unsafe {
            ffi::webkit_settings_set_user_agent_with_application_details(
                self.to_glib_none().0,
                application_name.to_glib_none().0,
                application_version.to_glib_none().0,
            );
        }
    }

    /// Set the [property`Settings`] property.
    /// ## `udp_port_range`
    /// Value to be set
    #[cfg(feature = "v2_48")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v2_48")))]
    #[doc(alias = "webkit_settings_set_webrtc_udp_ports_range")]
    #[doc(alias = "webrtc-udp-ports-range")]
    pub fn set_webrtc_udp_ports_range(&self, udp_port_range: &str) {
        unsafe {
            ffi::webkit_settings_set_webrtc_udp_ports_range(
                self.to_glib_none().0,
                udp_port_range.to_glib_none().0,
            );
        }
    }

    /// Set the [`zoom-text-only`][struct@crate::Settings#zoom-text-only] property.
    /// ## `zoom_text_only`
    /// Value to be set
    #[doc(alias = "webkit_settings_set_zoom_text_only")]
    #[doc(alias = "zoom-text-only")]
    pub fn set_zoom_text_only(&self, zoom_text_only: bool) {
        unsafe {
            ffi::webkit_settings_set_zoom_text_only(
                self.to_glib_none().0,
                zoom_text_only.into_glib(),
            );
        }
    }

    /// Convert `points` to the equivalent value in pixels.
    ///
    /// Applications can use this function to convert font size values
    /// in points to font size values in pixels when setting the font size properties
    /// of [`Settings`][crate::Settings].
    /// ## `points`
    /// the font size in points to convert to pixels
    ///
    /// # Returns
    ///
    /// the equivalent font size in pixels.
    #[doc(alias = "webkit_settings_font_size_to_pixels")]
    pub fn font_size_to_pixels(points: u32) -> u32 {
        assert_initialized_main_thread!();
        unsafe { ffi::webkit_settings_font_size_to_pixels(points) }
    }

    /// Convert `pixels` to the equivalent value in points.
    ///
    /// Applications can use this function to convert font size values
    /// in pixels to font size values in points when getting the font size properties
    /// of [`Settings`][crate::Settings].
    /// ## `pixels`
    /// the font size in pixels to convert to points
    ///
    /// # Returns
    ///
    /// the equivalent font size in points.
    #[doc(alias = "webkit_settings_font_size_to_points")]
    pub fn font_size_to_points(pixels: u32) -> u32 {
        assert_initialized_main_thread!();
        unsafe { ffi::webkit_settings_font_size_to_points(pixels) }
    }

    /// Gets the list of all available WebKit features.
    ///
    /// Features can be toggled with [method`Settings`],
    /// and their current state determined with
    /// [method`Settings`].
    ///
    /// Note that most applications should use
    /// [func`Settings`] and
    /// [func`Settings`] instead.
    ///
    /// # Returns
    ///
    /// List of all features.
    #[cfg(feature = "v2_42")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v2_42")))]
    #[doc(alias = "webkit_settings_get_all_features")]
    #[doc(alias = "get_all_features")]
    pub fn all_features() -> Option<FeatureList> {
        assert_initialized_main_thread!();
        unsafe { from_glib_full(ffi::webkit_settings_get_all_features()) }
    }

    /// Gets the list of available development WebKit features.
    ///
    /// The returned features are a subset of those returned by
    /// [func`Settings`], and includes those which
    /// web and WebKit developers might find useful, but in general should
    /// *not* be exposed to end users; see [enum`FeatureStatus`] for
    /// more details.
    ///
    /// # Returns
    ///
    /// List of development features.
    #[cfg(feature = "v2_42")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v2_42")))]
    #[doc(alias = "webkit_settings_get_development_features")]
    #[doc(alias = "get_development_features")]
    pub fn development_features() -> Option<FeatureList> {
        assert_initialized_main_thread!();
        unsafe { from_glib_full(ffi::webkit_settings_get_development_features()) }
    }

    /// Gets the list of available experimental WebKit features.
    ///
    /// The returned features are a subset of those returned by
    /// [func`Settings`], and includes those which
    /// certain applications may want to expose to end users; see
    /// [enum`FeatureStatus`] for more details.
    ///
    /// # Returns
    ///
    /// List of experimental features.
    #[cfg(feature = "v2_42")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v2_42")))]
    #[doc(alias = "webkit_settings_get_experimental_features")]
    #[doc(alias = "get_experimental_features")]
    pub fn experimental_features() -> Option<FeatureList> {
        assert_initialized_main_thread!();
        unsafe { from_glib_full(ffi::webkit_settings_get_experimental_features()) }
    }

    #[doc(alias = "allow-file-access-from-file-urls")]
    pub fn connect_allow_file_access_from_file_urls_notify<F: Fn(&Self) + 'static>(
        &self,
        f: F,
    ) -> SignalHandlerId {
        unsafe extern "C" fn notify_allow_file_access_from_file_urls_trampoline<
            F: Fn(&Settings) + 'static,
        >(
            this: *mut ffi::WebKitSettings,
            _param_spec: glib::ffi::gpointer,
            f: glib::ffi::gpointer,
        ) {
            unsafe {
                let f: &F = &*(f as *const F);
                f(&from_glib_borrow(this))
            }
        }
        unsafe {
            let f: Box_<F> = Box_::new(f);
            connect_raw(
                self.as_ptr() as *mut _,
                c"notify::allow-file-access-from-file-urls".as_ptr(),
                Some(std::mem::transmute::<*const (), unsafe extern "C" fn()>(
                    notify_allow_file_access_from_file_urls_trampoline::<F> as *const (),
                )),
                Box_::into_raw(f),
            )
        }
    }

    #[doc(alias = "allow-modal-dialogs")]
    pub fn connect_allow_modal_dialogs_notify<F: Fn(&Self) + 'static>(
        &self,
        f: F,
    ) -> SignalHandlerId {
        unsafe extern "C" fn notify_allow_modal_dialogs_trampoline<F: Fn(&Settings) + 'static>(
            this: *mut ffi::WebKitSettings,
            _param_spec: glib::ffi::gpointer,
            f: glib::ffi::gpointer,
        ) {
            unsafe {
                let f: &F = &*(f as *const F);
                f(&from_glib_borrow(this))
            }
        }
        unsafe {
            let f: Box_<F> = Box_::new(f);
            connect_raw(
                self.as_ptr() as *mut _,
                c"notify::allow-modal-dialogs".as_ptr(),
                Some(std::mem::transmute::<*const (), unsafe extern "C" fn()>(
                    notify_allow_modal_dialogs_trampoline::<F> as *const (),
                )),
                Box_::into_raw(f),
            )
        }
    }

    #[doc(alias = "allow-top-navigation-to-data-urls")]
    pub fn connect_allow_top_navigation_to_data_urls_notify<F: Fn(&Self) + 'static>(
        &self,
        f: F,
    ) -> SignalHandlerId {
        unsafe extern "C" fn notify_allow_top_navigation_to_data_urls_trampoline<
            F: Fn(&Settings) + 'static,
        >(
            this: *mut ffi::WebKitSettings,
            _param_spec: glib::ffi::gpointer,
            f: glib::ffi::gpointer,
        ) {
            unsafe {
                let f: &F = &*(f as *const F);
                f(&from_glib_borrow(this))
            }
        }
        unsafe {
            let f: Box_<F> = Box_::new(f);
            connect_raw(
                self.as_ptr() as *mut _,
                c"notify::allow-top-navigation-to-data-urls".as_ptr(),
                Some(std::mem::transmute::<*const (), unsafe extern "C" fn()>(
                    notify_allow_top_navigation_to_data_urls_trampoline::<F> as *const (),
                )),
                Box_::into_raw(f),
            )
        }
    }

    #[doc(alias = "allow-universal-access-from-file-urls")]
    pub fn connect_allow_universal_access_from_file_urls_notify<F: Fn(&Self) + 'static>(
        &self,
        f: F,
    ) -> SignalHandlerId {
        unsafe extern "C" fn notify_allow_universal_access_from_file_urls_trampoline<
            F: Fn(&Settings) + 'static,
        >(
            this: *mut ffi::WebKitSettings,
            _param_spec: glib::ffi::gpointer,
            f: glib::ffi::gpointer,
        ) {
            unsafe {
                let f: &F = &*(f as *const F);
                f(&from_glib_borrow(this))
            }
        }
        unsafe {
            let f: Box_<F> = Box_::new(f);
            connect_raw(
                self.as_ptr() as *mut _,
                c"notify::allow-universal-access-from-file-urls".as_ptr(),
                Some(std::mem::transmute::<*const (), unsafe extern "C" fn()>(
                    notify_allow_universal_access_from_file_urls_trampoline::<F> as *const (),
                )),
                Box_::into_raw(f),
            )
        }
    }

    #[doc(alias = "auto-load-images")]
    pub fn connect_auto_load_images_notify<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId {
        unsafe extern "C" fn notify_auto_load_images_trampoline<F: Fn(&Settings) + 'static>(
            this: *mut ffi::WebKitSettings,
            _param_spec: glib::ffi::gpointer,
            f: glib::ffi::gpointer,
        ) {
            unsafe {
                let f: &F = &*(f as *const F);
                f(&from_glib_borrow(this))
            }
        }
        unsafe {
            let f: Box_<F> = Box_::new(f);
            connect_raw(
                self.as_ptr() as *mut _,
                c"notify::auto-load-images".as_ptr(),
                Some(std::mem::transmute::<*const (), unsafe extern "C" fn()>(
                    notify_auto_load_images_trampoline::<F> as *const (),
                )),
                Box_::into_raw(f),
            )
        }
    }

    #[doc(alias = "cursive-font-family")]
    pub fn connect_cursive_font_family_notify<F: Fn(&Self) + 'static>(
        &self,
        f: F,
    ) -> SignalHandlerId {
        unsafe extern "C" fn notify_cursive_font_family_trampoline<F: Fn(&Settings) + 'static>(
            this: *mut ffi::WebKitSettings,
            _param_spec: glib::ffi::gpointer,
            f: glib::ffi::gpointer,
        ) {
            unsafe {
                let f: &F = &*(f as *const F);
                f(&from_glib_borrow(this))
            }
        }
        unsafe {
            let f: Box_<F> = Box_::new(f);
            connect_raw(
                self.as_ptr() as *mut _,
                c"notify::cursive-font-family".as_ptr(),
                Some(std::mem::transmute::<*const (), unsafe extern "C" fn()>(
                    notify_cursive_font_family_trampoline::<F> as *const (),
                )),
                Box_::into_raw(f),
            )
        }
    }

    #[doc(alias = "default-charset")]
    pub fn connect_default_charset_notify<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId {
        unsafe extern "C" fn notify_default_charset_trampoline<F: Fn(&Settings) + 'static>(
            this: *mut ffi::WebKitSettings,
            _param_spec: glib::ffi::gpointer,
            f: glib::ffi::gpointer,
        ) {
            unsafe {
                let f: &F = &*(f as *const F);
                f(&from_glib_borrow(this))
            }
        }
        unsafe {
            let f: Box_<F> = Box_::new(f);
            connect_raw(
                self.as_ptr() as *mut _,
                c"notify::default-charset".as_ptr(),
                Some(std::mem::transmute::<*const (), unsafe extern "C" fn()>(
                    notify_default_charset_trampoline::<F> as *const (),
                )),
                Box_::into_raw(f),
            )
        }
    }

    #[doc(alias = "default-font-family")]
    pub fn connect_default_font_family_notify<F: Fn(&Self) + 'static>(
        &self,
        f: F,
    ) -> SignalHandlerId {
        unsafe extern "C" fn notify_default_font_family_trampoline<F: Fn(&Settings) + 'static>(
            this: *mut ffi::WebKitSettings,
            _param_spec: glib::ffi::gpointer,
            f: glib::ffi::gpointer,
        ) {
            unsafe {
                let f: &F = &*(f as *const F);
                f(&from_glib_borrow(this))
            }
        }
        unsafe {
            let f: Box_<F> = Box_::new(f);
            connect_raw(
                self.as_ptr() as *mut _,
                c"notify::default-font-family".as_ptr(),
                Some(std::mem::transmute::<*const (), unsafe extern "C" fn()>(
                    notify_default_font_family_trampoline::<F> as *const (),
                )),
                Box_::into_raw(f),
            )
        }
    }

    #[doc(alias = "default-font-size")]
    pub fn connect_default_font_size_notify<F: Fn(&Self) + 'static>(
        &self,
        f: F,
    ) -> SignalHandlerId {
        unsafe extern "C" fn notify_default_font_size_trampoline<F: Fn(&Settings) + 'static>(
            this: *mut ffi::WebKitSettings,
            _param_spec: glib::ffi::gpointer,
            f: glib::ffi::gpointer,
        ) {
            unsafe {
                let f: &F = &*(f as *const F);
                f(&from_glib_borrow(this))
            }
        }
        unsafe {
            let f: Box_<F> = Box_::new(f);
            connect_raw(
                self.as_ptr() as *mut _,
                c"notify::default-font-size".as_ptr(),
                Some(std::mem::transmute::<*const (), unsafe extern "C" fn()>(
                    notify_default_font_size_trampoline::<F> as *const (),
                )),
                Box_::into_raw(f),
            )
        }
    }

    #[doc(alias = "default-monospace-font-size")]
    pub fn connect_default_monospace_font_size_notify<F: Fn(&Self) + 'static>(
        &self,
        f: F,
    ) -> SignalHandlerId {
        unsafe extern "C" fn notify_default_monospace_font_size_trampoline<
            F: Fn(&Settings) + 'static,
        >(
            this: *mut ffi::WebKitSettings,
            _param_spec: glib::ffi::gpointer,
            f: glib::ffi::gpointer,
        ) {
            unsafe {
                let f: &F = &*(f as *const F);
                f(&from_glib_borrow(this))
            }
        }
        unsafe {
            let f: Box_<F> = Box_::new(f);
            connect_raw(
                self.as_ptr() as *mut _,
                c"notify::default-monospace-font-size".as_ptr(),
                Some(std::mem::transmute::<*const (), unsafe extern "C" fn()>(
                    notify_default_monospace_font_size_trampoline::<F> as *const (),
                )),
                Box_::into_raw(f),
            )
        }
    }

    #[doc(alias = "disable-web-security")]
    pub fn connect_disable_web_security_notify<F: Fn(&Self) + 'static>(
        &self,
        f: F,
    ) -> SignalHandlerId {
        unsafe extern "C" fn notify_disable_web_security_trampoline<F: Fn(&Settings) + 'static>(
            this: *mut ffi::WebKitSettings,
            _param_spec: glib::ffi::gpointer,
            f: glib::ffi::gpointer,
        ) {
            unsafe {
                let f: &F = &*(f as *const F);
                f(&from_glib_borrow(this))
            }
        }
        unsafe {
            let f: Box_<F> = Box_::new(f);
            connect_raw(
                self.as_ptr() as *mut _,
                c"notify::disable-web-security".as_ptr(),
                Some(std::mem::transmute::<*const (), unsafe extern "C" fn()>(
                    notify_disable_web_security_trampoline::<F> as *const (),
                )),
                Box_::into_raw(f),
            )
        }
    }

    #[doc(alias = "draw-compositing-indicators")]
    pub fn connect_draw_compositing_indicators_notify<F: Fn(&Self) + 'static>(
        &self,
        f: F,
    ) -> SignalHandlerId {
        unsafe extern "C" fn notify_draw_compositing_indicators_trampoline<
            F: Fn(&Settings) + 'static,
        >(
            this: *mut ffi::WebKitSettings,
            _param_spec: glib::ffi::gpointer,
            f: glib::ffi::gpointer,
        ) {
            unsafe {
                let f: &F = &*(f as *const F);
                f(&from_glib_borrow(this))
            }
        }
        unsafe {
            let f: Box_<F> = Box_::new(f);
            connect_raw(
                self.as_ptr() as *mut _,
                c"notify::draw-compositing-indicators".as_ptr(),
                Some(std::mem::transmute::<*const (), unsafe extern "C" fn()>(
                    notify_draw_compositing_indicators_trampoline::<F> as *const (),
                )),
                Box_::into_raw(f),
            )
        }
    }

    #[cfg(feature = "v2_46")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v2_46")))]
    #[doc(alias = "enable-2d-canvas-acceleration")]
    pub fn connect_enable_2d_canvas_acceleration_notify<F: Fn(&Self) + 'static>(
        &self,
        f: F,
    ) -> SignalHandlerId {
        unsafe extern "C" fn notify_enable_2d_canvas_acceleration_trampoline<
            F: Fn(&Settings) + 'static,
        >(
            this: *mut ffi::WebKitSettings,
            _param_spec: glib::ffi::gpointer,
            f: glib::ffi::gpointer,
        ) {
            unsafe {
                let f: &F = &*(f as *const F);
                f(&from_glib_borrow(this))
            }
        }
        unsafe {
            let f: Box_<F> = Box_::new(f);
            connect_raw(
                self.as_ptr() as *mut _,
                c"notify::enable-2d-canvas-acceleration".as_ptr(),
                Some(std::mem::transmute::<*const (), unsafe extern "C" fn()>(
                    notify_enable_2d_canvas_acceleration_trampoline::<F> as *const (),
                )),
                Box_::into_raw(f),
            )
        }
    }

    #[doc(alias = "enable-back-forward-navigation-gestures")]
    pub fn connect_enable_back_forward_navigation_gestures_notify<F: Fn(&Self) + 'static>(
        &self,
        f: F,
    ) -> SignalHandlerId {
        unsafe extern "C" fn notify_enable_back_forward_navigation_gestures_trampoline<
            F: Fn(&Settings) + 'static,
        >(
            this: *mut ffi::WebKitSettings,
            _param_spec: glib::ffi::gpointer,
            f: glib::ffi::gpointer,
        ) {
            unsafe {
                let f: &F = &*(f as *const F);
                f(&from_glib_borrow(this))
            }
        }
        unsafe {
            let f: Box_<F> = Box_::new(f);
            connect_raw(
                self.as_ptr() as *mut _,
                c"notify::enable-back-forward-navigation-gestures".as_ptr(),
                Some(std::mem::transmute::<*const (), unsafe extern "C" fn()>(
                    notify_enable_back_forward_navigation_gestures_trampoline::<F> as *const (),
                )),
                Box_::into_raw(f),
            )
        }
    }

    #[doc(alias = "enable-caret-browsing")]
    pub fn connect_enable_caret_browsing_notify<F: Fn(&Self) + 'static>(
        &self,
        f: F,
    ) -> SignalHandlerId {
        unsafe extern "C" fn notify_enable_caret_browsing_trampoline<F: Fn(&Settings) + 'static>(
            this: *mut ffi::WebKitSettings,
            _param_spec: glib::ffi::gpointer,
            f: glib::ffi::gpointer,
        ) {
            unsafe {
                let f: &F = &*(f as *const F);
                f(&from_glib_borrow(this))
            }
        }
        unsafe {
            let f: Box_<F> = Box_::new(f);
            connect_raw(
                self.as_ptr() as *mut _,
                c"notify::enable-caret-browsing".as_ptr(),
                Some(std::mem::transmute::<*const (), unsafe extern "C" fn()>(
                    notify_enable_caret_browsing_trampoline::<F> as *const (),
                )),
                Box_::into_raw(f),
            )
        }
    }

    #[doc(alias = "enable-developer-extras")]
    pub fn connect_enable_developer_extras_notify<F: Fn(&Self) + 'static>(
        &self,
        f: F,
    ) -> SignalHandlerId {
        unsafe extern "C" fn notify_enable_developer_extras_trampoline<
            F: Fn(&Settings) + 'static,
        >(
            this: *mut ffi::WebKitSettings,
            _param_spec: glib::ffi::gpointer,
            f: glib::ffi::gpointer,
        ) {
            unsafe {
                let f: &F = &*(f as *const F);
                f(&from_glib_borrow(this))
            }
        }
        unsafe {
            let f: Box_<F> = Box_::new(f);
            connect_raw(
                self.as_ptr() as *mut _,
                c"notify::enable-developer-extras".as_ptr(),
                Some(std::mem::transmute::<*const (), unsafe extern "C" fn()>(
                    notify_enable_developer_extras_trampoline::<F> as *const (),
                )),
                Box_::into_raw(f),
            )
        }
    }

    #[cfg_attr(feature = "v2_48", deprecated = "Since 2.48")]
    #[doc(alias = "enable-dns-prefetching")]
    pub fn connect_enable_dns_prefetching_notify<F: Fn(&Self) + 'static>(
        &self,
        f: F,
    ) -> SignalHandlerId {
        unsafe extern "C" fn notify_enable_dns_prefetching_trampoline<
            F: Fn(&Settings) + 'static,
        >(
            this: *mut ffi::WebKitSettings,
            _param_spec: glib::ffi::gpointer,
            f: glib::ffi::gpointer,
        ) {
            unsafe {
                let f: &F = &*(f as *const F);
                f(&from_glib_borrow(this))
            }
        }
        unsafe {
            let f: Box_<F> = Box_::new(f);
            connect_raw(
                self.as_ptr() as *mut _,
                c"notify::enable-dns-prefetching".as_ptr(),
                Some(std::mem::transmute::<*const (), unsafe extern "C" fn()>(
                    notify_enable_dns_prefetching_trampoline::<F> as *const (),
                )),
                Box_::into_raw(f),
            )
        }
    }

    #[doc(alias = "enable-encrypted-media")]
    pub fn connect_enable_encrypted_media_notify<F: Fn(&Self) + 'static>(
        &self,
        f: F,
    ) -> SignalHandlerId {
        unsafe extern "C" fn notify_enable_encrypted_media_trampoline<
            F: Fn(&Settings) + 'static,
        >(
            this: *mut ffi::WebKitSettings,
            _param_spec: glib::ffi::gpointer,
            f: glib::ffi::gpointer,
        ) {
            unsafe {
                let f: &F = &*(f as *const F);
                f(&from_glib_borrow(this))
            }
        }
        unsafe {
            let f: Box_<F> = Box_::new(f);
            connect_raw(
                self.as_ptr() as *mut _,
                c"notify::enable-encrypted-media".as_ptr(),
                Some(std::mem::transmute::<*const (), unsafe extern "C" fn()>(
                    notify_enable_encrypted_media_trampoline::<F> as *const (),
                )),
                Box_::into_raw(f),
            )
        }
    }

    #[doc(alias = "enable-fullscreen")]
    pub fn connect_enable_fullscreen_notify<F: Fn(&Self) + 'static>(
        &self,
        f: F,
    ) -> SignalHandlerId {
        unsafe extern "C" fn notify_enable_fullscreen_trampoline<F: Fn(&Settings) + 'static>(
            this: *mut ffi::WebKitSettings,
            _param_spec: glib::ffi::gpointer,
            f: glib::ffi::gpointer,
        ) {
            unsafe {
                let f: &F = &*(f as *const F);
                f(&from_glib_borrow(this))
            }
        }
        unsafe {
            let f: Box_<F> = Box_::new(f);
            connect_raw(
                self.as_ptr() as *mut _,
                c"notify::enable-fullscreen".as_ptr(),
                Some(std::mem::transmute::<*const (), unsafe extern "C" fn()>(
                    notify_enable_fullscreen_trampoline::<F> as *const (),
                )),
                Box_::into_raw(f),
            )
        }
    }

    #[doc(alias = "enable-html5-database")]
    pub fn connect_enable_html5_database_notify<F: Fn(&Self) + 'static>(
        &self,
        f: F,
    ) -> SignalHandlerId {
        unsafe extern "C" fn notify_enable_html5_database_trampoline<F: Fn(&Settings) + 'static>(
            this: *mut ffi::WebKitSettings,
            _param_spec: glib::ffi::gpointer,
            f: glib::ffi::gpointer,
        ) {
            unsafe {
                let f: &F = &*(f as *const F);
                f(&from_glib_borrow(this))
            }
        }
        unsafe {
            let f: Box_<F> = Box_::new(f);
            connect_raw(
                self.as_ptr() as *mut _,
                c"notify::enable-html5-database".as_ptr(),
                Some(std::mem::transmute::<*const (), unsafe extern "C" fn()>(
                    notify_enable_html5_database_trampoline::<F> as *const (),
                )),
                Box_::into_raw(f),
            )
        }
    }

    #[doc(alias = "enable-html5-local-storage")]
    pub fn connect_enable_html5_local_storage_notify<F: Fn(&Self) + 'static>(
        &self,
        f: F,
    ) -> SignalHandlerId {
        unsafe extern "C" fn notify_enable_html5_local_storage_trampoline<
            F: Fn(&Settings) + 'static,
        >(
            this: *mut ffi::WebKitSettings,
            _param_spec: glib::ffi::gpointer,
            f: glib::ffi::gpointer,
        ) {
            unsafe {
                let f: &F = &*(f as *const F);
                f(&from_glib_borrow(this))
            }
        }
        unsafe {
            let f: Box_<F> = Box_::new(f);
            connect_raw(
                self.as_ptr() as *mut _,
                c"notify::enable-html5-local-storage".as_ptr(),
                Some(std::mem::transmute::<*const (), unsafe extern "C" fn()>(
                    notify_enable_html5_local_storage_trampoline::<F> as *const (),
                )),
                Box_::into_raw(f),
            )
        }
    }

    #[cfg_attr(feature = "v2_50", deprecated = "Since 2.50")]
    #[doc(alias = "enable-hyperlink-auditing")]
    pub fn connect_enable_hyperlink_auditing_notify<F: Fn(&Self) + 'static>(
        &self,
        f: F,
    ) -> SignalHandlerId {
        unsafe extern "C" fn notify_enable_hyperlink_auditing_trampoline<
            F: Fn(&Settings) + 'static,
        >(
            this: *mut ffi::WebKitSettings,
            _param_spec: glib::ffi::gpointer,
            f: glib::ffi::gpointer,
        ) {
            unsafe {
                let f: &F = &*(f as *const F);
                f(&from_glib_borrow(this))
            }
        }
        unsafe {
            let f: Box_<F> = Box_::new(f);
            connect_raw(
                self.as_ptr() as *mut _,
                c"notify::enable-hyperlink-auditing".as_ptr(),
                Some(std::mem::transmute::<*const (), unsafe extern "C" fn()>(
                    notify_enable_hyperlink_auditing_trampoline::<F> as *const (),
                )),
                Box_::into_raw(f),
            )
        }
    }

    #[doc(alias = "enable-javascript")]
    pub fn connect_enable_javascript_notify<F: Fn(&Self) + 'static>(
        &self,
        f: F,
    ) -> SignalHandlerId {
        unsafe extern "C" fn notify_enable_javascript_trampoline<F: Fn(&Settings) + 'static>(
            this: *mut ffi::WebKitSettings,
            _param_spec: glib::ffi::gpointer,
            f: glib::ffi::gpointer,
        ) {
            unsafe {
                let f: &F = &*(f as *const F);
                f(&from_glib_borrow(this))
            }
        }
        unsafe {
            let f: Box_<F> = Box_::new(f);
            connect_raw(
                self.as_ptr() as *mut _,
                c"notify::enable-javascript".as_ptr(),
                Some(std::mem::transmute::<*const (), unsafe extern "C" fn()>(
                    notify_enable_javascript_trampoline::<F> as *const (),
                )),
                Box_::into_raw(f),
            )
        }
    }

    #[doc(alias = "enable-javascript-markup")]
    pub fn connect_enable_javascript_markup_notify<F: Fn(&Self) + 'static>(
        &self,
        f: F,
    ) -> SignalHandlerId {
        unsafe extern "C" fn notify_enable_javascript_markup_trampoline<
            F: Fn(&Settings) + 'static,
        >(
            this: *mut ffi::WebKitSettings,
            _param_spec: glib::ffi::gpointer,
            f: glib::ffi::gpointer,
        ) {
            unsafe {
                let f: &F = &*(f as *const F);
                f(&from_glib_borrow(this))
            }
        }
        unsafe {
            let f: Box_<F> = Box_::new(f);
            connect_raw(
                self.as_ptr() as *mut _,
                c"notify::enable-javascript-markup".as_ptr(),
                Some(std::mem::transmute::<*const (), unsafe extern "C" fn()>(
                    notify_enable_javascript_markup_trampoline::<F> as *const (),
                )),
                Box_::into_raw(f),
            )
        }
    }

    #[doc(alias = "enable-media")]
    pub fn connect_enable_media_notify<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId {
        unsafe extern "C" fn notify_enable_media_trampoline<F: Fn(&Settings) + 'static>(
            this: *mut ffi::WebKitSettings,
            _param_spec: glib::ffi::gpointer,
            f: glib::ffi::gpointer,
        ) {
            unsafe {
                let f: &F = &*(f as *const F);
                f(&from_glib_borrow(this))
            }
        }
        unsafe {
            let f: Box_<F> = Box_::new(f);
            connect_raw(
                self.as_ptr() as *mut _,
                c"notify::enable-media".as_ptr(),
                Some(std::mem::transmute::<*const (), unsafe extern "C" fn()>(
                    notify_enable_media_trampoline::<F> as *const (),
                )),
                Box_::into_raw(f),
            )
        }
    }

    #[doc(alias = "enable-media-capabilities")]
    pub fn connect_enable_media_capabilities_notify<F: Fn(&Self) + 'static>(
        &self,
        f: F,
    ) -> SignalHandlerId {
        unsafe extern "C" fn notify_enable_media_capabilities_trampoline<
            F: Fn(&Settings) + 'static,
        >(
            this: *mut ffi::WebKitSettings,
            _param_spec: glib::ffi::gpointer,
            f: glib::ffi::gpointer,
        ) {
            unsafe {
                let f: &F = &*(f as *const F);
                f(&from_glib_borrow(this))
            }
        }
        unsafe {
            let f: Box_<F> = Box_::new(f);
            connect_raw(
                self.as_ptr() as *mut _,
                c"notify::enable-media-capabilities".as_ptr(),
                Some(std::mem::transmute::<*const (), unsafe extern "C" fn()>(
                    notify_enable_media_capabilities_trampoline::<F> as *const (),
                )),
                Box_::into_raw(f),
            )
        }
    }

    #[doc(alias = "enable-media-stream")]
    pub fn connect_enable_media_stream_notify<F: Fn(&Self) + 'static>(
        &self,
        f: F,
    ) -> SignalHandlerId {
        unsafe extern "C" fn notify_enable_media_stream_trampoline<F: Fn(&Settings) + 'static>(
            this: *mut ffi::WebKitSettings,
            _param_spec: glib::ffi::gpointer,
            f: glib::ffi::gpointer,
        ) {
            unsafe {
                let f: &F = &*(f as *const F);
                f(&from_glib_borrow(this))
            }
        }
        unsafe {
            let f: Box_<F> = Box_::new(f);
            connect_raw(
                self.as_ptr() as *mut _,
                c"notify::enable-media-stream".as_ptr(),
                Some(std::mem::transmute::<*const (), unsafe extern "C" fn()>(
                    notify_enable_media_stream_trampoline::<F> as *const (),
                )),
                Box_::into_raw(f),
            )
        }
    }

    #[doc(alias = "enable-mediasource")]
    pub fn connect_enable_mediasource_notify<F: Fn(&Self) + 'static>(
        &self,
        f: F,
    ) -> SignalHandlerId {
        unsafe extern "C" fn notify_enable_mediasource_trampoline<F: Fn(&Settings) + 'static>(
            this: *mut ffi::WebKitSettings,
            _param_spec: glib::ffi::gpointer,
            f: glib::ffi::gpointer,
        ) {
            unsafe {
                let f: &F = &*(f as *const F);
                f(&from_glib_borrow(this))
            }
        }
        unsafe {
            let f: Box_<F> = Box_::new(f);
            connect_raw(
                self.as_ptr() as *mut _,
                c"notify::enable-mediasource".as_ptr(),
                Some(std::mem::transmute::<*const (), unsafe extern "C" fn()>(
                    notify_enable_mediasource_trampoline::<F> as *const (),
                )),
                Box_::into_raw(f),
            )
        }
    }

    #[doc(alias = "enable-mock-capture-devices")]
    pub fn connect_enable_mock_capture_devices_notify<F: Fn(&Self) + 'static>(
        &self,
        f: F,
    ) -> SignalHandlerId {
        unsafe extern "C" fn notify_enable_mock_capture_devices_trampoline<
            F: Fn(&Settings) + 'static,
        >(
            this: *mut ffi::WebKitSettings,
            _param_spec: glib::ffi::gpointer,
            f: glib::ffi::gpointer,
        ) {
            unsafe {
                let f: &F = &*(f as *const F);
                f(&from_glib_borrow(this))
            }
        }
        unsafe {
            let f: Box_<F> = Box_::new(f);
            connect_raw(
                self.as_ptr() as *mut _,
                c"notify::enable-mock-capture-devices".as_ptr(),
                Some(std::mem::transmute::<*const (), unsafe extern "C" fn()>(
                    notify_enable_mock_capture_devices_trampoline::<F> as *const (),
                )),
                Box_::into_raw(f),
            )
        }
    }

    #[cfg_attr(feature = "v2_44", deprecated = "Since 2.44")]
    #[doc(alias = "enable-offline-web-application-cache")]
    pub fn connect_enable_offline_web_application_cache_notify<F: Fn(&Self) + 'static>(
        &self,
        f: F,
    ) -> SignalHandlerId {
        unsafe extern "C" fn notify_enable_offline_web_application_cache_trampoline<
            F: Fn(&Settings) + 'static,
        >(
            this: *mut ffi::WebKitSettings,
            _param_spec: glib::ffi::gpointer,
            f: glib::ffi::gpointer,
        ) {
            unsafe {
                let f: &F = &*(f as *const F);
                f(&from_glib_borrow(this))
            }
        }
        unsafe {
            let f: Box_<F> = Box_::new(f);
            connect_raw(
                self.as_ptr() as *mut _,
                c"notify::enable-offline-web-application-cache".as_ptr(),
                Some(std::mem::transmute::<*const (), unsafe extern "C" fn()>(
                    notify_enable_offline_web_application_cache_trampoline::<F> as *const (),
                )),
                Box_::into_raw(f),
            )
        }
    }

    #[doc(alias = "enable-page-cache")]
    pub fn connect_enable_page_cache_notify<F: Fn(&Self) + 'static>(
        &self,
        f: F,
    ) -> SignalHandlerId {
        unsafe extern "C" fn notify_enable_page_cache_trampoline<F: Fn(&Settings) + 'static>(
            this: *mut ffi::WebKitSettings,
            _param_spec: glib::ffi::gpointer,
            f: glib::ffi::gpointer,
        ) {
            unsafe {
                let f: &F = &*(f as *const F);
                f(&from_glib_borrow(this))
            }
        }
        unsafe {
            let f: Box_<F> = Box_::new(f);
            connect_raw(
                self.as_ptr() as *mut _,
                c"notify::enable-page-cache".as_ptr(),
                Some(std::mem::transmute::<*const (), unsafe extern "C" fn()>(
                    notify_enable_page_cache_trampoline::<F> as *const (),
                )),
                Box_::into_raw(f),
            )
        }
    }

    #[doc(alias = "enable-resizable-text-areas")]
    pub fn connect_enable_resizable_text_areas_notify<F: Fn(&Self) + 'static>(
        &self,
        f: F,
    ) -> SignalHandlerId {
        unsafe extern "C" fn notify_enable_resizable_text_areas_trampoline<
            F: Fn(&Settings) + 'static,
        >(
            this: *mut ffi::WebKitSettings,
            _param_spec: glib::ffi::gpointer,
            f: glib::ffi::gpointer,
        ) {
            unsafe {
                let f: &F = &*(f as *const F);
                f(&from_glib_borrow(this))
            }
        }
        unsafe {
            let f: Box_<F> = Box_::new(f);
            connect_raw(
                self.as_ptr() as *mut _,
                c"notify::enable-resizable-text-areas".as_ptr(),
                Some(std::mem::transmute::<*const (), unsafe extern "C" fn()>(
                    notify_enable_resizable_text_areas_trampoline::<F> as *const (),
                )),
                Box_::into_raw(f),
            )
        }
    }

    #[doc(alias = "enable-site-specific-quirks")]
    pub fn connect_enable_site_specific_quirks_notify<F: Fn(&Self) + 'static>(
        &self,
        f: F,
    ) -> SignalHandlerId {
        unsafe extern "C" fn notify_enable_site_specific_quirks_trampoline<
            F: Fn(&Settings) + 'static,
        >(
            this: *mut ffi::WebKitSettings,
            _param_spec: glib::ffi::gpointer,
            f: glib::ffi::gpointer,
        ) {
            unsafe {
                let f: &F = &*(f as *const F);
                f(&from_glib_borrow(this))
            }
        }
        unsafe {
            let f: Box_<F> = Box_::new(f);
            connect_raw(
                self.as_ptr() as *mut _,
                c"notify::enable-site-specific-quirks".as_ptr(),
                Some(std::mem::transmute::<*const (), unsafe extern "C" fn()>(
                    notify_enable_site_specific_quirks_trampoline::<F> as *const (),
                )),
                Box_::into_raw(f),
            )
        }
    }

    #[doc(alias = "enable-smooth-scrolling")]
    pub fn connect_enable_smooth_scrolling_notify<F: Fn(&Self) + 'static>(
        &self,
        f: F,
    ) -> SignalHandlerId {
        unsafe extern "C" fn notify_enable_smooth_scrolling_trampoline<
            F: Fn(&Settings) + 'static,
        >(
            this: *mut ffi::WebKitSettings,
            _param_spec: glib::ffi::gpointer,
            f: glib::ffi::gpointer,
        ) {
            unsafe {
                let f: &F = &*(f as *const F);
                f(&from_glib_borrow(this))
            }
        }
        unsafe {
            let f: Box_<F> = Box_::new(f);
            connect_raw(
                self.as_ptr() as *mut _,
                c"notify::enable-smooth-scrolling".as_ptr(),
                Some(std::mem::transmute::<*const (), unsafe extern "C" fn()>(
                    notify_enable_smooth_scrolling_trampoline::<F> as *const (),
                )),
                Box_::into_raw(f),
            )
        }
    }

    #[doc(alias = "enable-spatial-navigation")]
    pub fn connect_enable_spatial_navigation_notify<F: Fn(&Self) + 'static>(
        &self,
        f: F,
    ) -> SignalHandlerId {
        unsafe extern "C" fn notify_enable_spatial_navigation_trampoline<
            F: Fn(&Settings) + 'static,
        >(
            this: *mut ffi::WebKitSettings,
            _param_spec: glib::ffi::gpointer,
            f: glib::ffi::gpointer,
        ) {
            unsafe {
                let f: &F = &*(f as *const F);
                f(&from_glib_borrow(this))
            }
        }
        unsafe {
            let f: Box_<F> = Box_::new(f);
            connect_raw(
                self.as_ptr() as *mut _,
                c"notify::enable-spatial-navigation".as_ptr(),
                Some(std::mem::transmute::<*const (), unsafe extern "C" fn()>(
                    notify_enable_spatial_navigation_trampoline::<F> as *const (),
                )),
                Box_::into_raw(f),
            )
        }
    }

    #[doc(alias = "enable-tabs-to-links")]
    pub fn connect_enable_tabs_to_links_notify<F: Fn(&Self) + 'static>(
        &self,
        f: F,
    ) -> SignalHandlerId {
        unsafe extern "C" fn notify_enable_tabs_to_links_trampoline<F: Fn(&Settings) + 'static>(
            this: *mut ffi::WebKitSettings,
            _param_spec: glib::ffi::gpointer,
            f: glib::ffi::gpointer,
        ) {
            unsafe {
                let f: &F = &*(f as *const F);
                f(&from_glib_borrow(this))
            }
        }
        unsafe {
            let f: Box_<F> = Box_::new(f);
            connect_raw(
                self.as_ptr() as *mut _,
                c"notify::enable-tabs-to-links".as_ptr(),
                Some(std::mem::transmute::<*const (), unsafe extern "C" fn()>(
                    notify_enable_tabs_to_links_trampoline::<F> as *const (),
                )),
                Box_::into_raw(f),
            )
        }
    }

    #[doc(alias = "enable-webaudio")]
    pub fn connect_enable_webaudio_notify<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId {
        unsafe extern "C" fn notify_enable_webaudio_trampoline<F: Fn(&Settings) + 'static>(
            this: *mut ffi::WebKitSettings,
            _param_spec: glib::ffi::gpointer,
            f: glib::ffi::gpointer,
        ) {
            unsafe {
                let f: &F = &*(f as *const F);
                f(&from_glib_borrow(this))
            }
        }
        unsafe {
            let f: Box_<F> = Box_::new(f);
            connect_raw(
                self.as_ptr() as *mut _,
                c"notify::enable-webaudio".as_ptr(),
                Some(std::mem::transmute::<*const (), unsafe extern "C" fn()>(
                    notify_enable_webaudio_trampoline::<F> as *const (),
                )),
                Box_::into_raw(f),
            )
        }
    }

    #[doc(alias = "enable-webgl")]
    pub fn connect_enable_webgl_notify<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId {
        unsafe extern "C" fn notify_enable_webgl_trampoline<F: Fn(&Settings) + 'static>(
            this: *mut ffi::WebKitSettings,
            _param_spec: glib::ffi::gpointer,
            f: glib::ffi::gpointer,
        ) {
            unsafe {
                let f: &F = &*(f as *const F);
                f(&from_glib_borrow(this))
            }
        }
        unsafe {
            let f: Box_<F> = Box_::new(f);
            connect_raw(
                self.as_ptr() as *mut _,
                c"notify::enable-webgl".as_ptr(),
                Some(std::mem::transmute::<*const (), unsafe extern "C" fn()>(
                    notify_enable_webgl_trampoline::<F> as *const (),
                )),
                Box_::into_raw(f),
            )
        }
    }

    #[doc(alias = "enable-webrtc")]
    pub fn connect_enable_webrtc_notify<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId {
        unsafe extern "C" fn notify_enable_webrtc_trampoline<F: Fn(&Settings) + 'static>(
            this: *mut ffi::WebKitSettings,
            _param_spec: glib::ffi::gpointer,
            f: glib::ffi::gpointer,
        ) {
            unsafe {
                let f: &F = &*(f as *const F);
                f(&from_glib_borrow(this))
            }
        }
        unsafe {
            let f: Box_<F> = Box_::new(f);
            connect_raw(
                self.as_ptr() as *mut _,
                c"notify::enable-webrtc".as_ptr(),
                Some(std::mem::transmute::<*const (), unsafe extern "C" fn()>(
                    notify_enable_webrtc_trampoline::<F> as *const (),
                )),
                Box_::into_raw(f),
            )
        }
    }

    #[doc(alias = "enable-write-console-messages-to-stdout")]
    pub fn connect_enable_write_console_messages_to_stdout_notify<F: Fn(&Self) + 'static>(
        &self,
        f: F,
    ) -> SignalHandlerId {
        unsafe extern "C" fn notify_enable_write_console_messages_to_stdout_trampoline<
            F: Fn(&Settings) + 'static,
        >(
            this: *mut ffi::WebKitSettings,
            _param_spec: glib::ffi::gpointer,
            f: glib::ffi::gpointer,
        ) {
            unsafe {
                let f: &F = &*(f as *const F);
                f(&from_glib_borrow(this))
            }
        }
        unsafe {
            let f: Box_<F> = Box_::new(f);
            connect_raw(
                self.as_ptr() as *mut _,
                c"notify::enable-write-console-messages-to-stdout".as_ptr(),
                Some(std::mem::transmute::<*const (), unsafe extern "C" fn()>(
                    notify_enable_write_console_messages_to_stdout_trampoline::<F> as *const (),
                )),
                Box_::into_raw(f),
            )
        }
    }

    #[doc(alias = "fantasy-font-family")]
    pub fn connect_fantasy_font_family_notify<F: Fn(&Self) + 'static>(
        &self,
        f: F,
    ) -> SignalHandlerId {
        unsafe extern "C" fn notify_fantasy_font_family_trampoline<F: Fn(&Settings) + 'static>(
            this: *mut ffi::WebKitSettings,
            _param_spec: glib::ffi::gpointer,
            f: glib::ffi::gpointer,
        ) {
            unsafe {
                let f: &F = &*(f as *const F);
                f(&from_glib_borrow(this))
            }
        }
        unsafe {
            let f: Box_<F> = Box_::new(f);
            connect_raw(
                self.as_ptr() as *mut _,
                c"notify::fantasy-font-family".as_ptr(),
                Some(std::mem::transmute::<*const (), unsafe extern "C" fn()>(
                    notify_fantasy_font_family_trampoline::<F> as *const (),
                )),
                Box_::into_raw(f),
            )
        }
    }

    #[doc(alias = "hardware-acceleration-policy")]
    pub fn connect_hardware_acceleration_policy_notify<F: Fn(&Self) + 'static>(
        &self,
        f: F,
    ) -> SignalHandlerId {
        unsafe extern "C" fn notify_hardware_acceleration_policy_trampoline<
            F: Fn(&Settings) + 'static,
        >(
            this: *mut ffi::WebKitSettings,
            _param_spec: glib::ffi::gpointer,
            f: glib::ffi::gpointer,
        ) {
            unsafe {
                let f: &F = &*(f as *const F);
                f(&from_glib_borrow(this))
            }
        }
        unsafe {
            let f: Box_<F> = Box_::new(f);
            connect_raw(
                self.as_ptr() as *mut _,
                c"notify::hardware-acceleration-policy".as_ptr(),
                Some(std::mem::transmute::<*const (), unsafe extern "C" fn()>(
                    notify_hardware_acceleration_policy_trampoline::<F> as *const (),
                )),
                Box_::into_raw(f),
            )
        }
    }

    #[doc(alias = "javascript-can-access-clipboard")]
    pub fn connect_javascript_can_access_clipboard_notify<F: Fn(&Self) + 'static>(
        &self,
        f: F,
    ) -> SignalHandlerId {
        unsafe extern "C" fn notify_javascript_can_access_clipboard_trampoline<
            F: Fn(&Settings) + 'static,
        >(
            this: *mut ffi::WebKitSettings,
            _param_spec: glib::ffi::gpointer,
            f: glib::ffi::gpointer,
        ) {
            unsafe {
                let f: &F = &*(f as *const F);
                f(&from_glib_borrow(this))
            }
        }
        unsafe {
            let f: Box_<F> = Box_::new(f);
            connect_raw(
                self.as_ptr() as *mut _,
                c"notify::javascript-can-access-clipboard".as_ptr(),
                Some(std::mem::transmute::<*const (), unsafe extern "C" fn()>(
                    notify_javascript_can_access_clipboard_trampoline::<F> as *const (),
                )),
                Box_::into_raw(f),
            )
        }
    }

    #[doc(alias = "javascript-can-open-windows-automatically")]
    pub fn connect_javascript_can_open_windows_automatically_notify<F: Fn(&Self) + 'static>(
        &self,
        f: F,
    ) -> SignalHandlerId {
        unsafe extern "C" fn notify_javascript_can_open_windows_automatically_trampoline<
            F: Fn(&Settings) + 'static,
        >(
            this: *mut ffi::WebKitSettings,
            _param_spec: glib::ffi::gpointer,
            f: glib::ffi::gpointer,
        ) {
            unsafe {
                let f: &F = &*(f as *const F);
                f(&from_glib_borrow(this))
            }
        }
        unsafe {
            let f: Box_<F> = Box_::new(f);
            connect_raw(
                self.as_ptr() as *mut _,
                c"notify::javascript-can-open-windows-automatically".as_ptr(),
                Some(std::mem::transmute::<*const (), unsafe extern "C" fn()>(
                    notify_javascript_can_open_windows_automatically_trampoline::<F> as *const (),
                )),
                Box_::into_raw(f),
            )
        }
    }

    #[cfg_attr(feature = "v2_42", deprecated = "Since 2.42")]
    #[doc(alias = "load-icons-ignoring-image-load-setting")]
    pub fn connect_load_icons_ignoring_image_load_setting_notify<F: Fn(&Self) + 'static>(
        &self,
        f: F,
    ) -> SignalHandlerId {
        unsafe extern "C" fn notify_load_icons_ignoring_image_load_setting_trampoline<
            F: Fn(&Settings) + 'static,
        >(
            this: *mut ffi::WebKitSettings,
            _param_spec: glib::ffi::gpointer,
            f: glib::ffi::gpointer,
        ) {
            unsafe {
                let f: &F = &*(f as *const F);
                f(&from_glib_borrow(this))
            }
        }
        unsafe {
            let f: Box_<F> = Box_::new(f);
            connect_raw(
                self.as_ptr() as *mut _,
                c"notify::load-icons-ignoring-image-load-setting".as_ptr(),
                Some(std::mem::transmute::<*const (), unsafe extern "C" fn()>(
                    notify_load_icons_ignoring_image_load_setting_trampoline::<F> as *const (),
                )),
                Box_::into_raw(f),
            )
        }
    }

    #[cfg(feature = "v2_52")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v2_52")))]
    #[doc(alias = "math-font-family")]
    pub fn connect_math_font_family_notify<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId {
        unsafe extern "C" fn notify_math_font_family_trampoline<F: Fn(&Settings) + 'static>(
            this: *mut ffi::WebKitSettings,
            _param_spec: glib::ffi::gpointer,
            f: glib::ffi::gpointer,
        ) {
            unsafe {
                let f: &F = &*(f as *const F);
                f(&from_glib_borrow(this))
            }
        }
        unsafe {
            let f: Box_<F> = Box_::new(f);
            connect_raw(
                self.as_ptr() as *mut _,
                c"notify::math-font-family".as_ptr(),
                Some(std::mem::transmute::<*const (), unsafe extern "C" fn()>(
                    notify_math_font_family_trampoline::<F> as *const (),
                )),
                Box_::into_raw(f),
            )
        }
    }

    #[doc(alias = "media-content-types-requiring-hardware-support")]
    pub fn connect_media_content_types_requiring_hardware_support_notify<F: Fn(&Self) + 'static>(
        &self,
        f: F,
    ) -> SignalHandlerId {
        unsafe extern "C" fn notify_media_content_types_requiring_hardware_support_trampoline<
            F: Fn(&Settings) + 'static,
        >(
            this: *mut ffi::WebKitSettings,
            _param_spec: glib::ffi::gpointer,
            f: glib::ffi::gpointer,
        ) {
            unsafe {
                let f: &F = &*(f as *const F);
                f(&from_glib_borrow(this))
            }
        }
        unsafe {
            let f: Box_<F> = Box_::new(f);
            connect_raw(
                self.as_ptr() as *mut _,
                c"notify::media-content-types-requiring-hardware-support".as_ptr(),
                Some(std::mem::transmute::<*const (), unsafe extern "C" fn()>(
                    notify_media_content_types_requiring_hardware_support_trampoline::<F>
                        as *const (),
                )),
                Box_::into_raw(f),
            )
        }
    }

    #[doc(alias = "media-playback-allows-inline")]
    pub fn connect_media_playback_allows_inline_notify<F: Fn(&Self) + 'static>(
        &self,
        f: F,
    ) -> SignalHandlerId {
        unsafe extern "C" fn notify_media_playback_allows_inline_trampoline<
            F: Fn(&Settings) + 'static,
        >(
            this: *mut ffi::WebKitSettings,
            _param_spec: glib::ffi::gpointer,
            f: glib::ffi::gpointer,
        ) {
            unsafe {
                let f: &F = &*(f as *const F);
                f(&from_glib_borrow(this))
            }
        }
        unsafe {
            let f: Box_<F> = Box_::new(f);
            connect_raw(
                self.as_ptr() as *mut _,
                c"notify::media-playback-allows-inline".as_ptr(),
                Some(std::mem::transmute::<*const (), unsafe extern "C" fn()>(
                    notify_media_playback_allows_inline_trampoline::<F> as *const (),
                )),
                Box_::into_raw(f),
            )
        }
    }

    #[doc(alias = "media-playback-requires-user-gesture")]
    pub fn connect_media_playback_requires_user_gesture_notify<F: Fn(&Self) + 'static>(
        &self,
        f: F,
    ) -> SignalHandlerId {
        unsafe extern "C" fn notify_media_playback_requires_user_gesture_trampoline<
            F: Fn(&Settings) + 'static,
        >(
            this: *mut ffi::WebKitSettings,
            _param_spec: glib::ffi::gpointer,
            f: glib::ffi::gpointer,
        ) {
            unsafe {
                let f: &F = &*(f as *const F);
                f(&from_glib_borrow(this))
            }
        }
        unsafe {
            let f: Box_<F> = Box_::new(f);
            connect_raw(
                self.as_ptr() as *mut _,
                c"notify::media-playback-requires-user-gesture".as_ptr(),
                Some(std::mem::transmute::<*const (), unsafe extern "C" fn()>(
                    notify_media_playback_requires_user_gesture_trampoline::<F> as *const (),
                )),
                Box_::into_raw(f),
            )
        }
    }

    #[doc(alias = "minimum-font-size")]
    pub fn connect_minimum_font_size_notify<F: Fn(&Self) + 'static>(
        &self,
        f: F,
    ) -> SignalHandlerId {
        unsafe extern "C" fn notify_minimum_font_size_trampoline<F: Fn(&Settings) + 'static>(
            this: *mut ffi::WebKitSettings,
            _param_spec: glib::ffi::gpointer,
            f: glib::ffi::gpointer,
        ) {
            unsafe {
                let f: &F = &*(f as *const F);
                f(&from_glib_borrow(this))
            }
        }
        unsafe {
            let f: Box_<F> = Box_::new(f);
            connect_raw(
                self.as_ptr() as *mut _,
                c"notify::minimum-font-size".as_ptr(),
                Some(std::mem::transmute::<*const (), unsafe extern "C" fn()>(
                    notify_minimum_font_size_trampoline::<F> as *const (),
                )),
                Box_::into_raw(f),
            )
        }
    }

    #[doc(alias = "monospace-font-family")]
    pub fn connect_monospace_font_family_notify<F: Fn(&Self) + 'static>(
        &self,
        f: F,
    ) -> SignalHandlerId {
        unsafe extern "C" fn notify_monospace_font_family_trampoline<F: Fn(&Settings) + 'static>(
            this: *mut ffi::WebKitSettings,
            _param_spec: glib::ffi::gpointer,
            f: glib::ffi::gpointer,
        ) {
            unsafe {
                let f: &F = &*(f as *const F);
                f(&from_glib_borrow(this))
            }
        }
        unsafe {
            let f: Box_<F> = Box_::new(f);
            connect_raw(
                self.as_ptr() as *mut _,
                c"notify::monospace-font-family".as_ptr(),
                Some(std::mem::transmute::<*const (), unsafe extern "C" fn()>(
                    notify_monospace_font_family_trampoline::<F> as *const (),
                )),
                Box_::into_raw(f),
            )
        }
    }

    #[doc(alias = "pictograph-font-family")]
    pub fn connect_pictograph_font_family_notify<F: Fn(&Self) + 'static>(
        &self,
        f: F,
    ) -> SignalHandlerId {
        unsafe extern "C" fn notify_pictograph_font_family_trampoline<
            F: Fn(&Settings) + 'static,
        >(
            this: *mut ffi::WebKitSettings,
            _param_spec: glib::ffi::gpointer,
            f: glib::ffi::gpointer,
        ) {
            unsafe {
                let f: &F = &*(f as *const F);
                f(&from_glib_borrow(this))
            }
        }
        unsafe {
            let f: Box_<F> = Box_::new(f);
            connect_raw(
                self.as_ptr() as *mut _,
                c"notify::pictograph-font-family".as_ptr(),
                Some(std::mem::transmute::<*const (), unsafe extern "C" fn()>(
                    notify_pictograph_font_family_trampoline::<F> as *const (),
                )),
                Box_::into_raw(f),
            )
        }
    }

    #[doc(alias = "print-backgrounds")]
    pub fn connect_print_backgrounds_notify<F: Fn(&Self) + 'static>(
        &self,
        f: F,
    ) -> SignalHandlerId {
        unsafe extern "C" fn notify_print_backgrounds_trampoline<F: Fn(&Settings) + 'static>(
            this: *mut ffi::WebKitSettings,
            _param_spec: glib::ffi::gpointer,
            f: glib::ffi::gpointer,
        ) {
            unsafe {
                let f: &F = &*(f as *const F);
                f(&from_glib_borrow(this))
            }
        }
        unsafe {
            let f: Box_<F> = Box_::new(f);
            connect_raw(
                self.as_ptr() as *mut _,
                c"notify::print-backgrounds".as_ptr(),
                Some(std::mem::transmute::<*const (), unsafe extern "C" fn()>(
                    notify_print_backgrounds_trampoline::<F> as *const (),
                )),
                Box_::into_raw(f),
            )
        }
    }

    #[doc(alias = "sans-serif-font-family")]
    pub fn connect_sans_serif_font_family_notify<F: Fn(&Self) + 'static>(
        &self,
        f: F,
    ) -> SignalHandlerId {
        unsafe extern "C" fn notify_sans_serif_font_family_trampoline<
            F: Fn(&Settings) + 'static,
        >(
            this: *mut ffi::WebKitSettings,
            _param_spec: glib::ffi::gpointer,
            f: glib::ffi::gpointer,
        ) {
            unsafe {
                let f: &F = &*(f as *const F);
                f(&from_glib_borrow(this))
            }
        }
        unsafe {
            let f: Box_<F> = Box_::new(f);
            connect_raw(
                self.as_ptr() as *mut _,
                c"notify::sans-serif-font-family".as_ptr(),
                Some(std::mem::transmute::<*const (), unsafe extern "C" fn()>(
                    notify_sans_serif_font_family_trampoline::<F> as *const (),
                )),
                Box_::into_raw(f),
            )
        }
    }

    #[doc(alias = "serif-font-family")]
    pub fn connect_serif_font_family_notify<F: Fn(&Self) + 'static>(
        &self,
        f: F,
    ) -> SignalHandlerId {
        unsafe extern "C" fn notify_serif_font_family_trampoline<F: Fn(&Settings) + 'static>(
            this: *mut ffi::WebKitSettings,
            _param_spec: glib::ffi::gpointer,
            f: glib::ffi::gpointer,
        ) {
            unsafe {
                let f: &F = &*(f as *const F);
                f(&from_glib_borrow(this))
            }
        }
        unsafe {
            let f: Box_<F> = Box_::new(f);
            connect_raw(
                self.as_ptr() as *mut _,
                c"notify::serif-font-family".as_ptr(),
                Some(std::mem::transmute::<*const (), unsafe extern "C" fn()>(
                    notify_serif_font_family_trampoline::<F> as *const (),
                )),
                Box_::into_raw(f),
            )
        }
    }

    #[doc(alias = "user-agent")]
    pub fn connect_user_agent_notify<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId {
        unsafe extern "C" fn notify_user_agent_trampoline<F: Fn(&Settings) + 'static>(
            this: *mut ffi::WebKitSettings,
            _param_spec: glib::ffi::gpointer,
            f: glib::ffi::gpointer,
        ) {
            unsafe {
                let f: &F = &*(f as *const F);
                f(&from_glib_borrow(this))
            }
        }
        unsafe {
            let f: Box_<F> = Box_::new(f);
            connect_raw(
                self.as_ptr() as *mut _,
                c"notify::user-agent".as_ptr(),
                Some(std::mem::transmute::<*const (), unsafe extern "C" fn()>(
                    notify_user_agent_trampoline::<F> as *const (),
                )),
                Box_::into_raw(f),
            )
        }
    }

    #[cfg(feature = "v2_48")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v2_48")))]
    #[doc(alias = "webrtc-udp-ports-range")]
    pub fn connect_webrtc_udp_ports_range_notify<F: Fn(&Self) + 'static>(
        &self,
        f: F,
    ) -> SignalHandlerId {
        unsafe extern "C" fn notify_webrtc_udp_ports_range_trampoline<
            F: Fn(&Settings) + 'static,
        >(
            this: *mut ffi::WebKitSettings,
            _param_spec: glib::ffi::gpointer,
            f: glib::ffi::gpointer,
        ) {
            unsafe {
                let f: &F = &*(f as *const F);
                f(&from_glib_borrow(this))
            }
        }
        unsafe {
            let f: Box_<F> = Box_::new(f);
            connect_raw(
                self.as_ptr() as *mut _,
                c"notify::webrtc-udp-ports-range".as_ptr(),
                Some(std::mem::transmute::<*const (), unsafe extern "C" fn()>(
                    notify_webrtc_udp_ports_range_trampoline::<F> as *const (),
                )),
                Box_::into_raw(f),
            )
        }
    }

    #[doc(alias = "zoom-text-only")]
    pub fn connect_zoom_text_only_notify<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId {
        unsafe extern "C" fn notify_zoom_text_only_trampoline<F: Fn(&Settings) + 'static>(
            this: *mut ffi::WebKitSettings,
            _param_spec: glib::ffi::gpointer,
            f: glib::ffi::gpointer,
        ) {
            unsafe {
                let f: &F = &*(f as *const F);
                f(&from_glib_borrow(this))
            }
        }
        unsafe {
            let f: Box_<F> = Box_::new(f);
            connect_raw(
                self.as_ptr() as *mut _,
                c"notify::zoom-text-only".as_ptr(),
                Some(std::mem::transmute::<*const (), unsafe extern "C" fn()>(
                    notify_zoom_text_only_trampoline::<F> as *const (),
                )),
                Box_::into_raw(f),
            )
        }
    }
}

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

// rustdoc-stripper-ignore-next
/// A [builder-pattern] type to construct [`Settings`] 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 SettingsBuilder {
    builder: glib::object::ObjectBuilder<'static, Settings>,
}

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

    /// Whether file access is allowed from file URLs. By default, when
    /// something is loaded in a [`WebView`][crate::WebView] using a file URI, cross
    /// origin requests to other file resources are not allowed. This
    /// setting allows you to change that behaviour, so that it would be
    /// possible to do a XMLHttpRequest of a local file, for example.
    pub fn allow_file_access_from_file_urls(self, allow_file_access_from_file_urls: bool) -> Self {
        Self {
            builder: self.builder.property(
                "allow-file-access-from-file-urls",
                allow_file_access_from_file_urls,
            ),
        }
    }

    /// Determine whether it's allowed to create and run modal dialogs
    /// from a [`WebView`][crate::WebView] through JavaScript with
    /// `<function>`window.showModalDialog`</function>`. If it's set to
    /// [`false`], the associated [`WebView`][crate::WebView] won't be able to create
    /// new modal dialogs, so not even the [`create`][struct@crate::WebView#create]
    /// signal will be emitted.
    pub fn allow_modal_dialogs(self, allow_modal_dialogs: bool) -> Self {
        Self {
            builder: self
                .builder
                .property("allow-modal-dialogs", allow_modal_dialogs),
        }
    }

    /// Whether or not the top frame is allowed to navigate to data URLs. It is disabled by default
    /// due to the risk it poses when loading untrusted URLs, with data URLs being used in scamming
    /// and phishing attacks. In contrast, a scenario where it could be enabled could be an app that
    /// embeds a WebView and you have control of the pages being show instead of a generic browser.
    pub fn allow_top_navigation_to_data_urls(
        self,
        allow_top_navigation_to_data_urls: bool,
    ) -> Self {
        Self {
            builder: self.builder.property(
                "allow-top-navigation-to-data-urls",
                allow_top_navigation_to_data_urls,
            ),
        }
    }

    /// Whether or not JavaScript running in the context of a file scheme URL
    /// should be allowed to access content from any origin. By default, when
    /// something is loaded in a [`WebView`][crate::WebView] using a file scheme URL,
    /// access to the local file system and arbitrary local storage is not
    /// allowed. This setting allows you to change that behaviour, so that
    /// it would be possible to use local storage, for example.
    pub fn allow_universal_access_from_file_urls(
        self,
        allow_universal_access_from_file_urls: bool,
    ) -> Self {
        Self {
            builder: self.builder.property(
                "allow-universal-access-from-file-urls",
                allow_universal_access_from_file_urls,
            ),
        }
    }

    /// Determines whether images should be automatically loaded or not.
    /// On devices where network bandwidth is of concern, it might be
    /// useful to turn this property off.
    pub fn auto_load_images(self, auto_load_images: bool) -> Self {
        Self {
            builder: self.builder.property("auto-load-images", auto_load_images),
        }
    }

    /// The font family used as the default for content using a cursive font.
    pub fn cursive_font_family(self, cursive_font_family: impl Into<glib::GString>) -> Self {
        Self {
            builder: self
                .builder
                .property("cursive-font-family", cursive_font_family.into()),
        }
    }

    /// The default text charset used when interpreting content with an unspecified charset.
    pub fn default_charset(self, default_charset: impl Into<glib::GString>) -> Self {
        Self {
            builder: self
                .builder
                .property("default-charset", default_charset.into()),
        }
    }

    /// The font family to use as the default for content that does not specify a font.
    pub fn default_font_family(self, default_font_family: impl Into<glib::GString>) -> Self {
        Self {
            builder: self
                .builder
                .property("default-font-family", default_font_family.into()),
        }
    }

    /// The default font size in pixels to use for content displayed if
    /// no font size is specified.
    pub fn default_font_size(self, default_font_size: u32) -> Self {
        Self {
            builder: self
                .builder
                .property("default-font-size", default_font_size),
        }
    }

    /// The default font size in pixels to use for content displayed in
    /// monospace font if no font size is specified.
    pub fn default_monospace_font_size(self, default_monospace_font_size: u32) -> Self {
        Self {
            builder: self
                .builder
                .property("default-monospace-font-size", default_monospace_font_size),
        }
    }

    /// Enable or disable support for Web Security on pages.
    ///
    /// This setting disables the same-origin policy, allowing every website full control over
    /// all other websites. This is for use in special environments where you wish to disable
    /// all security and allow websites to hack each other. It is impossible to use this setting
    /// securely.
    pub fn disable_web_security(self, disable_web_security: bool) -> Self {
        Self {
            builder: self
                .builder
                .property("disable-web-security", disable_web_security),
        }
    }

    /// Whether to draw compositing borders and repaint counters on layers drawn
    /// with accelerated compositing. This is useful for debugging issues related
    /// to web content that is composited with the GPU.
    pub fn draw_compositing_indicators(self, draw_compositing_indicators: bool) -> Self {
        Self {
            builder: self
                .builder
                .property("draw-compositing-indicators", draw_compositing_indicators),
        }
    }

    /// Enable or disable 2D canvas acceleration.
    /// If this setting is enabled, the 2D canvas will be accelerated even if Skia CPU
    /// is used for rendering. However, the canvas can be unaccelerated even when this setting
    /// is enabled, for other reasons like its size or when willReadFrequently property is used.
    #[cfg(feature = "v2_46")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v2_46")))]
    pub fn enable_2d_canvas_acceleration(self, enable_2d_canvas_acceleration: bool) -> Self {
        Self {
            builder: self.builder.property(
                "enable-2d-canvas-acceleration",
                enable_2d_canvas_acceleration,
            ),
        }
    }

    /// Enable or disable horizontal swipe gesture for back-forward navigation.
    pub fn enable_back_forward_navigation_gestures(
        self,
        enable_back_forward_navigation_gestures: bool,
    ) -> Self {
        Self {
            builder: self.builder.property(
                "enable-back-forward-navigation-gestures",
                enable_back_forward_navigation_gestures,
            ),
        }
    }

    /// Whether to enable accessibility enhanced keyboard navigation.
    pub fn enable_caret_browsing(self, enable_caret_browsing: bool) -> Self {
        Self {
            builder: self
                .builder
                .property("enable-caret-browsing", enable_caret_browsing),
        }
    }

    /// Determines whether or not developer tools, such as the Web Inspector, are enabled.
    pub fn enable_developer_extras(self, enable_developer_extras: bool) -> Self {
        Self {
            builder: self
                .builder
                .property("enable-developer-extras", enable_developer_extras),
        }
    }

    /// Determines whether or not to prefetch domain names. DNS prefetching attempts
    /// to resolve domain names before a user tries to follow a link.
    #[cfg_attr(feature = "v2_48", deprecated = "Since 2.48")]
    pub fn enable_dns_prefetching(self, enable_dns_prefetching: bool) -> Self {
        Self {
            builder: self
                .builder
                .property("enable-dns-prefetching", enable_dns_prefetching),
        }
    }

    /// Enable or disable support for Encrypted Media API on pages.
    /// EncryptedMedia is an experimental JavaScript API for playing encrypted media in HTML.
    /// This property will only work as intended if the EncryptedMedia feature is enabled at build time
    /// with the ENABLE_ENCRYPTED_MEDIA flag.
    ///
    /// See https://www.w3.org/TR/encrypted-media/
    pub fn enable_encrypted_media(self, enable_encrypted_media: bool) -> Self {
        Self {
            builder: self
                .builder
                .property("enable-encrypted-media", enable_encrypted_media),
        }
    }

    /// Whether to enable the Javascript Fullscreen API. The API
    /// allows any HTML element to request fullscreen display. See also
    /// the current draft of the spec:
    /// http://www.w3.org/TR/fullscreen/
    pub fn enable_fullscreen(self, enable_fullscreen: bool) -> Self {
        Self {
            builder: self
                .builder
                .property("enable-fullscreen", enable_fullscreen),
        }
    }

    /// Whether to enable HTML5 client-side SQL database support (IndexedDB).
    pub fn enable_html5_database(self, enable_html5_database: bool) -> Self {
        Self {
            builder: self
                .builder
                .property("enable-html5-database", enable_html5_database),
        }
    }

    /// Whether to enable HTML5 local storage support. Local storage provides
    /// simple synchronous storage access.
    ///
    /// HTML5 local storage specification is available at
    /// http://dev.w3.org/html5/webstorage/.
    pub fn enable_html5_local_storage(self, enable_html5_local_storage: bool) -> Self {
        Self {
            builder: self
                .builder
                .property("enable-html5-local-storage", enable_html5_local_storage),
        }
    }

    /// Determines whether or not hyperlink auditing is enabled.
    ///
    /// The hyperlink auditing specification is available at
    /// http://www.whatwg.org/specs/web-apps/current-work/multipage/links.html`hyperlink`-auditing.
    #[cfg_attr(feature = "v2_50", deprecated = "Since 2.50")]
    pub fn enable_hyperlink_auditing(self, enable_hyperlink_auditing: bool) -> Self {
        Self {
            builder: self
                .builder
                .property("enable-hyperlink-auditing", enable_hyperlink_auditing),
        }
    }

    /// Determines whether or not JavaScript executes within a page.
    pub fn enable_javascript(self, enable_javascript: bool) -> Self {
        Self {
            builder: self
                .builder
                .property("enable-javascript", enable_javascript),
        }
    }

    /// Determines whether or not JavaScript markup is allowed in document. When this setting is disabled,
    /// all JavaScript-related elements and attributes are removed from the document during parsing. Note that
    /// executing JavaScript is still allowed if [`enable-javascript`][struct@crate::Settings#enable-javascript] is [`true`].
    pub fn enable_javascript_markup(self, enable_javascript_markup: bool) -> Self {
        Self {
            builder: self
                .builder
                .property("enable-javascript-markup", enable_javascript_markup),
        }
    }

    /// Enable or disable support for media playback on pages. This setting is enabled by
    /// default. Disabling it means ``<audio>``, ``<track>`` and ``<video>`` elements will have
    /// playback support disabled.
    pub fn enable_media(self, enable_media: bool) -> Self {
        Self {
            builder: self.builder.property("enable-media", enable_media),
        }
    }

    /// Enable or disable support for MediaCapabilities on pages. This
    /// specification intends to provide APIs to allow websites to make an optimal
    /// decision when picking media content for the user. The APIs will expose
    /// information about the decoding and encoding capabilities for a given format
    /// but also output capabilities to find the best match based on the device’s
    /// display.
    ///
    /// See also https://wicg.github.io/media-capabilities/
    pub fn enable_media_capabilities(self, enable_media_capabilities: bool) -> Self {
        Self {
            builder: self
                .builder
                .property("enable-media-capabilities", enable_media_capabilities),
        }
    }

    /// Enable or disable support for MediaStream on pages. MediaStream
    /// is an experimental proposal for allowing web pages to access
    /// audio and video devices for capture.
    ///
    /// See also http://dev.w3.org/2011/webrtc/editor/getusermedia.html
    pub fn enable_media_stream(self, enable_media_stream: bool) -> Self {
        Self {
            builder: self
                .builder
                .property("enable-media-stream", enable_media_stream),
        }
    }

    /// Enable or disable support for MediaSource on pages. MediaSource
    /// extends HTMLMediaElement to allow JavaScript to generate media
    /// streams for playback.
    ///
    /// See also http://www.w3.org/TR/media-source/
    pub fn enable_mediasource(self, enable_mediasource: bool) -> Self {
        Self {
            builder: self
                .builder
                .property("enable-mediasource", enable_mediasource),
        }
    }

    /// Enable or disable the Mock Capture Devices. Those are fake
    /// Microphone and Camera devices to be used as MediaStream
    /// sources.
    pub fn enable_mock_capture_devices(self, enable_mock_capture_devices: bool) -> Self {
        Self {
            builder: self
                .builder
                .property("enable-mock-capture-devices", enable_mock_capture_devices),
        }
    }

    /// Unsupported setting. This property does nothing.
    #[cfg_attr(feature = "v2_44", deprecated = "Since 2.44")]
    pub fn enable_offline_web_application_cache(
        self,
        enable_offline_web_application_cache: bool,
    ) -> Self {
        Self {
            builder: self.builder.property(
                "enable-offline-web-application-cache",
                enable_offline_web_application_cache,
            ),
        }
    }

    /// Enable or disable the page cache. Disabling the page cache is
    /// generally only useful for special circumstances like low-memory
    /// scenarios or special purpose applications like static HTML
    /// viewers. This setting only controls the Page Cache, this cache
    /// is different than the disk-based or memory-based traditional
    /// resource caches, its point is to make going back and forth
    /// between pages much faster. For details about the different types
    /// of caches and their purposes see:
    /// http://webkit.org/blog/427/webkit-page-cache-i-the-basics/
    pub fn enable_page_cache(self, enable_page_cache: bool) -> Self {
        Self {
            builder: self
                .builder
                .property("enable-page-cache", enable_page_cache),
        }
    }

    /// Determines whether or not text areas can be resized.
    pub fn enable_resizable_text_areas(self, enable_resizable_text_areas: bool) -> Self {
        Self {
            builder: self
                .builder
                .property("enable-resizable-text-areas", enable_resizable_text_areas),
        }
    }

    /// Whether to turn on site-specific quirks. Turning this on will
    /// tell WebKit to use some site-specific workarounds for
    /// better web compatibility. For example, older versions of
    /// MediaWiki will incorrectly send to WebKit a CSS file with KHTML
    /// workarounds. By turning on site-specific quirks, WebKit will
    /// special-case this and other cases to make some specific sites work.
    pub fn enable_site_specific_quirks(self, enable_site_specific_quirks: bool) -> Self {
        Self {
            builder: self
                .builder
                .property("enable-site-specific-quirks", enable_site_specific_quirks),
        }
    }

    /// Enable or disable smooth scrolling.
    pub fn enable_smooth_scrolling(self, enable_smooth_scrolling: bool) -> Self {
        Self {
            builder: self
                .builder
                .property("enable-smooth-scrolling", enable_smooth_scrolling),
        }
    }

    /// Whether to enable Spatial Navigation. This feature consists in the ability
    /// to navigate between focusable elements in a Web page, such as hyperlinks
    /// and form controls, by using Left, Right, Up and Down arrow keys.
    /// For example, if an user presses the Right key, heuristics determine whether
    /// there is an element they might be trying to reach towards the right, and if
    /// there are multiple elements, which element they probably wants.
    pub fn enable_spatial_navigation(self, enable_spatial_navigation: bool) -> Self {
        Self {
            builder: self
                .builder
                .property("enable-spatial-navigation", enable_spatial_navigation),
        }
    }

    /// Determines whether the tab key cycles through the elements on the page.
    /// When this setting is enabled, users will be able to focus the next element
    /// in the page by pressing the tab key. If the selected element is editable,
    /// then pressing tab key will insert the tab character.
    pub fn enable_tabs_to_links(self, enable_tabs_to_links: bool) -> Self {
        Self {
            builder: self
                .builder
                .property("enable-tabs-to-links", enable_tabs_to_links),
        }
    }

    /// Enable or disable support for WebAudio on pages. WebAudio is an
    /// API for processing and synthesizing audio in web applications
    ///
    /// See also https://webaudio.github.io/web-audio-api
    pub fn enable_webaudio(self, enable_webaudio: bool) -> Self {
        Self {
            builder: self.builder.property("enable-webaudio", enable_webaudio),
        }
    }

    /// Enable or disable support for WebGL on pages. WebGL enables web
    /// content to use an API based on OpenGL ES 2.0.
    pub fn enable_webgl(self, enable_webgl: bool) -> Self {
        Self {
            builder: self.builder.property("enable-webgl", enable_webgl),
        }
    }

    /// Enable WebRTC support for loaded pages.
    ///
    /// Enabling this setting implies that [property`Settings`]
    /// will be enabled as well.
    ///
    /// See also https://www.w3.org/TR/webrtc/
    pub fn enable_webrtc(self, enable_webrtc: bool) -> Self {
        Self {
            builder: self.builder.property("enable-webrtc", enable_webrtc),
        }
    }

    /// Enable or disable writing console messages to stdout. These are messages
    /// sent to the console with console.log and related methods.
    pub fn enable_write_console_messages_to_stdout(
        self,
        enable_write_console_messages_to_stdout: bool,
    ) -> Self {
        Self {
            builder: self.builder.property(
                "enable-write-console-messages-to-stdout",
                enable_write_console_messages_to_stdout,
            ),
        }
    }

    /// The font family used as the default for content using a fantasy font.
    pub fn fantasy_font_family(self, fantasy_font_family: impl Into<glib::GString>) -> Self {
        Self {
            builder: self
                .builder
                .property("fantasy-font-family", fantasy_font_family.into()),
        }
    }

    /// The [`HardwareAccelerationPolicy`][crate::HardwareAccelerationPolicy] to decide how to enable and disable
    /// hardware acceleration. Disabling hardware acceleration might
    /// cause some websites to not render correctly or consume more CPU.
    ///
    /// Note that changing this setting might not be possible if hardware acceleration is not
    /// supported by the hardware or the system. In that case, you can get the value to know the
    /// actual policy being used, but changing the setting will not have any effect.
    pub fn hardware_acceleration_policy(
        self,
        hardware_acceleration_policy: HardwareAccelerationPolicy,
    ) -> Self {
        Self {
            builder: self
                .builder
                .property("hardware-acceleration-policy", hardware_acceleration_policy),
        }
    }

    /// Whether JavaScript can access the clipboard. The default value is [`false`]. If
    /// set to [`true`], document.execCommand() allows cut, copy and paste commands.
    pub fn javascript_can_access_clipboard(self, javascript_can_access_clipboard: bool) -> Self {
        Self {
            builder: self.builder.property(
                "javascript-can-access-clipboard",
                javascript_can_access_clipboard,
            ),
        }
    }

    /// Whether JavaScript can open popup windows automatically without user
    /// intervention.
    pub fn javascript_can_open_windows_automatically(
        self,
        javascript_can_open_windows_automatically: bool,
    ) -> Self {
        Self {
            builder: self.builder.property(
                "javascript-can-open-windows-automatically",
                javascript_can_open_windows_automatically,
            ),
        }
    }

    /// Unsupported setting. This property does nothing.
    #[cfg_attr(feature = "v2_42", deprecated = "Since 2.42")]
    pub fn load_icons_ignoring_image_load_setting(
        self,
        load_icons_ignoring_image_load_setting: bool,
    ) -> Self {
        Self {
            builder: self.builder.property(
                "load-icons-ignoring-image-load-setting",
                load_icons_ignoring_image_load_setting,
            ),
        }
    }

    /// The font family used as the default for content using a math font.
    #[cfg(feature = "v2_52")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v2_52")))]
    pub fn math_font_family(self, math_font_family: impl Into<glib::GString>) -> Self {
        Self {
            builder: self
                .builder
                .property("math-font-family", math_font_family.into()),
        }
    }

    /// List of media content types requiring hardware support, split by semicolons (:).
    /// For example: 'video/webm; codecs="vp*":video/mp4; codecs="avc*":video/&ast; codecs="av1*"'.
    pub fn media_content_types_requiring_hardware_support(
        self,
        media_content_types_requiring_hardware_support: impl Into<glib::GString>,
    ) -> Self {
        Self {
            builder: self.builder.property(
                "media-content-types-requiring-hardware-support",
                media_content_types_requiring_hardware_support.into(),
            ),
        }
    }

    /// Whether media playback is full-screen only or inline playback is allowed.
    /// This is [`true`] by default, so media playback can be inline. Setting it to
    /// [`false`] allows specifying that media playback should be always fullscreen.
    pub fn media_playback_allows_inline(self, media_playback_allows_inline: bool) -> Self {
        Self {
            builder: self
                .builder
                .property("media-playback-allows-inline", media_playback_allows_inline),
        }
    }

    /// Whether a user gesture (such as clicking the play button)
    /// would be required to start media playback or load media. This is off
    /// by default, so media playback could start automatically.
    /// Setting it on requires a gesture by the user to start playback, or to
    /// load the media.
    pub fn media_playback_requires_user_gesture(
        self,
        media_playback_requires_user_gesture: bool,
    ) -> Self {
        Self {
            builder: self.builder.property(
                "media-playback-requires-user-gesture",
                media_playback_requires_user_gesture,
            ),
        }
    }

    /// The minimum font size in pixels used to display text. This setting
    /// controls the absolute smallest size. Values other than 0 can
    /// potentially break page layouts.
    pub fn minimum_font_size(self, minimum_font_size: u32) -> Self {
        Self {
            builder: self
                .builder
                .property("minimum-font-size", minimum_font_size),
        }
    }

    /// The font family used as the default for content using a monospace font.
    pub fn monospace_font_family(self, monospace_font_family: impl Into<glib::GString>) -> Self {
        Self {
            builder: self
                .builder
                .property("monospace-font-family", monospace_font_family.into()),
        }
    }

    /// The font family used as the default for content using a pictograph font.
    pub fn pictograph_font_family(self, pictograph_font_family: impl Into<glib::GString>) -> Self {
        Self {
            builder: self
                .builder
                .property("pictograph-font-family", pictograph_font_family.into()),
        }
    }

    /// Whether background images should be drawn during printing.
    pub fn print_backgrounds(self, print_backgrounds: bool) -> Self {
        Self {
            builder: self
                .builder
                .property("print-backgrounds", print_backgrounds),
        }
    }

    /// The font family used as the default for content using a sans-serif font.
    pub fn sans_serif_font_family(self, sans_serif_font_family: impl Into<glib::GString>) -> Self {
        Self {
            builder: self
                .builder
                .property("sans-serif-font-family", sans_serif_font_family.into()),
        }
    }

    /// The font family used as the default for content using a serif font.
    pub fn serif_font_family(self, serif_font_family: impl Into<glib::GString>) -> Self {
        Self {
            builder: self
                .builder
                .property("serif-font-family", serif_font_family.into()),
        }
    }

    /// The user-agent string used by WebKit. Unusual user-agent strings may cause web
    /// content to render incorrectly or fail to run, as many web pages are written to
    /// parse the user-agent strings of only the most popular browsers. Therefore, it's
    /// typically better to not completely override the standard user-agent, but to use
    /// [`Settings::set_user_agent_with_application_details()`][crate::Settings::set_user_agent_with_application_details()] instead.
    ///
    /// If this property is set to the empty string or [`None`], it will revert to the standard
    /// user-agent.
    pub fn user_agent(self, user_agent: impl Into<glib::GString>) -> Self {
        Self {
            builder: self.builder.property("user-agent", user_agent.into()),
        }
    }

    /// Allow customization of the WebRTC UDP ports range.
    ///
    /// In some constrained environments where a firewall blocks UDP network traffic excepted on a
    /// specific port range, this settings can be used to give hints to the WebRTC backend regarding
    /// which ports to allocate. The format is min-port:max-port, so for instance 20000:30000. The
    /// default empty string value means the OS will use no hints from the WebRTC backend. Using 0
    /// for one of the values is allowed and means the value is unspecified.
    #[cfg(feature = "v2_48")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v2_48")))]
    pub fn webrtc_udp_ports_range(self, webrtc_udp_ports_range: impl Into<glib::GString>) -> Self {
        Self {
            builder: self
                .builder
                .property("webrtc-udp-ports-range", webrtc_udp_ports_range.into()),
        }
    }

    /// Whether [`zoom-level`][struct@crate::WebView#zoom-level] affects only the
    /// text of the page or all the contents. Other contents containing text
    /// like form controls will be also affected by zoom factor when
    /// this property is enabled.
    pub fn zoom_text_only(self, zoom_text_only: bool) -> Self {
        Self {
            builder: self.builder.property("zoom-text-only", zoom_text_only),
        }
    }

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