gtk/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)
// DO NOT EDIT

use crate::{StyleProvider, ffi};
use glib::{
    prelude::*,
    signal::{SignalHandlerId, connect_raw},
    translate::*,
};
use std::boxed::Box as Box_;

glib::wrapper! {
    /// GtkSettings provide a mechanism to share global settings between
    /// applications.
    ///
    /// On the X window system, this sharing is realized by an
    /// [XSettings](http://www.freedesktop.org/wiki/Specifications/xsettings-spec)
    /// manager that is usually part of the desktop environment, along with
    /// utilities that let the user change these settings. In the absence of
    /// an Xsettings manager, GTK+ reads default values for settings from
    /// `settings.ini` files in
    /// `/etc/gtk-3.0`, `$XDG_CONFIG_DIRS/gtk-3.0`
    /// and `$XDG_CONFIG_HOME/gtk-3.0`.
    /// These files must be valid key files (see [`glib::KeyFile`][crate::glib::KeyFile]), and have
    /// a section called Settings. Themes can also provide default values
    /// for settings by installing a `settings.ini` file
    /// next to their `gtk.css` file.
    ///
    /// Applications can override system-wide settings by setting the property
    /// of the GtkSettings object with [`ObjectExt::set()`][crate::glib::prelude::ObjectExt::set()]. This should be restricted
    /// to special cases though; GtkSettings are not meant as an application
    /// configuration facility. When doing so, you need to be aware that settings
    /// that are specific to individual widgets may not be available before the
    /// widget type has been realized at least once. The following example
    /// demonstrates a way to do this:
    ///
    ///
    /// **⚠️ The following code is in C ⚠️**
    ///
    /// ```C
    ///   gtk_init (&argc, &argv);
    ///
    ///   // make sure the type is realized
    ///   g_type_class_unref (g_type_class_ref (GTK_TYPE_IMAGE_MENU_ITEM));
    ///
    ///   g_object_set (gtk_settings_get_default (), "gtk-enable-animations", FALSE, NULL);
    /// ```
    ///
    /// There is one GtkSettings instance per screen. It can be obtained with
    /// [`for_screen()`][Self::for_screen()], but in many cases, it is more convenient
    /// to use [`WidgetExt::settings()`][crate::prelude::WidgetExt::settings()]. [`default()`][Self::default()] returns the
    /// GtkSettings instance for the default screen.
    ///
    /// ## Properties
    ///
    ///
    /// #### `color-hash`
    ///  Holds a hash table representation of the [`gtk-color-scheme`][struct@crate::Settings#gtk-color-scheme]
    /// setting, mapping color names to `GdkColors`.
    ///
    /// Readable
    ///
    ///
    /// #### `gtk-alternative-button-order`
    ///  Readable | Writable
    ///
    ///
    /// #### `gtk-alternative-sort-arrows`
    ///  Controls the direction of the sort indicators in sorted list and tree
    /// views. By default an arrow pointing down means the column is sorted
    /// in ascending order. When set to [`true`], this order will be inverted.
    ///
    /// Readable | Writable
    ///
    ///
    /// #### `gtk-application-prefer-dark-theme`
    ///  Whether the application prefers to use a dark theme. If a GTK+ theme
    /// includes a dark variant, it will be used instead of the configured
    /// theme.
    ///
    /// Some applications benefit from minimizing the amount of light pollution that
    /// interferes with the content. Good candidates for dark themes are photo and
    /// video editors that make the actual content get all the attention and minimize
    /// the distraction of the chrome.
    ///
    /// Dark themes should not be used for documents, where large spaces are white/light
    /// and the dark chrome creates too much contrast (web browser, text editor...).
    ///
    /// Readable | Writable
    ///
    ///
    /// #### `gtk-auto-mnemonics`
    ///  Whether mnemonics should be automatically shown and hidden when the user
    /// presses the mnemonic activator.
    ///
    /// Readable | Writable
    ///
    ///
    /// #### `gtk-button-images`
    ///  Whether images should be shown on buttons
    ///
    /// Readable | Writable
    ///
    ///
    /// #### `gtk-can-change-accels`
    ///  Whether menu accelerators can be changed by pressing a key over the menu item.
    ///
    /// Readable | Writable
    ///
    ///
    /// #### `gtk-color-palette`
    ///  Palette to use in the deprecated color selector.
    ///
    /// Readable | Writable
    ///
    ///
    /// #### `gtk-color-scheme`
    ///  A palette of named colors for use in themes. The format of the string is
    ///
    /// ```text
    /// name1: color1
    /// name2: color2
    /// ...
    /// ```
    /// Color names must be acceptable as identifiers in the
    /// [gtkrc][gtk3-Resource-Files] syntax, and
    /// color specifications must be in the format accepted by
    /// `gdk_color_parse()`.
    ///
    /// Note that due to the way the color tables from different sources are
    /// merged, color specifications will be converted to hexadecimal form
    /// when getting this property.
    ///
    /// Starting with GTK+ 2.12, the entries can alternatively be separated
    /// by ';' instead of newlines:
    ///
    /// ```text
    /// name1: color1; name2: color2; ...
    /// ```
    ///
    /// Readable | Writable
    ///
    ///
    /// #### `gtk-cursor-aspect-ratio`
    ///  Readable | Writable
    ///
    ///
    /// #### `gtk-cursor-blink`
    ///  Whether the cursor should blink.
    ///
    /// Also see the [`gtk-cursor-blink-timeout`][struct@crate::Settings#gtk-cursor-blink-timeout] setting,
    /// which allows more flexible control over cursor blinking.
    ///
    /// Readable | Writable
    ///
    ///
    /// #### `gtk-cursor-blink-time`
    ///  Readable | Writable
    ///
    ///
    /// #### `gtk-cursor-blink-timeout`
    ///  Time after which the cursor stops blinking, in seconds.
    /// The timer is reset after each user interaction.
    ///
    /// Setting this to zero has the same effect as setting
    /// [`gtk-cursor-blink`][struct@crate::Settings#gtk-cursor-blink] to [`false`].
    ///
    /// Readable | Writable
    ///
    ///
    /// #### `gtk-cursor-theme-name`
    ///  Readable | Writable
    ///
    ///
    /// #### `gtk-cursor-theme-size`
    ///  Readable | Writable
    ///
    ///
    /// #### `gtk-decoration-layout`
    ///  This setting determines which buttons should be put in the
    /// titlebar of client-side decorated windows, and whether they
    /// should be placed at the left of right.
    ///
    /// The format of the string is button names, separated by commas.
    /// A colon separates the buttons that should appear on the left
    /// from those on the right. Recognized button names are minimize,
    /// maximize, close, icon (the window icon) and menu (a menu button
    /// for the fallback app menu).
    ///
    /// For example, "menu:minimize,maximize,close" specifies a menu
    /// on the left, and minimize, maximize and close buttons on the right.
    ///
    /// Note that buttons will only be shown when they are meaningful.
    /// E.g. a menu button only appears when the desktop shell does not
    /// show the app menu, and a close button only appears on a window
    /// that can be closed.
    ///
    /// Also note that the setting can be overridden with the
    /// [`decoration-layout`][struct@crate::HeaderBar#decoration-layout] property.
    ///
    /// Readable | Writable
    ///
    ///
    /// #### `gtk-dialogs-use-header`
    ///  Whether builtin GTK+ dialogs such as the file chooser, the
    /// color chooser or the font chooser will use a header bar at
    /// the top to show action widgets, or an action area at the bottom.
    ///
    /// This setting does not affect custom dialogs using GtkDialog
    /// directly, or message dialogs.
    ///
    /// Readable | Writable
    ///
    ///
    /// #### `gtk-dnd-drag-threshold`
    ///  Readable | Writable
    ///
    ///
    /// #### `gtk-double-click-distance`
    ///  Readable | Writable
    ///
    ///
    /// #### `gtk-double-click-time`
    ///  Readable | Writable
    ///
    ///
    /// #### `gtk-enable-accels`
    ///  Whether menu items should have visible accelerators which can be
    /// activated.
    ///
    /// Readable | Writable
    ///
    ///
    /// #### `gtk-enable-animations`
    ///  Readable | Writable
    ///
    ///
    /// #### `gtk-enable-event-sounds`
    ///  Whether to play any event sounds at all.
    ///
    /// See the [Sound Theme Specifications](http://www.freedesktop.org/wiki/Specifications/sound-theme-spec)
    /// for more information on event sounds and sound themes.
    ///
    /// GTK+ itself does not support event sounds, you have to use a loadable
    /// module like the one that comes with libcanberra.
    ///
    /// Readable | Writable
    ///
    ///
    /// #### `gtk-enable-input-feedback-sounds`
    ///  Whether to play event sounds as feedback to user input.
    ///
    /// See the [Sound Theme Specifications](http://www.freedesktop.org/wiki/Specifications/sound-theme-spec)
    /// for more information on event sounds and sound themes.
    ///
    /// GTK+ itself does not support event sounds, you have to use a loadable
    /// module like the one that comes with libcanberra.
    ///
    /// Readable | Writable
    ///
    ///
    /// #### `gtk-enable-mnemonics`
    ///  Whether labels and menu items should have visible mnemonics which
    /// can be activated.
    ///
    /// Readable | Writable
    ///
    ///
    /// #### `gtk-enable-primary-paste`
    ///  Whether a middle click on a mouse should paste the
    /// 'PRIMARY' clipboard content at the cursor location.
    ///
    /// Readable | Writable
    ///
    ///
    /// #### `gtk-enable-tooltips`
    ///  Whether tooltips should be shown on widgets.
    ///
    /// Readable | Writable
    ///
    ///
    /// #### `gtk-entry-password-hint-timeout`
    ///  How long to show the last input character in hidden
    /// entries. This value is in milliseconds. 0 disables showing the
    /// last char. 600 is a good value for enabling it.
    ///
    /// Readable | Writable
    ///
    ///
    /// #### `gtk-entry-select-on-focus`
    ///  Readable | Writable
    ///
    ///
    /// #### `gtk-error-bell`
    ///  When [`true`], keyboard navigation and other input-related errors
    /// will cause a beep. Since the error bell is implemented using
    /// [`Window::beep()`][crate::gdk::Window::beep()], the windowing system may offer ways to
    /// configure the error bell in many ways, such as flashing the
    /// window or similar visual effects.
    ///
    /// Readable | Writable
    ///
    ///
    /// #### `gtk-fallback-icon-theme`
    ///  Name of a icon theme to fall back to.
    ///
    /// Readable | Writable
    ///
    ///
    /// #### `gtk-file-chooser-backend`
    ///  Name of the GtkFileChooser backend to use by default.
    ///
    /// Readable | Writable
    ///
    ///
    /// #### `gtk-font-name`
    ///  The default font to use. GTK+ uses the family name and size from this string.
    ///
    /// Readable | Writable
    ///
    ///
    /// #### `gtk-fontconfig-timestamp`
    ///  Readable | Writable
    ///
    ///
    /// #### `gtk-icon-sizes`
    ///  A list of icon sizes. The list is separated by colons, and
    /// item has the form:
    ///
    /// `size-name` = `width` , `height`
    ///
    /// E.g. "gtk-menu=16,16:gtk-button=20,20:gtk-dialog=48,48".
    /// GTK+ itself use the following named icon sizes: gtk-menu,
    /// gtk-button, gtk-small-toolbar, gtk-large-toolbar, gtk-dnd,
    /// gtk-dialog. Applications can register their own named icon
    /// sizes with `gtk_icon_size_register()`.
    ///
    /// Readable | Writable
    ///
    ///
    /// #### `gtk-icon-theme-name`
    ///  Readable | Writable
    ///
    ///
    /// #### `gtk-im-module`
    ///  Which IM (input method) module should be used by default. This is the
    /// input method that will be used if the user has not explicitly chosen
    /// another input method from the IM context menu.
    /// This also can be a colon-separated list of input methods, which GTK+
    /// will try in turn until it finds one available on the system.
    ///
    /// See [`IMContext`][crate::IMContext].
    ///
    /// Readable | Writable
    ///
    ///
    /// #### `gtk-im-preedit-style`
    ///  How to draw the input method preedit string.
    ///
    /// Readable | Writable
    ///
    ///
    /// #### `gtk-im-status-style`
    ///  How to draw the input method statusbar.
    ///
    /// Readable | Writable
    ///
    ///
    /// #### `gtk-key-theme-name`
    ///  Readable | Writable
    ///
    ///
    /// #### `gtk-keynav-cursor-only`
    ///  When [`true`], keyboard navigation should be able to reach all widgets
    /// by using the cursor keys only. Tab, Shift etc. keys can't be expected
    /// to be present on the used input device.
    ///
    /// Readable | Writable
    ///
    ///
    /// #### `gtk-keynav-use-caret`
    ///  Whether GTK+ should make sure that text can be navigated with
    /// a caret, even if it is not editable. This is useful when using
    /// a screen reader.
    ///
    /// Readable | Writable
    ///
    ///
    /// #### `gtk-keynav-wrap-around`
    ///  When [`true`], some widgets will wrap around when doing keyboard
    /// navigation, such as menus, menubars and notebooks.
    ///
    /// Readable | Writable
    ///
    ///
    /// #### `gtk-label-select-on-focus`
    ///  Readable | Writable
    ///
    ///
    /// #### `gtk-long-press-time`
    ///  The time for a button or touch press to be considered a "long press".
    ///
    /// Readable | Writable
    ///
    ///
    /// #### `gtk-menu-bar-accel`
    ///  Keybinding to activate the menu bar.
    ///
    /// Readable | Writable
    ///
    ///
    /// #### `gtk-menu-bar-popup-delay`
    ///  Delay before the submenus of a menu bar appear.
    ///
    /// Readable | Writable
    ///
    ///
    /// #### `gtk-menu-images`
    ///  Whether images should be shown in menu items
    ///
    /// Readable | Writable
    ///
    ///
    /// #### `gtk-menu-popdown-delay`
    ///  The time before hiding a submenu when the pointer is moving towards the submenu.
    ///
    /// Readable | Writable
    ///
    ///
    /// #### `gtk-menu-popup-delay`
    ///  Minimum time the pointer must stay over a menu item before the submenu appear.
    ///
    /// Readable | Writable
    ///
    ///
    /// #### `gtk-modules`
    ///  Readable | Writable
    ///
    ///
    /// #### `gtk-overlay-scrolling`
    ///  Whether scrolled windows may use overlayed scrolling indicators.
    /// If this is set to [`false`], scrolled windows will have permanent
    /// scrollbars.
    ///
    /// Readable | Writable
    ///
    ///
    /// #### `gtk-primary-button-warps-slider`
    ///  If the value of this setting is [`true`], clicking the primary button in a
    /// [`Range`][crate::Range] trough will move the slider, and hence set the range’s value, to
    /// the point that you clicked. If it is [`false`], a primary click will cause the
    /// slider/value to move by the range’s page-size towards the point clicked.
    ///
    /// Whichever action you choose for the primary button, the other action will
    /// be available by holding Shift and primary-clicking, or (since GTK+ 3.22.25)
    /// clicking the middle mouse button.
    ///
    /// Readable | Writable
    ///
    ///
    /// #### `gtk-print-backends`
    ///  A comma-separated list of print backends to use in the print
    /// dialog. Available print backends depend on the GTK+ installation,
    /// and may include "file", "cups", "lpr" or "papi".
    ///
    /// Readable | Writable
    ///
    ///
    /// #### `gtk-print-preview-command`
    ///  A command to run for displaying the print preview. The command
    /// should contain a ``f`` placeholder, which will get replaced by
    /// the path to the pdf file. The command may also contain a ``s``
    /// placeholder, which will get replaced by the path to a file
    /// containing the print settings in the format produced by
    /// [`PrintSettings::to_file()`][crate::PrintSettings::to_file()].
    ///
    /// The preview application is responsible for removing the pdf file
    /// and the print settings file when it is done.
    ///
    /// Readable | Writable
    ///
    ///
    /// #### `gtk-recent-files-enabled`
    ///  Whether GTK+ should keep track of items inside the recently used
    /// resources list. If set to [`false`], the list will always be empty.
    ///
    /// Readable | Writable
    ///
    ///
    /// #### `gtk-recent-files-limit`
    ///  The number of recently used files that should be displayed by default by
    /// [`RecentChooser`][crate::RecentChooser] implementations and by the [`FileChooser`][crate::FileChooser]. A value of
    /// -1 means every recently used file stored.
    ///
    /// Readable | Writable
    ///
    ///
    /// #### `gtk-recent-files-max-age`
    ///  The maximum age, in days, of the items inside the recently used
    /// resources list. Items older than this setting will be excised
    /// from the list. If set to 0, the list will always be empty; if
    /// set to -1, no item will be removed.
    ///
    /// Readable | Writable
    ///
    ///
    /// #### `gtk-scrolled-window-placement`
    ///  Where the contents of scrolled windows are located with respect to the
    /// scrollbars, if not overridden by the scrolled window's own placement.
    ///
    /// Readable | Writable
    ///
    ///
    /// #### `gtk-shell-shows-app-menu`
    ///  Readable | Writable
    ///
    ///
    /// #### `gtk-shell-shows-desktop`
    ///  Readable | Writable
    ///
    ///
    /// #### `gtk-shell-shows-menubar`
    ///  Readable | Writable
    ///
    ///
    /// #### `gtk-show-input-method-menu`
    ///  Readable | Writable
    ///
    ///
    /// #### `gtk-show-unicode-menu`
    ///  Readable | Writable
    ///
    ///
    /// #### `gtk-sound-theme-name`
    ///  The XDG sound theme to use for event sounds.
    ///
    /// See the [Sound Theme Specifications](http://www.freedesktop.org/wiki/Specifications/sound-theme-spec)
    /// for more information on event sounds and sound themes.
    ///
    /// GTK+ itself does not support event sounds, you have to use a loadable
    /// module like the one that comes with libcanberra.
    ///
    /// Readable | Writable
    ///
    ///
    /// #### `gtk-split-cursor`
    ///  Readable | Writable
    ///
    ///
    /// #### `gtk-theme-name`
    ///  Readable | Writable
    ///
    ///
    /// #### `gtk-timeout-expand`
    ///  Readable | Writable
    ///
    ///
    /// #### `gtk-timeout-initial`
    ///  Readable | Writable
    ///
    ///
    /// #### `gtk-timeout-repeat`
    ///  Readable | Writable
    ///
    ///
    /// #### `gtk-titlebar-double-click`
    ///  This setting determines the action to take when a double-click
    /// occurs on the titlebar of client-side decorated windows.
    ///
    /// Recognized actions are minimize, toggle-maximize, menu, lower
    /// or none.
    ///
    /// Readable | Writable
    ///
    ///
    /// #### `gtk-titlebar-middle-click`
    ///  This setting determines the action to take when a middle-click
    /// occurs on the titlebar of client-side decorated windows.
    ///
    /// Recognized actions are minimize, toggle-maximize, menu, lower
    /// or none.
    ///
    /// Readable | Writable
    ///
    ///
    /// #### `gtk-titlebar-right-click`
    ///  This setting determines the action to take when a right-click
    /// occurs on the titlebar of client-side decorated windows.
    ///
    /// Recognized actions are minimize, toggle-maximize, menu, lower
    /// or none.
    ///
    /// Readable | Writable
    ///
    ///
    /// #### `gtk-toolbar-icon-size`
    ///  The size of icons in default toolbars.
    ///
    /// Readable | Writable
    ///
    ///
    /// #### `gtk-toolbar-style`
    ///  The size of icons in default toolbars.
    ///
    /// Readable | Writable
    ///
    ///
    /// #### `gtk-tooltip-browse-mode-timeout`
    ///  Amount of time, in milliseconds, after which the browse mode
    /// will be disabled.
    ///
    /// See [`gtk-tooltip-browse-timeout`][struct@crate::Settings#gtk-tooltip-browse-timeout] for more information
    /// about browse mode.
    ///
    /// Readable | Writable
    ///
    ///
    /// #### `gtk-tooltip-browse-timeout`
    ///  Controls the time after which tooltips will appear when
    /// browse mode is enabled, in milliseconds.
    ///
    /// Browse mode is enabled when the mouse pointer moves off an object
    /// where a tooltip was currently being displayed. If the mouse pointer
    /// hits another object before the browse mode timeout expires (see
    /// [`gtk-tooltip-browse-mode-timeout`][struct@crate::Settings#gtk-tooltip-browse-mode-timeout]), it will take the
    /// amount of milliseconds specified by this setting to popup the tooltip
    /// for the new object.
    ///
    /// Readable | Writable
    ///
    ///
    /// #### `gtk-tooltip-timeout`
    ///  Time, in milliseconds, after which a tooltip could appear if the
    /// cursor is hovering on top of a widget.
    ///
    /// Readable | Writable
    ///
    ///
    /// #### `gtk-touchscreen-mode`
    ///  When [`true`], there are no motion notify events delivered on this screen,
    /// and widgets can't use the pointer hovering them for any essential
    /// functionality.
    ///
    /// Readable | Writable
    ///
    ///
    /// #### `gtk-visible-focus`
    ///  Whether 'focus rectangles' should be always visible, never visible,
    /// or hidden until the user starts to use the keyboard.
    ///
    /// Readable | Writable
    ///
    ///
    /// #### `gtk-xft-antialias`
    ///  Readable | Writable
    ///
    ///
    /// #### `gtk-xft-dpi`
    ///  Readable | Writable
    ///
    ///
    /// #### `gtk-xft-hinting`
    ///  Readable | Writable
    ///
    ///
    /// #### `gtk-xft-hintstyle`
    ///  Readable | Writable
    ///
    ///
    /// #### `gtk-xft-rgba`
    ///  Readable | Writable
    ///
    /// # Implements
    ///
    /// [`GtkSettingsExt`][trait@crate::prelude::GtkSettingsExt], [`trait@glib::ObjectExt`], [`StyleProviderExt`][trait@crate::prelude::StyleProviderExt]
    #[doc(alias = "GtkSettings")]
    pub struct Settings(Object<ffi::GtkSettings, ffi::GtkSettingsClass>) @implements StyleProvider;

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

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

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

    /// Gets the [`Settings`][crate::Settings] object for the default GDK screen, creating
    /// it if necessary. See [`for_screen()`][Self::for_screen()].
    ///
    /// # Returns
    ///
    /// a [`Settings`][crate::Settings] object. If there is
    /// no default screen, then returns [`None`].
    #[doc(alias = "gtk_settings_get_default")]
    #[doc(alias = "get_default")]
    #[allow(clippy::should_implement_trait)]
    pub fn default() -> Option<Settings> {
        assert_initialized_main_thread!();
        unsafe { from_glib_none(ffi::gtk_settings_get_default()) }
    }

    /// Gets the [`Settings`][crate::Settings] object for `screen`, creating it if necessary.
    /// ## `screen`
    /// a [`gdk::Screen`][crate::gdk::Screen].
    ///
    /// # Returns
    ///
    /// a [`Settings`][crate::Settings] object.
    #[doc(alias = "gtk_settings_get_for_screen")]
    #[doc(alias = "get_for_screen")]
    pub fn for_screen(screen: &gdk::Screen) -> Option<Settings> {
        assert_initialized_main_thread!();
        unsafe { from_glib_none(ffi::gtk_settings_get_for_screen(screen.to_glib_none().0)) }
    }
}

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

    pub fn gtk_alternative_button_order(self, gtk_alternative_button_order: bool) -> Self {
        Self {
            builder: self
                .builder
                .property("gtk-alternative-button-order", gtk_alternative_button_order),
        }
    }

    /// Controls the direction of the sort indicators in sorted list and tree
    /// views. By default an arrow pointing down means the column is sorted
    /// in ascending order. When set to [`true`], this order will be inverted.
    pub fn gtk_alternative_sort_arrows(self, gtk_alternative_sort_arrows: bool) -> Self {
        Self {
            builder: self
                .builder
                .property("gtk-alternative-sort-arrows", gtk_alternative_sort_arrows),
        }
    }

    /// Whether the application prefers to use a dark theme. If a GTK+ theme
    /// includes a dark variant, it will be used instead of the configured
    /// theme.
    ///
    /// Some applications benefit from minimizing the amount of light pollution that
    /// interferes with the content. Good candidates for dark themes are photo and
    /// video editors that make the actual content get all the attention and minimize
    /// the distraction of the chrome.
    ///
    /// Dark themes should not be used for documents, where large spaces are white/light
    /// and the dark chrome creates too much contrast (web browser, text editor...).
    pub fn gtk_application_prefer_dark_theme(
        self,
        gtk_application_prefer_dark_theme: bool,
    ) -> Self {
        Self {
            builder: self.builder.property(
                "gtk-application-prefer-dark-theme",
                gtk_application_prefer_dark_theme,
            ),
        }
    }

    #[cfg(feature = "v3_24")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v3_24")))]
    pub fn gtk_cursor_aspect_ratio(self, gtk_cursor_aspect_ratio: f32) -> Self {
        Self {
            builder: self
                .builder
                .property("gtk-cursor-aspect-ratio", gtk_cursor_aspect_ratio),
        }
    }

    /// Whether the cursor should blink.
    ///
    /// Also see the [`gtk-cursor-blink-timeout`][struct@crate::Settings#gtk-cursor-blink-timeout] setting,
    /// which allows more flexible control over cursor blinking.
    pub fn gtk_cursor_blink(self, gtk_cursor_blink: bool) -> Self {
        Self {
            builder: self.builder.property("gtk-cursor-blink", gtk_cursor_blink),
        }
    }

    pub fn gtk_cursor_blink_time(self, gtk_cursor_blink_time: i32) -> Self {
        Self {
            builder: self
                .builder
                .property("gtk-cursor-blink-time", gtk_cursor_blink_time),
        }
    }

    /// Time after which the cursor stops blinking, in seconds.
    /// The timer is reset after each user interaction.
    ///
    /// Setting this to zero has the same effect as setting
    /// [`gtk-cursor-blink`][struct@crate::Settings#gtk-cursor-blink] to [`false`].
    pub fn gtk_cursor_blink_timeout(self, gtk_cursor_blink_timeout: i32) -> Self {
        Self {
            builder: self
                .builder
                .property("gtk-cursor-blink-timeout", gtk_cursor_blink_timeout),
        }
    }

    pub fn gtk_cursor_theme_name(self, gtk_cursor_theme_name: impl Into<glib::GString>) -> Self {
        Self {
            builder: self
                .builder
                .property("gtk-cursor-theme-name", gtk_cursor_theme_name.into()),
        }
    }

    pub fn gtk_cursor_theme_size(self, gtk_cursor_theme_size: i32) -> Self {
        Self {
            builder: self
                .builder
                .property("gtk-cursor-theme-size", gtk_cursor_theme_size),
        }
    }

    /// This setting determines which buttons should be put in the
    /// titlebar of client-side decorated windows, and whether they
    /// should be placed at the left of right.
    ///
    /// The format of the string is button names, separated by commas.
    /// A colon separates the buttons that should appear on the left
    /// from those on the right. Recognized button names are minimize,
    /// maximize, close, icon (the window icon) and menu (a menu button
    /// for the fallback app menu).
    ///
    /// For example, "menu:minimize,maximize,close" specifies a menu
    /// on the left, and minimize, maximize and close buttons on the right.
    ///
    /// Note that buttons will only be shown when they are meaningful.
    /// E.g. a menu button only appears when the desktop shell does not
    /// show the app menu, and a close button only appears on a window
    /// that can be closed.
    ///
    /// Also note that the setting can be overridden with the
    /// [`decoration-layout`][struct@crate::HeaderBar#decoration-layout] property.
    pub fn gtk_decoration_layout(self, gtk_decoration_layout: impl Into<glib::GString>) -> Self {
        Self {
            builder: self
                .builder
                .property("gtk-decoration-layout", gtk_decoration_layout.into()),
        }
    }

    /// Whether builtin GTK+ dialogs such as the file chooser, the
    /// color chooser or the font chooser will use a header bar at
    /// the top to show action widgets, or an action area at the bottom.
    ///
    /// This setting does not affect custom dialogs using GtkDialog
    /// directly, or message dialogs.
    pub fn gtk_dialogs_use_header(self, gtk_dialogs_use_header: bool) -> Self {
        Self {
            builder: self
                .builder
                .property("gtk-dialogs-use-header", gtk_dialogs_use_header),
        }
    }

    pub fn gtk_dnd_drag_threshold(self, gtk_dnd_drag_threshold: i32) -> Self {
        Self {
            builder: self
                .builder
                .property("gtk-dnd-drag-threshold", gtk_dnd_drag_threshold),
        }
    }

    pub fn gtk_double_click_distance(self, gtk_double_click_distance: i32) -> Self {
        Self {
            builder: self
                .builder
                .property("gtk-double-click-distance", gtk_double_click_distance),
        }
    }

    pub fn gtk_double_click_time(self, gtk_double_click_time: i32) -> Self {
        Self {
            builder: self
                .builder
                .property("gtk-double-click-time", gtk_double_click_time),
        }
    }

    /// Whether menu items should have visible accelerators which can be
    /// activated.
    pub fn gtk_enable_accels(self, gtk_enable_accels: bool) -> Self {
        Self {
            builder: self
                .builder
                .property("gtk-enable-accels", gtk_enable_accels),
        }
    }

    pub fn gtk_enable_animations(self, gtk_enable_animations: bool) -> Self {
        Self {
            builder: self
                .builder
                .property("gtk-enable-animations", gtk_enable_animations),
        }
    }

    /// Whether to play any event sounds at all.
    ///
    /// See the [Sound Theme Specifications](http://www.freedesktop.org/wiki/Specifications/sound-theme-spec)
    /// for more information on event sounds and sound themes.
    ///
    /// GTK+ itself does not support event sounds, you have to use a loadable
    /// module like the one that comes with libcanberra.
    pub fn gtk_enable_event_sounds(self, gtk_enable_event_sounds: bool) -> Self {
        Self {
            builder: self
                .builder
                .property("gtk-enable-event-sounds", gtk_enable_event_sounds),
        }
    }

    /// Whether to play event sounds as feedback to user input.
    ///
    /// See the [Sound Theme Specifications](http://www.freedesktop.org/wiki/Specifications/sound-theme-spec)
    /// for more information on event sounds and sound themes.
    ///
    /// GTK+ itself does not support event sounds, you have to use a loadable
    /// module like the one that comes with libcanberra.
    pub fn gtk_enable_input_feedback_sounds(self, gtk_enable_input_feedback_sounds: bool) -> Self {
        Self {
            builder: self.builder.property(
                "gtk-enable-input-feedback-sounds",
                gtk_enable_input_feedback_sounds,
            ),
        }
    }

    /// Whether a middle click on a mouse should paste the
    /// 'PRIMARY' clipboard content at the cursor location.
    pub fn gtk_enable_primary_paste(self, gtk_enable_primary_paste: bool) -> Self {
        Self {
            builder: self
                .builder
                .property("gtk-enable-primary-paste", gtk_enable_primary_paste),
        }
    }

    /// How long to show the last input character in hidden
    /// entries. This value is in milliseconds. 0 disables showing the
    /// last char. 600 is a good value for enabling it.
    pub fn gtk_entry_password_hint_timeout(self, gtk_entry_password_hint_timeout: u32) -> Self {
        Self {
            builder: self.builder.property(
                "gtk-entry-password-hint-timeout",
                gtk_entry_password_hint_timeout,
            ),
        }
    }

    pub fn gtk_entry_select_on_focus(self, gtk_entry_select_on_focus: bool) -> Self {
        Self {
            builder: self
                .builder
                .property("gtk-entry-select-on-focus", gtk_entry_select_on_focus),
        }
    }

    /// When [`true`], keyboard navigation and other input-related errors
    /// will cause a beep. Since the error bell is implemented using
    /// [`Window::beep()`][crate::gdk::Window::beep()], the windowing system may offer ways to
    /// configure the error bell in many ways, such as flashing the
    /// window or similar visual effects.
    pub fn gtk_error_bell(self, gtk_error_bell: bool) -> Self {
        Self {
            builder: self.builder.property("gtk-error-bell", gtk_error_bell),
        }
    }

    /// The default font to use. GTK+ uses the family name and size from this string.
    pub fn gtk_font_name(self, gtk_font_name: impl Into<glib::GString>) -> Self {
        Self {
            builder: self.builder.property("gtk-font-name", gtk_font_name.into()),
        }
    }

    pub fn gtk_fontconfig_timestamp(self, gtk_fontconfig_timestamp: u32) -> Self {
        Self {
            builder: self
                .builder
                .property("gtk-fontconfig-timestamp", gtk_fontconfig_timestamp),
        }
    }

    pub fn gtk_icon_theme_name(self, gtk_icon_theme_name: impl Into<glib::GString>) -> Self {
        Self {
            builder: self
                .builder
                .property("gtk-icon-theme-name", gtk_icon_theme_name.into()),
        }
    }

    /// Which IM (input method) module should be used by default. This is the
    /// input method that will be used if the user has not explicitly chosen
    /// another input method from the IM context menu.
    /// This also can be a colon-separated list of input methods, which GTK+
    /// will try in turn until it finds one available on the system.
    ///
    /// See [`IMContext`][crate::IMContext].
    pub fn gtk_im_module(self, gtk_im_module: impl Into<glib::GString>) -> Self {
        Self {
            builder: self.builder.property("gtk-im-module", gtk_im_module.into()),
        }
    }

    pub fn gtk_key_theme_name(self, gtk_key_theme_name: impl Into<glib::GString>) -> Self {
        Self {
            builder: self
                .builder
                .property("gtk-key-theme-name", gtk_key_theme_name.into()),
        }
    }

    /// Whether GTK+ should make sure that text can be navigated with
    /// a caret, even if it is not editable. This is useful when using
    /// a screen reader.
    pub fn gtk_keynav_use_caret(self, gtk_keynav_use_caret: bool) -> Self {
        Self {
            builder: self
                .builder
                .property("gtk-keynav-use-caret", gtk_keynav_use_caret),
        }
    }

    pub fn gtk_label_select_on_focus(self, gtk_label_select_on_focus: bool) -> Self {
        Self {
            builder: self
                .builder
                .property("gtk-label-select-on-focus", gtk_label_select_on_focus),
        }
    }

    /// The time for a button or touch press to be considered a "long press".
    pub fn gtk_long_press_time(self, gtk_long_press_time: u32) -> Self {
        Self {
            builder: self
                .builder
                .property("gtk-long-press-time", gtk_long_press_time),
        }
    }

    pub fn gtk_modules(self, gtk_modules: impl Into<glib::GString>) -> Self {
        Self {
            builder: self.builder.property("gtk-modules", gtk_modules.into()),
        }
    }

    /// Whether scrolled windows may use overlayed scrolling indicators.
    /// If this is set to [`false`], scrolled windows will have permanent
    /// scrollbars.
    #[cfg(feature = "v3_24_9")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v3_24_9")))]
    pub fn gtk_overlay_scrolling(self, gtk_overlay_scrolling: bool) -> Self {
        Self {
            builder: self
                .builder
                .property("gtk-overlay-scrolling", gtk_overlay_scrolling),
        }
    }

    /// If the value of this setting is [`true`], clicking the primary button in a
    /// [`Range`][crate::Range] trough will move the slider, and hence set the range’s value, to
    /// the point that you clicked. If it is [`false`], a primary click will cause the
    /// slider/value to move by the range’s page-size towards the point clicked.
    ///
    /// Whichever action you choose for the primary button, the other action will
    /// be available by holding Shift and primary-clicking, or (since GTK+ 3.22.25)
    /// clicking the middle mouse button.
    pub fn gtk_primary_button_warps_slider(self, gtk_primary_button_warps_slider: bool) -> Self {
        Self {
            builder: self.builder.property(
                "gtk-primary-button-warps-slider",
                gtk_primary_button_warps_slider,
            ),
        }
    }

    /// A comma-separated list of print backends to use in the print
    /// dialog. Available print backends depend on the GTK+ installation,
    /// and may include "file", "cups", "lpr" or "papi".
    pub fn gtk_print_backends(self, gtk_print_backends: impl Into<glib::GString>) -> Self {
        Self {
            builder: self
                .builder
                .property("gtk-print-backends", gtk_print_backends.into()),
        }
    }

    /// A command to run for displaying the print preview. The command
    /// should contain a ``f`` placeholder, which will get replaced by
    /// the path to the pdf file. The command may also contain a ``s``
    /// placeholder, which will get replaced by the path to a file
    /// containing the print settings in the format produced by
    /// [`PrintSettings::to_file()`][crate::PrintSettings::to_file()].
    ///
    /// The preview application is responsible for removing the pdf file
    /// and the print settings file when it is done.
    pub fn gtk_print_preview_command(
        self,
        gtk_print_preview_command: impl Into<glib::GString>,
    ) -> Self {
        Self {
            builder: self.builder.property(
                "gtk-print-preview-command",
                gtk_print_preview_command.into(),
            ),
        }
    }

    /// Whether GTK+ should keep track of items inside the recently used
    /// resources list. If set to [`false`], the list will always be empty.
    pub fn gtk_recent_files_enabled(self, gtk_recent_files_enabled: bool) -> Self {
        Self {
            builder: self
                .builder
                .property("gtk-recent-files-enabled", gtk_recent_files_enabled),
        }
    }

    /// The maximum age, in days, of the items inside the recently used
    /// resources list. Items older than this setting will be excised
    /// from the list. If set to 0, the list will always be empty; if
    /// set to -1, no item will be removed.
    pub fn gtk_recent_files_max_age(self, gtk_recent_files_max_age: i32) -> Self {
        Self {
            builder: self
                .builder
                .property("gtk-recent-files-max-age", gtk_recent_files_max_age),
        }
    }

    pub fn gtk_shell_shows_app_menu(self, gtk_shell_shows_app_menu: bool) -> Self {
        Self {
            builder: self
                .builder
                .property("gtk-shell-shows-app-menu", gtk_shell_shows_app_menu),
        }
    }

    pub fn gtk_shell_shows_desktop(self, gtk_shell_shows_desktop: bool) -> Self {
        Self {
            builder: self
                .builder
                .property("gtk-shell-shows-desktop", gtk_shell_shows_desktop),
        }
    }

    pub fn gtk_shell_shows_menubar(self, gtk_shell_shows_menubar: bool) -> Self {
        Self {
            builder: self
                .builder
                .property("gtk-shell-shows-menubar", gtk_shell_shows_menubar),
        }
    }

    /// The XDG sound theme to use for event sounds.
    ///
    /// See the [Sound Theme Specifications](http://www.freedesktop.org/wiki/Specifications/sound-theme-spec)
    /// for more information on event sounds and sound themes.
    ///
    /// GTK+ itself does not support event sounds, you have to use a loadable
    /// module like the one that comes with libcanberra.
    pub fn gtk_sound_theme_name(self, gtk_sound_theme_name: impl Into<glib::GString>) -> Self {
        Self {
            builder: self
                .builder
                .property("gtk-sound-theme-name", gtk_sound_theme_name.into()),
        }
    }

    pub fn gtk_split_cursor(self, gtk_split_cursor: bool) -> Self {
        Self {
            builder: self.builder.property("gtk-split-cursor", gtk_split_cursor),
        }
    }

    pub fn gtk_theme_name(self, gtk_theme_name: impl Into<glib::GString>) -> Self {
        Self {
            builder: self
                .builder
                .property("gtk-theme-name", gtk_theme_name.into()),
        }
    }

    /// This setting determines the action to take when a double-click
    /// occurs on the titlebar of client-side decorated windows.
    ///
    /// Recognized actions are minimize, toggle-maximize, menu, lower
    /// or none.
    pub fn gtk_titlebar_double_click(
        self,
        gtk_titlebar_double_click: impl Into<glib::GString>,
    ) -> Self {
        Self {
            builder: self.builder.property(
                "gtk-titlebar-double-click",
                gtk_titlebar_double_click.into(),
            ),
        }
    }

    /// This setting determines the action to take when a middle-click
    /// occurs on the titlebar of client-side decorated windows.
    ///
    /// Recognized actions are minimize, toggle-maximize, menu, lower
    /// or none.
    pub fn gtk_titlebar_middle_click(
        self,
        gtk_titlebar_middle_click: impl Into<glib::GString>,
    ) -> Self {
        Self {
            builder: self.builder.property(
                "gtk-titlebar-middle-click",
                gtk_titlebar_middle_click.into(),
            ),
        }
    }

    /// This setting determines the action to take when a right-click
    /// occurs on the titlebar of client-side decorated windows.
    ///
    /// Recognized actions are minimize, toggle-maximize, menu, lower
    /// or none.
    pub fn gtk_titlebar_right_click(
        self,
        gtk_titlebar_right_click: impl Into<glib::GString>,
    ) -> Self {
        Self {
            builder: self
                .builder
                .property("gtk-titlebar-right-click", gtk_titlebar_right_click.into()),
        }
    }

    pub fn gtk_xft_antialias(self, gtk_xft_antialias: i32) -> Self {
        Self {
            builder: self
                .builder
                .property("gtk-xft-antialias", gtk_xft_antialias),
        }
    }

    pub fn gtk_xft_dpi(self, gtk_xft_dpi: i32) -> Self {
        Self {
            builder: self.builder.property("gtk-xft-dpi", gtk_xft_dpi),
        }
    }

    pub fn gtk_xft_hinting(self, gtk_xft_hinting: i32) -> Self {
        Self {
            builder: self.builder.property("gtk-xft-hinting", gtk_xft_hinting),
        }
    }

    pub fn gtk_xft_hintstyle(self, gtk_xft_hintstyle: impl Into<glib::GString>) -> Self {
        Self {
            builder: self
                .builder
                .property("gtk-xft-hintstyle", gtk_xft_hintstyle.into()),
        }
    }

    pub fn gtk_xft_rgba(self, gtk_xft_rgba: impl Into<glib::GString>) -> Self {
        Self {
            builder: self.builder.property("gtk-xft-rgba", gtk_xft_rgba.into()),
        }
    }

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

/// Trait containing all [`struct@Settings`] methods.
///
/// # Implementors
///
/// [`Settings`][struct@crate::Settings]
pub trait GtkSettingsExt: IsA<Settings> + 'static {
    /// Undoes the effect of calling [`ObjectExt::set()`][crate::glib::prelude::ObjectExt::set()] to install an
    /// application-specific value for a setting. After this call,
    /// the setting will again follow the session-wide value for
    /// this setting.
    /// ## `name`
    /// the name of the setting to reset
    #[doc(alias = "gtk_settings_reset_property")]
    fn reset_property(&self, name: &str) {
        unsafe {
            ffi::gtk_settings_reset_property(self.as_ref().to_glib_none().0, name.to_glib_none().0);
        }
    }

    #[doc(alias = "gtk-alternative-button-order")]
    fn is_gtk_alternative_button_order(&self) -> bool {
        ObjectExt::property(self.as_ref(), "gtk-alternative-button-order")
    }

    #[doc(alias = "gtk-alternative-button-order")]
    fn set_gtk_alternative_button_order(&self, gtk_alternative_button_order: bool) {
        ObjectExt::set_property(
            self.as_ref(),
            "gtk-alternative-button-order",
            gtk_alternative_button_order,
        )
    }

    /// Controls the direction of the sort indicators in sorted list and tree
    /// views. By default an arrow pointing down means the column is sorted
    /// in ascending order. When set to [`true`], this order will be inverted.
    #[doc(alias = "gtk-alternative-sort-arrows")]
    fn is_gtk_alternative_sort_arrows(&self) -> bool {
        ObjectExt::property(self.as_ref(), "gtk-alternative-sort-arrows")
    }

    /// Controls the direction of the sort indicators in sorted list and tree
    /// views. By default an arrow pointing down means the column is sorted
    /// in ascending order. When set to [`true`], this order will be inverted.
    #[doc(alias = "gtk-alternative-sort-arrows")]
    fn set_gtk_alternative_sort_arrows(&self, gtk_alternative_sort_arrows: bool) {
        ObjectExt::set_property(
            self.as_ref(),
            "gtk-alternative-sort-arrows",
            gtk_alternative_sort_arrows,
        )
    }

    /// Whether the application prefers to use a dark theme. If a GTK+ theme
    /// includes a dark variant, it will be used instead of the configured
    /// theme.
    ///
    /// Some applications benefit from minimizing the amount of light pollution that
    /// interferes with the content. Good candidates for dark themes are photo and
    /// video editors that make the actual content get all the attention and minimize
    /// the distraction of the chrome.
    ///
    /// Dark themes should not be used for documents, where large spaces are white/light
    /// and the dark chrome creates too much contrast (web browser, text editor...).
    #[doc(alias = "gtk-application-prefer-dark-theme")]
    fn is_gtk_application_prefer_dark_theme(&self) -> bool {
        ObjectExt::property(self.as_ref(), "gtk-application-prefer-dark-theme")
    }

    /// Whether the application prefers to use a dark theme. If a GTK+ theme
    /// includes a dark variant, it will be used instead of the configured
    /// theme.
    ///
    /// Some applications benefit from minimizing the amount of light pollution that
    /// interferes with the content. Good candidates for dark themes are photo and
    /// video editors that make the actual content get all the attention and minimize
    /// the distraction of the chrome.
    ///
    /// Dark themes should not be used for documents, where large spaces are white/light
    /// and the dark chrome creates too much contrast (web browser, text editor...).
    #[doc(alias = "gtk-application-prefer-dark-theme")]
    fn set_gtk_application_prefer_dark_theme(&self, gtk_application_prefer_dark_theme: bool) {
        ObjectExt::set_property(
            self.as_ref(),
            "gtk-application-prefer-dark-theme",
            gtk_application_prefer_dark_theme,
        )
    }

    #[cfg(feature = "v3_24")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v3_24")))]
    #[doc(alias = "gtk-cursor-aspect-ratio")]
    fn gtk_cursor_aspect_ratio(&self) -> f32 {
        ObjectExt::property(self.as_ref(), "gtk-cursor-aspect-ratio")
    }

    #[cfg(feature = "v3_24")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v3_24")))]
    #[doc(alias = "gtk-cursor-aspect-ratio")]
    fn set_gtk_cursor_aspect_ratio(&self, gtk_cursor_aspect_ratio: f32) {
        ObjectExt::set_property(
            self.as_ref(),
            "gtk-cursor-aspect-ratio",
            gtk_cursor_aspect_ratio,
        )
    }

    /// Whether the cursor should blink.
    ///
    /// Also see the [`gtk-cursor-blink-timeout`][struct@crate::Settings#gtk-cursor-blink-timeout] setting,
    /// which allows more flexible control over cursor blinking.
    #[doc(alias = "gtk-cursor-blink")]
    fn is_gtk_cursor_blink(&self) -> bool {
        ObjectExt::property(self.as_ref(), "gtk-cursor-blink")
    }

    /// Whether the cursor should blink.
    ///
    /// Also see the [`gtk-cursor-blink-timeout`][struct@crate::Settings#gtk-cursor-blink-timeout] setting,
    /// which allows more flexible control over cursor blinking.
    #[doc(alias = "gtk-cursor-blink")]
    fn set_gtk_cursor_blink(&self, gtk_cursor_blink: bool) {
        ObjectExt::set_property(self.as_ref(), "gtk-cursor-blink", gtk_cursor_blink)
    }

    #[doc(alias = "gtk-cursor-blink-time")]
    fn gtk_cursor_blink_time(&self) -> i32 {
        ObjectExt::property(self.as_ref(), "gtk-cursor-blink-time")
    }

    #[doc(alias = "gtk-cursor-blink-time")]
    fn set_gtk_cursor_blink_time(&self, gtk_cursor_blink_time: i32) {
        ObjectExt::set_property(
            self.as_ref(),
            "gtk-cursor-blink-time",
            gtk_cursor_blink_time,
        )
    }

    /// Time after which the cursor stops blinking, in seconds.
    /// The timer is reset after each user interaction.
    ///
    /// Setting this to zero has the same effect as setting
    /// [`gtk-cursor-blink`][struct@crate::Settings#gtk-cursor-blink] to [`false`].
    #[doc(alias = "gtk-cursor-blink-timeout")]
    fn gtk_cursor_blink_timeout(&self) -> i32 {
        ObjectExt::property(self.as_ref(), "gtk-cursor-blink-timeout")
    }

    /// Time after which the cursor stops blinking, in seconds.
    /// The timer is reset after each user interaction.
    ///
    /// Setting this to zero has the same effect as setting
    /// [`gtk-cursor-blink`][struct@crate::Settings#gtk-cursor-blink] to [`false`].
    #[doc(alias = "gtk-cursor-blink-timeout")]
    fn set_gtk_cursor_blink_timeout(&self, gtk_cursor_blink_timeout: i32) {
        ObjectExt::set_property(
            self.as_ref(),
            "gtk-cursor-blink-timeout",
            gtk_cursor_blink_timeout,
        )
    }

    #[doc(alias = "gtk-cursor-theme-name")]
    fn gtk_cursor_theme_name(&self) -> Option<glib::GString> {
        ObjectExt::property(self.as_ref(), "gtk-cursor-theme-name")
    }

    #[doc(alias = "gtk-cursor-theme-name")]
    fn set_gtk_cursor_theme_name(&self, gtk_cursor_theme_name: Option<&str>) {
        ObjectExt::set_property(
            self.as_ref(),
            "gtk-cursor-theme-name",
            gtk_cursor_theme_name,
        )
    }

    #[doc(alias = "gtk-cursor-theme-size")]
    fn gtk_cursor_theme_size(&self) -> i32 {
        ObjectExt::property(self.as_ref(), "gtk-cursor-theme-size")
    }

    #[doc(alias = "gtk-cursor-theme-size")]
    fn set_gtk_cursor_theme_size(&self, gtk_cursor_theme_size: i32) {
        ObjectExt::set_property(
            self.as_ref(),
            "gtk-cursor-theme-size",
            gtk_cursor_theme_size,
        )
    }

    /// This setting determines which buttons should be put in the
    /// titlebar of client-side decorated windows, and whether they
    /// should be placed at the left of right.
    ///
    /// The format of the string is button names, separated by commas.
    /// A colon separates the buttons that should appear on the left
    /// from those on the right. Recognized button names are minimize,
    /// maximize, close, icon (the window icon) and menu (a menu button
    /// for the fallback app menu).
    ///
    /// For example, "menu:minimize,maximize,close" specifies a menu
    /// on the left, and minimize, maximize and close buttons on the right.
    ///
    /// Note that buttons will only be shown when they are meaningful.
    /// E.g. a menu button only appears when the desktop shell does not
    /// show the app menu, and a close button only appears on a window
    /// that can be closed.
    ///
    /// Also note that the setting can be overridden with the
    /// [`decoration-layout`][struct@crate::HeaderBar#decoration-layout] property.
    #[doc(alias = "gtk-decoration-layout")]
    fn gtk_decoration_layout(&self) -> Option<glib::GString> {
        ObjectExt::property(self.as_ref(), "gtk-decoration-layout")
    }

    /// This setting determines which buttons should be put in the
    /// titlebar of client-side decorated windows, and whether they
    /// should be placed at the left of right.
    ///
    /// The format of the string is button names, separated by commas.
    /// A colon separates the buttons that should appear on the left
    /// from those on the right. Recognized button names are minimize,
    /// maximize, close, icon (the window icon) and menu (a menu button
    /// for the fallback app menu).
    ///
    /// For example, "menu:minimize,maximize,close" specifies a menu
    /// on the left, and minimize, maximize and close buttons on the right.
    ///
    /// Note that buttons will only be shown when they are meaningful.
    /// E.g. a menu button only appears when the desktop shell does not
    /// show the app menu, and a close button only appears on a window
    /// that can be closed.
    ///
    /// Also note that the setting can be overridden with the
    /// [`decoration-layout`][struct@crate::HeaderBar#decoration-layout] property.
    #[doc(alias = "gtk-decoration-layout")]
    fn set_gtk_decoration_layout(&self, gtk_decoration_layout: Option<&str>) {
        ObjectExt::set_property(
            self.as_ref(),
            "gtk-decoration-layout",
            gtk_decoration_layout,
        )
    }

    /// Whether builtin GTK+ dialogs such as the file chooser, the
    /// color chooser or the font chooser will use a header bar at
    /// the top to show action widgets, or an action area at the bottom.
    ///
    /// This setting does not affect custom dialogs using GtkDialog
    /// directly, or message dialogs.
    #[doc(alias = "gtk-dialogs-use-header")]
    fn is_gtk_dialogs_use_header(&self) -> bool {
        ObjectExt::property(self.as_ref(), "gtk-dialogs-use-header")
    }

    /// Whether builtin GTK+ dialogs such as the file chooser, the
    /// color chooser or the font chooser will use a header bar at
    /// the top to show action widgets, or an action area at the bottom.
    ///
    /// This setting does not affect custom dialogs using GtkDialog
    /// directly, or message dialogs.
    #[doc(alias = "gtk-dialogs-use-header")]
    fn set_gtk_dialogs_use_header(&self, gtk_dialogs_use_header: bool) {
        ObjectExt::set_property(
            self.as_ref(),
            "gtk-dialogs-use-header",
            gtk_dialogs_use_header,
        )
    }

    #[doc(alias = "gtk-dnd-drag-threshold")]
    fn gtk_dnd_drag_threshold(&self) -> i32 {
        ObjectExt::property(self.as_ref(), "gtk-dnd-drag-threshold")
    }

    #[doc(alias = "gtk-dnd-drag-threshold")]
    fn set_gtk_dnd_drag_threshold(&self, gtk_dnd_drag_threshold: i32) {
        ObjectExt::set_property(
            self.as_ref(),
            "gtk-dnd-drag-threshold",
            gtk_dnd_drag_threshold,
        )
    }

    #[doc(alias = "gtk-double-click-distance")]
    fn gtk_double_click_distance(&self) -> i32 {
        ObjectExt::property(self.as_ref(), "gtk-double-click-distance")
    }

    #[doc(alias = "gtk-double-click-distance")]
    fn set_gtk_double_click_distance(&self, gtk_double_click_distance: i32) {
        ObjectExt::set_property(
            self.as_ref(),
            "gtk-double-click-distance",
            gtk_double_click_distance,
        )
    }

    #[doc(alias = "gtk-double-click-time")]
    fn gtk_double_click_time(&self) -> i32 {
        ObjectExt::property(self.as_ref(), "gtk-double-click-time")
    }

    #[doc(alias = "gtk-double-click-time")]
    fn set_gtk_double_click_time(&self, gtk_double_click_time: i32) {
        ObjectExt::set_property(
            self.as_ref(),
            "gtk-double-click-time",
            gtk_double_click_time,
        )
    }

    /// Whether menu items should have visible accelerators which can be
    /// activated.
    #[doc(alias = "gtk-enable-accels")]
    fn is_gtk_enable_accels(&self) -> bool {
        ObjectExt::property(self.as_ref(), "gtk-enable-accels")
    }

    /// Whether menu items should have visible accelerators which can be
    /// activated.
    #[doc(alias = "gtk-enable-accels")]
    fn set_gtk_enable_accels(&self, gtk_enable_accels: bool) {
        ObjectExt::set_property(self.as_ref(), "gtk-enable-accels", gtk_enable_accels)
    }

    #[doc(alias = "gtk-enable-animations")]
    fn is_gtk_enable_animations(&self) -> bool {
        ObjectExt::property(self.as_ref(), "gtk-enable-animations")
    }

    #[doc(alias = "gtk-enable-animations")]
    fn set_gtk_enable_animations(&self, gtk_enable_animations: bool) {
        ObjectExt::set_property(
            self.as_ref(),
            "gtk-enable-animations",
            gtk_enable_animations,
        )
    }

    /// Whether to play any event sounds at all.
    ///
    /// See the [Sound Theme Specifications](http://www.freedesktop.org/wiki/Specifications/sound-theme-spec)
    /// for more information on event sounds and sound themes.
    ///
    /// GTK+ itself does not support event sounds, you have to use a loadable
    /// module like the one that comes with libcanberra.
    #[doc(alias = "gtk-enable-event-sounds")]
    fn is_gtk_enable_event_sounds(&self) -> bool {
        ObjectExt::property(self.as_ref(), "gtk-enable-event-sounds")
    }

    /// Whether to play any event sounds at all.
    ///
    /// See the [Sound Theme Specifications](http://www.freedesktop.org/wiki/Specifications/sound-theme-spec)
    /// for more information on event sounds and sound themes.
    ///
    /// GTK+ itself does not support event sounds, you have to use a loadable
    /// module like the one that comes with libcanberra.
    #[doc(alias = "gtk-enable-event-sounds")]
    fn set_gtk_enable_event_sounds(&self, gtk_enable_event_sounds: bool) {
        ObjectExt::set_property(
            self.as_ref(),
            "gtk-enable-event-sounds",
            gtk_enable_event_sounds,
        )
    }

    /// Whether to play event sounds as feedback to user input.
    ///
    /// See the [Sound Theme Specifications](http://www.freedesktop.org/wiki/Specifications/sound-theme-spec)
    /// for more information on event sounds and sound themes.
    ///
    /// GTK+ itself does not support event sounds, you have to use a loadable
    /// module like the one that comes with libcanberra.
    #[doc(alias = "gtk-enable-input-feedback-sounds")]
    fn is_gtk_enable_input_feedback_sounds(&self) -> bool {
        ObjectExt::property(self.as_ref(), "gtk-enable-input-feedback-sounds")
    }

    /// Whether to play event sounds as feedback to user input.
    ///
    /// See the [Sound Theme Specifications](http://www.freedesktop.org/wiki/Specifications/sound-theme-spec)
    /// for more information on event sounds and sound themes.
    ///
    /// GTK+ itself does not support event sounds, you have to use a loadable
    /// module like the one that comes with libcanberra.
    #[doc(alias = "gtk-enable-input-feedback-sounds")]
    fn set_gtk_enable_input_feedback_sounds(&self, gtk_enable_input_feedback_sounds: bool) {
        ObjectExt::set_property(
            self.as_ref(),
            "gtk-enable-input-feedback-sounds",
            gtk_enable_input_feedback_sounds,
        )
    }

    /// Whether a middle click on a mouse should paste the
    /// 'PRIMARY' clipboard content at the cursor location.
    #[doc(alias = "gtk-enable-primary-paste")]
    fn is_gtk_enable_primary_paste(&self) -> bool {
        ObjectExt::property(self.as_ref(), "gtk-enable-primary-paste")
    }

    /// Whether a middle click on a mouse should paste the
    /// 'PRIMARY' clipboard content at the cursor location.
    #[doc(alias = "gtk-enable-primary-paste")]
    fn set_gtk_enable_primary_paste(&self, gtk_enable_primary_paste: bool) {
        ObjectExt::set_property(
            self.as_ref(),
            "gtk-enable-primary-paste",
            gtk_enable_primary_paste,
        )
    }

    /// How long to show the last input character in hidden
    /// entries. This value is in milliseconds. 0 disables showing the
    /// last char. 600 is a good value for enabling it.
    #[doc(alias = "gtk-entry-password-hint-timeout")]
    fn gtk_entry_password_hint_timeout(&self) -> u32 {
        ObjectExt::property(self.as_ref(), "gtk-entry-password-hint-timeout")
    }

    /// How long to show the last input character in hidden
    /// entries. This value is in milliseconds. 0 disables showing the
    /// last char. 600 is a good value for enabling it.
    #[doc(alias = "gtk-entry-password-hint-timeout")]
    fn set_gtk_entry_password_hint_timeout(&self, gtk_entry_password_hint_timeout: u32) {
        ObjectExt::set_property(
            self.as_ref(),
            "gtk-entry-password-hint-timeout",
            gtk_entry_password_hint_timeout,
        )
    }

    #[doc(alias = "gtk-entry-select-on-focus")]
    fn is_gtk_entry_select_on_focus(&self) -> bool {
        ObjectExt::property(self.as_ref(), "gtk-entry-select-on-focus")
    }

    #[doc(alias = "gtk-entry-select-on-focus")]
    fn set_gtk_entry_select_on_focus(&self, gtk_entry_select_on_focus: bool) {
        ObjectExt::set_property(
            self.as_ref(),
            "gtk-entry-select-on-focus",
            gtk_entry_select_on_focus,
        )
    }

    /// When [`true`], keyboard navigation and other input-related errors
    /// will cause a beep. Since the error bell is implemented using
    /// [`Window::beep()`][crate::gdk::Window::beep()], the windowing system may offer ways to
    /// configure the error bell in many ways, such as flashing the
    /// window or similar visual effects.
    #[doc(alias = "gtk-error-bell")]
    fn is_gtk_error_bell(&self) -> bool {
        ObjectExt::property(self.as_ref(), "gtk-error-bell")
    }

    /// When [`true`], keyboard navigation and other input-related errors
    /// will cause a beep. Since the error bell is implemented using
    /// [`Window::beep()`][crate::gdk::Window::beep()], the windowing system may offer ways to
    /// configure the error bell in many ways, such as flashing the
    /// window or similar visual effects.
    #[doc(alias = "gtk-error-bell")]
    fn set_gtk_error_bell(&self, gtk_error_bell: bool) {
        ObjectExt::set_property(self.as_ref(), "gtk-error-bell", gtk_error_bell)
    }

    /// The default font to use. GTK+ uses the family name and size from this string.
    #[doc(alias = "gtk-font-name")]
    fn gtk_font_name(&self) -> Option<glib::GString> {
        ObjectExt::property(self.as_ref(), "gtk-font-name")
    }

    /// The default font to use. GTK+ uses the family name and size from this string.
    #[doc(alias = "gtk-font-name")]
    fn set_gtk_font_name(&self, gtk_font_name: Option<&str>) {
        ObjectExt::set_property(self.as_ref(), "gtk-font-name", gtk_font_name)
    }

    #[doc(alias = "gtk-fontconfig-timestamp")]
    fn gtk_fontconfig_timestamp(&self) -> u32 {
        ObjectExt::property(self.as_ref(), "gtk-fontconfig-timestamp")
    }

    #[doc(alias = "gtk-fontconfig-timestamp")]
    fn set_gtk_fontconfig_timestamp(&self, gtk_fontconfig_timestamp: u32) {
        ObjectExt::set_property(
            self.as_ref(),
            "gtk-fontconfig-timestamp",
            gtk_fontconfig_timestamp,
        )
    }

    #[doc(alias = "gtk-icon-theme-name")]
    fn gtk_icon_theme_name(&self) -> Option<glib::GString> {
        ObjectExt::property(self.as_ref(), "gtk-icon-theme-name")
    }

    #[doc(alias = "gtk-icon-theme-name")]
    fn set_gtk_icon_theme_name(&self, gtk_icon_theme_name: Option<&str>) {
        ObjectExt::set_property(self.as_ref(), "gtk-icon-theme-name", gtk_icon_theme_name)
    }

    /// Which IM (input method) module should be used by default. This is the
    /// input method that will be used if the user has not explicitly chosen
    /// another input method from the IM context menu.
    /// This also can be a colon-separated list of input methods, which GTK+
    /// will try in turn until it finds one available on the system.
    ///
    /// See [`IMContext`][crate::IMContext].
    #[doc(alias = "gtk-im-module")]
    fn gtk_im_module(&self) -> Option<glib::GString> {
        ObjectExt::property(self.as_ref(), "gtk-im-module")
    }

    /// Which IM (input method) module should be used by default. This is the
    /// input method that will be used if the user has not explicitly chosen
    /// another input method from the IM context menu.
    /// This also can be a colon-separated list of input methods, which GTK+
    /// will try in turn until it finds one available on the system.
    ///
    /// See [`IMContext`][crate::IMContext].
    #[doc(alias = "gtk-im-module")]
    fn set_gtk_im_module(&self, gtk_im_module: Option<&str>) {
        ObjectExt::set_property(self.as_ref(), "gtk-im-module", gtk_im_module)
    }

    #[doc(alias = "gtk-key-theme-name")]
    fn gtk_key_theme_name(&self) -> Option<glib::GString> {
        ObjectExt::property(self.as_ref(), "gtk-key-theme-name")
    }

    #[doc(alias = "gtk-key-theme-name")]
    fn set_gtk_key_theme_name(&self, gtk_key_theme_name: Option<&str>) {
        ObjectExt::set_property(self.as_ref(), "gtk-key-theme-name", gtk_key_theme_name)
    }

    /// Whether GTK+ should make sure that text can be navigated with
    /// a caret, even if it is not editable. This is useful when using
    /// a screen reader.
    #[doc(alias = "gtk-keynav-use-caret")]
    fn is_gtk_keynav_use_caret(&self) -> bool {
        ObjectExt::property(self.as_ref(), "gtk-keynav-use-caret")
    }

    /// Whether GTK+ should make sure that text can be navigated with
    /// a caret, even if it is not editable. This is useful when using
    /// a screen reader.
    #[doc(alias = "gtk-keynav-use-caret")]
    fn set_gtk_keynav_use_caret(&self, gtk_keynav_use_caret: bool) {
        ObjectExt::set_property(self.as_ref(), "gtk-keynav-use-caret", gtk_keynav_use_caret)
    }

    #[doc(alias = "gtk-label-select-on-focus")]
    fn is_gtk_label_select_on_focus(&self) -> bool {
        ObjectExt::property(self.as_ref(), "gtk-label-select-on-focus")
    }

    #[doc(alias = "gtk-label-select-on-focus")]
    fn set_gtk_label_select_on_focus(&self, gtk_label_select_on_focus: bool) {
        ObjectExt::set_property(
            self.as_ref(),
            "gtk-label-select-on-focus",
            gtk_label_select_on_focus,
        )
    }

    /// The time for a button or touch press to be considered a "long press".
    #[doc(alias = "gtk-long-press-time")]
    fn gtk_long_press_time(&self) -> u32 {
        ObjectExt::property(self.as_ref(), "gtk-long-press-time")
    }

    /// The time for a button or touch press to be considered a "long press".
    #[doc(alias = "gtk-long-press-time")]
    fn set_gtk_long_press_time(&self, gtk_long_press_time: u32) {
        ObjectExt::set_property(self.as_ref(), "gtk-long-press-time", gtk_long_press_time)
    }

    #[doc(alias = "gtk-modules")]
    fn gtk_modules(&self) -> Option<glib::GString> {
        ObjectExt::property(self.as_ref(), "gtk-modules")
    }

    #[doc(alias = "gtk-modules")]
    fn set_gtk_modules(&self, gtk_modules: Option<&str>) {
        ObjectExt::set_property(self.as_ref(), "gtk-modules", gtk_modules)
    }

    /// Whether scrolled windows may use overlayed scrolling indicators.
    /// If this is set to [`false`], scrolled windows will have permanent
    /// scrollbars.
    #[cfg(feature = "v3_24_9")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v3_24_9")))]
    #[doc(alias = "gtk-overlay-scrolling")]
    fn is_gtk_overlay_scrolling(&self) -> bool {
        ObjectExt::property(self.as_ref(), "gtk-overlay-scrolling")
    }

    /// Whether scrolled windows may use overlayed scrolling indicators.
    /// If this is set to [`false`], scrolled windows will have permanent
    /// scrollbars.
    #[cfg(feature = "v3_24_9")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v3_24_9")))]
    #[doc(alias = "gtk-overlay-scrolling")]
    fn set_gtk_overlay_scrolling(&self, gtk_overlay_scrolling: bool) {
        ObjectExt::set_property(
            self.as_ref(),
            "gtk-overlay-scrolling",
            gtk_overlay_scrolling,
        )
    }

    /// If the value of this setting is [`true`], clicking the primary button in a
    /// [`Range`][crate::Range] trough will move the slider, and hence set the range’s value, to
    /// the point that you clicked. If it is [`false`], a primary click will cause the
    /// slider/value to move by the range’s page-size towards the point clicked.
    ///
    /// Whichever action you choose for the primary button, the other action will
    /// be available by holding Shift and primary-clicking, or (since GTK+ 3.22.25)
    /// clicking the middle mouse button.
    #[doc(alias = "gtk-primary-button-warps-slider")]
    fn is_gtk_primary_button_warps_slider(&self) -> bool {
        ObjectExt::property(self.as_ref(), "gtk-primary-button-warps-slider")
    }

    /// If the value of this setting is [`true`], clicking the primary button in a
    /// [`Range`][crate::Range] trough will move the slider, and hence set the range’s value, to
    /// the point that you clicked. If it is [`false`], a primary click will cause the
    /// slider/value to move by the range’s page-size towards the point clicked.
    ///
    /// Whichever action you choose for the primary button, the other action will
    /// be available by holding Shift and primary-clicking, or (since GTK+ 3.22.25)
    /// clicking the middle mouse button.
    #[doc(alias = "gtk-primary-button-warps-slider")]
    fn set_gtk_primary_button_warps_slider(&self, gtk_primary_button_warps_slider: bool) {
        ObjectExt::set_property(
            self.as_ref(),
            "gtk-primary-button-warps-slider",
            gtk_primary_button_warps_slider,
        )
    }

    /// A comma-separated list of print backends to use in the print
    /// dialog. Available print backends depend on the GTK+ installation,
    /// and may include "file", "cups", "lpr" or "papi".
    #[doc(alias = "gtk-print-backends")]
    fn gtk_print_backends(&self) -> Option<glib::GString> {
        ObjectExt::property(self.as_ref(), "gtk-print-backends")
    }

    /// A comma-separated list of print backends to use in the print
    /// dialog. Available print backends depend on the GTK+ installation,
    /// and may include "file", "cups", "lpr" or "papi".
    #[doc(alias = "gtk-print-backends")]
    fn set_gtk_print_backends(&self, gtk_print_backends: Option<&str>) {
        ObjectExt::set_property(self.as_ref(), "gtk-print-backends", gtk_print_backends)
    }

    /// A command to run for displaying the print preview. The command
    /// should contain a ``f`` placeholder, which will get replaced by
    /// the path to the pdf file. The command may also contain a ``s``
    /// placeholder, which will get replaced by the path to a file
    /// containing the print settings in the format produced by
    /// [`PrintSettings::to_file()`][crate::PrintSettings::to_file()].
    ///
    /// The preview application is responsible for removing the pdf file
    /// and the print settings file when it is done.
    #[doc(alias = "gtk-print-preview-command")]
    fn gtk_print_preview_command(&self) -> Option<glib::GString> {
        ObjectExt::property(self.as_ref(), "gtk-print-preview-command")
    }

    /// A command to run for displaying the print preview. The command
    /// should contain a ``f`` placeholder, which will get replaced by
    /// the path to the pdf file. The command may also contain a ``s``
    /// placeholder, which will get replaced by the path to a file
    /// containing the print settings in the format produced by
    /// [`PrintSettings::to_file()`][crate::PrintSettings::to_file()].
    ///
    /// The preview application is responsible for removing the pdf file
    /// and the print settings file when it is done.
    #[doc(alias = "gtk-print-preview-command")]
    fn set_gtk_print_preview_command(&self, gtk_print_preview_command: Option<&str>) {
        ObjectExt::set_property(
            self.as_ref(),
            "gtk-print-preview-command",
            gtk_print_preview_command,
        )
    }

    /// Whether GTK+ should keep track of items inside the recently used
    /// resources list. If set to [`false`], the list will always be empty.
    #[doc(alias = "gtk-recent-files-enabled")]
    fn is_gtk_recent_files_enabled(&self) -> bool {
        ObjectExt::property(self.as_ref(), "gtk-recent-files-enabled")
    }

    /// Whether GTK+ should keep track of items inside the recently used
    /// resources list. If set to [`false`], the list will always be empty.
    #[doc(alias = "gtk-recent-files-enabled")]
    fn set_gtk_recent_files_enabled(&self, gtk_recent_files_enabled: bool) {
        ObjectExt::set_property(
            self.as_ref(),
            "gtk-recent-files-enabled",
            gtk_recent_files_enabled,
        )
    }

    /// The maximum age, in days, of the items inside the recently used
    /// resources list. Items older than this setting will be excised
    /// from the list. If set to 0, the list will always be empty; if
    /// set to -1, no item will be removed.
    #[doc(alias = "gtk-recent-files-max-age")]
    fn gtk_recent_files_max_age(&self) -> i32 {
        ObjectExt::property(self.as_ref(), "gtk-recent-files-max-age")
    }

    /// The maximum age, in days, of the items inside the recently used
    /// resources list. Items older than this setting will be excised
    /// from the list. If set to 0, the list will always be empty; if
    /// set to -1, no item will be removed.
    #[doc(alias = "gtk-recent-files-max-age")]
    fn set_gtk_recent_files_max_age(&self, gtk_recent_files_max_age: i32) {
        ObjectExt::set_property(
            self.as_ref(),
            "gtk-recent-files-max-age",
            gtk_recent_files_max_age,
        )
    }

    #[doc(alias = "gtk-shell-shows-app-menu")]
    fn is_gtk_shell_shows_app_menu(&self) -> bool {
        ObjectExt::property(self.as_ref(), "gtk-shell-shows-app-menu")
    }

    #[doc(alias = "gtk-shell-shows-app-menu")]
    fn set_gtk_shell_shows_app_menu(&self, gtk_shell_shows_app_menu: bool) {
        ObjectExt::set_property(
            self.as_ref(),
            "gtk-shell-shows-app-menu",
            gtk_shell_shows_app_menu,
        )
    }

    #[doc(alias = "gtk-shell-shows-desktop")]
    fn is_gtk_shell_shows_desktop(&self) -> bool {
        ObjectExt::property(self.as_ref(), "gtk-shell-shows-desktop")
    }

    #[doc(alias = "gtk-shell-shows-desktop")]
    fn set_gtk_shell_shows_desktop(&self, gtk_shell_shows_desktop: bool) {
        ObjectExt::set_property(
            self.as_ref(),
            "gtk-shell-shows-desktop",
            gtk_shell_shows_desktop,
        )
    }

    #[doc(alias = "gtk-shell-shows-menubar")]
    fn is_gtk_shell_shows_menubar(&self) -> bool {
        ObjectExt::property(self.as_ref(), "gtk-shell-shows-menubar")
    }

    #[doc(alias = "gtk-shell-shows-menubar")]
    fn set_gtk_shell_shows_menubar(&self, gtk_shell_shows_menubar: bool) {
        ObjectExt::set_property(
            self.as_ref(),
            "gtk-shell-shows-menubar",
            gtk_shell_shows_menubar,
        )
    }

    /// The XDG sound theme to use for event sounds.
    ///
    /// See the [Sound Theme Specifications](http://www.freedesktop.org/wiki/Specifications/sound-theme-spec)
    /// for more information on event sounds and sound themes.
    ///
    /// GTK+ itself does not support event sounds, you have to use a loadable
    /// module like the one that comes with libcanberra.
    #[doc(alias = "gtk-sound-theme-name")]
    fn gtk_sound_theme_name(&self) -> Option<glib::GString> {
        ObjectExt::property(self.as_ref(), "gtk-sound-theme-name")
    }

    /// The XDG sound theme to use for event sounds.
    ///
    /// See the [Sound Theme Specifications](http://www.freedesktop.org/wiki/Specifications/sound-theme-spec)
    /// for more information on event sounds and sound themes.
    ///
    /// GTK+ itself does not support event sounds, you have to use a loadable
    /// module like the one that comes with libcanberra.
    #[doc(alias = "gtk-sound-theme-name")]
    fn set_gtk_sound_theme_name(&self, gtk_sound_theme_name: Option<&str>) {
        ObjectExt::set_property(self.as_ref(), "gtk-sound-theme-name", gtk_sound_theme_name)
    }

    #[doc(alias = "gtk-split-cursor")]
    fn is_gtk_split_cursor(&self) -> bool {
        ObjectExt::property(self.as_ref(), "gtk-split-cursor")
    }

    #[doc(alias = "gtk-split-cursor")]
    fn set_gtk_split_cursor(&self, gtk_split_cursor: bool) {
        ObjectExt::set_property(self.as_ref(), "gtk-split-cursor", gtk_split_cursor)
    }

    #[doc(alias = "gtk-theme-name")]
    fn gtk_theme_name(&self) -> Option<glib::GString> {
        ObjectExt::property(self.as_ref(), "gtk-theme-name")
    }

    #[doc(alias = "gtk-theme-name")]
    fn set_gtk_theme_name(&self, gtk_theme_name: Option<&str>) {
        ObjectExt::set_property(self.as_ref(), "gtk-theme-name", gtk_theme_name)
    }

    /// This setting determines the action to take when a double-click
    /// occurs on the titlebar of client-side decorated windows.
    ///
    /// Recognized actions are minimize, toggle-maximize, menu, lower
    /// or none.
    #[doc(alias = "gtk-titlebar-double-click")]
    fn gtk_titlebar_double_click(&self) -> Option<glib::GString> {
        ObjectExt::property(self.as_ref(), "gtk-titlebar-double-click")
    }

    /// This setting determines the action to take when a double-click
    /// occurs on the titlebar of client-side decorated windows.
    ///
    /// Recognized actions are minimize, toggle-maximize, menu, lower
    /// or none.
    #[doc(alias = "gtk-titlebar-double-click")]
    fn set_gtk_titlebar_double_click(&self, gtk_titlebar_double_click: Option<&str>) {
        ObjectExt::set_property(
            self.as_ref(),
            "gtk-titlebar-double-click",
            gtk_titlebar_double_click,
        )
    }

    /// This setting determines the action to take when a middle-click
    /// occurs on the titlebar of client-side decorated windows.
    ///
    /// Recognized actions are minimize, toggle-maximize, menu, lower
    /// or none.
    #[doc(alias = "gtk-titlebar-middle-click")]
    fn gtk_titlebar_middle_click(&self) -> Option<glib::GString> {
        ObjectExt::property(self.as_ref(), "gtk-titlebar-middle-click")
    }

    /// This setting determines the action to take when a middle-click
    /// occurs on the titlebar of client-side decorated windows.
    ///
    /// Recognized actions are minimize, toggle-maximize, menu, lower
    /// or none.
    #[doc(alias = "gtk-titlebar-middle-click")]
    fn set_gtk_titlebar_middle_click(&self, gtk_titlebar_middle_click: Option<&str>) {
        ObjectExt::set_property(
            self.as_ref(),
            "gtk-titlebar-middle-click",
            gtk_titlebar_middle_click,
        )
    }

    /// This setting determines the action to take when a right-click
    /// occurs on the titlebar of client-side decorated windows.
    ///
    /// Recognized actions are minimize, toggle-maximize, menu, lower
    /// or none.
    #[doc(alias = "gtk-titlebar-right-click")]
    fn gtk_titlebar_right_click(&self) -> Option<glib::GString> {
        ObjectExt::property(self.as_ref(), "gtk-titlebar-right-click")
    }

    /// This setting determines the action to take when a right-click
    /// occurs on the titlebar of client-side decorated windows.
    ///
    /// Recognized actions are minimize, toggle-maximize, menu, lower
    /// or none.
    #[doc(alias = "gtk-titlebar-right-click")]
    fn set_gtk_titlebar_right_click(&self, gtk_titlebar_right_click: Option<&str>) {
        ObjectExt::set_property(
            self.as_ref(),
            "gtk-titlebar-right-click",
            gtk_titlebar_right_click,
        )
    }

    #[doc(alias = "gtk-xft-antialias")]
    fn gtk_xft_antialias(&self) -> i32 {
        ObjectExt::property(self.as_ref(), "gtk-xft-antialias")
    }

    #[doc(alias = "gtk-xft-antialias")]
    fn set_gtk_xft_antialias(&self, gtk_xft_antialias: i32) {
        ObjectExt::set_property(self.as_ref(), "gtk-xft-antialias", gtk_xft_antialias)
    }

    #[doc(alias = "gtk-xft-dpi")]
    fn gtk_xft_dpi(&self) -> i32 {
        ObjectExt::property(self.as_ref(), "gtk-xft-dpi")
    }

    #[doc(alias = "gtk-xft-dpi")]
    fn set_gtk_xft_dpi(&self, gtk_xft_dpi: i32) {
        ObjectExt::set_property(self.as_ref(), "gtk-xft-dpi", gtk_xft_dpi)
    }

    #[doc(alias = "gtk-xft-hinting")]
    fn gtk_xft_hinting(&self) -> i32 {
        ObjectExt::property(self.as_ref(), "gtk-xft-hinting")
    }

    #[doc(alias = "gtk-xft-hinting")]
    fn set_gtk_xft_hinting(&self, gtk_xft_hinting: i32) {
        ObjectExt::set_property(self.as_ref(), "gtk-xft-hinting", gtk_xft_hinting)
    }

    #[doc(alias = "gtk-xft-hintstyle")]
    fn gtk_xft_hintstyle(&self) -> Option<glib::GString> {
        ObjectExt::property(self.as_ref(), "gtk-xft-hintstyle")
    }

    #[doc(alias = "gtk-xft-hintstyle")]
    fn set_gtk_xft_hintstyle(&self, gtk_xft_hintstyle: Option<&str>) {
        ObjectExt::set_property(self.as_ref(), "gtk-xft-hintstyle", gtk_xft_hintstyle)
    }

    #[doc(alias = "gtk-xft-rgba")]
    fn gtk_xft_rgba(&self) -> Option<glib::GString> {
        ObjectExt::property(self.as_ref(), "gtk-xft-rgba")
    }

    #[doc(alias = "gtk-xft-rgba")]
    fn set_gtk_xft_rgba(&self, gtk_xft_rgba: Option<&str>) {
        ObjectExt::set_property(self.as_ref(), "gtk-xft-rgba", gtk_xft_rgba)
    }

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

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

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

    #[cfg(feature = "v3_24")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v3_24")))]
    #[doc(alias = "gtk-cursor-aspect-ratio")]
    fn connect_gtk_cursor_aspect_ratio_notify<F: Fn(&Self) + 'static>(
        &self,
        f: F,
    ) -> SignalHandlerId {
        unsafe extern "C" fn notify_gtk_cursor_aspect_ratio_trampoline<
            P: IsA<Settings>,
            F: Fn(&P) + 'static,
        >(
            this: *mut ffi::GtkSettings,
            _param_spec: glib::ffi::gpointer,
            f: glib::ffi::gpointer,
        ) {
            unsafe {
                let f: &F = &*(f as *const F);
                f(Settings::from_glib_borrow(this).unsafe_cast_ref())
            }
        }
        unsafe {
            let f: Box_<F> = Box_::new(f);
            connect_raw(
                self.as_ptr() as *mut _,
                c"notify::gtk-cursor-aspect-ratio".as_ptr(),
                Some(std::mem::transmute::<*const (), unsafe extern "C" fn()>(
                    notify_gtk_cursor_aspect_ratio_trampoline::<Self, F> as *const (),
                )),
                Box_::into_raw(f),
            )
        }
    }

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

impl<O: IsA<Settings>> GtkSettingsExt for O {}