// 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::object::IsA;
use glib::object::ObjectType as ObjectType_;
use glib::signal::connect_raw;
use glib::signal::SignalHandlerId;
use glib::translate::*;
use std::boxed::Box as Box_;
use std::fmt;
use std::mem::transmute;

glib::wrapper! {
    /// [`DirectoryList`][crate::DirectoryList] is a list model that wraps g_file_enumerate_children_async().
    ///
    /// It presents a `GListModel` and fills it asynchronously with the `GFileInfo`s
    /// returned from that function.
    ///
    /// Enumeration will start automatically when a the
    /// `property::DirectoryList::file` property is set.
    ///
    /// While the [`DirectoryList`][crate::DirectoryList] is being filled, the
    /// `property::DirectoryList::loading` property will be set to [`true`]. You can
    /// listen to that property if you want to show information like a [`Spinner`][crate::Spinner]
    /// or a "Loading..." text.
    ///
    /// If loading fails at any point, the `property::DirectoryList::error`
    /// property will be set to give more indication about the failure.
    ///
    /// The `GFileInfo`s returned from a [`DirectoryList`][crate::DirectoryList] have the "standard::file"
    /// attribute set to the `GFile` they refer to. This way you can get at the file
    /// that is referred to in the same way you would via g_file_enumerator_get_child().
    /// This means you do not need access to the [`DirectoryList`][crate::DirectoryList], but can access
    /// the `GFile` directly from the `GFileInfo` when operating with a [`ListView`][crate::ListView]
    /// or similar.
    ///
    /// # Implements
    ///
    /// [`trait@glib::ObjectExt`], [`trait@gio::prelude::ListModelExt`]
    #[doc(alias = "GtkDirectoryList")]
    pub struct DirectoryList(Object<ffi::GtkDirectoryList, ffi::GtkDirectoryListClass>) @implements gio::ListModel;

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

impl DirectoryList {
    /// Creates a new [`DirectoryList`][crate::DirectoryList].
    ///
    /// The [`DirectoryList`][crate::DirectoryList] is querying the given @file
    /// with the given @attributes.
    /// ## `attributes`
    /// The attributes to query with
    /// ## `file`
    /// The file to query
    ///
    /// # Returns
    ///
    /// a new [`DirectoryList`][crate::DirectoryList]
    #[doc(alias = "gtk_directory_list_new")]
    pub fn new(attributes: Option<&str>, file: Option<&impl IsA<gio::File>>) -> DirectoryList {
        assert_initialized_main_thread!();
        unsafe {
            from_glib_full(ffi::gtk_directory_list_new(
                attributes.to_glib_none().0,
                file.map(|p| p.as_ref()).to_glib_none().0,
            ))
        }
    }

    /// Gets the attributes queried on the children.
    ///
    /// # Returns
    ///
    /// The queried attributes
    #[doc(alias = "gtk_directory_list_get_attributes")]
    #[doc(alias = "get_attributes")]
    pub fn attributes(&self) -> Option<glib::GString> {
        unsafe {
            from_glib_none(ffi::gtk_directory_list_get_attributes(
                self.to_glib_none().0,
            ))
        }
    }

    /// Gets the loading error, if any.
    ///
    /// If an error occurs during the loading process, the loading process
    /// will finish and this property allows querying the error that happened.
    /// This error will persist until a file is loaded again.
    ///
    /// An error being set does not mean that no files were loaded, and all
    /// successfully queried files will remain in the list.
    ///
    /// # Returns
    ///
    /// The loading error or [`None`] if
    ///   loading finished successfully
    #[doc(alias = "gtk_directory_list_get_error")]
    #[doc(alias = "get_error")]
    pub fn error(&self) -> Option<glib::Error> {
        unsafe { from_glib_none(ffi::gtk_directory_list_get_error(self.to_glib_none().0)) }
    }

    /// Gets the file whose children are currently enumerated.
    ///
    /// # Returns
    ///
    /// The file whose children are enumerated
    #[doc(alias = "gtk_directory_list_get_file")]
    #[doc(alias = "get_file")]
    pub fn file(&self) -> Option<gio::File> {
        unsafe { from_glib_none(ffi::gtk_directory_list_get_file(self.to_glib_none().0)) }
    }

    /// Returns whether the directory list is monitoring
    /// the directory for changes.
    ///
    /// # Returns
    ///
    /// [`true`] if the directory is monitored
    #[doc(alias = "gtk_directory_list_get_monitored")]
    #[doc(alias = "get_monitored")]
    pub fn is_monitored(&self) -> bool {
        unsafe { from_glib(ffi::gtk_directory_list_get_monitored(self.to_glib_none().0)) }
    }

    /// Returns [`true`] if the children enumeration is currently in
    /// progress.
    ///
    /// Files will be added to @self from time to time while loading is
    /// going on. The order in which are added is undefined and may change
    /// in between runs.
    ///
    /// # Returns
    ///
    /// [`true`] if @self is loading
    #[doc(alias = "gtk_directory_list_is_loading")]
    pub fn is_loading(&self) -> bool {
        unsafe { from_glib(ffi::gtk_directory_list_is_loading(self.to_glib_none().0)) }
    }

    /// Sets the @attributes to be enumerated and starts the enumeration.
    ///
    /// If @attributes is [`None`], the list of file infos will still be created, it will just
    /// not contain any extra attributes.
    /// ## `attributes`
    /// the attributes to enumerate
    #[doc(alias = "gtk_directory_list_set_attributes")]
    pub fn set_attributes(&self, attributes: Option<&str>) {
        unsafe {
            ffi::gtk_directory_list_set_attributes(
                self.to_glib_none().0,
                attributes.to_glib_none().0,
            );
        }
    }

    /// Sets the @file to be enumerated and starts the enumeration.
    ///
    /// If @file is [`None`], the result will be an empty list.
    /// ## `file`
    /// the `GFile` to be enumerated
    #[doc(alias = "gtk_directory_list_set_file")]
    pub fn set_file(&self, file: Option<&impl IsA<gio::File>>) {
        unsafe {
            ffi::gtk_directory_list_set_file(
                self.to_glib_none().0,
                file.map(|p| p.as_ref()).to_glib_none().0,
            );
        }
    }

    /// Sets whether the directory list will monitor the directory
    /// for changes.
    ///
    /// If monitoring is enabled, the ::items-changed signal will
    /// be emitted when the directory contents change.
    ///
    ///
    /// When monitoring is turned on after the initial creation
    /// of the directory list, the directory is reloaded to avoid
    /// missing files that appeared between the initial loading
    /// and when monitoring was turned on.
    /// ## `monitored`
    /// [`true`] to monitor the directory for changes
    #[doc(alias = "gtk_directory_list_set_monitored")]
    pub fn set_monitored(&self, monitored: bool) {
        unsafe {
            ffi::gtk_directory_list_set_monitored(self.to_glib_none().0, monitored.into_glib());
        }
    }

    #[doc(alias = "attributes")]
    pub fn connect_attributes_notify<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId {
        unsafe extern "C" fn notify_attributes_trampoline<F: Fn(&DirectoryList) + 'static>(
            this: *mut ffi::GtkDirectoryList,
            _param_spec: glib::ffi::gpointer,
            f: glib::ffi::gpointer,
        ) {
            let f: &F = &*(f as *const F);
            f(&from_glib_borrow(this))
        }
        unsafe {
            let f: Box_<F> = Box_::new(f);
            connect_raw(
                self.as_ptr() as *mut _,
                b"notify::attributes\0".as_ptr() as *const _,
                Some(transmute::<_, unsafe extern "C" fn()>(
                    notify_attributes_trampoline::<F> as *const (),
                )),
                Box_::into_raw(f),
            )
        }
    }

    #[doc(alias = "error")]
    pub fn connect_error_notify<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId {
        unsafe extern "C" fn notify_error_trampoline<F: Fn(&DirectoryList) + 'static>(
            this: *mut ffi::GtkDirectoryList,
            _param_spec: glib::ffi::gpointer,
            f: glib::ffi::gpointer,
        ) {
            let f: &F = &*(f as *const F);
            f(&from_glib_borrow(this))
        }
        unsafe {
            let f: Box_<F> = Box_::new(f);
            connect_raw(
                self.as_ptr() as *mut _,
                b"notify::error\0".as_ptr() as *const _,
                Some(transmute::<_, unsafe extern "C" fn()>(
                    notify_error_trampoline::<F> as *const (),
                )),
                Box_::into_raw(f),
            )
        }
    }

    #[doc(alias = "file")]
    pub fn connect_file_notify<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId {
        unsafe extern "C" fn notify_file_trampoline<F: Fn(&DirectoryList) + 'static>(
            this: *mut ffi::GtkDirectoryList,
            _param_spec: glib::ffi::gpointer,
            f: glib::ffi::gpointer,
        ) {
            let f: &F = &*(f as *const F);
            f(&from_glib_borrow(this))
        }
        unsafe {
            let f: Box_<F> = Box_::new(f);
            connect_raw(
                self.as_ptr() as *mut _,
                b"notify::file\0".as_ptr() as *const _,
                Some(transmute::<_, unsafe extern "C" fn()>(
                    notify_file_trampoline::<F> as *const (),
                )),
                Box_::into_raw(f),
            )
        }
    }

    #[doc(alias = "io-priority")]
    pub fn connect_io_priority_notify<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId {
        unsafe extern "C" fn notify_io_priority_trampoline<F: Fn(&DirectoryList) + 'static>(
            this: *mut ffi::GtkDirectoryList,
            _param_spec: glib::ffi::gpointer,
            f: glib::ffi::gpointer,
        ) {
            let f: &F = &*(f as *const F);
            f(&from_glib_borrow(this))
        }
        unsafe {
            let f: Box_<F> = Box_::new(f);
            connect_raw(
                self.as_ptr() as *mut _,
                b"notify::io-priority\0".as_ptr() as *const _,
                Some(transmute::<_, unsafe extern "C" fn()>(
                    notify_io_priority_trampoline::<F> as *const (),
                )),
                Box_::into_raw(f),
            )
        }
    }

    #[doc(alias = "loading")]
    pub fn connect_loading_notify<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId {
        unsafe extern "C" fn notify_loading_trampoline<F: Fn(&DirectoryList) + 'static>(
            this: *mut ffi::GtkDirectoryList,
            _param_spec: glib::ffi::gpointer,
            f: glib::ffi::gpointer,
        ) {
            let f: &F = &*(f as *const F);
            f(&from_glib_borrow(this))
        }
        unsafe {
            let f: Box_<F> = Box_::new(f);
            connect_raw(
                self.as_ptr() as *mut _,
                b"notify::loading\0".as_ptr() as *const _,
                Some(transmute::<_, unsafe extern "C" fn()>(
                    notify_loading_trampoline::<F> as *const (),
                )),
                Box_::into_raw(f),
            )
        }
    }

    #[doc(alias = "monitored")]
    pub fn connect_monitored_notify<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId {
        unsafe extern "C" fn notify_monitored_trampoline<F: Fn(&DirectoryList) + 'static>(
            this: *mut ffi::GtkDirectoryList,
            _param_spec: glib::ffi::gpointer,
            f: glib::ffi::gpointer,
        ) {
            let f: &F = &*(f as *const F);
            f(&from_glib_borrow(this))
        }
        unsafe {
            let f: Box_<F> = Box_::new(f);
            connect_raw(
                self.as_ptr() as *mut _,
                b"notify::monitored\0".as_ptr() as *const _,
                Some(transmute::<_, unsafe extern "C" fn()>(
                    notify_monitored_trampoline::<F> as *const (),
                )),
                Box_::into_raw(f),
            )
        }
    }
}

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