gio/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

#[cfg(feature = "v2_82")]
#[cfg_attr(docsrs, doc(cfg(feature = "v2_82")))]
use crate::SettingsBindFlags;
use crate::{Action, SettingsBackend, SettingsSchema, ffi};
use glib::{
    object::ObjectType as _,
    prelude::*,
    signal::{SignalHandlerId, connect_raw},
    translate::*,
};
use std::boxed::Box as Box_;

glib::wrapper! {
    /// ` elements which have a
    /// `l10n` attribute set.
    ///
    /// Translations **must not** be included in the `.gschema.xml` file by the build
    /// system, for example by using a rule to generate the XML file from a template.
    ///
    /// ## Properties
    ///
    ///
    /// #### `backend`
    ///  The name of the context that the settings are stored in.
    ///
    /// Readable | Writable | Construct Only
    ///
    ///
    /// #### `delay-apply`
    ///   mode](class.Settings.html#delay-apply-mode).
    ///
    /// Readable
    ///
    ///
    /// #### `has-unapplied`
    ///  Whether the [`Settings`][crate::Settings] object has outstanding changes.
    ///
    /// These changes will be applied when [`SettingsExt::apply()`][crate::prelude::SettingsExt::apply()] is called.
    ///
    /// Readable
    ///
    ///
    /// #### `path`
    ///  The path within the backend where the settings are stored.
    ///
    /// Readable | Writable | Construct Only
    ///
    ///
    /// #### `schema`
    ///  The name of the schema that describes the types of keys
    /// for this [`Settings`][crate::Settings] object.
    ///
    /// The type of this property is *not* [`SettingsSchema`][crate::SettingsSchema].
    /// [`SettingsSchema`][crate::SettingsSchema] has only existed since version 2.32 and
    /// unfortunately this name was used in previous versions to refer to
    /// the schema ID rather than the schema itself.  Take care to use the
    /// [`settings-schema`][struct@crate::Settings#settings-schema] property if you wish to pass in a
    /// [`SettingsSchema`][crate::SettingsSchema].
    ///
    /// Readable | Writable | Construct Only
    ///
    ///
    /// #### `schema-id`
    ///  The name of the schema that describes the types of keys
    /// for this [`Settings`][crate::Settings] object.
    ///
    /// Readable | Writable | Construct Only
    ///
    ///
    /// #### `settings-schema`
    ///  The [`SettingsSchema`][crate::SettingsSchema] describing the types of keys for this
    /// [`Settings`][crate::Settings] object.
    ///
    /// Ideally, this property would be called [`schema`][struct@crate::Settings#schema].
    /// [`SettingsSchema`][crate::SettingsSchema]
    /// has only existed since version 2.32, however, and before then the
    /// [`schema`][struct@crate::Settings#schema] property was used to refer to the ID of the schema rather
    /// than the schema itself.  Take care.
    ///
    /// Readable | Writable | Construct Only
    ///
    /// ## Signals
    ///
    ///
    /// #### `change-event`
    ///  Emitted once per change event that affects this settings object.
    ///
    /// You should connect to this signal
    /// only if you are interested in viewing groups of changes before they
    /// are split out into multiple emissions of the [`changed`][struct@crate::Settings#changed] signal.
    /// For most use cases it is more appropriate to use the [`changed`][struct@crate::Settings#changed] signal.
    ///
    /// In the event that the change event applies to one or more specified
    /// keys, @keys will be an array of `alias::GLib.Quark`s of length @n_keys.  In the
    /// event that the change event applies to the [`Settings`][crate::Settings] object as a
    /// whole (ie: potentially every key has been changed) then @keys will
    /// be `NULL` and @n_keys will be `0`.
    ///
    /// The default handler for this signal invokes the [`changed`][struct@crate::Settings#changed] signal
    /// for each affected key.  If any other connected handler returns
    /// true then this default functionality will be suppressed.
    ///
    ///
    ///
    ///
    /// #### `changed`
    ///  Emitted when a key has potentially changed.
    ///
    /// You should call one of the `Gio::Settings::get()` calls to check the new
    /// value.
    ///
    /// This signal supports detailed connections.  You can connect to the
    /// detailed signal `changed::x` in order to only receive callbacks
    /// when key `x` changes.
    ///
    /// Note that @settings only emits this signal if you have read @key at
    /// least once while a signal handler was already connected for @key.
    ///
    /// Detailed
    ///
    ///
    /// #### `writable-change-event`
    ///  Emitted once per writability change event that affects this settings object.
    ///
    /// You should connect
    /// to this signal if you are interested in viewing groups of changes
    /// before they are split out into multiple emissions of the
    /// [`writable-changed`][struct@crate::Settings#writable-changed] signal.  For most use cases it is more
    /// appropriate to use the [`writable-changed`][struct@crate::Settings#writable-changed] signal.
    ///
    /// In the event that the writability change applies only to a single
    /// key, @key will be set to the `alias::GLib.Quark` for that key.  In the event
    /// that the writability change affects the entire settings object,
    /// @key will be `0`.
    ///
    /// The default handler for this signal invokes the [`writable-changed`][struct@crate::Settings#writable-changed]
    /// and [`changed`][struct@crate::Settings#changed] signals for each affected key.  This is done because
    /// changes in writability might also imply changes in value (if for
    /// example, a new mandatory setting is introduced).  If any other
    /// connected handler returns true then this default functionality
    /// will be suppressed.
    ///
    ///
    ///
    ///
    /// #### `writable-changed`
    ///  Emitted when the writability of a key has potentially changed.
    ///
    /// You should call [`SettingsExt::is_writable()`][crate::prelude::SettingsExt::is_writable()] in order to determine the
    /// new status.
    ///
    /// This signal supports detailed connections.  You can connect to the
    /// detailed signal `writable-changed::x` in order to only receive
    /// callbacks when the writability of `x` changes.
    ///
    /// Detailed
    ///
    /// # Implements
    ///
    /// [`SettingsExt`][trait@crate::prelude::SettingsExt], [`trait@glib::ObjectExt`], [`SettingsExtManual`][trait@crate::prelude::SettingsExtManual]
    #[doc(alias = "GSettings")]
    pub struct Settings(Object<ffi::GSettings, ffi::GSettingsClass>);

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

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

    /// Creates a new [`Settings`][crate::Settings] object with the schema specified by
    /// @schema_id.
    ///
    /// It is an error for the schema to not exist: schemas are an
    /// essential part of a program, as they provide type information.
    /// If schemas need to be dynamically loaded (for example, from an
    /// optional runtime dependency), [`SettingsSchemaSource::lookup()`][crate::SettingsSchemaSource::lookup()]
    /// can be used to test for their existence before loading them.
    ///
    /// Signals on the newly created [`Settings`][crate::Settings] object will be dispatched
    /// via the thread-default [`glib::MainContext`][crate::glib::MainContext] in effect at the time of the
    /// call to [`new()`][Self::new()].  The new [`Settings`][crate::Settings] will hold a reference
    /// on the context.  See [`glib::MainContext::push_thread_default()`][crate::glib::MainContext::push_thread_default()].
    /// ## `schema_id`
    /// the ID of the schema
    ///
    /// # Returns
    ///
    /// a new [`Settings`][crate::Settings] object
    #[doc(alias = "g_settings_new")]
    pub fn new(schema_id: &str) -> Settings {
        unsafe { from_glib_full(ffi::g_settings_new(schema_id.to_glib_none().0)) }
    }

    /// Creates a new [`Settings`][crate::Settings] object with a given schema, backend and
    /// path.
    ///
    /// It should be extremely rare that you ever want to use this function.
    /// It is made available for advanced use-cases (such as plugin systems
    /// that want to provide access to schemas loaded from custom locations,
    /// etc).
    ///
    /// At the most basic level, a [`Settings`][crate::Settings] object is a pure composition of
    /// four things: a [`SettingsSchema`][crate::SettingsSchema], a [`SettingsBackend`][crate::SettingsBackend], a path within that
    /// backend, and a [`glib::MainContext`][crate::glib::MainContext] to which signals are dispatched.
    ///
    /// This constructor therefore gives you full control over constructing
    /// [`Settings`][crate::Settings] instances.  The first 3 parameters are given directly as
    /// @schema, @backend and @path, and the main context is taken from the
    /// thread-default (as per [`new()`][Self::new()]).
    ///
    /// If @backend is `NULL` then the default backend is used.
    ///
    /// If @path is `NULL` then the path from the schema is used.  It is an
    /// error if @path is `NULL` and the schema has no path of its own or if
    /// @path is non-`NULL` and not equal to the path that the schema does
    /// have.
    /// ## `schema`
    /// the schema describing the settings
    /// ## `backend`
    /// the settings backend to use
    /// ## `path`
    /// the path to use
    ///
    /// # Returns
    ///
    /// a new [`Settings`][crate::Settings] object
    #[doc(alias = "g_settings_new_full")]
    pub fn new_full(
        schema: &SettingsSchema,
        backend: Option<&impl IsA<SettingsBackend>>,
        path: Option<&str>,
    ) -> Settings {
        unsafe {
            from_glib_full(ffi::g_settings_new_full(
                schema.to_glib_none().0,
                backend.map(|p| p.as_ref()).to_glib_none().0,
                path.to_glib_none().0,
            ))
        }
    }

    ///  settings database on
    /// the system to get a settings object that modifies the system default
    /// settings instead of the settings for this user.
    /// ## `schema_id`
    /// the ID of the schema
    /// ## `backend`
    /// the settings backend to use
    ///
    /// # Returns
    ///
    /// a new [`Settings`][crate::Settings] object
    #[doc(alias = "g_settings_new_with_backend")]
    #[doc(alias = "new_with_backend")]
    pub fn with_backend(schema_id: &str, backend: &impl IsA<SettingsBackend>) -> Settings {
        unsafe {
            from_glib_full(ffi::g_settings_new_with_backend(
                schema_id.to_glib_none().0,
                backend.as_ref().to_glib_none().0,
            ))
        }
    }

    /// Creates a new [`Settings`][crate::Settings] object with the schema specified by
    /// @schema_id and a given [`SettingsBackend`][crate::SettingsBackend] and path.
    ///
    /// This is a mix of [`with_backend()`][Self::with_backend()] and
    /// [`with_path()`][Self::with_path()].
    /// ## `schema_id`
    /// the ID of the schema
    /// ## `backend`
    /// the settings backend to use
    /// ## `path`
    /// the path to use
    ///
    /// # Returns
    ///
    /// a new [`Settings`][crate::Settings] object
    #[doc(alias = "g_settings_new_with_backend_and_path")]
    #[doc(alias = "new_with_backend_and_path")]
    pub fn with_backend_and_path(
        schema_id: &str,
        backend: &impl IsA<SettingsBackend>,
        path: &str,
    ) -> Settings {
        unsafe {
            from_glib_full(ffi::g_settings_new_with_backend_and_path(
                schema_id.to_glib_none().0,
                backend.as_ref().to_glib_none().0,
                path.to_glib_none().0,
            ))
        }
    }

    /// s quite rare.
    ///
    /// It is a programmer error to call this function for a schema that
    /// has an explicitly specified path.
    ///
    /// It is a programmer error if @path is not a valid path.  A valid path
    /// begins and ends with `/` and does not contain two consecutive `/`
    /// characters.
    /// ## `schema_id`
    /// the ID of the schema
    /// ## `path`
    /// the path to use
    ///
    /// # Returns
    ///
    /// a new [`Settings`][crate::Settings] object
    #[doc(alias = "g_settings_new_with_path")]
    #[doc(alias = "new_with_path")]
    pub fn with_path(schema_id: &str, path: &str) -> Settings {
        unsafe {
            from_glib_full(ffi::g_settings_new_with_path(
                schema_id.to_glib_none().0,
                path.to_glib_none().0,
            ))
        }
    }

    /// Ensures that all pending operations are complete for the default backend.
    ///
    /// Writes made to a [`Settings`][crate::Settings] are handled asynchronously.  For this
    /// reason, it is very unlikely that the changes have it to disk by the
    /// time `Gio::Settings::set()` returns.
    ///
    /// This call will block until all of the writes have made it to the
    /// backend.  Since the main loop is not running, no change notifications
    /// will be dispatched during this call (but some may be queued by the
    /// time the call is done).
    #[doc(alias = "g_settings_sync")]
    pub fn sync() {
        unsafe {
            ffi::g_settings_sync();
        }
    }

    /// Removes an existing binding for @property on @object.
    ///
    /// Note that bindings are automatically removed when the
    /// object is finalized, so it is rarely necessary to call this
    /// function.
    /// ## `object`
    /// the object with property to unbind
    /// ## `property`
    /// the property whose binding is removed
    #[doc(alias = "g_settings_unbind")]
    pub fn unbind(object: &impl IsA<glib::Object>, property: &str) {
        unsafe {
            ffi::g_settings_unbind(object.as_ref().to_glib_none().0, property.to_glib_none().0);
        }
    }
}

/// Trait containing all [`struct@Settings`] methods.
///
/// # Implementors
///
/// [`Settings`][struct@crate::Settings]
pub trait SettingsExt: IsA<Settings> + 'static {
    ///  mode](class.Settings.html#delay-apply-mode).  In the normal
    /// case settings are always applied immediately.
    #[doc(alias = "g_settings_apply")]
    fn apply(&self) {
        unsafe {
            ffi::g_settings_apply(self.as_ref().to_glib_none().0);
        }
    }

    /// Version of [`SettingsExtManual::bind_with_mapping()`][crate::prelude::SettingsExtManual::bind_with_mapping()] using closures instead of
    /// callbacks for easier binding in other languages.
    /// ## `key`
    /// the key to bind
    /// ## `object`
    /// the object with property to bind
    /// ## `property`
    /// the name of the property to bind
    /// ## `flags`
    /// flags for the binding
    /// ## `get_mapping`
    /// a function that gets called to convert values
    ///   from @self to @object, or `NULL` to use the default GIO mapping
    /// ## `set_mapping`
    /// a function that gets called to convert values
    ///   from @object to @self, or `NULL` to use the default GIO mapping
    #[cfg(feature = "v2_82")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v2_82")))]
    #[doc(alias = "g_settings_bind_with_mapping_closures")]
    fn bind_with_mapping_closures(
        &self,
        key: &str,
        object: &impl IsA<glib::Object>,
        property: &str,
        flags: SettingsBindFlags,
        get_mapping: Option<&glib::Closure>,
        set_mapping: Option<&glib::Closure>,
    ) {
        unsafe {
            ffi::g_settings_bind_with_mapping_closures(
                self.as_ref().to_glib_none().0,
                key.to_glib_none().0,
                object.as_ref().to_glib_none().0,
                property.to_glib_none().0,
                flags.into_glib(),
                get_mapping.to_glib_none().0,
                set_mapping.to_glib_none().0,
            );
        }
    }

    /// Create a binding between the writability of @key in the
    /// @self object and the property @property of @object.
    ///
    /// The property must be boolean; `sensitive` or `visible`
    /// properties of widgets are the most likely candidates.
    ///
    /// Writable bindings are always uni-directional; changes of the
    /// writability of the setting will be propagated to the object
    /// property, not the other way.
    ///
    /// When the @inverted argument is true, the binding inverts the
    /// value as it passes from the setting to the object, i.e. @property
    /// will be set to true if the key is not writable.
    ///
    /// Note that the lifecycle of the binding is tied to @object,
    /// and that you can have only one binding per object property.
    /// If you bind the same property twice on the same object, the second
    /// binding overrides the first one.
    /// ## `key`
    /// the key to bind
    /// ## `object`
    /// the object with property to bind
    /// ## `property`
    /// the name of a boolean property to bind
    /// ## `inverted`
    ///  the value
    #[doc(alias = "g_settings_bind_writable")]
    fn bind_writable(
        &self,
        key: &str,
        object: &impl IsA<glib::Object>,
        property: &str,
        inverted: bool,
    ) {
        unsafe {
            ffi::g_settings_bind_writable(
                self.as_ref().to_glib_none().0,
                key.to_glib_none().0,
                object.as_ref().to_glib_none().0,
                property.to_glib_none().0,
                inverted.into_glib(),
            );
        }
    }

    /// Creates a [`Action`][crate::Action] corresponding to a given [`Settings`][crate::Settings] key.
    ///
    /// The action has the same name as the key.
    ///
    /// The value of the key becomes the state of the action and the action
    /// is enabled when the key is writable.  Changing the state of the
    /// action results in the key being written to.  Changes to the value or
    /// writability of the key cause appropriate change notifications to be
    /// emitted for the action.
    ///
    /// For boolean-valued keys, action activations take no parameter and
    /// result in the toggling of the value.  For all other types,
    /// activations take the new value for the key (which must have the
    /// correct type).
    /// ## `key`
    /// the name of a key in @self
    ///
    /// # Returns
    ///
    /// a new [`Action`][crate::Action]
    #[doc(alias = "g_settings_create_action")]
    fn create_action(&self, key: &str) -> Action {
        unsafe {
            from_glib_full(ffi::g_settings_create_action(
                self.as_ref().to_glib_none().0,
                key.to_glib_none().0,
            ))
        }
    }

    ///  mode](class.Settings.html#delay-apply-mode).
    ///
    /// In this
    /// mode, changes to @self are not immediately propagated to the
    /// backend, but kept locally until [`apply()`][Self::apply()] is called.
    #[doc(alias = "g_settings_delay")]
    fn delay(&self) {
        unsafe {
            ffi::g_settings_delay(self.as_ref().to_glib_none().0);
        }
    }

    //#[doc(alias = "g_settings_get")]
    //fn get(&self, key: &str, format: &str, : /*Unknown conversion*//*Unimplemented*/Basic: VarArgs) {
    //    unsafe { TODO: call ffi:g_settings_get() }
    //}

    /// t specified as
    /// having a `b` type in the schema for @self (see [`glib::VariantType`][crate::glib::VariantType]).
    /// ## `key`
    /// the key to get the value for
    ///
    /// # Returns
    ///
    /// a boolean
    #[doc(alias = "g_settings_get_boolean")]
    #[doc(alias = "get_boolean")]
    fn boolean(&self, key: &str) -> bool {
        unsafe {
            from_glib(ffi::g_settings_get_boolean(
                self.as_ref().to_glib_none().0,
                key.to_glib_none().0,
            ))
        }
    }

    /// ` element.
    ///
    /// The created child settings object will inherit the
    /// [`delay-apply`][struct@crate::Settings#delay-apply] mode from @self.
    /// ## `name`
    /// the name of the child schema
    ///
    /// # Returns
    ///
    ///  settings object
    #[doc(alias = "g_settings_get_child")]
    #[doc(alias = "get_child")]
    #[must_use]
    fn child(&self, name: &str) -> Settings {
        unsafe {
            from_glib_full(ffi::g_settings_get_child(
                self.as_ref().to_glib_none().0,
                name.to_glib_none().0,
            ))
        }
    }

    /// t contained in the
    /// schema for @self.
    /// ## `key`
    /// the key to get the default value for
    ///
    /// # Returns
    ///
    /// the default value
    #[doc(alias = "g_settings_get_default_value")]
    #[doc(alias = "get_default_value")]
    fn default_value(&self, key: &str) -> Option<glib::Variant> {
        unsafe {
            from_glib_full(ffi::g_settings_get_default_value(
                self.as_ref().to_glib_none().0,
                key.to_glib_none().0,
            ))
        }
    }

    /// t specified as
    /// having a `d` type in the schema for @self (see [`glib::VariantType`][crate::glib::VariantType]).
    /// ## `key`
    /// the key to get the value for
    ///
    /// # Returns
    ///
    /// a double
    #[doc(alias = "g_settings_get_double")]
    #[doc(alias = "get_double")]
    fn double(&self, key: &str) -> f64 {
        unsafe { ffi::g_settings_get_double(self.as_ref().to_glib_none().0, key.to_glib_none().0) }
    }

    /// t contained in the
    /// schema for @self or is not marked as an enumerated type.
    ///
    /// If the value stored in the configuration database is not a valid
    /// value for the enumerated type then this function will return the
    /// default value.
    /// ## `key`
    /// the key to get the value for
    ///
    /// # Returns
    ///
    /// the enum value
    #[doc(alias = "g_settings_get_enum")]
    #[doc(alias = "get_enum")]
    fn enum_(&self, key: &str) -> i32 {
        unsafe { ffi::g_settings_get_enum(self.as_ref().to_glib_none().0, key.to_glib_none().0) }
    }

    /// t contained in the
    /// schema for @self or is not marked as a flags type.
    ///
    /// If the value stored in the configuration database is not a valid
    /// value for the flags type then this function will return the default
    /// value.
    /// ## `key`
    /// the key to get the value for
    ///
    /// # Returns
    ///
    /// the flags value
    #[doc(alias = "g_settings_get_flags")]
    #[doc(alias = "get_flags")]
    fn flags(&self, key: &str) -> u32 {
        unsafe { ffi::g_settings_get_flags(self.as_ref().to_glib_none().0, key.to_glib_none().0) }
    }

    ///  mode](class.Settings.html#delay-apply-mode).
    ///
    /// # Returns
    ///
    /// true if @self has unapplied changes, false otherwise
    #[doc(alias = "g_settings_get_has_unapplied")]
    #[doc(alias = "get_has_unapplied")]
    #[doc(alias = "has-unapplied")]
    fn has_unapplied(&self) -> bool {
        unsafe {
            from_glib(ffi::g_settings_get_has_unapplied(
                self.as_ref().to_glib_none().0,
            ))
        }
    }

    /// t specified as
    /// having an `i` type in the schema for @self (see [`glib::VariantType`][crate::glib::VariantType]).
    /// ## `key`
    /// the key to get the value for
    ///
    /// # Returns
    ///
    /// an integer
    #[doc(alias = "g_settings_get_int")]
    #[doc(alias = "get_int")]
    fn int(&self, key: &str) -> i32 {
        unsafe { ffi::g_settings_get_int(self.as_ref().to_glib_none().0, key.to_glib_none().0) }
    }

    /// t specified as
    /// having an `x` type in the schema for @self (see [`glib::VariantType`][crate::glib::VariantType]).
    /// ## `key`
    /// the key to get the value for
    ///
    /// # Returns
    ///
    /// a 64-bit integer
    #[doc(alias = "g_settings_get_int64")]
    #[doc(alias = "get_int64")]
    fn int64(&self, key: &str) -> i64 {
        unsafe { ffi::g_settings_get_int64(self.as_ref().to_glib_none().0, key.to_glib_none().0) }
    }

    //#[doc(alias = "g_settings_get_mapped")]
    //#[doc(alias = "get_mapped")]
    //fn mapped(&self, key: &str, mapping: /*Unimplemented*/FnMut(Option<&glib::Variant>, /*Unimplemented*/Option<Basic: Pointer>) -> bool, user_data: /*Unimplemented*/Option<Basic: Pointer>) -> /*Unimplemented*/Option<Basic: Pointer> {
    //    unsafe { TODO: call ffi:g_settings_get_mapped() }
    //}

    /// t specified as
    /// having an `s` type in the schema for @self (see [`glib::VariantType`][crate::glib::VariantType]).
    /// ## `key`
    /// the key to get the value for
    ///
    /// # Returns
    ///
    /// a newly-allocated string
    #[doc(alias = "g_settings_get_string")]
    #[doc(alias = "get_string")]
    fn string(&self, key: &str) -> glib::GString {
        unsafe {
            from_glib_full(ffi::g_settings_get_string(
                self.as_ref().to_glib_none().0,
                key.to_glib_none().0,
            ))
        }
    }

    /// t specified as
    /// having a `u` type in the schema for @self (see [`glib::VariantType`][crate::glib::VariantType]).
    /// ## `key`
    /// the key to get the value for
    ///
    /// # Returns
    ///
    /// an unsigned integer
    #[doc(alias = "g_settings_get_uint")]
    #[doc(alias = "get_uint")]
    fn uint(&self, key: &str) -> u32 {
        unsafe { ffi::g_settings_get_uint(self.as_ref().to_glib_none().0, key.to_glib_none().0) }
    }

    /// t specified as
    /// having a `t` type in the schema for @self (see [`glib::VariantType`][crate::glib::VariantType]).
    /// ## `key`
    /// the key to get the value for
    ///
    /// # Returns
    ///
    /// a 64-bit unsigned integer
    #[doc(alias = "g_settings_get_uint64")]
    #[doc(alias = "get_uint64")]
    fn uint64(&self, key: &str) -> u64 {
        unsafe { ffi::g_settings_get_uint64(self.as_ref().to_glib_none().0, key.to_glib_none().0) }
    }

    /// t contained in the
    /// schema for @self.
    /// ## `key`
    /// the key to get the user value for
    ///
    /// # Returns
    ///
    /// s value, if set
    #[doc(alias = "g_settings_get_user_value")]
    #[doc(alias = "get_user_value")]
    fn user_value(&self, key: &str) -> Option<glib::Variant> {
        unsafe {
            from_glib_full(ffi::g_settings_get_user_value(
                self.as_ref().to_glib_none().0,
                key.to_glib_none().0,
            ))
        }
    }

    /// t contained in the
    /// schema for @self.
    /// ## `key`
    /// the key to get the value for
    ///
    /// # Returns
    ///
    /// a new [`glib::Variant`][struct@crate::glib::Variant]
    #[doc(alias = "g_settings_get_value")]
    #[doc(alias = "get_value")]
    fn value(&self, key: &str) -> glib::Variant {
        unsafe {
            from_glib_full(ffi::g_settings_get_value(
                self.as_ref().to_glib_none().0,
                key.to_glib_none().0,
            ))
        }
    }

    /// Finds out if a key can be written.
    /// ## `name`
    /// the name of a key
    ///
    /// # Returns
    ///
    /// true if the key @name is writable, false otherwise
    #[doc(alias = "g_settings_is_writable")]
    fn is_writable(&self, name: &str) -> bool {
        unsafe {
            from_glib(ffi::g_settings_is_writable(
                self.as_ref().to_glib_none().0,
                name.to_glib_none().0,
            ))
        }
    }

    ///  code, since
    /// you should already know what children are in your schema. This function
    /// may still be useful there for introspection reasons, however.
    ///
    /// You should free the return value with `strfreev()` when you are done
    /// with it.
    ///
    /// # Returns
    ///
    /// a list of the children
    ///   on @self, in no defined order
    #[doc(alias = "g_settings_list_children")]
    fn list_children(&self) -> Vec<glib::GString> {
        unsafe {
            FromGlibPtrContainer::from_glib_full(ffi::g_settings_list_children(
                self.as_ref().to_glib_none().0,
            ))
        }
    }

    /// Resets @key to its default value.
    ///
    /// This call resets the key, as much as possible, to its default value.
    /// That might be the value specified in the schema or the one set by the
    /// administrator.
    /// ## `key`
    /// the name of a key
    #[doc(alias = "g_settings_reset")]
    fn reset(&self, key: &str) {
        unsafe {
            ffi::g_settings_reset(self.as_ref().to_glib_none().0, key.to_glib_none().0);
        }
    }

    ///  mode](class.Settings.html#delay-apply-mode).  In the normal
    /// case settings are always applied immediately.
    ///
    /// Change notifications will be emitted for affected keys.
    #[doc(alias = "g_settings_revert")]
    fn revert(&self) {
        unsafe {
            ffi::g_settings_revert(self.as_ref().to_glib_none().0);
        }
    }

    //#[doc(alias = "g_settings_set")]
    //fn set(&self, key: &str, format: &str, : /*Unknown conversion*//*Unimplemented*/Basic: VarArgs) -> bool {
    //    unsafe { TODO: call ffi:g_settings_set() }
    //}

    /// t specified as
    /// having a `b` type in the schema for @self (see [`glib::VariantType`][crate::glib::VariantType]).
    /// ## `key`
    /// the key to set the value for
    /// ## `value`
    /// the value to set it to
    ///
    /// # Returns
    ///
    /// true if setting the key succeeded,
    ///   false if the key was not writable
    #[doc(alias = "g_settings_set_boolean")]
    fn set_boolean(&self, key: &str, value: bool) -> Result<(), glib::error::BoolError> {
        unsafe {
            glib::result_from_gboolean!(
                ffi::g_settings_set_boolean(
                    self.as_ref().to_glib_none().0,
                    key.to_glib_none().0,
                    value.into_glib()
                ),
                "Can't set readonly key"
            )
        }
    }

    /// t specified as
    /// having a `d` type in the schema for @self (see [`glib::VariantType`][crate::glib::VariantType]).
    /// ## `key`
    /// the key to set the value for
    /// ## `value`
    /// the value to set it to
    ///
    /// # Returns
    ///
    /// true if setting the key succeeded,
    ///   false if the key was not writable
    #[doc(alias = "g_settings_set_double")]
    fn set_double(&self, key: &str, value: f64) -> Result<(), glib::error::BoolError> {
        unsafe {
            glib::result_from_gboolean!(
                ffi::g_settings_set_double(
                    self.as_ref().to_glib_none().0,
                    key.to_glib_none().0,
                    value
                ),
                "Can't set readonly key"
            )
        }
    }

    ///  associated with
    /// @value.
    /// ## `key`
    /// the key to set the value for
    /// ## `value`
    /// an enumerated value
    ///
    /// # Returns
    ///
    /// true if the set succeeds, false otherwise
    #[doc(alias = "g_settings_set_enum")]
    fn set_enum(&self, key: &str, value: i32) -> Result<(), glib::error::BoolError> {
        unsafe {
            glib::result_from_gboolean!(
                ffi::g_settings_set_enum(
                    self.as_ref().to_glib_none().0,
                    key.to_glib_none().0,
                    value
                ),
                "Can't set readonly key"
            )
        }
    }

    /// ; one for each
    /// bit in @value.
    /// ## `key`
    /// the key to set the value for
    /// ## `value`
    /// a flags value
    ///
    /// # Returns
    ///
    /// true if the set succeeds, false otherwise
    #[doc(alias = "g_settings_set_flags")]
    fn set_flags(&self, key: &str, value: u32) -> Result<(), glib::error::BoolError> {
        unsafe {
            glib::result_from_gboolean!(
                ffi::g_settings_set_flags(
                    self.as_ref().to_glib_none().0,
                    key.to_glib_none().0,
                    value
                ),
                "Can't set readonly key"
            )
        }
    }

    /// t specified as
    /// having an `i` type in the schema for @self (see [`glib::VariantType`][crate::glib::VariantType]).
    /// ## `key`
    /// the key to set the value for
    /// ## `value`
    /// the value to set it to
    ///
    /// # Returns
    ///
    /// true if setting the key succeeded,
    ///   false if the key was not writable
    #[doc(alias = "g_settings_set_int")]
    fn set_int(&self, key: &str, value: i32) -> Result<(), glib::error::BoolError> {
        unsafe {
            glib::result_from_gboolean!(
                ffi::g_settings_set_int(
                    self.as_ref().to_glib_none().0,
                    key.to_glib_none().0,
                    value
                ),
                "Can't set readonly key"
            )
        }
    }

    /// t specified as
    /// having an `x` type in the schema for @self (see [`glib::VariantType`][crate::glib::VariantType]).
    /// ## `key`
    /// the key to set the value for
    /// ## `value`
    /// the value to set it to
    ///
    /// # Returns
    ///
    /// true if setting the key succeeded,
    ///   false if the key was not writable
    #[doc(alias = "g_settings_set_int64")]
    fn set_int64(&self, key: &str, value: i64) -> Result<(), glib::error::BoolError> {
        unsafe {
            glib::result_from_gboolean!(
                ffi::g_settings_set_int64(
                    self.as_ref().to_glib_none().0,
                    key.to_glib_none().0,
                    value
                ),
                "Can't set readonly key"
            )
        }
    }

    /// t specified as
    /// having an `s` type in the schema for @self (see [`glib::VariantType`][crate::glib::VariantType]).
    /// ## `key`
    /// the key to set the value for
    /// ## `value`
    /// the value to set it to
    ///
    /// # Returns
    ///
    /// true if setting the key succeeded,
    ///   false if the key was not writable
    #[doc(alias = "g_settings_set_string")]
    fn set_string(&self, key: &str, value: &str) -> Result<(), glib::error::BoolError> {
        unsafe {
            glib::result_from_gboolean!(
                ffi::g_settings_set_string(
                    self.as_ref().to_glib_none().0,
                    key.to_glib_none().0,
                    value.to_glib_none().0
                ),
                "Can't set readonly key"
            )
        }
    }

    /// t specified as
    /// having a `u` type in the schema for @self (see [`glib::VariantType`][crate::glib::VariantType]).
    /// ## `key`
    /// the key to set the value for
    /// ## `value`
    /// the value to set it to
    ///
    /// # Returns
    ///
    /// true if setting the key succeeded,
    ///   false if the key was not writable
    #[doc(alias = "g_settings_set_uint")]
    fn set_uint(&self, key: &str, value: u32) -> Result<(), glib::error::BoolError> {
        unsafe {
            glib::result_from_gboolean!(
                ffi::g_settings_set_uint(
                    self.as_ref().to_glib_none().0,
                    key.to_glib_none().0,
                    value
                ),
                "Can't set readonly key"
            )
        }
    }

    /// t specified as
    /// having a `t` type in the schema for @self (see [`glib::VariantType`][crate::glib::VariantType]).
    /// ## `key`
    /// the key to set the value for
    /// ## `value`
    /// the value to set it to
    ///
    /// # Returns
    ///
    /// true if setting the key succeeded,
    ///   false if the key was not writable
    #[doc(alias = "g_settings_set_uint64")]
    fn set_uint64(&self, key: &str, value: u64) -> Result<(), glib::error::BoolError> {
        unsafe {
            glib::result_from_gboolean!(
                ffi::g_settings_set_uint64(
                    self.as_ref().to_glib_none().0,
                    key.to_glib_none().0,
                    value
                ),
                "Can't set readonly key"
            )
        }
    }

    /// t contained in the
    /// schema for @self or for @value to have the incorrect type, per
    /// the schema.
    ///
    /// If @value is floating then this function consumes the reference.
    /// ## `key`
    /// the key to set the value for
    /// ## `value`
    /// a [`glib::Variant`][struct@crate::glib::Variant] of the correct type
    ///
    /// # Returns
    ///
    /// true if setting the key succeeded,
    ///   false if the key was not writable
    #[doc(alias = "g_settings_set_value")]
    fn set_value(&self, key: &str, value: &glib::Variant) -> Result<(), glib::error::BoolError> {
        unsafe {
            glib::result_from_gboolean!(
                ffi::g_settings_set_value(
                    self.as_ref().to_glib_none().0,
                    key.to_glib_none().0,
                    value.to_glib_none().0
                ),
                "Can't set readonly key"
            )
        }
    }

    /// The name of the context that the settings are stored in.
    fn backend(&self) -> Option<SettingsBackend> {
        ObjectExt::property(self.as_ref(), "backend")
    }

    ///  mode](class.Settings.html#delay-apply-mode).
    #[doc(alias = "delay-apply")]
    fn is_delay_apply(&self) -> bool {
        ObjectExt::property(self.as_ref(), "delay-apply")
    }

    /// The path within the backend where the settings are stored.
    fn path(&self) -> Option<glib::GString> {
        ObjectExt::property(self.as_ref(), "path")
    }

    /// The name of the schema that describes the types of keys
    /// for this [`Settings`][crate::Settings] object.
    #[doc(alias = "schema-id")]
    fn schema_id(&self) -> Option<glib::GString> {
        ObjectExt::property(self.as_ref(), "schema-id")
    }

    /// The [`SettingsSchema`][crate::SettingsSchema] describing the types of keys for this
    /// [`Settings`][crate::Settings] object.
    ///
    /// Ideally, this property would be called [`schema`][struct@crate::Settings#schema].
    /// [`SettingsSchema`][crate::SettingsSchema]
    /// has only existed since version 2.32, however, and before then the
    /// [`schema`][struct@crate::Settings#schema] property was used to refer to the ID of the schema rather
    /// than the schema itself.  Take care.
    #[doc(alias = "settings-schema")]
    fn settings_schema(&self) -> Option<SettingsSchema> {
        ObjectExt::property(self.as_ref(), "settings-schema")
    }

    //#[doc(alias = "change-event")]
    //fn connect_change_event<Unsupported or ignored types>(&self, f: F) -> SignalHandlerId {
    //    Unimplemented keys: *.CArray TypeId { ns_id: 3, id: 13 }
    //}

    /// Emitted when a key has potentially changed.
    ///
    /// You should call one of the `Gio::Settings::get()` calls to check the new
    /// value.
    ///
    /// This signal supports detailed connections.  You can connect to the
    /// detailed signal `changed::x` in order to only receive callbacks
    /// when key `x` changes.
    ///
    /// Note that @settings only emits this signal if you have read @key at
    /// least once while a signal handler was already connected for @key.
    /// ## `key`
    /// the name of the key that changed
    #[doc(alias = "changed")]
    fn connect_changed<F: Fn(&Self, &str) + 'static>(
        &self,
        detail: Option<&str>,
        f: F,
    ) -> SignalHandlerId {
        unsafe extern "C" fn changed_trampoline<P: IsA<Settings>, F: Fn(&P, &str) + 'static>(
            this: *mut ffi::GSettings,
            key: *mut std::ffi::c_char,
            f: glib::ffi::gpointer,
        ) {
            unsafe {
                let f: &F = &*(f as *const F);
                f(
                    Settings::from_glib_borrow(this).unsafe_cast_ref(),
                    &glib::GString::from_glib_borrow(key),
                )
            }
        }
        unsafe {
            let f: Box_<F> = Box_::new(f);
            let detailed_signal_name = detail.map(|name| format!("changed::{name}\0"));
            let signal_name = detailed_signal_name.as_ref().map_or(c"changed", |n| {
                std::ffi::CStr::from_bytes_with_nul_unchecked(n.as_bytes())
            });
            connect_raw(
                self.as_ptr() as *mut _,
                signal_name.as_ptr(),
                Some(std::mem::transmute::<*const (), unsafe extern "C" fn()>(
                    changed_trampoline::<Self, F> as *const (),
                )),
                Box_::into_raw(f),
            )
        }
    }

    /// Emitted once per writability change event that affects this settings object.
    ///
    /// You should connect
    /// to this signal if you are interested in viewing groups of changes
    /// before they are split out into multiple emissions of the
    /// [`writable-changed`][struct@crate::Settings#writable-changed] signal.  For most use cases it is more
    /// appropriate to use the [`writable-changed`][struct@crate::Settings#writable-changed] signal.
    ///
    /// In the event that the writability change applies only to a single
    /// key, @key will be set to the `alias::GLib.Quark` for that key.  In the event
    /// that the writability change affects the entire settings object,
    /// @key will be `0`.
    ///
    /// The default handler for this signal invokes the [`writable-changed`][struct@crate::Settings#writable-changed]
    /// and [`changed`][struct@crate::Settings#changed] signals for each affected key.  This is done because
    /// changes in writability might also imply changes in value (if for
    /// example, a new mandatory setting is introduced).  If any other
    /// connected handler returns true then this default functionality
    /// will be suppressed.
    /// ## `key`
    /// the quark of the key, or `0`
    ///
    /// # Returns
    ///
    /// true to stop other handlers from being invoked for the
    ///   event, false to propagate the event further
    #[doc(alias = "writable-change-event")]
    fn connect_writable_change_event<F: Fn(&Self, u32) -> glib::Propagation + 'static>(
        &self,
        f: F,
    ) -> SignalHandlerId {
        unsafe extern "C" fn writable_change_event_trampoline<
            P: IsA<Settings>,
            F: Fn(&P, u32) -> glib::Propagation + 'static,
        >(
            this: *mut ffi::GSettings,
            key: std::ffi::c_uint,
            f: glib::ffi::gpointer,
        ) -> glib::ffi::gboolean {
            unsafe {
                let f: &F = &*(f as *const F);
                f(Settings::from_glib_borrow(this).unsafe_cast_ref(), key).into_glib()
            }
        }
        unsafe {
            let f: Box_<F> = Box_::new(f);
            connect_raw(
                self.as_ptr() as *mut _,
                c"writable-change-event".as_ptr(),
                Some(std::mem::transmute::<*const (), unsafe extern "C" fn()>(
                    writable_change_event_trampoline::<Self, F> as *const (),
                )),
                Box_::into_raw(f),
            )
        }
    }

    /// Emitted when the writability of a key has potentially changed.
    ///
    /// You should call [`is_writable()`][Self::is_writable()] in order to determine the
    /// new status.
    ///
    /// This signal supports detailed connections.  You can connect to the
    /// detailed signal `writable-changed::x` in order to only receive
    /// callbacks when the writability of `x` changes.
    /// ## `key`
    /// the key
    #[doc(alias = "writable-changed")]
    fn connect_writable_changed<F: Fn(&Self, &str) + 'static>(
        &self,
        detail: Option<&str>,
        f: F,
    ) -> SignalHandlerId {
        unsafe extern "C" fn writable_changed_trampoline<
            P: IsA<Settings>,
            F: Fn(&P, &str) + 'static,
        >(
            this: *mut ffi::GSettings,
            key: *mut std::ffi::c_char,
            f: glib::ffi::gpointer,
        ) {
            unsafe {
                let f: &F = &*(f as *const F);
                f(
                    Settings::from_glib_borrow(this).unsafe_cast_ref(),
                    &glib::GString::from_glib_borrow(key),
                )
            }
        }
        unsafe {
            let f: Box_<F> = Box_::new(f);
            let detailed_signal_name = detail.map(|name| format!("writable-changed::{name}\0"));
            let signal_name = detailed_signal_name
                .as_ref()
                .map_or(c"writable-changed", |n| {
                    std::ffi::CStr::from_bytes_with_nul_unchecked(n.as_bytes())
                });
            connect_raw(
                self.as_ptr() as *mut _,
                signal_name.as_ptr(),
                Some(std::mem::transmute::<*const (), unsafe extern "C" fn()>(
                    writable_changed_trampoline::<Self, F> as *const (),
                )),
                Box_::into_raw(f),
            )
        }
    }

    #[doc(alias = "delay-apply")]
    fn connect_delay_apply_notify<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId {
        unsafe extern "C" fn notify_delay_apply_trampoline<
            P: IsA<Settings>,
            F: Fn(&P) + 'static,
        >(
            this: *mut ffi::GSettings,
            _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::delay-apply".as_ptr(),
                Some(std::mem::transmute::<*const (), unsafe extern "C" fn()>(
                    notify_delay_apply_trampoline::<Self, F> as *const (),
                )),
                Box_::into_raw(f),
            )
        }
    }

    #[doc(alias = "has-unapplied")]
    fn connect_has_unapplied_notify<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId {
        unsafe extern "C" fn notify_has_unapplied_trampoline<
            P: IsA<Settings>,
            F: Fn(&P) + 'static,
        >(
            this: *mut ffi::GSettings,
            _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::has-unapplied".as_ptr(),
                Some(std::mem::transmute::<*const (), unsafe extern "C" fn()>(
                    notify_has_unapplied_trampoline::<Self, F> as *const (),
                )),
                Box_::into_raw(f),
            )
        }
    }
}

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