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

use crate::FilterChange;
use crate::FilterMatch;
use glib::object::Cast;
use glib::object::IsA;
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! {
    /// A [`Filter`][crate::Filter] object describes the filtering to be performed by a
    /// [`FilterListModel`][crate::FilterListModel].
    ///
    /// The model will use the filter to determine if it should include items
    /// or not by calling [``FilterExt::match_()``][crate::prelude::`FilterExt::match_()`] for each item and only
    /// keeping the ones that the function returns [`true`] for.
    ///
    /// Filters may change what items they match through their lifetime. In that
    /// case, they will emit the `signal::Filter::changed` signal to notify
    /// that previous filter results are no longer valid and that items should
    /// be checked again via [``FilterExt::match_()``][crate::prelude::`FilterExt::match_()`].
    ///
    /// GTK provides various pre-made filter implementations for common filtering
    /// operations. These filters often include properties that can be linked to
    /// various widgets to easily allow searches.
    ///
    /// However, in particular for large lists or complex search methods, it is
    /// also possible to subclass [`Filter`][crate::Filter] and provide one's own filter.
    ///
    /// # Implements
    ///
    /// [`FilterExt`][trait@crate::prelude::FilterExt], [`trait@glib::ObjectExt`]
    #[doc(alias = "GtkFilter")]
    pub struct Filter(Object<ffi::GtkFilter, ffi::GtkFilterClass>);

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

pub const NONE_FILTER: Option<&Filter> = None;

/// Trait containing all [`struct@Filter`] methods.
///
/// # Implementors
///
/// [`BoolFilter`][struct@crate::BoolFilter], [`CustomFilter`][struct@crate::CustomFilter], [`FileFilter`][struct@crate::FileFilter], [`Filter`][struct@crate::Filter], [`MultiFilter`][struct@crate::MultiFilter], [`StringFilter`][struct@crate::StringFilter]
pub trait FilterExt: 'static {
    /// Notifies all users of the filter that it has changed.
    ///
    /// This emits the `signal::Filter::changed` signal. Users
    /// of the filter should then check items again via
    /// [``match_()``][`Self::match_()`].
    ///
    /// Depending on the `change` parameter, not all items need to
    /// be changed, but only some. Refer to the [`FilterChange`][crate::FilterChange]
    /// documentation for details.
    ///
    /// This function is intended for implementors of [`Filter`][crate::Filter]
    /// subclasses and should not be called from other functions.
    /// ## `change`
    /// How the filter changed
    #[doc(alias = "gtk_filter_changed")]
    fn changed(&self, change: FilterChange);

    /// Gets the known strictness of `filters`.
    ///
    /// If the strictness is not known, [`FilterMatch::Some`][crate::FilterMatch::Some] is returned.
    ///
    /// This value may change after emission of the `signal::Filter::changed`
    /// signal.
    ///
    /// This function is meant purely for optimization purposes, filters can
    /// choose to omit implementing it, but [`FilterListModel`][crate::FilterListModel] uses it.
    ///
    /// # Returns
    ///
    /// the strictness of `self`
    #[doc(alias = "gtk_filter_get_strictness")]
    #[doc(alias = "get_strictness")]
    fn strictness(&self) -> FilterMatch;

    #[doc(alias = "gtk_filter_match")]
    #[doc(alias = "match")]
    fn match_<P: IsA<glib::Object>>(&self, item: &P) -> bool;

    /// Emitted whenever the filter changed.
    ///
    /// Users of the filter should then check items again via
    /// [``match_()``][`Self::match_()`].
    ///
    /// [`FilterListModel`][crate::FilterListModel] handles this signal automatically.
    ///
    /// Depending on the `change` parameter, not all items need
    /// to be checked, but only some. Refer to the [`FilterChange`][crate::FilterChange]
    /// documentation for details.
    /// ## `change`
    /// how the filter changed
    #[doc(alias = "changed")]
    fn connect_changed<F: Fn(&Self, FilterChange) + 'static>(&self, f: F) -> SignalHandlerId;
}

impl<O: IsA<Filter>> FilterExt for O {
    fn changed(&self, change: FilterChange) {
        unsafe {
            ffi::gtk_filter_changed(self.as_ref().to_glib_none().0, change.into_glib());
        }
    }

    fn strictness(&self) -> FilterMatch {
        unsafe {
            from_glib(ffi::gtk_filter_get_strictness(
                self.as_ref().to_glib_none().0,
            ))
        }
    }

    fn match_<P: IsA<glib::Object>>(&self, item: &P) -> bool {
        unsafe {
            from_glib(ffi::gtk_filter_match(
                self.as_ref().to_glib_none().0,
                item.as_ref().to_glib_none().0,
            ))
        }
    }

    fn connect_changed<F: Fn(&Self, FilterChange) + 'static>(&self, f: F) -> SignalHandlerId {
        unsafe extern "C" fn changed_trampoline<
            P: IsA<Filter>,
            F: Fn(&P, FilterChange) + 'static,
        >(
            this: *mut ffi::GtkFilter,
            change: ffi::GtkFilterChange,
            f: glib::ffi::gpointer,
        ) {
            let f: &F = &*(f as *const F);
            f(
                Filter::from_glib_borrow(this).unsafe_cast_ref(),
                from_glib(change),
            )
        }
        unsafe {
            let f: Box_<F> = Box_::new(f);
            connect_raw(
                self.as_ptr() as *mut _,
                b"changed\0".as_ptr() as *const _,
                Some(transmute::<_, unsafe extern "C" fn()>(
                    changed_trampoline::<Self, F> as *const (),
                )),
                Box_::into_raw(f),
            )
        }
    }
}

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