// 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 glib::translate::*;
use std::fmt;

glib::wrapper! {
    /// [`SettingsSchemaKey`][crate::SettingsSchemaKey] is an opaque data structure and can only be accessed
    /// using the following functions.
    #[derive(Debug, PartialEq, Eq, PartialOrd, Ord, Hash)]
    pub struct SettingsSchemaKey(Shared<ffi::GSettingsSchemaKey>);

    match fn {
        ref => |ptr| ffi::g_settings_schema_key_ref(ptr),
        unref => |ptr| ffi::g_settings_schema_key_unref(ptr),
        type_ => || ffi::g_settings_schema_key_get_type(),
    }
}

impl SettingsSchemaKey {
    /// Gets the default value for `self`.
    ///
    /// Note that this is the default value according to the schema. System
    /// administrator defaults and lockdown are not visible via this API.
    ///
    /// # Returns
    ///
    /// the default value for the key
    #[doc(alias = "g_settings_schema_key_get_default_value")]
    #[doc(alias = "get_default_value")]
    pub fn default_value(&self) -> glib::Variant {
        unsafe {
            from_glib_full(ffi::g_settings_schema_key_get_default_value(
                self.to_glib_none().0,
            ))
        }
    }

    /// Gets the description for `self`.
    ///
    /// If no description has been provided in the schema for `self`, returns
    /// [`None`].
    ///
    /// The description can be one sentence to several paragraphs in length.
    /// Paragraphs are delimited with a double newline. Descriptions can be
    /// translated and the value returned from this function is is the
    /// current locale.
    ///
    /// This function is slow. The summary and description information for
    /// the schemas is not stored in the compiled schema database so this
    /// function has to parse all of the source XML files in the schema
    /// directory.
    ///
    /// # Returns
    ///
    /// the description for `self`, or [`None`]
    #[doc(alias = "g_settings_schema_key_get_description")]
    #[doc(alias = "get_description")]
    pub fn description(&self) -> Option<glib::GString> {
        unsafe {
            from_glib_none(ffi::g_settings_schema_key_get_description(
                self.to_glib_none().0,
            ))
        }
    }

    /// Gets the name of `self`.
    ///
    /// # Returns
    ///
    /// the name of `self`.
    #[doc(alias = "g_settings_schema_key_get_name")]
    #[doc(alias = "get_name")]
    pub fn name(&self) -> glib::GString {
        unsafe { from_glib_none(ffi::g_settings_schema_key_get_name(self.to_glib_none().0)) }
    }

    /// Queries the range of a key.
    ///
    /// This function will return a [`glib::Variant`][struct@crate::glib::Variant] that fully describes the range
    /// of values that are valid for `self`.
    ///
    /// The type of [`glib::Variant`][struct@crate::glib::Variant] returned is `(sv)`. The string describes
    /// the type of range restriction in effect. The type and meaning of
    /// the value contained in the variant depends on the string.
    ///
    /// If the string is `'type'` then the variant contains an empty array.
    /// The element type of that empty array is the expected type of value
    /// and all values of that type are valid.
    ///
    /// If the string is `'enum'` then the variant contains an array
    /// enumerating the possible values. Each item in the array is
    /// a possible valid value and no other values are valid.
    ///
    /// If the string is `'flags'` then the variant contains an array. Each
    /// item in the array is a value that may appear zero or one times in an
    /// array to be used as the value for this key. For example, if the
    /// variant contained the array `['x', 'y']` then the valid values for
    /// the key would be `[]`, `['x']`, `['y']`, `['x', 'y']` and
    /// `['y', 'x']`.
    ///
    /// Finally, if the string is `'range'` then the variant contains a pair
    /// of like-typed values -- the minimum and maximum permissible values
    /// for this key.
    ///
    /// This information should not be used by normal programs. It is
    /// considered to be a hint for introspection purposes. Normal programs
    /// should already know what is permitted by their own schema. The
    /// format may change in any way in the future -- but particularly, new
    /// forms may be added to the possibilities described above.
    ///
    /// You should free the returned value with `g_variant_unref()` when it is
    /// no longer needed.
    ///
    /// # Returns
    ///
    /// a [`glib::Variant`][struct@crate::glib::Variant] describing the range
    #[doc(alias = "g_settings_schema_key_get_range")]
    #[doc(alias = "get_range")]
    pub fn range(&self) -> glib::Variant {
        unsafe { from_glib_full(ffi::g_settings_schema_key_get_range(self.to_glib_none().0)) }
    }

    /// Gets the summary for `self`.
    ///
    /// If no summary has been provided in the schema for `self`, returns
    /// [`None`].
    ///
    /// The summary is a short description of the purpose of the key; usually
    /// one short sentence. Summaries can be translated and the value
    /// returned from this function is is the current locale.
    ///
    /// This function is slow. The summary and description information for
    /// the schemas is not stored in the compiled schema database so this
    /// function has to parse all of the source XML files in the schema
    /// directory.
    ///
    /// # Returns
    ///
    /// the summary for `self`, or [`None`]
    #[doc(alias = "g_settings_schema_key_get_summary")]
    #[doc(alias = "get_summary")]
    pub fn summary(&self) -> Option<glib::GString> {
        unsafe {
            from_glib_none(ffi::g_settings_schema_key_get_summary(
                self.to_glib_none().0,
            ))
        }
    }

    /// Gets the [`glib::VariantType`][crate::glib::VariantType] of `self`.
    ///
    /// # Returns
    ///
    /// the type of `self`
    #[doc(alias = "g_settings_schema_key_get_value_type")]
    #[doc(alias = "get_value_type")]
    pub fn value_type(&self) -> glib::VariantType {
        unsafe {
            from_glib_none(ffi::g_settings_schema_key_get_value_type(
                self.to_glib_none().0,
            ))
        }
    }

    /// Checks if the given `value` is within the
    /// permitted range for `self`.
    ///
    /// It is a programmer error if `value` is not of the correct type — you
    /// must check for this first.
    /// ## `value`
    /// the value to check
    ///
    /// # Returns
    ///
    /// [`true`] if `value` is valid for `self`
    #[doc(alias = "g_settings_schema_key_range_check")]
    pub fn range_check(&self, value: &glib::Variant) -> bool {
        unsafe {
            from_glib(ffi::g_settings_schema_key_range_check(
                self.to_glib_none().0,
                value.to_glib_none().0,
            ))
        }
    }
}

impl fmt::Display for SettingsSchemaKey {
    #[inline]
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        f.write_str(&self.name())
    }
}