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

glib::wrapper! {
    /// The `GSettings` class provides a convenient API for storing and retrieving
    /// application settings.
    ///
    /// Reads and writes can be considered to be non-blocking.  Reading
    /// settings with `GSettings` is typically extremely fast: on
    /// approximately the same order of magnitude (but slower than) a
    /// `GLib::HashTable` lookup.  Writing settings is also extremely fast in
    /// terms of time to return to your application, but can be extremely expensive
    /// for other threads and other processes.  Many settings backends
    /// (including dconf) have lazy initialisation which means in the common
    /// case of the user using their computer without modifying any settings
    /// a lot of work can be avoided.  For dconf, the D-Bus service doesn’t
    /// even need to be started in this case.  For this reason, you should
    /// only ever modify `GSettings` keys in response to explicit user action.
    /// Particular care should be paid to ensure that modifications are not
    /// made during startup — for example, when setting the initial value
    /// of preferences widgets.  The built-in [`SettingsExtManual::bind()`][crate::prelude::SettingsExtManual::bind()]
    /// functionality is careful not to write settings in response to notify signals
    /// as a result of modifications that it makes to widgets.
    ///
    /// When creating a `GSettings` instance, you have to specify a schema
    /// that describes the keys in your settings and their types and default
    /// values, as well as some other information.
    ///
    /// Normally, a schema has a fixed path that determines where the settings
    /// are stored in the conceptual global tree of settings. However, schemas
    /// can also be ‘[relocatable](#relocatable-schemas)’, i.e. not equipped with
    /// a fixed path. This is
    /// useful e.g. when the schema describes an ‘account’, and you want to be
    /// able to store a arbitrary number of accounts.
    ///
    /// Paths must start with and end with a forward slash character (`/`)
    /// and must not contain two sequential slash characters.  Paths should
    /// be chosen based on a domain name associated with the program or
    /// library to which the settings belong.  Examples of paths are
    /// `/org/gtk/settings/file-chooser/` and `/ca/desrt/dconf-editor/`.
    /// Paths should not start with `/apps/`, `/desktop/` or `/system/` as
    /// they often did in GConf.
    ///
    /// Unlike other configuration systems (like GConf), GSettings does not
    /// restrict keys to basic types like strings and numbers. GSettings stores
    /// values as [`glib::Variant`][struct@crate::glib::Variant], and allows any [type@GLib.VariantType] for
    /// keys. Key names are restricted to lowercase characters, numbers and `-`.
    /// Furthermore, the names must begin with a lowercase character, must not end
    /// with a `-`, and must not contain consecutive dashes.
    ///
    /// Similar to GConf, the default values in GSettings schemas can be
    /// localized, but the localized values are stored in gettext catalogs
    /// and looked up with the domain that is specified in the
    /// `gettext-domain` attribute of the `<schemalist>` or `<schema>`
    /// elements and the category that is specified in the `l10n` attribute of
    /// the `<default>` element. The string which is translated includes all text in
    /// the `<default>` element, including any surrounding quotation marks.
    ///
    /// The `l10n` attribute must be set to `messages` or `time`, and sets the
    /// [locale category for
    /// translation](https://www.gnu.org/software/gettext/manual/html_node/Aspects.html#index-locale-categories-1).
    /// The `messages` category should be used by default; use `time` for
    /// translatable date or time formats. A translation comment can be added as an
    /// XML comment immediately above the `<default>` element — it is recommended to
    /// add these comments to aid translators understand the meaning and
    /// implications of the default value. An optional translation `context`
    /// attribute can be set on the `<default>` element to disambiguate multiple
    /// defaults which use the same string.
    ///
    /// For example:
    /// ```xml
    ///  <!-- Translators: A list of words which are not allowed to be typed, in
    ///       GVariant serialization syntax.
    ///       See: https://developer.gnome.org/glib/stable/gvariant-text.html -->
    ///  <default l10n='messages' context='Banned words'>['bad', 'words']</default>
    /// ```
    ///
    /// Translations of default values must remain syntactically valid serialized
    /// [`glib::Variant`][struct@crate::glib::Variant]s (e.g. retaining any surrounding quotation marks) or
    /// runtime errors will occur.
    ///
    /// GSettings uses schemas in a compact binary form that is created
    /// by the [`glib-compile-schemas`](glib-compile-schemas.html)
    /// utility. The input is a schema description in an XML format.
    ///
    /// A DTD for the gschema XML format can be found here:
    /// [gschema.dtd](https://gitlab.gnome.org/GNOME/glib/-/blob/HEAD/gio/gschema.dtd)
    ///
    /// The [`glib-compile-schemas`](glib-compile-schemas.html) tool expects schema
    /// files to have the extension `.gschema.xml`.
    ///
    /// At runtime, schemas are identified by their ID (as specified in the
    /// `id` attribute of the `<schema>` element). The convention for schema
    /// IDs is to use a dotted name, similar in style to a D-Bus bus name,
    /// e.g. `org.gnome.SessionManager`. In particular, if the settings are
    /// for a specific service that owns a D-Bus bus name, the D-Bus bus name
    /// and schema ID should match. For schemas which deal with settings not
    /// associated with one named application, the ID should not use
    /// StudlyCaps, e.g. `org.gnome.font-rendering`.
    ///
    /// In addition to [`glib::Variant`][struct@crate::glib::Variant] types, keys can have types that have
    /// enumerated types. These can be described by a `<choice>`,
    /// `<enum>` or `<flags>` element, as seen in the
    /// second example below. The underlying type of such a key
    /// is string, but you can use [`SettingsExt::enum_()`][crate::prelude::SettingsExt::enum_()],
    /// [`SettingsExt::set_enum()`][crate::prelude::SettingsExt::set_enum()], [`SettingsExt::flags()`][crate::prelude::SettingsExt::flags()],
    /// [`SettingsExt::set_flags()`][crate::prelude::SettingsExt::set_flags()] access the numeric values corresponding to
    /// the string value of enum and flags keys.
    ///
    /// An example for default value:
    /// ```xml
    /// <schemalist>
    ///   <schema id="org.gtk.Test" path="/org/gtk/Test/" gettext-domain="test">
    ///
    ///     <key name="greeting" type="s">
    ///       <default l10n="messages">"Hello, earthlings"</default>
    ///       <summary>A greeting</summary>
    ///       <description>
    ///         Greeting of the invading martians
    ///       </description>
    ///     </key>
    ///
    ///     <key name="box" type="(ii)">
    ///       <default>(20,30)</default>
    ///     </key>
    ///
    ///     <key name="empty-string" type="s">
    ///       <default>""</default>
    ///       <summary>Empty strings have to be provided in GVariant form</summary>
    ///     </key>
    ///
    ///   </schema>
    /// </schemalist>
    /// ```
    ///
    /// An example for ranges, choices and enumerated types:
    /// ```xml
    /// <schemalist>
    ///
    ///   <enum id="org.gtk.Test.myenum">
    ///     <value nick="first" value="1"/>
    ///     <value nick="second" value="2"/>
    ///   </enum>
    ///
    ///   <flags id="org.gtk.Test.myflags">
    ///     <value nick="flag1" value="1"/>
    ///     <value nick="flag2" value="2"/>
    ///     <value nick="flag3" value="4"/>
    ///   </flags>
    ///
    ///   <schema id="org.gtk.Test">
    ///
    ///     <key name="key-with-range" type="i">
    ///       <range min="1" max="100"/>
    ///       <default>10</default>
    ///     </key>
    ///
    ///     <key name="key-with-choices" type="s">
    ///       <choices>
    ///         <choice value='Elisabeth'/>
    ///         <choice value='Annabeth'/>
    ///         <choice value='Joe'/>
    ///       </choices>
    ///       <aliases>
    ///         <alias value='Anna' target='Annabeth'/>
    ///         <alias value='Beth' target='Elisabeth'/>
    ///       </aliases>
    ///       <default>'Joe'</default>
    ///     </key>
    ///
    ///     <key name='enumerated-key' enum='org.gtk.Test.myenum'>
    ///       <default>'first'</default>
    ///     </key>
    ///
    ///     <key name='flags-key' flags='org.gtk.Test.myflags'>
    ///       <default>["flag1","flag2"]</default>
    ///     </key>
    ///   </schema>
    /// </schemalist>
    /// ```
    ///
    /// ## Vendor overrides
    ///
    /// Default values are defined in the schemas that get installed by
    /// an application. Sometimes, it is necessary for a vendor or distributor
    /// to adjust these defaults. Since patching the XML source for the schema
    /// is inconvenient and error-prone,
    /// [`glib-compile-schemas`](glib-compile-schemas.html) reads so-called ‘vendor
    /// override’ files. These are keyfiles in the same directory as the XML
    /// schema sources which can override default values. The schema ID serves
    /// as the group name in the key file, and the values are expected in
    /// serialized [`glib::Variant`][struct@crate::glib::Variant] form, as in the following example:
    /// ```text
    /// [org.gtk.Example]
    /// key1='string'
    /// key2=1.5
    /// ```
    ///
    /// `glib-compile-schemas` expects schema files to have the extension
    /// `.gschema.override`.
    ///
    /// ## Binding
    ///
    /// A very convenient feature of GSettings lets you bind [`glib::Object`][crate::glib::Object]
    /// properties directly to settings, using [`SettingsExtManual::bind()`][crate::prelude::SettingsExtManual::bind()]. Once a
    /// [`glib::Object`][crate::glib::Object] property has been bound to a setting, changes on
    /// either side are automatically propagated to the other side. GSettings handles
    /// details like mapping between [`glib::Object`][crate::glib::Object] and [`glib::Variant`][struct@crate::glib::Variant]
    /// types, and preventing infinite cycles.
    ///
    /// This makes it very easy to hook up a preferences dialog to the
    /// underlying settings. To make this even more convenient, GSettings
    /// looks for a boolean property with the name `sensitivity` and
    /// automatically binds it to the writability of the bound setting.
    /// If this ‘magic’ gets in the way, it can be suppressed with the
    /// `G_SETTINGS_BIND_NO_SENSITIVITY` flag.
    ///
    /// ## Relocatable schemas
    ///
    /// A relocatable schema is one with no `path` attribute specified on its
    /// `<schema>` element. By using [`with_path()`][Self::with_path()], a `GSettings`
    /// object can be instantiated for a relocatable schema, assigning a path to the
    /// instance. Paths passed to [`with_path()`][Self::with_path()] will typically be
    /// constructed dynamically from a constant prefix plus some form of instance
    /// identifier; but they must still be valid GSettings paths. Paths could also
    /// be constant and used with a globally installed schema originating from a
    /// dependency library.
    ///
    /// For example, a relocatable schema could be used to store geometry information
    /// for different windows in an application. If the schema ID was
    /// `org.foo.MyApp.Window`, it could be instantiated for paths
    /// `/org/foo/MyApp/main/`, `/org/foo/MyApp/document-1/`,
    /// `/org/foo/MyApp/document-2/`, etc. If any of the paths are well-known
    /// they can be specified as `<child>` elements in the parent schema, e.g.:
    /// ```xml
    /// <schema id="org.foo.MyApp" path="/org/foo/MyApp/">
    ///   <child name="main" schema="org.foo.MyApp.Window"/>
    /// </schema>
    /// ```
    ///
    /// ## Build system integration
    ///
    /// ### Meson
    ///
    /// GSettings is natively supported by Meson's [GNOME module](https://mesonbuild.com/Gnome-module.html).
    ///
    /// You can install the schemas as any other data file:
    ///
    /// ```text
    /// install_data(
    ///   'org.foo.MyApp.gschema.xml',
    ///   install_dir: get_option('datadir') / 'glib-2.0/schemas',
    /// )
    /// ```
    ///
    /// You can use `gnome.post_install()` function to compile the schemas on
    /// installation:
    ///
    /// ```text
    /// gnome = import('gnome')
    /// gnome.post_install(
    ///   glib_compile_schemas: true,
    /// )
    /// ```
    ///
    /// If an enumerated type defined in a C header file is to be used in a GSettings
    /// schema, it can either be defined manually using an `<enum>` element in the
    /// schema XML, or it can be extracted automatically from the C header. This
    /// approach is preferred, as it ensures the two representations are always
    /// synchronised. To do so, you will need to use the `gnome.mkenums()` function
    /// with the following templates:
    ///
    /// ```text
    /// schemas_enums = gnome.mkenums('org.foo.MyApp.enums.xml',
    ///   comments: '<!-- @comment@ -->',
    ///   fhead: '<schemalist>',
    ///   vhead: '  <@type@ id="org.foo.MyApp.@EnumName@">',
    ///   vprod: '    <value nick="@valuenick@" value="@valuenum@"/>',
    ///   vtail: '  </@type@>',
    ///   ftail: '</schemalist>',
    ///   sources: enum_sources,
    ///   install_header: true,
    ///   install_dir: get_option('datadir') / 'glib-2.0/schemas',
    /// )
    /// ```
    ///
    /// It is recommended to validate your schemas as part of the test suite for
    /// your application:
    ///
    /// ```text
    /// test('validate-schema',
    ///   find_program('glib-compile-schemas'),
    ///   args: ['--strict', '--dry-run', meson.current_source_dir()],
    /// )
    /// ```
    ///
    /// If your application allows running uninstalled, you should also use the
    /// `gnome.compile_schemas()` function to compile the schemas in the current
    /// build directory:
    ///
    /// ```text
    /// gnome.compile_schemas()
    /// ```
    ///
    /// ### Autotools
    ///
    /// GSettings comes with autotools integration to simplify compiling and
    /// installing schemas. To add GSettings support to an application, add the
    /// following to your `configure.ac`:
    /// ```text
    /// GLIB_GSETTINGS
    /// ```
    ///
    /// In the appropriate `Makefile.am`, use the following snippet to compile and
    /// install the named schema:
    /// ```text
    /// gsettings_SCHEMAS = org.foo.MyApp.gschema.xml
    /// EXTRA_DIST = $(gsettings_SCHEMAS)
    ///
    /// @GSETTINGS_RULES@
    /// ```
    ///
    /// If an enumerated type defined in a C header file is to be used in a GSettings
    /// schema, it can either be defined manually using an `<enum>` element in the
    /// schema XML, or it can be extracted automatically from the C header. This
    /// approach is preferred, as it ensures the two representations are always
    /// synchronised. To do so, add the following to the relevant `Makefile.am`:
    /// ```text
    /// gsettings_ENUM_NAMESPACE = org.foo.MyApp
    /// gsettings_ENUM_FILES = my-app-enums.h my-app-misc.h
    /// ```
    ///
    /// `gsettings_ENUM_NAMESPACE` specifies the schema namespace for the enum files,
    /// which are specified in `gsettings_ENUM_FILES`. This will generate a
    /// `org.foo.MyApp.enums.xml` file containing the extracted enums, which will be
    /// automatically included in the schema compilation, install and uninstall
    /// rules. It should not be committed to version control or included in
    /// `EXTRA_DIST`.
    ///
    /// ## Localization
    ///
    /// No changes are needed to the build system to mark a schema XML file for
    /// translation. Assuming it sets the `gettext-domain` attribute, a schema may
    /// be marked for translation by adding it to `POTFILES.in`, assuming gettext
    /// 0.19 or newer is in use (the preferred method for translation):
    /// ```text
    /// data/org.foo.MyApp.gschema.xml
    /// ```
    ///
    /// Alternatively, if intltool 0.50.1 is in use:
    /// ```text
    /// [type: gettext/gsettings]data/org.foo.MyApp.gschema.xml
    /// ```
    ///
    /// GSettings will use gettext to look up translations for the `<summary>` and
    /// `<description>` elements, and also any `<default>` 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 | Writeable | Construct Only
    ///
    ///
    /// #### `delay-apply`
    ///  Whether the #GSettings object is in 'delay-apply' mode. See
    /// g_settings_delay() for details.
    ///
    /// Readable
    ///
    ///
    /// #### `has-unapplied`
    ///  If this property is [`true`], the #GSettings object has outstanding
    /// changes that will be applied when g_settings_apply() is called.
    ///
    /// Readable
    ///
    ///
    /// #### `path`
    ///  The path within the backend where the settings are stored.
    ///
    /// Readable | Writeable | Construct Only
    ///
    ///
    /// #### `schema`
    ///  The name of the schema that describes the types of keys
    /// for this #GSettings object.
    ///
    /// The type of this property is *not* #GSettingsSchema.
    /// #GSettingsSchema 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' property if you wish to pass in a
    /// #GSettingsSchema.
    ///
    /// Readable | Writeable | Construct Only
    ///
    ///
    /// #### `schema-id`
    ///  The name of the schema that describes the types of keys
    /// for this #GSettings object.
    ///
    /// Readable | Writeable | Construct Only
    ///
    ///
    /// #### `settings-schema`
    ///  The #GSettingsSchema describing the types of keys for this
    /// #GSettings object.
    ///
    /// Ideally, this property would be called 'schema'.  #GSettingsSchema
    /// has only existed since version 2.32, however, and before then the
    /// 'schema' property was used to refer to the ID of the schema rather
    /// than the schema itself.  Take care.
    ///
    /// Readable | Writeable | Construct Only
    ///
    /// ## Signals
    ///
    ///
    /// #### `change-event`
    ///  The "change-event" signal is 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" signal.
    /// For most use cases it is more appropriate to use the "changed" signal.
    ///
    /// In the event that the change event applies to one or more specified
    /// keys, @keys will be an array of #GQuark of length @n_keys.  In the
    /// event that the change event applies to the #GSettings object as a
    /// whole (ie: potentially every key has been changed) then @keys will
    /// be [`None`] and @n_keys will be 0.
    ///
    /// The default handler for this signal invokes the "changed" signal
    /// for each affected key.  If any other connected handler returns
    /// [`true`] then this default functionality will be suppressed.
    ///
    ///
    ///
    ///
    /// #### `changed`
    ///  The "changed" signal is emitted when a key has potentially changed.
    /// You should call one of the g_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`
    ///  The "writable-change-event" signal is 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" signal.  For most use cases it is more
    /// appropriate to use the "writable-changed" signal.
    ///
    /// In the event that the writability change applies only to a single
    /// key, @key will be set to the #GQuark 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"
    /// and "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`
    ///  The "writable-changed" signal is emitted when the writability of a
    /// key has potentially changed.  You should call
    /// g_settings_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 #GSettings 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), g_settings_schema_source_lookup()
    /// can be used to test for their existence before loading them.
    ///
    /// Signals on the newly created #GSettings object will be dispatched
    /// via the thread-default #GMainContext in effect at the time of the
    /// call to g_settings_new().  The new #GSettings will hold a reference
    /// on the context.  See g_main_context_push_thread_default().
    /// ## `schema_id`
    /// the id of the schema
    ///
    /// # Returns
    ///
    /// a new #GSettings 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 #GSettings 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 #GSettings object is a pure composition of
    /// 4 things: a #GSettingsSchema, a #GSettingsBackend, a path within that
    /// backend, and a #GMainContext to which signals are dispatched.
    ///
    /// This constructor therefore gives you full control over constructing
    /// #GSettings 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 g_settings_new()).
    ///
    /// If @backend is [`None`] then the default backend is used.
    ///
    /// If @path is [`None`] then the path from the schema is used.  It is an
    /// error if @path is [`None`] and the schema has no path of its own or if
    /// @path is non-[`None`] and not equal to the path that the schema does
    /// have.
    /// ## `schema`
    /// a #GSettingsSchema
    /// ## `backend`
    /// a #GSettingsBackend
    /// ## `path`
    /// the path to use
    ///
    /// # Returns
    ///
    /// a new #GSettings 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,
            ))
        }
    }

    /// Creates a new #GSettings object with the schema specified by
    /// @schema_id and a given #GSettingsBackend.
    ///
    /// Creating a #GSettings object with a different backend allows accessing
    /// settings from a database other than the usual one. For example, it may make
    /// sense to pass a backend corresponding to the "defaults" 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 #GSettingsBackend to use
    ///
    /// # Returns
    ///
    /// a new #GSettings 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 #GSettings object with the schema specified by
    /// @schema_id and a given #GSettingsBackend and path.
    ///
    /// This is a mix of g_settings_new_with_backend() and
    /// g_settings_new_with_path().
    /// ## `schema_id`
    /// the id of the schema
    /// ## `backend`
    /// the #GSettingsBackend to use
    /// ## `path`
    /// the path to use
    ///
    /// # Returns
    ///
    /// a new #GSettings 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,
            ))
        }
    }

    /// Creates a new #GSettings object with the relocatable schema specified
    /// by @schema_id and a given path.
    ///
    /// You only need to do this if you want to directly create a settings
    /// object with a schema that doesn't have a specified path of its own.
    /// That'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 #GSettings 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 #GSettings are handled asynchronously.  For this
    /// reason, it is very unlikely that the changes have it to disk by the
    /// time g_settings_set() returns.
    ///
    /// This call will block until all of the writes have made it to the
    /// backend.  Since the mainloop 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
    /// ## `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);
        }
    }
}

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

/// Trait containing all [`struct@Settings`] methods.
///
/// # Implementors
///
/// [`Settings`][struct@crate::Settings]
pub trait SettingsExt: IsA<Settings> + sealed::Sealed + 'static {
    /// Applies any changes that have been made to the settings.  This
    /// function does nothing unless @self is in 'delay-apply' mode;
    /// see g_settings_delay().  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 g_settings_bind_with_mapping() using closures instead of callbacks
    /// for easier binding in other languages.
    /// ## `key`
    /// the key to bind
    /// ## `object`
    /// a #GObject
    /// ## `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 [`None`] to use the default GIO mapping
    /// ## `set_mapping`
    /// a function that gets called to convert values
    ///     from @object to @self, or [`None`] 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`
    /// a #GObject
    /// ## `property`
    /// the name of a boolean property to bind
    /// ## `inverted`
    /// whether to 'invert' 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 #GAction corresponding to a given #GSettings 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 #GAction
    #[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,
            ))
        }
    }

    /// Changes the #GSettings object into 'delay-apply' mode. In this
    /// mode, changes to @self are not immediately propagated to the
    /// backend, but kept locally until g_settings_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() }
    //}

    /// Gets the value that is stored at @key in @self.
    ///
    /// A convenience variant of g_settings_get() for booleans.
    ///
    /// It is a programmer error to give a @key that isn't specified as
    /// having a boolean type in the schema for @self.
    /// ## `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,
            ))
        }
    }

    /// Creates a child settings object which has a base path of
    /// `base-path/@name`, where `base-path` is the base path of
    /// @self.
    ///
    /// The schema for the child settings object must have been declared
    /// in the schema of @self using a `<child>` element.
    ///
    /// The created child settings object will inherit the #GSettings:delay-apply
    /// mode from @self.
    /// ## `name`
    /// the name of the child schema
    ///
    /// # Returns
    ///
    /// a 'child' 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,
            ))
        }
    }

    /// Gets the "default value" of a key.
    ///
    /// This is the value that would be read if g_settings_reset() were to be
    /// called on the key.
    ///
    /// Note that this may be a different value than returned by
    /// g_settings_schema_key_get_default_value() if the system administrator
    /// has provided a default value.
    ///
    /// Comparing the return values of g_settings_get_default_value() and
    /// g_settings_get_value() is not sufficient for determining if a value
    /// has been set because the user may have explicitly set the value to
    /// something that happens to be equal to the default.  The difference
    /// here is that if the default changes in the future, the user's key
    /// will still be set.
    ///
    /// This function may be useful for adding an indication to a UI of what
    /// the default value was before the user set it.
    ///
    /// It is a programmer error to give a @key that isn'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,
            ))
        }
    }

    /// Gets the value that is stored at @key in @self.
    ///
    /// A convenience variant of g_settings_get() for doubles.
    ///
    /// It is a programmer error to give a @key that isn't specified as
    /// having a 'double' type in the schema for @self.
    /// ## `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) }
    }

    /// Gets the value that is stored in @self for @key and converts it
    /// to the enum value that it represents.
    ///
    /// In order to use this function the type of the value must be a string
    /// and it must be marked in the schema file as an enumerated type.
    ///
    /// It is a programmer error to give a @key that isn'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) }
    }

    /// Gets the value that is stored in @self for @key and converts it
    /// to the flags value that it represents.
    ///
    /// In order to use this function the type of the value must be an array
    /// of strings and it must be marked in the schema file as a flags type.
    ///
    /// It is a programmer error to give a @key that isn'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) }
    }

    /// Returns whether the #GSettings object has any unapplied
    /// changes.  This can only be the case if it is in 'delayed-apply' mode.
    ///
    /// # Returns
    ///
    /// [`true`] if @self has unapplied changes
    #[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,
            ))
        }
    }

    /// Gets the value that is stored at @key in @self.
    ///
    /// A convenience variant of g_settings_get() for 32-bit integers.
    ///
    /// It is a programmer error to give a @key that isn't specified as
    /// having a int32 type in the schema for @self.
    /// ## `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) }
    }

    /// Gets the value that is stored at @key in @self.
    ///
    /// A convenience variant of g_settings_get() for 64-bit integers.
    ///
    /// It is a programmer error to give a @key that isn't specified as
    /// having a int64 type in the schema for @self.
    /// ## `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(&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() }
    //}

    /// Gets the value that is stored at @key in @self.
    ///
    /// A convenience variant of g_settings_get() for strings.
    ///
    /// It is a programmer error to give a @key that isn't specified as
    /// having a string type in the schema for @self.
    /// ## `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,
            ))
        }
    }

    /// Gets the value that is stored at @key in @self.
    ///
    /// A convenience variant of g_settings_get() for 32-bit unsigned
    /// integers.
    ///
    /// It is a programmer error to give a @key that isn't specified as
    /// having a uint32 type in the schema for @self.
    /// ## `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) }
    }

    /// Gets the value that is stored at @key in @self.
    ///
    /// A convenience variant of g_settings_get() for 64-bit unsigned
    /// integers.
    ///
    /// It is a programmer error to give a @key that isn't specified as
    /// having a uint64 type in the schema for @self.
    /// ## `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) }
    }

    /// Checks the "user value" of a key, if there is one.
    ///
    /// The user value of a key is the last value that was set by the user.
    ///
    /// After calling g_settings_reset() this function should always return
    /// [`None`] (assuming something is not wrong with the system
    /// configuration).
    ///
    /// It is possible that g_settings_get_value() will return a different
    /// value than this function.  This can happen in the case that the user
    /// set a value for a key that was subsequently locked down by the system
    /// administrator -- this function will return the user's old value.
    ///
    /// This function may be useful for adding a "reset" option to a UI or
    /// for providing indication that a particular value has been changed.
    ///
    /// It is a programmer error to give a @key that isn't contained in the
    /// schema for @self.
    /// ## `key`
    /// the key to get the user value for
    ///
    /// # Returns
    ///
    /// the user'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,
            ))
        }
    }

    /// Gets the value that is stored in @self for @key.
    ///
    /// It is a programmer error to give a @key that isn't contained in the
    /// schema for @self.
    /// ## `key`
    /// the key to get the value for
    ///
    /// # Returns
    ///
    /// a new #GVariant
    #[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 or not
    /// ## `name`
    /// the name of a key
    ///
    /// # Returns
    ///
    /// [`true`] if the key @name is writable
    #[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,
            ))
        }
    }

    /// Gets the list of children on @self.
    ///
    /// The list is exactly the list of strings for which it is not an error
    /// to call g_settings_get_child().
    ///
    /// There is little reason to call this function from "normal" 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 g_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);
        }
    }

    /// Reverts all non-applied changes to the settings.  This function
    /// does nothing unless @self is in 'delay-apply' mode; see
    /// g_settings_delay().  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() }
    //}

    /// Sets @key in @self to @value.
    ///
    /// A convenience variant of g_settings_set() for booleans.
    ///
    /// It is a programmer error to give a @key that isn't specified as
    /// having a boolean type in the schema for @self.
    /// ## `key`
    /// the name of the key to set
    /// ## `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"
            )
        }
    }

    /// Sets @key in @self to @value.
    ///
    /// A convenience variant of g_settings_set() for doubles.
    ///
    /// It is a programmer error to give a @key that isn't specified as
    /// having a 'double' type in the schema for @self.
    /// ## `key`
    /// the name of the key to set
    /// ## `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"
            )
        }
    }

    /// Looks up the enumerated type nick for @value and writes it to @key,
    /// within @self.
    ///
    /// It is a programmer error to give a @key that isn't contained in the
    /// schema for @self or is not marked as an enumerated type, or for
    /// @value not to be a valid value for the named type.
    ///
    /// After performing the write, accessing @key directly with
    /// g_settings_get_string() will return the 'nick' associated with
    /// @value.
    /// ## `key`
    /// a key, within @self
    /// ## `value`
    /// an enumerated value
    ///
    /// # Returns
    ///
    /// [`true`], if the set succeeds
    #[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"
            )
        }
    }

    /// Looks up the flags type nicks for the bits specified by @value, puts
    /// them in an array of strings and writes the array to @key, within
    /// @self.
    ///
    /// It is a programmer error to give a @key that isn't contained in the
    /// schema for @self or is not marked as a flags type, or for @value
    /// to contain any bits that are not value for the named type.
    ///
    /// After performing the write, accessing @key directly with
    /// g_settings_get_strv() will return an array of 'nicks'; one for each
    /// bit in @value.
    /// ## `key`
    /// a key, within @self
    /// ## `value`
    /// a flags value
    ///
    /// # Returns
    ///
    /// [`true`], if the set succeeds
    #[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"
            )
        }
    }

    /// Sets @key in @self to @value.
    ///
    /// A convenience variant of g_settings_set() for 32-bit integers.
    ///
    /// It is a programmer error to give a @key that isn't specified as
    /// having a int32 type in the schema for @self.
    /// ## `key`
    /// the name of the key to set
    /// ## `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"
            )
        }
    }

    /// Sets @key in @self to @value.
    ///
    /// A convenience variant of g_settings_set() for 64-bit integers.
    ///
    /// It is a programmer error to give a @key that isn't specified as
    /// having a int64 type in the schema for @self.
    /// ## `key`
    /// the name of the key to set
    /// ## `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"
            )
        }
    }

    /// Sets @key in @self to @value.
    ///
    /// A convenience variant of g_settings_set() for strings.
    ///
    /// It is a programmer error to give a @key that isn't specified as
    /// having a string type in the schema for @self.
    /// ## `key`
    /// the name of the key to set
    /// ## `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"
            )
        }
    }

    /// Sets @key in @self to @value.
    ///
    /// A convenience variant of g_settings_set() for 32-bit unsigned
    /// integers.
    ///
    /// It is a programmer error to give a @key that isn't specified as
    /// having a uint32 type in the schema for @self.
    /// ## `key`
    /// the name of the key to set
    /// ## `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"
            )
        }
    }

    /// Sets @key in @self to @value.
    ///
    /// A convenience variant of g_settings_set() for 64-bit unsigned
    /// integers.
    ///
    /// It is a programmer error to give a @key that isn't specified as
    /// having a uint64 type in the schema for @self.
    /// ## `key`
    /// the name of the key to set
    /// ## `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"
            )
        }
    }

    /// Sets @key in @self to @value.
    ///
    /// It is a programmer error to give a @key that isn'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 name of the key to set
    /// ## `value`
    /// a #GVariant 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")
    }

    /// Whether the #GSettings object is in 'delay-apply' mode. See
    /// g_settings_delay() for details.
    #[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 #GSettings object.
    #[doc(alias = "schema-id")]
    fn schema_id(&self) -> Option<glib::GString> {
        ObjectExt::property(self.as_ref(), "schema-id")
    }

    /// The #GSettingsSchema describing the types of keys for this
    /// #GSettings object.
    ///
    /// Ideally, this property would be called 'schema'.  #GSettingsSchema
    /// has only existed since version 2.32, however, and before then the
    /// '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: 2, id: 5 }
    //}

    /// The "changed" signal is emitted when a key has potentially changed.
    /// You should call one of the g_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,
        ) {
            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: &[u8] = detailed_signal_name
                .as_ref()
                .map_or(&b"changed\0"[..], |n| n.as_bytes());
            connect_raw(
                self.as_ptr() as *mut _,
                signal_name.as_ptr() as *const _,
                Some(std::mem::transmute::<*const (), unsafe extern "C" fn()>(
                    changed_trampoline::<Self, F> as *const (),
                )),
                Box_::into_raw(f),
            )
        }
    }

    /// The "writable-change-event" signal is 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" signal.  For most use cases it is more
    /// appropriate to use the "writable-changed" signal.
    ///
    /// In the event that the writability change applies only to a single
    /// key, @key will be set to the #GQuark 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"
    /// and "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 {
            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 _,
                b"writable-change-event\0".as_ptr() as *const _,
                Some(std::mem::transmute::<*const (), unsafe extern "C" fn()>(
                    writable_change_event_trampoline::<Self, F> as *const (),
                )),
                Box_::into_raw(f),
            )
        }
    }

    /// The "writable-changed" signal is emitted when the writability of a
    /// key has potentially changed.  You should call
    /// g_settings_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,
        ) {
            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: &[u8] = detailed_signal_name
                .as_ref()
                .map_or(&b"writable-changed\0"[..], |n| n.as_bytes());
            connect_raw(
                self.as_ptr() as *mut _,
                signal_name.as_ptr() as *const _,
                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,
        ) {
            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 _,
                b"notify::delay-apply\0".as_ptr() as *const _,
                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,
        ) {
            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 _,
                b"notify::has-unapplied\0".as_ptr() as *const _,
                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 {}