gtk4/auto/

tree_list_row.rs

// 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::ffi;
use glib::{
    prelude::*,
    signal::{SignalHandlerId, connect_raw},
    translate::*,
};
use std::boxed::Box as Box_;

glib::wrapper! {
    /// The type of item used by [`TreeListModel`][crate::TreeListModel].
    ///
    /// It allows navigating the model as a tree and modify the state of rows.
    ///
    /// [`TreeListRow`][crate::TreeListRow] instances are created by a [`TreeListModel`][crate::TreeListModel] only
    /// when the [`passthrough`][struct@crate::TreeListModel#passthrough] property is not set.
    ///
    /// There are various support objects that can make use of [`TreeListRow`][crate::TreeListRow]
    /// objects, such as the [`TreeExpander`][crate::TreeExpander] widget that allows displaying
    /// an icon to expand or collapse a row or [`TreeListRowSorter`][crate::TreeListRowSorter] that
    /// makes it possible to sort trees properly.
    ///
    /// ## Properties
    ///
    ///
    /// #### `children`
    ///  The model holding the row's children.
    ///
    /// Readable
    ///
    ///
    /// #### `depth`
    ///  The depth in the tree of this row.
    ///
    /// Readable
    ///
    ///
    /// #### `expandable`
    ///  If this row can ever be expanded.
    ///
    /// Readable
    ///
    ///
    /// #### `expanded`
    ///  If this row is currently expanded.
    ///
    /// Readable | Writeable
    ///
    ///
    /// #### `item`
    ///  The item held in this row.
    ///
    /// Readable
    ///
    /// # Implements
    ///
    /// [`trait@glib::ObjectExt`]
    #[doc(alias = "GtkTreeListRow")]
    pub struct TreeListRow(Object<ffi::GtkTreeListRow, ffi::GtkTreeListRowClass>);

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

impl TreeListRow {
    /// If @self is not expanded or @position is greater than the
    /// number of children, [`None`] is returned.
    /// ## `position`
    /// position of the child to get
    ///
    /// # Returns
    ///
    /// the child in @position
    #[doc(alias = "gtk_tree_list_row_get_child_row")]
    #[doc(alias = "get_child_row")]
    #[must_use]
    pub fn child_row(&self, position: u32) -> Option<TreeListRow> {
        unsafe {
            from_glib_full(ffi::gtk_tree_list_row_get_child_row(
                self.to_glib_none().0,
                position,
            ))
        }
    }

    /// If the row is expanded, gets the model holding the children of @self.
    ///
    /// This model is the model created by the
    /// `callback::Gtk::TreeListModelCreateModelFunc
    /// and contains the original items, no matter what value
    /// [`passthrough`][struct@crate::TreeListModel#passthrough] is set to.
    ///
    /// # Returns
    ///
    /// The model containing the children
    #[doc(alias = "gtk_tree_list_row_get_children")]
    #[doc(alias = "get_children")]
    pub fn children(&self) -> Option<gio::ListModel> {
        unsafe { from_glib_none(ffi::gtk_tree_list_row_get_children(self.to_glib_none().0)) }
    }

    /// Gets the depth of this row.
    ///
    /// Rows that correspond to items in the root model have a depth
    /// of zero, rows corresponding to items of models of direct children
    /// of the root model have a depth of 1 and so on.
    ///
    /// The depth of a row never changes until the row is removed from its model
    /// at which point it will forever return 0.
    ///
    /// # Returns
    ///
    /// The depth of this row
    #[doc(alias = "gtk_tree_list_row_get_depth")]
    #[doc(alias = "get_depth")]
    pub fn depth(&self) -> u32 {
        unsafe { ffi::gtk_tree_list_row_get_depth(self.to_glib_none().0) }
    }

    /// Gets if a row is currently expanded.
    ///
    /// # Returns
    ///
    /// [`true`] if the row is expanded
    #[doc(alias = "gtk_tree_list_row_get_expanded")]
    #[doc(alias = "get_expanded")]
    #[doc(alias = "expanded")]
    pub fn is_expanded(&self) -> bool {
        unsafe { from_glib(ffi::gtk_tree_list_row_get_expanded(self.to_glib_none().0)) }
    }

    /// Gets the item corresponding to this row,
    ///
    /// # Returns
    ///
    /// The item
    ///   of this row. This function is only marked as nullable for backwards
    ///   compatibility reasons.
    #[doc(alias = "gtk_tree_list_row_get_item")]
    #[doc(alias = "get_item")]
    pub fn item(&self) -> Option<glib::Object> {
        unsafe { from_glib_full(ffi::gtk_tree_list_row_get_item(self.to_glib_none().0)) }
    }

    /// Gets the row representing the parent for @self.
    ///
    /// That is the row that would need to be collapsed
    /// to make this row disappear.
    ///
    /// If @self is a row corresponding to the root model,
    /// [`None`] is returned.
    ///
    /// The value returned by this function never changes
    /// until the row is removed from its model at which point
    /// it will forever return [`None`].
    ///
    /// # Returns
    ///
    /// The parent of @self
    #[doc(alias = "gtk_tree_list_row_get_parent")]
    #[doc(alias = "get_parent")]
    #[must_use]
    pub fn parent(&self) -> Option<TreeListRow> {
        unsafe { from_glib_full(ffi::gtk_tree_list_row_get_parent(self.to_glib_none().0)) }
    }

    /// Returns the position in the [`TreeListModel`][crate::TreeListModel] that @self occupies
    /// at the moment.
    ///
    /// # Returns
    ///
    /// The position in the model
    #[doc(alias = "gtk_tree_list_row_get_position")]
    #[doc(alias = "get_position")]
    pub fn position(&self) -> u32 {
        unsafe { ffi::gtk_tree_list_row_get_position(self.to_glib_none().0) }
    }

    /// Checks if a row can be expanded.
    ///
    /// This does not mean that the row is actually expanded,
    /// this can be checked with [`is_expanded()`][Self::is_expanded()].
    ///
    /// If a row is expandable never changes until the row is removed
    /// from its model at which point it will forever return [`false`].
    ///
    /// # Returns
    ///
    /// [`true`] if the row is expandable
    #[doc(alias = "gtk_tree_list_row_is_expandable")]
    #[doc(alias = "expandable")]
    pub fn is_expandable(&self) -> bool {
        unsafe { from_glib(ffi::gtk_tree_list_row_is_expandable(self.to_glib_none().0)) }
    }

    /// Expands or collapses a row.
    ///
    /// If a row is expanded, the model of calling the
    /// `callback::Gtk::TreeListModelCreateModelFunc for the row's
    /// item will be inserted after this row. If a row is collapsed,
    /// those items will be removed from the model.
    ///
    /// If the row is not expandable, this function does nothing.
    /// ## `expanded`
    /// [`true`] if the row should be expanded
    #[doc(alias = "gtk_tree_list_row_set_expanded")]
    #[doc(alias = "expanded")]
    pub fn set_expanded(&self, expanded: bool) {
        unsafe {
            ffi::gtk_tree_list_row_set_expanded(self.to_glib_none().0, expanded.into_glib());
        }
    }

    #[doc(alias = "children")]
    pub fn connect_children_notify<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId {
        unsafe extern "C" fn notify_children_trampoline<F: Fn(&TreeListRow) + 'static>(
            this: *mut ffi::GtkTreeListRow,
            _param_spec: glib::ffi::gpointer,
            f: glib::ffi::gpointer,
        ) {
            unsafe {
                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 _,
                c"notify::children".as_ptr(),
                Some(std::mem::transmute::<*const (), unsafe extern "C" fn()>(
                    notify_children_trampoline::<F> as *const (),
                )),
                Box_::into_raw(f),
            )
        }
    }

    #[doc(alias = "depth")]
    pub fn connect_depth_notify<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId {
        unsafe extern "C" fn notify_depth_trampoline<F: Fn(&TreeListRow) + 'static>(
            this: *mut ffi::GtkTreeListRow,
            _param_spec: glib::ffi::gpointer,
            f: glib::ffi::gpointer,
        ) {
            unsafe {
                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 _,
                c"notify::depth".as_ptr(),
                Some(std::mem::transmute::<*const (), unsafe extern "C" fn()>(
                    notify_depth_trampoline::<F> as *const (),
                )),
                Box_::into_raw(f),
            )
        }
    }

    #[doc(alias = "expandable")]
    pub fn connect_expandable_notify<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId {
        unsafe extern "C" fn notify_expandable_trampoline<F: Fn(&TreeListRow) + 'static>(
            this: *mut ffi::GtkTreeListRow,
            _param_spec: glib::ffi::gpointer,
            f: glib::ffi::gpointer,
        ) {
            unsafe {
                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 _,
                c"notify::expandable".as_ptr(),
                Some(std::mem::transmute::<*const (), unsafe extern "C" fn()>(
                    notify_expandable_trampoline::<F> as *const (),
                )),
                Box_::into_raw(f),
            )
        }
    }

    #[doc(alias = "expanded")]
    pub fn connect_expanded_notify<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId {
        unsafe extern "C" fn notify_expanded_trampoline<F: Fn(&TreeListRow) + 'static>(
            this: *mut ffi::GtkTreeListRow,
            _param_spec: glib::ffi::gpointer,
            f: glib::ffi::gpointer,
        ) {
            unsafe {
                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 _,
                c"notify::expanded".as_ptr(),
                Some(std::mem::transmute::<*const (), unsafe extern "C" fn()>(
                    notify_expanded_trampoline::<F> as *const (),
                )),
                Box_::into_raw(f),
            )
        }
    }

    #[doc(alias = "item")]
    pub fn connect_item_notify<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId {
        unsafe extern "C" fn notify_item_trampoline<F: Fn(&TreeListRow) + 'static>(
            this: *mut ffi::GtkTreeListRow,
            _param_spec: glib::ffi::gpointer,
            f: glib::ffi::gpointer,
        ) {
            unsafe {
                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 _,
                c"notify::item".as_ptr(),
                Some(std::mem::transmute::<*const (), unsafe extern "C" fn()>(
                    notify_item_trampoline::<F> as *const (),
                )),
                Box_::into_raw(f),
            )
        }
    }
}