gtk4/subclass/
sorter.rs

1// Take a look at the license at the top of the repository in the LICENSE file.
2
3// rustdoc-stripper-ignore-next
4//! Traits intended for subclassing [`Sorter`](crate::Sorter).
5
6use glib::{translate::*, Object};
7
8use crate::{ffi, prelude::*, subclass::prelude::*, Ordering, Sorter, SorterOrder};
9
10pub trait SorterImpl: SorterImplExt + ObjectImpl {
11    fn compare(&self, item1: &Object, item2: &Object) -> Ordering {
12        self.parent_compare(item1, item2)
13    }
14    /// Gets the order that @self conforms to.
15    ///
16    /// See [`SorterOrder`][crate::SorterOrder] for details
17    /// of the possible return values.
18    ///
19    /// This function is intended to allow optimizations.
20    ///
21    /// # Returns
22    ///
23    /// The order
24    #[doc(alias = "get_order")]
25    fn order(&self) -> SorterOrder {
26        self.parent_order()
27    }
28}
29
30mod sealed {
31    pub trait Sealed {}
32    impl<T: super::SorterImplExt> Sealed for T {}
33}
34
35pub trait SorterImplExt: sealed::Sealed + ObjectSubclass {
36    fn parent_compare(&self, item1: &Object, item2: &Object) -> Ordering {
37        unsafe {
38            let data = Self::type_data();
39            let parent_class = data.as_ref().parent_class() as *mut ffi::GtkSorterClass;
40            let f = (*parent_class)
41                .compare
42                .expect("No parent class impl for \"compare\"");
43            from_glib(f(
44                self.obj().unsafe_cast_ref::<Sorter>().to_glib_none().0,
45                item1.to_glib_none().0,
46                item2.to_glib_none().0,
47            ))
48        }
49    }
50
51    fn parent_order(&self) -> SorterOrder {
52        unsafe {
53            let data = Self::type_data();
54            let parent_class = data.as_ref().parent_class() as *mut ffi::GtkSorterClass;
55            let f = (*parent_class)
56                .get_order
57                .expect("No parent class impl for \"get_order\"");
58            from_glib(f(self.obj().unsafe_cast_ref::<Sorter>().to_glib_none().0))
59        }
60    }
61}
62
63impl<T: SorterImpl> SorterImplExt for T {}
64
65unsafe impl<T: SorterImpl> IsSubclassable<T> for Sorter {
66    fn class_init(class: &mut glib::Class<Self>) {
67        Self::parent_class_init::<T>(class);
68
69        assert_initialized_main_thread!();
70
71        let klass = class.as_mut();
72        klass.compare = Some(sorter_compare::<T>);
73        klass.get_order = Some(sorter_get_order::<T>);
74    }
75}
76
77unsafe extern "C" fn sorter_compare<T: SorterImpl>(
78    ptr: *mut ffi::GtkSorter,
79    item1ptr: *mut glib::gobject_ffi::GObject,
80    item2ptr: *mut glib::gobject_ffi::GObject,
81) -> ffi::GtkOrdering {
82    let instance = &*(ptr as *mut T::Instance);
83    let imp = instance.imp();
84
85    imp.compare(&from_glib_borrow(item1ptr), &from_glib_borrow(item2ptr))
86        .into_glib()
87}
88
89unsafe extern "C" fn sorter_get_order<T: SorterImpl>(
90    ptr: *mut ffi::GtkSorter,
91) -> ffi::GtkSorterOrder {
92    let instance = &*(ptr as *mut T::Instance);
93    let imp = instance.imp();
94
95    imp.order().into_glib()
96}