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

glib::wrapper! {
    /// This is an opaque structure type. You may not access it directly.
    #[derive(Debug, PartialEq, Eq, PartialOrd, Ord, Hash)]
    pub struct SettingsSchemaSource(Shared<ffi::GSettingsSchemaSource>);

    match fn {
        ref => |ptr| ffi::g_settings_schema_source_ref(ptr),
        unref => |ptr| ffi::g_settings_schema_source_unref(ptr),
        type_ => || ffi::g_settings_schema_source_get_type(),
    }
}

impl SettingsSchemaSource {
    /// Attempts to create a new schema source corresponding to the contents
    /// of the given directory.
    ///
    /// This function is not required for normal uses of [`Settings`][crate::Settings] but it
    /// may be useful to authors of plugin management systems.
    ///
    /// The directory should contain a file called `gschemas.compiled` as
    /// produced by the [glib-compile-schemas][glib-compile-schemas] tool.
    ///
    /// If `trusted` is [`true`] then `gschemas.compiled` is trusted not to be
    /// corrupted. This assumption has a performance advantage, but can result
    /// in crashes or inconsistent behaviour in the case of a corrupted file.
    /// Generally, you should set `trusted` to [`true`] for files installed by the
    /// system and to [`false`] for files in the home directory.
    ///
    /// In either case, an empty file or some types of corruption in the file will
    /// result in `G_FILE_ERROR_INVAL` being returned.
    ///
    /// If `parent` is non-[`None`] then there are two effects.
    ///
    /// First, if [`lookup()`][Self::lookup()] is called with the
    /// `recursive` flag set to [`true`] and the schema can not be found in the
    /// source, the lookup will recurse to the parent.
    ///
    /// Second, any references to other schemas specified within this
    /// source (ie: `child` or `extends`) references may be resolved
    /// from the `parent`.
    ///
    /// For this second reason, except in very unusual situations, the
    /// `parent` should probably be given as the default schema source, as
    /// returned by [`default()`][Self::default()].
    /// ## `directory`
    /// the filename of a directory
    /// ## `parent`
    /// a [`SettingsSchemaSource`][crate::SettingsSchemaSource], or [`None`]
    /// ## `trusted`
    /// [`true`], if the directory is trusted
    #[doc(alias = "g_settings_schema_source_new_from_directory")]
    #[doc(alias = "new_from_directory")]
    pub fn from_directory(
        directory: impl AsRef<std::path::Path>,
        parent: Option<&SettingsSchemaSource>,
        trusted: bool,
    ) -> Result<SettingsSchemaSource, glib::Error> {
        unsafe {
            let mut error = ptr::null_mut();
            let ret = ffi::g_settings_schema_source_new_from_directory(
                directory.as_ref().to_glib_none().0,
                parent.to_glib_none().0,
                trusted.into_glib(),
                &mut error,
            );
            if error.is_null() {
                Ok(from_glib_full(ret))
            } else {
                Err(from_glib_full(error))
            }
        }
    }

    /// Lists the schemas in a given source.
    ///
    /// If `recursive` is [`true`] then include parent sources. If [`false`] then
    /// only include the schemas from one source (ie: one directory). You
    /// probably want [`true`].
    ///
    /// Non-relocatable schemas are those for which you can call
    /// [`Settings::new()`][crate::Settings::new()]. Relocatable schemas are those for which you must
    /// use [`Settings::with_path()`][crate::Settings::with_path()].
    ///
    /// Do not call this function from normal programs. This is designed for
    /// use by database editors, commandline tools, etc.
    /// ## `recursive`
    /// if we should recurse
    ///
    /// # Returns
    ///
    ///
    /// ## `non_relocatable`
    /// the
    ///  list of non-relocatable schemas, in no defined order
    ///
    /// ## `relocatable`
    /// the list
    ///  of relocatable schemas, in no defined order
    #[doc(alias = "g_settings_schema_source_list_schemas")]
    pub fn list_schemas(&self, recursive: bool) -> (Vec<glib::GString>, Vec<glib::GString>) {
        unsafe {
            let mut non_relocatable = ptr::null_mut();
            let mut relocatable = ptr::null_mut();
            ffi::g_settings_schema_source_list_schemas(
                self.to_glib_none().0,
                recursive.into_glib(),
                &mut non_relocatable,
                &mut relocatable,
            );
            (
                FromGlibPtrContainer::from_glib_full(non_relocatable),
                FromGlibPtrContainer::from_glib_full(relocatable),
            )
        }
    }

    /// Looks up a schema with the identifier `schema_id` in `self`.
    ///
    /// This function is not required for normal uses of [`Settings`][crate::Settings] but it
    /// may be useful to authors of plugin management systems or to those who
    /// want to introspect the content of schemas.
    ///
    /// If the schema isn't found directly in `self` and `recursive` is [`true`]
    /// then the parent sources will also be checked.
    ///
    /// If the schema isn't found, [`None`] is returned.
    /// ## `schema_id`
    /// a schema ID
    /// ## `recursive`
    /// [`true`] if the lookup should be recursive
    ///
    /// # Returns
    ///
    /// a new [`SettingsSchema`][crate::SettingsSchema]
    #[doc(alias = "g_settings_schema_source_lookup")]
    pub fn lookup(&self, schema_id: &str, recursive: bool) -> Option<SettingsSchema> {
        unsafe {
            from_glib_full(ffi::g_settings_schema_source_lookup(
                self.to_glib_none().0,
                schema_id.to_glib_none().0,
                recursive.into_glib(),
            ))
        }
    }

    /// Gets the default system schema source.
    ///
    /// This function is not required for normal uses of [`Settings`][crate::Settings] but it
    /// may be useful to authors of plugin management systems or to those who
    /// want to introspect the content of schemas.
    ///
    /// If no schemas are installed, [`None`] will be returned.
    ///
    /// The returned source may actually consist of multiple schema sources
    /// from different directories, depending on which directories were given
    /// in `XDG_DATA_DIRS` and `GSETTINGS_SCHEMA_DIR`. For this reason, all
    /// lookups performed against the default source should probably be done
    /// recursively.
    ///
    /// # Returns
    ///
    /// the default schema source
    #[doc(alias = "g_settings_schema_source_get_default")]
    #[doc(alias = "get_default")]
    pub fn default() -> Option<SettingsSchemaSource> {
        unsafe { from_glib_none(ffi::g_settings_schema_source_get_default()) }
    }
}