gtk/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

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! {
    /// iter);
    ///  row_count++;
    ///  }
    /// ]|
    ///
    /// 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]
    #[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 [`foreach()`][Self::foreach()] returns.
    /// ## `func`
    /// a function to be called on each row
    #[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 _,
            );
        }
    }

    //#[doc(alias = "gtk_tree_model_get")]
    //fn get(&self, iter: &TreeIter, : /*Unknown conversion*//*Unimplemented*/Basic: VarArgs) {
    //    unsafe { TODO: call ffi:gtk_tree_model_get() }
    //}

    /// Returns the type of the column.
    /// ## `index_`
    /// the column index
    ///
    /// # Returns
    ///
    /// the type of the column
    #[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 [`TreeModelFlags`][crate::TreeModelFlags].
    /// The flags supported should not change during the lifetime
    /// of the `self`.
    ///
    /// # Returns
    ///
    /// the flags supported by this interface
    #[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.
    /// ## `path`
    /// the [`TreePath`][crate::TreePath]-struct
    ///
    /// # Returns
    ///
    /// [`true`], if `iter` was set
    ///
    /// ## `iter`
    /// the uninitialized [`TreeIter`][crate::TreeIter]-struct
    #[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") and returns [`true`]. Returns
    /// [`false`] if the tree is empty.
    ///
    /// # Returns
    ///
    /// [`true`], if `iter` was set
    ///
    /// ## `iter`
    /// the uninitialized [`TreeIter`][crate::TreeIter]-struct
    #[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.
    /// ## `path_string`
    /// a string representation of a [`TreePath`][crate::TreePath]-struct
    ///
    /// # Returns
    ///
    /// [`true`], if `iter` was set
    ///
    /// ## `iter`
    /// an uninitialized [`TreeIter`][crate::TreeIter]-struct
    #[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`.
    ///
    /// # Returns
    ///
    /// the number of columns
    #[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]-struct referenced by `iter`.
    ///
    /// This path should be freed with `gtk_tree_path_free()`.
    /// ## `iter`
    /// the [`TreeIter`][crate::TreeIter]-struct
    ///
    /// # Returns
    ///
    /// a newly-created [`TreePath`][crate::TreePath]-struct
    #[doc(alias = "gtk_tree_model_get_path")]
    #[doc(alias = "get_path")]
    fn path(&self, iter: &TreeIter) -> Option<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),
            ))
        }
    }

    /// Generates a string representation of the iter.
    ///
    /// This string is a “:” separated list of numbers.
    /// For example, “4:10:0:3” would be an acceptable
    /// return value for this string.
    /// ## `iter`
    /// a [`TreeIter`][crate::TreeIter]-struct
    ///
    /// # Returns
    ///
    /// a newly-allocated string.
    ///  Must be freed with `g_free()`.
    #[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),
            ))
        }
    }

    //#[doc(alias = "gtk_tree_model_get_valist")]
    //#[doc(alias = "get_valist")]
    //fn valist(&self, iter: &TreeIter, var_args: /*Unknown conversion*//*Unimplemented*/Unsupported) {
    //    unsafe { TODO: call ffi:gtk_tree_model_get_valist() }
    //}

    /// Initializes and sets `value` to that at `column`.
    ///
    /// When done with `value`, [`glib::Value::unset()`][crate::glib::Value::unset()] needs to be called
    /// to free any allocated memory.
    /// ## `iter`
    /// the [`TreeIter`][crate::TreeIter]-struct
    /// ## `column`
    /// the column to lookup the value at
    ///
    /// # Returns
    ///
    ///
    /// ## `value`
    /// an empty [`glib::Value`][crate::glib::Value] to set
    #[doc(alias = "gtk_tree_model_get_value")]
    #[doc(alias = "get_value")]
    fn value(&self, iter: &TreeIter, column: i32) -> glib::Value {
        unsafe {
            let mut value = glib::Value::uninitialized();
            ffi::gtk_tree_model_get_value(
                self.as_ref().to_glib_none().0,
                mut_override(iter.to_glib_none().0),
                column,
                value.to_glib_none_mut().0,
            );
            value
        }
    }

    /// 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);`
    /// ## `parent`
    /// the [`TreeIter`][crate::TreeIter]-struct, or [`None`]
    ///
    /// # Returns
    ///
    /// [`true`], if `iter` has been set to the first child
    ///
    /// ## `iter`
    /// the new [`TreeIter`][crate::TreeIter]-struct to be set to the child
    #[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.
    /// ## `iter`
    /// the [`TreeIter`][crate::TreeIter]-struct to test for children
    ///
    /// # Returns
    ///
    /// [`true`] if `iter` has children
    #[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.
    /// ## `iter`
    /// the [`TreeIter`][crate::TreeIter]-struct, or [`None`]
    ///
    /// # Returns
    ///
    /// the number of children of `iter`
    #[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 point to the node following it at the current level.
    ///
    /// If there is no next `iter`, [`false`] is returned and `iter` is set
    /// to be invalid.
    /// ## `iter`
    /// the [`TreeIter`][crate::TreeIter]-struct
    ///
    /// # Returns
    ///
    /// [`true`] if `iter` has been changed to the next node
    #[doc(alias = "gtk_tree_model_iter_next")]
    fn iter_next(&self, iter: &TreeIter) -> bool {
        unsafe {
            from_glib(ffi::gtk_tree_model_iter_next(
                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.
    /// ## `parent`
    /// the [`TreeIter`][crate::TreeIter]-struct to get the child from, or [`None`].
    /// ## `n`
    /// the index of the desired child
    ///
    /// # Returns
    ///
    /// [`true`], if `parent` has an `n`-th child
    ///
    /// ## `iter`
    /// the [`TreeIter`][crate::TreeIter]-struct to set to the nth child
    #[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 }
        }
    }

    /// Sets `iter` to be the parent of `child`.
    ///
    /// If `child` is at the toplevel, and doesn’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.
    /// ## `child`
    /// the [`TreeIter`][crate::TreeIter]-struct
    ///
    /// # Returns
    ///
    /// [`true`], if `iter` is set to the parent of `child`
    ///
    /// ## `iter`
    /// the new [`TreeIter`][crate::TreeIter]-struct to set to the parent
    #[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 }
        }
    }

    /// Sets `iter` to point to the previous node at the current level.
    ///
    /// If there is no previous `iter`, [`false`] is returned and `iter` is
    /// set to be invalid.
    /// ## `iter`
    /// the [`TreeIter`][crate::TreeIter]-struct
    ///
    /// # Returns
    ///
    /// [`true`] if `iter` has been changed to the previous node
    #[doc(alias = "gtk_tree_model_iter_previous")]
    fn iter_previous(&self, iter: &TreeIter) -> bool {
        unsafe {
            from_glib(ffi::gtk_tree_model_iter_previous(
                self.as_ref().to_glib_none().0,
                mut_override(iter.to_glib_none().0),
            ))
        }
    }

    /// Emits the [`row-changed`][struct@crate::TreeModel#row-changed] signal on `self`.
    /// ## `path`
    /// a [`TreePath`][crate::TreePath]-struct pointing to the changed row
    /// ## `iter`
    /// a valid [`TreeIter`][crate::TreeIter]-struct pointing to the changed row
    #[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`][struct@crate::TreeModel#row-deleted] signal on `self`.
    ///
    /// 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.
    /// ## `path`
    /// a [`TreePath`][crate::TreePath]-struct pointing to the previous location of
    ///  the deleted row
    #[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`][struct@crate::TreeModel#row-has-child-toggled] signal on
    /// `self`. This should be called by models after the child
    /// state of a node changes.
    /// ## `path`
    /// a [`TreePath`][crate::TreePath]-struct pointing to the changed row
    /// ## `iter`
    /// a valid [`TreeIter`][crate::TreeIter]-struct pointing to the changed row
    #[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`][struct@crate::TreeModel#row-inserted] signal on `self`.
    /// ## `path`
    /// a [`TreePath`][crate::TreePath]-struct pointing to the inserted row
    /// ## `iter`
    /// a valid [`TreeIter`][crate::TreeIter]-struct pointing to the inserted row
    #[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),
            );
        }
    }

    /// Emits the [`rows-reordered`][struct@crate::TreeModel#rows-reordered] signal on `self`.
    ///
    /// This should be called by models when their rows have been
    /// reordered.
    /// ## `path`
    /// a [`TreePath`][crate::TreePath]-struct pointing to the tree node whose children
    ///  have been reordered
    /// ## `iter`
    /// a valid [`TreeIter`][crate::TreeIter]-struct pointing to the node
    ///  whose children have been reordered, or [`None`] if the depth
    ///  of `path` is 0
    /// ## `new_order`
    /// an array of integers
    ///  mapping the current position of each child to its old
    ///  position before the re-ordering,
    ///  i.e. `new_order``[newpos] = oldpos`
    #[doc(alias = "gtk_tree_model_rows_reordered_with_length")]
    fn rows_reordered_with_length(
        &self,
        path: &TreePath,
        iter: Option<&TreeIter>,
        new_order: &[i32],
    ) {
        let length = new_order.len() as _;
        unsafe {
            ffi::gtk_tree_model_rows_reordered_with_length(
                self.as_ref().to_glib_none().0,
                mut_override(path.to_glib_none().0),
                mut_override(iter.to_glib_none().0),
                new_order.to_glib_none().0,
                length,
            );
        }
    }

    /// This signal is emitted when a row in the model has changed.
    /// ## `path`
    /// a [`TreePath`][crate::TreePath]-struct identifying the changed row
    /// ## `iter`
    /// a valid [`TreeIter`][crate::TreeIter]-struct 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]-struct 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]-struct identifying the row
    /// ## `iter`
    /// a valid [`TreeIter`][crate::TreeIter]-struct 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]-struct identifying the new row
    /// ## `iter`
    /// a valid [`TreeIter`][crate::TreeIter]-struct 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 {}