gtk4/auto/

tree_model.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
#![allow(deprecated)]

use crate::{TreeIter, TreeModelFlags, TreePath, ffi};
use glib::{
    object::ObjectType as _,
    prelude::*,
    signal::{SignalHandlerId, connect_raw},
    translate::*,
};
use std::boxed::Box as Box_;

glib::wrapper! {
    /// Use [`gio::ListModel`][crate::gio::ListModel] instead
    /// iter);
    ///    row_count++;
    ///  }
    /// ```text
    ///
    /// The [`TreeModel`][crate::TreeModel] interface contains two methods for reference
    /// counting: gtk_tree_model_ref_node() and gtk_tree_model_unref_node().
    /// These two methods are optional to implement. The reference counting
    /// is meant as a way for views to let models know when nodes are being
    /// displayed. [`TreeView`][crate::TreeView] will take a reference on a node when it is
    /// visible, which means the node is either in the toplevel or expanded.
    /// Being displayed does not mean that the node is currently directly
    /// visible to the user in the viewport. Based on this reference counting
    /// scheme a caching model, for example, can decide whether or not to cache
    /// a node based on the reference count. A file-system based model would
    /// not want to keep the entire file hierarchy in memory, but just the
    /// folders that are currently expanded in every current view.
    ///
    /// When working with reference counting, the following rules must be taken
    /// into account:
    ///
    /// - Never take a reference on a node without owning a reference on its parent.
    ///   This means that all parent nodes of a referenced node must be referenced
    ///   as well.
    ///
    /// - Outstanding references on a deleted node are not released. This is not
    ///   possible because the node has already been deleted by the time the
    ///   row-deleted signal is received.
    ///
    /// - Models are not obligated to emit a signal on rows of which none of its
    ///   siblings are referenced. To phrase this differently, signals are only
    ///   required for levels in which nodes are referenced. For the root level
    ///   however, signals must be emitted at all times (however the root level
    ///   is always referenced when any view is attached).
    ///
    /// ## Signals
    ///
    ///
    /// #### `row-changed`
    ///  This signal is emitted when a row in the model has changed.
    ///
    ///
    ///
    ///
    /// #### `row-deleted`
    ///  This signal is emitted when a row has been deleted.
    ///
    /// Note that no iterator is passed to the signal handler,
    /// since the row is already deleted.
    ///
    /// This should be called by models after a row has been removed.
    /// The location pointed to by @path should be the location that
    /// the row previously was at. It may not be a valid location anymore.
    ///
    ///
    ///
    ///
    /// #### `row-has-child-toggled`
    ///  This signal is emitted when a row has gotten the first child
    /// row or lost its last child row.
    ///
    ///
    ///
    ///
    /// #### `row-inserted`
    ///  This signal is emitted when a new row has been inserted in
    /// the model.
    ///
    /// Note that the row may still be empty at this point, since
    /// it is a common pattern to first insert an empty row, and
    /// then fill it with the desired values.
    ///
    ///
    ///
    ///
    /// #### `rows-reordered`
    ///  This signal is emitted when the children of a node in the
    /// [`TreeModel`][crate::TreeModel] have been reordered.
    ///
    /// Note that this signal is not emitted
    /// when rows are reordered by DND, since this is implemented
    /// by removing and then reinserting the row.
    ///
    ///
    ///
    /// # Implements
    ///
    /// [`TreeModelExt`][trait@crate::prelude::TreeModelExt], [`TreeModelExtManual`][trait@crate::prelude::TreeModelExtManual]
    #[doc(alias = "GtkTreeModel")]
    pub struct TreeModel(Interface<ffi::GtkTreeModel, ffi::GtkTreeModelIface>);

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

impl TreeModel {
    pub const NONE: Option<&'static TreeModel> = None;
}

/// Trait containing all [`struct@TreeModel`] methods.
///
/// # Implementors
///
/// [`ListStore`][struct@crate::ListStore], [`TreeModelFilter`][struct@crate::TreeModelFilter], [`TreeModelSort`][struct@crate::TreeModelSort], [`TreeModel`][struct@crate::TreeModel], [`TreeSortable`][struct@crate::TreeSortable], [`TreeStore`][struct@crate::TreeStore]
pub trait TreeModelExt: IsA<TreeModel> + 'static {
    /// Calls @func on each node in model in a depth-first fashion.
    ///
    /// If @func returns [`true`], then the tree ceases to be walked,
    /// and gtk_tree_model_foreach() returns.
    ///
    /// # Deprecated since 4.10
    ///
    /// ## `func`
    /// a function to be called on each row
    #[cfg_attr(feature = "v4_10", deprecated = "Since 4.10")]
    #[allow(deprecated)]
    #[doc(alias = "gtk_tree_model_foreach")]
    fn foreach<P: FnMut(&TreeModel, &TreePath, &TreeIter) -> bool>(&self, func: P) {
        let mut func_data: P = func;
        unsafe extern "C" fn func_func<P: FnMut(&TreeModel, &TreePath, &TreeIter) -> bool>(
            model: *mut ffi::GtkTreeModel,
            path: *mut ffi::GtkTreePath,
            iter: *mut ffi::GtkTreeIter,
            data: glib::ffi::gpointer,
        ) -> glib::ffi::gboolean {
            unsafe {
                let model = from_glib_borrow(model);
                let path = from_glib_borrow(path);
                let iter = from_glib_borrow(iter);
                let callback = data as *mut P;
                (*callback)(&model, &path, &iter).into_glib()
            }
        }
        let func = Some(func_func::<P> as _);
        let super_callback0: &mut P = &mut func_data;
        unsafe {
            ffi::gtk_tree_model_foreach(
                self.as_ref().to_glib_none().0,
                func,
                super_callback0 as *mut _ as *mut _,
            );
        }
    }

    /// Returns the type of the column.
    ///
    /// # Deprecated since 4.10
    ///
    /// ## `index_`
    /// the column index
    ///
    /// # Returns
    ///
    /// the type of the column
    #[cfg_attr(feature = "v4_10", deprecated = "Since 4.10")]
    #[allow(deprecated)]
    #[doc(alias = "gtk_tree_model_get_column_type")]
    #[doc(alias = "get_column_type")]
    fn column_type(&self, index_: i32) -> glib::types::Type {
        unsafe {
            from_glib(ffi::gtk_tree_model_get_column_type(
                self.as_ref().to_glib_none().0,
                index_,
            ))
        }
    }

    /// Returns a set of flags supported by this interface.
    ///
    /// The flags are a bitwise combination of [`TreeModel`][crate::TreeModel]Flags.
    /// The flags supported should not change during the lifetime
    /// of the @self.
    ///
    /// # Deprecated since 4.10
    ///
    ///
    /// # Returns
    ///
    /// the flags supported by this interface
    #[cfg_attr(feature = "v4_10", deprecated = "Since 4.10")]
    #[allow(deprecated)]
    #[doc(alias = "gtk_tree_model_get_flags")]
    #[doc(alias = "get_flags")]
    fn flags(&self) -> TreeModelFlags {
        unsafe {
            from_glib(ffi::gtk_tree_model_get_flags(
                self.as_ref().to_glib_none().0,
            ))
        }
    }

    /// Sets @iter to a valid iterator pointing to @path.
    ///
    /// If @path does not exist, @iter is set to an invalid
    /// iterator and [`false`] is returned.
    ///
    /// # Deprecated since 4.10
    ///
    /// ## `path`
    /// the [`TreePath`][crate::TreePath]
    ///
    /// # Returns
    ///
    /// [`true`], if @iter was set
    ///
    /// ## `iter`
    /// the uninitialized [`TreeIter`][crate::TreeIter]
    #[cfg_attr(feature = "v4_10", deprecated = "Since 4.10")]
    #[allow(deprecated)]
    #[doc(alias = "gtk_tree_model_get_iter")]
    #[doc(alias = "get_iter")]
    fn iter(&self, path: &TreePath) -> Option<TreeIter> {
        unsafe {
            let mut iter = TreeIter::uninitialized();
            let ret = from_glib(ffi::gtk_tree_model_get_iter(
                self.as_ref().to_glib_none().0,
                iter.to_glib_none_mut().0,
                mut_override(path.to_glib_none().0),
            ));
            if ret { Some(iter) } else { None }
        }
    }

    /// Initializes @iter with the first iterator in the tree
    /// (the one at the path "0").
    ///
    /// Returns [`false`] if the tree is empty, [`true`] otherwise.
    ///
    /// # Deprecated since 4.10
    ///
    ///
    /// # Returns
    ///
    /// [`true`], if @iter was set
    ///
    /// ## `iter`
    /// the uninitialized [`TreeIter`][crate::TreeIter]
    #[cfg_attr(feature = "v4_10", deprecated = "Since 4.10")]
    #[allow(deprecated)]
    #[doc(alias = "gtk_tree_model_get_iter_first")]
    #[doc(alias = "get_iter_first")]
    fn iter_first(&self) -> Option<TreeIter> {
        unsafe {
            let mut iter = TreeIter::uninitialized();
            let ret = from_glib(ffi::gtk_tree_model_get_iter_first(
                self.as_ref().to_glib_none().0,
                iter.to_glib_none_mut().0,
            ));
            if ret { Some(iter) } else { None }
        }
    }

    /// Sets @iter to a valid iterator pointing to @path_string, if it
    /// exists.
    ///
    /// Otherwise, @iter is left invalid and [`false`] is returned.
    ///
    /// # Deprecated since 4.10
    ///
    /// ## `path_string`
    /// a string representation of a [`TreePath`][crate::TreePath]
    ///
    /// # Returns
    ///
    /// [`true`], if @iter was set
    ///
    /// ## `iter`
    /// an uninitialized [`TreeIter`][crate::TreeIter]
    #[cfg_attr(feature = "v4_10", deprecated = "Since 4.10")]
    #[allow(deprecated)]
    #[doc(alias = "gtk_tree_model_get_iter_from_string")]
    #[doc(alias = "get_iter_from_string")]
    fn iter_from_string(&self, path_string: &str) -> Option<TreeIter> {
        unsafe {
            let mut iter = TreeIter::uninitialized();
            let ret = from_glib(ffi::gtk_tree_model_get_iter_from_string(
                self.as_ref().to_glib_none().0,
                iter.to_glib_none_mut().0,
                path_string.to_glib_none().0,
            ));
            if ret { Some(iter) } else { None }
        }
    }

    /// Returns the number of columns supported by @self.
    ///
    /// # Deprecated since 4.10
    ///
    ///
    /// # Returns
    ///
    /// the number of columns
    #[cfg_attr(feature = "v4_10", deprecated = "Since 4.10")]
    #[allow(deprecated)]
    #[doc(alias = "gtk_tree_model_get_n_columns")]
    #[doc(alias = "get_n_columns")]
    fn n_columns(&self) -> i32 {
        unsafe { ffi::gtk_tree_model_get_n_columns(self.as_ref().to_glib_none().0) }
    }

    /// Returns a newly-created [`TreePath`][crate::TreePath] referenced by @iter.
    ///
    /// This path should be freed with gtk_tree_path_free().
    ///
    /// # Deprecated since 4.10
    ///
    /// ## `iter`
    /// the [`TreeIter`][crate::TreeIter]
    ///
    /// # Returns
    ///
    /// a newly-created [`TreePath`][crate::TreePath]
    #[cfg_attr(feature = "v4_10", deprecated = "Since 4.10")]
    #[allow(deprecated)]
    #[doc(alias = "gtk_tree_model_get_path")]
    #[doc(alias = "get_path")]
    fn path(&self, iter: &TreeIter) -> TreePath {
        unsafe {
            from_glib_full(ffi::gtk_tree_model_get_path(
                self.as_ref().to_glib_none().0,
                mut_override(iter.to_glib_none().0),
            ))
        }
    }

    ///  would be an acceptable
    /// return value for this string.
    ///
    /// # Deprecated since 4.10
    ///
    /// ## `iter`
    /// a [`TreeIter`][crate::TreeIter]
    ///
    /// # Returns
    ///
    /// a newly-allocated string
    #[cfg_attr(feature = "v4_10", deprecated = "Since 4.10")]
    #[allow(deprecated)]
    #[doc(alias = "gtk_tree_model_get_string_from_iter")]
    #[doc(alias = "get_string_from_iter")]
    fn string_from_iter(&self, iter: &TreeIter) -> Option<glib::GString> {
        unsafe {
            from_glib_full(ffi::gtk_tree_model_get_string_from_iter(
                self.as_ref().to_glib_none().0,
                mut_override(iter.to_glib_none().0),
            ))
        }
    }

    /// Sets @iter to point to the first child of @parent.
    ///
    /// If @parent has no children, [`false`] is returned and @iter is
    /// set to be invalid. @parent will remain a valid node after this
    /// function has been called.
    ///
    /// If @parent is [`None`] returns the first node, equivalent to
    /// `gtk_tree_model_get_iter_first (tree_model, iter);`
    ///
    /// # Deprecated since 4.10
    ///
    /// ## `parent`
    /// the [`TreeIter`][crate::TreeIter]
    ///
    /// # Returns
    ///
    /// [`true`], if @iter has been set to the first child
    ///
    /// ## `iter`
    /// the new [`TreeIter`][crate::TreeIter] to be set to the child
    #[cfg_attr(feature = "v4_10", deprecated = "Since 4.10")]
    #[allow(deprecated)]
    #[doc(alias = "gtk_tree_model_iter_children")]
    fn iter_children(&self, parent: Option<&TreeIter>) -> Option<TreeIter> {
        unsafe {
            let mut iter = TreeIter::uninitialized();
            let ret = from_glib(ffi::gtk_tree_model_iter_children(
                self.as_ref().to_glib_none().0,
                iter.to_glib_none_mut().0,
                mut_override(parent.to_glib_none().0),
            ));
            if ret { Some(iter) } else { None }
        }
    }

    /// Returns [`true`] if @iter has children, [`false`] otherwise.
    ///
    /// # Deprecated since 4.10
    ///
    /// ## `iter`
    /// the [`TreeIter`][crate::TreeIter] to test for children
    ///
    /// # Returns
    ///
    /// [`true`] if @iter has children
    #[cfg_attr(feature = "v4_10", deprecated = "Since 4.10")]
    #[allow(deprecated)]
    #[doc(alias = "gtk_tree_model_iter_has_child")]
    fn iter_has_child(&self, iter: &TreeIter) -> bool {
        unsafe {
            from_glib(ffi::gtk_tree_model_iter_has_child(
                self.as_ref().to_glib_none().0,
                mut_override(iter.to_glib_none().0),
            ))
        }
    }

    /// Returns the number of children that @iter has.
    ///
    /// As a special case, if @iter is [`None`], then the number
    /// of toplevel nodes is returned.
    ///
    /// # Deprecated since 4.10
    ///
    /// ## `iter`
    /// the [`TreeIter`][crate::TreeIter]
    ///
    /// # Returns
    ///
    /// the number of children of @iter
    #[cfg_attr(feature = "v4_10", deprecated = "Since 4.10")]
    #[allow(deprecated)]
    #[doc(alias = "gtk_tree_model_iter_n_children")]
    fn iter_n_children(&self, iter: Option<&TreeIter>) -> i32 {
        unsafe {
            ffi::gtk_tree_model_iter_n_children(
                self.as_ref().to_glib_none().0,
                mut_override(iter.to_glib_none().0),
            )
        }
    }

    /// Sets @iter to be the child of @parent, using the given index.
    ///
    /// The first index is 0. If @n is too big, or @parent has no children,
    /// @iter is set to an invalid iterator and [`false`] is returned. @parent
    /// will remain a valid node after this function has been called. As a
    /// special case, if @parent is [`None`], then the @n-th root node
    /// is set.
    ///
    /// # Deprecated since 4.10
    ///
    /// ## `parent`
    /// the [`TreeIter`][crate::TreeIter] to get the child from
    /// ## `n`
    /// the index of the desired child
    ///
    /// # Returns
    ///
    /// [`true`], if @parent has an @n-th child
    ///
    /// ## `iter`
    /// the [`TreeIter`][crate::TreeIter] to set to the nth child
    #[cfg_attr(feature = "v4_10", deprecated = "Since 4.10")]
    #[allow(deprecated)]
    #[doc(alias = "gtk_tree_model_iter_nth_child")]
    fn iter_nth_child(&self, parent: Option<&TreeIter>, n: i32) -> Option<TreeIter> {
        unsafe {
            let mut iter = TreeIter::uninitialized();
            let ret = from_glib(ffi::gtk_tree_model_iter_nth_child(
                self.as_ref().to_glib_none().0,
                iter.to_glib_none_mut().0,
                mut_override(parent.to_glib_none().0),
                n,
            ));
            if ret { Some(iter) } else { None }
        }
    }

    /// t have a parent, then
    /// @iter is set to an invalid iterator and [`false`] is returned.
    /// @child will remain a valid node after this function has been
    /// called.
    ///
    /// @iter will be initialized before the lookup is performed, so @child
    /// and @iter cannot point to the same memory location.
    ///
    /// # Deprecated since 4.10
    ///
    /// ## `child`
    /// the [`TreeIter`][crate::TreeIter]
    ///
    /// # Returns
    ///
    /// [`true`], if @iter is set to the parent of @child
    ///
    /// ## `iter`
    /// the new [`TreeIter`][crate::TreeIter] to set to the parent
    #[cfg_attr(feature = "v4_10", deprecated = "Since 4.10")]
    #[allow(deprecated)]
    #[doc(alias = "gtk_tree_model_iter_parent")]
    fn iter_parent(&self, child: &TreeIter) -> Option<TreeIter> {
        unsafe {
            let mut iter = TreeIter::uninitialized();
            let ret = from_glib(ffi::gtk_tree_model_iter_parent(
                self.as_ref().to_glib_none().0,
                iter.to_glib_none_mut().0,
                mut_override(child.to_glib_none().0),
            ));
            if ret { Some(iter) } else { None }
        }
    }

    /// Emits the ::row-changed signal on @self.
    ///
    /// See [`row-changed`][struct@crate::TreeModel#row-changed].
    ///
    /// # Deprecated since 4.10
    ///
    /// ## `path`
    /// a [`TreePath`][crate::TreePath] pointing to the changed row
    /// ## `iter`
    /// a valid [`TreeIter`][crate::TreeIter] pointing to the changed row
    #[cfg_attr(feature = "v4_10", deprecated = "Since 4.10")]
    #[allow(deprecated)]
    #[doc(alias = "gtk_tree_model_row_changed")]
    fn row_changed(&self, path: &TreePath, iter: &TreeIter) {
        unsafe {
            ffi::gtk_tree_model_row_changed(
                self.as_ref().to_glib_none().0,
                mut_override(path.to_glib_none().0),
                mut_override(iter.to_glib_none().0),
            );
        }
    }

    /// Emits the ::row-deleted signal on @self.
    ///
    /// See [`row-deleted`][struct@crate::TreeModel#row-deleted].
    ///
    /// This should be called by models after a row has been removed.
    /// The location pointed to by @path should be the location that
    /// the row previously was at. It may not be a valid location anymore.
    ///
    /// Nodes that are deleted are not unreffed, this means that any
    /// outstanding references on the deleted node should not be released.
    ///
    /// # Deprecated since 4.10
    ///
    /// ## `path`
    /// a [`TreePath`][crate::TreePath] pointing to the previous location of
    ///   the deleted row
    #[cfg_attr(feature = "v4_10", deprecated = "Since 4.10")]
    #[allow(deprecated)]
    #[doc(alias = "gtk_tree_model_row_deleted")]
    fn row_deleted(&self, path: &TreePath) {
        unsafe {
            ffi::gtk_tree_model_row_deleted(
                self.as_ref().to_glib_none().0,
                mut_override(path.to_glib_none().0),
            );
        }
    }

    /// Emits the ::row-has-child-toggled signal on @self.
    ///
    /// See [`row-has-child-toggled`][struct@crate::TreeModel#row-has-child-toggled].
    ///
    /// This should be called by models after the child
    /// state of a node changes.
    ///
    /// # Deprecated since 4.10
    ///
    /// ## `path`
    /// a [`TreePath`][crate::TreePath] pointing to the changed row
    /// ## `iter`
    /// a valid [`TreeIter`][crate::TreeIter] pointing to the changed row
    #[cfg_attr(feature = "v4_10", deprecated = "Since 4.10")]
    #[allow(deprecated)]
    #[doc(alias = "gtk_tree_model_row_has_child_toggled")]
    fn row_has_child_toggled(&self, path: &TreePath, iter: &TreeIter) {
        unsafe {
            ffi::gtk_tree_model_row_has_child_toggled(
                self.as_ref().to_glib_none().0,
                mut_override(path.to_glib_none().0),
                mut_override(iter.to_glib_none().0),
            );
        }
    }

    /// Emits the ::row-inserted signal on @self.
    ///
    /// See [`row-inserted`][struct@crate::TreeModel#row-inserted].
    ///
    /// # Deprecated since 4.10
    ///
    /// ## `path`
    /// a [`TreePath`][crate::TreePath] pointing to the inserted row
    /// ## `iter`
    /// a valid [`TreeIter`][crate::TreeIter] pointing to the inserted row
    #[cfg_attr(feature = "v4_10", deprecated = "Since 4.10")]
    #[allow(deprecated)]
    #[doc(alias = "gtk_tree_model_row_inserted")]
    fn row_inserted(&self, path: &TreePath, iter: &TreeIter) {
        unsafe {
            ffi::gtk_tree_model_row_inserted(
                self.as_ref().to_glib_none().0,
                mut_override(path.to_glib_none().0),
                mut_override(iter.to_glib_none().0),
            );
        }
    }

    /// This signal is emitted when a row in the model has changed.
    /// ## `path`
    /// a [`TreePath`][crate::TreePath] identifying the changed row
    /// ## `iter`
    /// a valid [`TreeIter`][crate::TreeIter] pointing to the changed row
    #[doc(alias = "row-changed")]
    fn connect_row_changed<F: Fn(&Self, &TreePath, &TreeIter) + 'static>(
        &self,
        f: F,
    ) -> SignalHandlerId {
        unsafe extern "C" fn row_changed_trampoline<
            P: IsA<TreeModel>,
            F: Fn(&P, &TreePath, &TreeIter) + 'static,
        >(
            this: *mut ffi::GtkTreeModel,
            path: *mut ffi::GtkTreePath,
            iter: *mut ffi::GtkTreeIter,
            f: glib::ffi::gpointer,
        ) {
            unsafe {
                let f: &F = &*(f as *const F);
                f(
                    TreeModel::from_glib_borrow(this).unsafe_cast_ref(),
                    &from_glib_borrow(path),
                    &from_glib_borrow(iter),
                )
            }
        }
        unsafe {
            let f: Box_<F> = Box_::new(f);
            connect_raw(
                self.as_ptr() as *mut _,
                c"row-changed".as_ptr(),
                Some(std::mem::transmute::<*const (), unsafe extern "C" fn()>(
                    row_changed_trampoline::<Self, F> as *const (),
                )),
                Box_::into_raw(f),
            )
        }
    }

    /// This signal is emitted when a row has been deleted.
    ///
    /// Note that no iterator is passed to the signal handler,
    /// since the row is already deleted.
    ///
    /// This should be called by models after a row has been removed.
    /// The location pointed to by @path should be the location that
    /// the row previously was at. It may not be a valid location anymore.
    /// ## `path`
    /// a [`TreePath`][crate::TreePath] identifying the row
    #[doc(alias = "row-deleted")]
    fn connect_row_deleted<F: Fn(&Self, &TreePath) + 'static>(&self, f: F) -> SignalHandlerId {
        unsafe extern "C" fn row_deleted_trampoline<
            P: IsA<TreeModel>,
            F: Fn(&P, &TreePath) + 'static,
        >(
            this: *mut ffi::GtkTreeModel,
            path: *mut ffi::GtkTreePath,
            f: glib::ffi::gpointer,
        ) {
            unsafe {
                let f: &F = &*(f as *const F);
                f(
                    TreeModel::from_glib_borrow(this).unsafe_cast_ref(),
                    &from_glib_borrow(path),
                )
            }
        }
        unsafe {
            let f: Box_<F> = Box_::new(f);
            connect_raw(
                self.as_ptr() as *mut _,
                c"row-deleted".as_ptr(),
                Some(std::mem::transmute::<*const (), unsafe extern "C" fn()>(
                    row_deleted_trampoline::<Self, F> as *const (),
                )),
                Box_::into_raw(f),
            )
        }
    }

    /// This signal is emitted when a row has gotten the first child
    /// row or lost its last child row.
    /// ## `path`
    /// a [`TreePath`][crate::TreePath] identifying the row
    /// ## `iter`
    /// a valid [`TreeIter`][crate::TreeIter] pointing to the row
    #[doc(alias = "row-has-child-toggled")]
    fn connect_row_has_child_toggled<F: Fn(&Self, &TreePath, &TreeIter) + 'static>(
        &self,
        f: F,
    ) -> SignalHandlerId {
        unsafe extern "C" fn row_has_child_toggled_trampoline<
            P: IsA<TreeModel>,
            F: Fn(&P, &TreePath, &TreeIter) + 'static,
        >(
            this: *mut ffi::GtkTreeModel,
            path: *mut ffi::GtkTreePath,
            iter: *mut ffi::GtkTreeIter,
            f: glib::ffi::gpointer,
        ) {
            unsafe {
                let f: &F = &*(f as *const F);
                f(
                    TreeModel::from_glib_borrow(this).unsafe_cast_ref(),
                    &from_glib_borrow(path),
                    &from_glib_borrow(iter),
                )
            }
        }
        unsafe {
            let f: Box_<F> = Box_::new(f);
            connect_raw(
                self.as_ptr() as *mut _,
                c"row-has-child-toggled".as_ptr(),
                Some(std::mem::transmute::<*const (), unsafe extern "C" fn()>(
                    row_has_child_toggled_trampoline::<Self, F> as *const (),
                )),
                Box_::into_raw(f),
            )
        }
    }

    /// This signal is emitted when a new row has been inserted in
    /// the model.
    ///
    /// Note that the row may still be empty at this point, since
    /// it is a common pattern to first insert an empty row, and
    /// then fill it with the desired values.
    /// ## `path`
    /// a [`TreePath`][crate::TreePath] identifying the new row
    /// ## `iter`
    /// a valid [`TreeIter`][crate::TreeIter] pointing to the new row
    #[doc(alias = "row-inserted")]
    fn connect_row_inserted<F: Fn(&Self, &TreePath, &TreeIter) + 'static>(
        &self,
        f: F,
    ) -> SignalHandlerId {
        unsafe extern "C" fn row_inserted_trampoline<
            P: IsA<TreeModel>,
            F: Fn(&P, &TreePath, &TreeIter) + 'static,
        >(
            this: *mut ffi::GtkTreeModel,
            path: *mut ffi::GtkTreePath,
            iter: *mut ffi::GtkTreeIter,
            f: glib::ffi::gpointer,
        ) {
            unsafe {
                let f: &F = &*(f as *const F);
                f(
                    TreeModel::from_glib_borrow(this).unsafe_cast_ref(),
                    &from_glib_borrow(path),
                    &from_glib_borrow(iter),
                )
            }
        }
        unsafe {
            let f: Box_<F> = Box_::new(f);
            connect_raw(
                self.as_ptr() as *mut _,
                c"row-inserted".as_ptr(),
                Some(std::mem::transmute::<*const (), unsafe extern "C" fn()>(
                    row_inserted_trampoline::<Self, F> as *const (),
                )),
                Box_::into_raw(f),
            )
        }
    }

    //#[doc(alias = "rows-reordered")]
    //fn connect_rows_reordered<Unsupported or ignored types>(&self, f: F) -> SignalHandlerId {
    //    Unimplemented new_order: *.Pointer
    //}
}

impl<O: IsA<TreeModel>> TreeModelExt for O {}