// This file was generated by gir (https://github.com/gtk-rs/gir)
// from gir-files (https://github.com/gtk-rs/gir-files)
// DO NOT EDIT

use crate::Action;
use crate::SettingsBackend;
use crate::SettingsSchema;
use glib::object::Cast;
use glib::object::IsA;
use glib::signal::connect_raw;
use glib::signal::SignalHandlerId;
use glib::translate::*;
use glib::StaticType;
use std::boxed::Box as Box_;
use std::fmt;
use std::mem::transmute;

glib::wrapper! {
    /// The [`Settings`][crate::Settings] class provides a convenient API for storing and retrieving
    /// application settings.
    ///
    /// Reads and writes can be considered to be non-blocking. Reading
    /// settings with [`Settings`][crate::Settings] is typically extremely fast: on
    /// approximately the same order of magnitude (but slower than) a
    /// `GHashTable` 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 [`Settings`][crate::Settings] 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][gsettings-relocatable]', 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 [`glib::VariantType`][crate::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:
    ///
    /// ```text
    ///  <!-- 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
    /// `GVariants` (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]
    /// 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] 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
    /// [example][schema-enumerated]. 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:
    ///
    /// ```text
    /// <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:
    ///
    /// ```text
    /// <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] 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 GVariant 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 GObject property
    /// has been bound to a setting, changes on either side are automatically
    /// propagated to the other side. GSettings handles details like mapping
    /// between GObject and GVariant 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
    /// [`SettingsBindFlags::NO_SENSITIVITY`][crate::SettingsBindFlags::NO_SENSITIVITY] flag.
    ///
    /// ## Relocatable schemas # {`gsettings`-relocatable}
    ///
    /// A relocatable schema is one with no `path` attribute specified on its
    /// `<schema>` element. By using [`with_path()`][Self::with_path()], a [`Settings`][crate::Settings] 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.:
    ///
    /// ```text
    /// <schema id="org.foo.MyApp" path="/org/foo/MyApp/">
    ///   <child name="main" schema="org.foo.MyApp.Window"/>
    /// </schema>
    /// ```
    ///
    /// ## Build system integration # {`gsettings`-build-system}
    ///
    /// 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@
    /// ```
    ///
    /// 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 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 intltool XML rules with a
    /// `.gschema.xml.in` template.
    ///
    /// 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`.
    ///
    /// # Implements
    ///
    /// [`SettingsExt`][trait@crate::prelude::SettingsExt], [`trait@glib::ObjectExt`]
    #[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
    /// 4 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 [`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 [`SettingsSchema`][crate::SettingsSchema]
    /// ## `backend`
    /// a [`SettingsBackend`][crate::SettingsBackend]
    /// ## `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,
            ))
        }
    }

    /// Creates a new [`Settings`][crate::Settings] object with the schema specified by
    /// `schema_id` and a given [`SettingsBackend`][crate::SettingsBackend].
    ///
    /// Creating a [`Settings`][crate::Settings] 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 [`SettingsBackend`][crate::SettingsBackend] 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 [`SettingsBackend`][crate::SettingsBackend] 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,
            ))
        }
    }

    /// Creates a new [`Settings`][crate::Settings] 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 [`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 `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);
        }
    }
}

/// Trait containing all [`struct@Settings`] methods.
///
/// # Implementors
///
/// [`Settings`][struct@crate::Settings]
pub trait SettingsExt: 'static {
    /// Applies any changes that have been made to the settings. This
    /// function does nothing unless `self` is in 'delay-apply' mode;
    /// see [`delay()`][Self::delay()]. In the normal case settings are always
    /// applied immediately.
    #[doc(alias = "g_settings_apply")]
    fn apply(&self);

    /// 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 [`glib::Object`][crate::glib::Object]
    /// ## `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,
    );

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

    /// Changes the [`Settings`][crate::Settings] object into '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);

    //#[doc(alias = "g_settings_get")]
    //fn get(&self, key: &str, format: &str, : /*Unknown conversion*//*Unimplemented*/Basic: VarArgs);

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

    /// 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 `property::Settings::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;

    /// Gets the "default value" of a key.
    ///
    /// This is the value that would be read if [`reset()`][Self::reset()] were to be
    /// called on the key.
    ///
    /// Note that this may be a different value than returned by
    /// [`SettingsSchemaKey::default_value()`][crate::SettingsSchemaKey::default_value()] if the system administrator
    /// has provided a default value.
    ///
    /// Comparing the return values of [`default_value()`][Self::default_value()] and
    /// [`value()`][Self::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>;

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

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

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

    /// Returns whether the [`Settings`][crate::Settings] 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")]
    fn has_unapplied(&self) -> bool;

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

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

    //#[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>;

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

    /// A convenience variant of `g_settings_get()` for string arrays.
    ///
    /// It is a programmer error to give a `key` that isn't specified as
    /// having an array of strings type in the schema for `self`.
    /// ## `key`
    /// the key to get the value for
    ///
    /// # Returns
    ///
    /// a
    /// newly-allocated, [`None`]-terminated array of strings, the value that
    /// is stored at `key` in `self`.
    #[doc(alias = "g_settings_get_strv")]
    #[doc(alias = "get_strv")]
    fn strv(&self, key: &str) -> Vec<glib::GString>;

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

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

    /// 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 [`reset()`][Self::reset()] this function should always return
    /// [`None`] (assuming something is not wrong with the system
    /// configuration).
    ///
    /// It is possible that [`value()`][Self::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>;

    /// 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 [`glib::Variant`][struct@crate::glib::Variant]
    #[doc(alias = "g_settings_get_value")]
    #[doc(alias = "get_value")]
    fn value(&self, key: &str) -> glib::Variant;

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

    /// Gets the list of children on `self`.
    ///
    /// The list is exactly the list of strings for which it is not an error
    /// to call [`child()`][Self::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>;

    /// 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);

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

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

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

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

    /// 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
    /// [`string()`][Self::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>;

    /// 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
    /// [`strv()`][Self::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>;

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

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

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

    /// Sets `key` in `self` to `value`.
    ///
    /// A convenience variant of `g_settings_set()` for string arrays. If
    /// `value` is [`None`], then `key` is set to be the empty array.
    ///
    /// It is a programmer error to give a `key` that isn't specified as
    /// having an array of strings type in the schema for `self`.
    /// ## `key`
    /// the name of the key to set
    /// ## `value`
    /// the value to set it to, or [`None`]
    ///
    /// # Returns
    ///
    /// [`true`] if setting the key succeeded,
    ///  [`false`] if the key was not writable
    #[doc(alias = "g_settings_set_strv")]
    fn set_strv(&self, key: &str, value: &[&str]) -> Result<(), glib::error::BoolError>;

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

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

    /// 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 [`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>;

    /// The name of the context that the settings are stored in.
    fn backend(&self) -> Option<SettingsBackend>;

    /// Whether the [`Settings`][crate::Settings] object is in 'delay-apply' mode. See
    /// [`delay()`][Self::delay()] for details.
    #[doc(alias = "delay-apply")]
    fn is_delay_apply(&self) -> bool;

    /// The path within the backend where the settings are stored.
    fn path(&self) -> Option<glib::GString>;

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

    /// The [`SettingsSchema`][crate::SettingsSchema] describing the types of keys for this
    /// [`Settings`][crate::Settings] object.
    ///
    /// Ideally, this property would be called 'schema'. [`SettingsSchema`][crate::SettingsSchema]
    /// 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>;

    //#[doc(alias = "change-event")]
    //fn connect_change_event<Unsupported or ignored types>(&self, f: F) -> SignalHandlerId;

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

    /// 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::signal::Inhibit + 'static>(
        &self,
        f: F,
    ) -> SignalHandlerId;

    /// The "writable-changed" signal is 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;

    #[doc(alias = "delay-apply")]
    fn connect_delay_apply_notify<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId;

    #[doc(alias = "has-unapplied")]
    fn connect_has_unapplied_notify<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId;
}

impl<O: IsA<Settings>> SettingsExt for O {
    fn apply(&self) {
        unsafe {
            ffi::g_settings_apply(self.as_ref().to_glib_none().0);
        }
    }

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

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

    fn delay(&self) {
        unsafe {
            ffi::g_settings_delay(self.as_ref().to_glib_none().0);
        }
    }

    //fn get(&self, key: &str, format: &str, : /*Unknown conversion*//*Unimplemented*/Basic: VarArgs) {
    //    unsafe { TODO: call ffi:g_settings_get() }
    //}

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

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

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

    fn double(&self, key: &str) -> f64 {
        unsafe { ffi::g_settings_get_double(self.as_ref().to_glib_none().0, key.to_glib_none().0) }
    }

    fn enum_(&self, key: &str) -> i32 {
        unsafe { ffi::g_settings_get_enum(self.as_ref().to_glib_none().0, key.to_glib_none().0) }
    }

    fn flags(&self, key: &str) -> u32 {
        unsafe { ffi::g_settings_get_flags(self.as_ref().to_glib_none().0, key.to_glib_none().0) }
    }

    fn has_unapplied(&self) -> bool {
        unsafe {
            from_glib(ffi::g_settings_get_has_unapplied(
                self.as_ref().to_glib_none().0,
            ))
        }
    }

    fn int(&self, key: &str) -> i32 {
        unsafe { ffi::g_settings_get_int(self.as_ref().to_glib_none().0, key.to_glib_none().0) }
    }

    fn int64(&self, key: &str) -> i64 {
        unsafe { ffi::g_settings_get_int64(self.as_ref().to_glib_none().0, key.to_glib_none().0) }
    }

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

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

    fn strv(&self, key: &str) -> Vec<glib::GString> {
        unsafe {
            FromGlibPtrContainer::from_glib_full(ffi::g_settings_get_strv(
                self.as_ref().to_glib_none().0,
                key.to_glib_none().0,
            ))
        }
    }

    fn uint(&self, key: &str) -> u32 {
        unsafe { ffi::g_settings_get_uint(self.as_ref().to_glib_none().0, key.to_glib_none().0) }
    }

    fn uint64(&self, key: &str) -> u64 {
        unsafe { ffi::g_settings_get_uint64(self.as_ref().to_glib_none().0, key.to_glib_none().0) }
    }

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

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

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

    fn list_children(&self) -> Vec<glib::GString> {
        unsafe {
            FromGlibPtrContainer::from_glib_full(ffi::g_settings_list_children(
                self.as_ref().to_glib_none().0,
            ))
        }
    }

    fn reset(&self, key: &str) {
        unsafe {
            ffi::g_settings_reset(self.as_ref().to_glib_none().0, key.to_glib_none().0);
        }
    }

    fn revert(&self) {
        unsafe {
            ffi::g_settings_revert(self.as_ref().to_glib_none().0);
        }
    }

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

    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"
            )
        }
    }

    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"
            )
        }
    }

    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"
            )
        }
    }

    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"
            )
        }
    }

    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"
            )
        }
    }

    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"
            )
        }
    }

    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"
            )
        }
    }

    fn set_strv(&self, key: &str, value: &[&str]) -> Result<(), glib::error::BoolError> {
        unsafe {
            glib::result_from_gboolean!(
                ffi::g_settings_set_strv(
                    self.as_ref().to_glib_none().0,
                    key.to_glib_none().0,
                    value.to_glib_none().0
                ),
                "Can't set readonly key"
            )
        }
    }

    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"
            )
        }
    }

    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"
            )
        }
    }

    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"
            )
        }
    }

    fn backend(&self) -> Option<SettingsBackend> {
        glib::ObjectExt::property(self.as_ref(), "backend")
    }

    fn is_delay_apply(&self) -> bool {
        glib::ObjectExt::property(self.as_ref(), "delay-apply")
    }

    fn path(&self) -> Option<glib::GString> {
        glib::ObjectExt::property(self.as_ref(), "path")
    }

    fn schema_id(&self) -> Option<glib::GString> {
        glib::ObjectExt::property(self.as_ref(), "schema-id")
    }

    fn settings_schema(&self) -> Option<SettingsSchema> {
        glib::ObjectExt::property(self.as_ref(), "settings-schema")
    }

    //fn connect_change_event<Unsupported or ignored types>(&self, f: F) -> SignalHandlerId {
    //    Unimplemented keys: *.CArray TypeId { ns_id: 2, id: 5 }
    //}

    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 libc::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(transmute::<_, unsafe extern "C" fn()>(
                    changed_trampoline::<Self, F> as *const (),
                )),
                Box_::into_raw(f),
            )
        }
    }

    fn connect_writable_change_event<F: Fn(&Self, u32) -> glib::signal::Inhibit + 'static>(
        &self,
        f: F,
    ) -> SignalHandlerId {
        unsafe extern "C" fn writable_change_event_trampoline<
            P: IsA<Settings>,
            F: Fn(&P, u32) -> glib::signal::Inhibit + 'static,
        >(
            this: *mut ffi::GSettings,
            key: libc::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(transmute::<_, unsafe extern "C" fn()>(
                    writable_change_event_trampoline::<Self, F> as *const (),
                )),
                Box_::into_raw(f),
            )
        }
    }

    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 libc::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(transmute::<_, unsafe extern "C" fn()>(
                    writable_changed_trampoline::<Self, F> as *const (),
                )),
                Box_::into_raw(f),
            )
        }
    }

    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(transmute::<_, unsafe extern "C" fn()>(
                    notify_delay_apply_trampoline::<Self, F> as *const (),
                )),
                Box_::into_raw(f),
            )
        }
    }

    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(transmute::<_, unsafe extern "C" fn()>(
                    notify_has_unapplied_trampoline::<Self, F> as *const (),
                )),
                Box_::into_raw(f),
            )
        }
    }
}

impl fmt::Display for Settings {
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        f.write_str("Settings")
    }
}