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! {
    /// The [`TreeModel`][crate::TreeModel] interface defines a generic tree interface for
    /// use by the [`TreeView`][crate::TreeView] widget. It is an abstract interface, and
    /// is designed to be usable with any appropriate data structure. The
    /// programmer just has to implement this interface on their own data
    /// type for it to be viewable by a [`TreeView`][crate::TreeView] widget.
    ///
    /// The model is represented as a hierarchical tree of strongly-typed,
    /// columned data. In other words, the model can be seen as a tree where
    /// every node has different values depending on which column is being
    /// queried. The type of data found in a column is determined by using
    /// the GType system (ie. `G_TYPE_INT`, `GTK_TYPE_BUTTON`, `G_TYPE_POINTER`,
    /// etc). The types are homogeneous per column across all nodes. It is
    /// important to note that this interface only provides a way of examining
    /// a model and observing changes. The implementation of each individual
    /// model decides how and if changes are made.
    ///
    /// In order to make life simpler for programmers who do not need to
    /// write their own specialized model, two generic models are provided
    /// — the [`TreeStore`][crate::TreeStore] and the [`ListStore`][crate::ListStore]. To use these, the
    /// developer simply pushes data into these models as necessary. These
    /// models provide the data structure as well as all appropriate tree
    /// interfaces. As a result, implementing drag and drop, sorting, and
    /// storing data is trivial. For the vast majority of trees and lists,
    /// these two models are sufficient.
    ///
    /// Models are accessed on a node/column level of granularity. One can
    /// query for the value of a model at a certain node and a certain
    /// column on that node. There are two structures used to reference a
    /// particular node in a model. They are the [`TreePath`][crate::TreePath]-struct and
    /// the [`TreeIter`][crate::TreeIter]-struct (“iter” is short for iterator). Most of the
    /// interface consists of operations on a [`TreeIter`][crate::TreeIter]-struct.
    ///
    /// A path is essentially a potential node. It is a location on a model
    /// that may or may not actually correspond to a node on a specific
    /// model. The [`TreePath`][crate::TreePath]-struct can be converted into either an
    /// array of unsigned integers or a string. The string form is a list
    /// of numbers separated by a colon. Each number refers to the offset
    /// at that level. Thus, the path `0` refers to the root
    /// node and the path `2:4` refers to the fifth child of
    /// the third node.
    ///
    /// By contrast, a [`TreeIter`][crate::TreeIter]-struct is a reference to a specific node on
    /// a specific model. It is a generic struct with an integer and three
    /// generic pointers. These are filled in by the model in a model-specific
    /// way. One can convert a path to an iterator by calling
    /// [`TreeModelExt::iter()`][crate::prelude::TreeModelExt::iter()]. These iterators are the primary way
    /// of accessing a model and are similar to the iterators used by
    /// [`TextBuffer`][crate::TextBuffer]. They are generally statically allocated on the
    /// stack and only used for a short time. The model interface defines
    /// a set of operations using them for navigating the model.
    ///
    /// It is expected that models fill in the iterator with private data.
    /// For example, the [`ListStore`][crate::ListStore] model, which is internally a simple
    /// linked list, stores a list node in one of the pointers. The
    /// [`TreeModelSort`][crate::TreeModelSort] stores an array and an offset in two of the
    /// pointers. Additionally, there is an integer field. This field is
    /// generally filled with a unique stamp per model. This stamp is for
    /// catching errors resulting from using invalid iterators with a model.
    ///
    /// The lifecycle of an iterator can be a little confusing at first.
    /// Iterators are expected to always be valid for as long as the model
    /// is unchanged (and doesn’t emit a signal). The model is considered
    /// to own all outstanding iterators and nothing needs to be done to
    /// free them from the user’s point of view. Additionally, some models
    /// guarantee that an iterator is valid for as long as the node it refers
    /// to is valid (most notably the [`TreeStore`][crate::TreeStore] and [`ListStore`][crate::ListStore]).
    /// Although generally uninteresting, as one always has to allow for
    /// the case where iterators do not persist beyond a signal, some very
    /// important performance enhancements were made in the sort model.
    /// As a result, the [`TreeModelFlags::ITERS_PERSIST`][crate::TreeModelFlags::ITERS_PERSIST] flag was added to
    /// indicate this behavior.
    ///
    /// To help show some common operation of a model, some examples are
    /// provided. The first example shows three ways of getting the iter at
    /// the location `3:2:5`. While the first method shown is
    /// easier, the second is much more common, as you often get paths from
    /// callbacks.
    ///
    /// ## Acquiring a [`TreeIter`][crate::TreeIter]-struct
    ///
    ///
    ///
    /// **⚠️ The following code is in C ⚠️**
    ///
    /// ```C
    /// // Three ways of getting the iter pointing to the location
    /// GtkTreePath *path;
    /// GtkTreeIter iter;
    /// GtkTreeIter parent_iter;
    ///
    /// // get the iterator from a string
    /// gtk_tree_model_get_iter_from_string (model,
    ///                                      &iter,
    ///                                      "3:2:5");
    ///
    /// // get the iterator from a path
    /// path = gtk_tree_path_new_from_string ("3:2:5");
    /// gtk_tree_model_get_iter (model, &iter, path);
    /// gtk_tree_path_free (path);
    ///
    /// // walk the tree to find the iterator
    /// gtk_tree_model_iter_nth_child (model, &iter,
    ///                                NULL, 3);
    /// parent_iter = iter;
    /// gtk_tree_model_iter_nth_child (model, &iter,
    ///                                &parent_iter, 2);
    /// parent_iter = iter;
    /// gtk_tree_model_iter_nth_child (model, &iter,
    ///                                &parent_iter, 5);
    /// ```
    ///
    /// This second example shows a quick way of iterating through a list
    /// and getting a string and an integer from each row. The
    /// `populate_model()` function used below is not
    /// shown, as it is specific to the [`ListStore`][crate::ListStore]. For information on
    /// how to write such a function, see the [`ListStore`][crate::ListStore] documentation.
    ///
    /// ## Reading data from a [`TreeModel`][crate::TreeModel]
    ///
    ///
    ///
    /// **⚠️ The following code is in C ⚠️**
    ///
    /// ```C
    /// enum
    /// {
    ///   STRING_COLUMN,
    ///   INT_COLUMN,
    ///   N_COLUMNS
    /// };
    ///
    /// ...
    ///
    /// GtkTreeModel *list_store;
    /// GtkTreeIter iter;
    /// gboolean valid;
    /// gint row_count = 0;
    ///
    /// // make a new list_store
    /// list_store = gtk_list_store_new (N_COLUMNS,
    ///                                  G_TYPE_STRING,
    ///                                  G_TYPE_INT);
    ///
    /// // Fill the list store with data
    /// populate_model (list_store);
    ///
    /// // Get the first iter in the list, check it is valid and walk
    /// // through the list, reading each row.
    ///
    /// valid = gtk_tree_model_get_iter_first (list_store,
    ///                                        &iter);
    /// while (valid)
    ///  {
    ///    gchar *str_data;
    ///    gint   int_data;
    ///
    ///    // Make sure you terminate calls to gtk_tree_model_get() with a “-1” value
    ///    gtk_tree_model_get (list_store, &iter,
    ///                        STRING_COLUMN, &str_data,
    ///                        INT_COLUMN, &int_data,
    ///                        -1);
    ///
    ///    // Do something with the data
    ///    g_print ("Row %d: (%s,%d)\n",
    ///             row_count, str_data, int_data);
    ///    g_free (str_data);
    ///
    ///    valid = gtk_tree_model_iter_next (list_store,
    ///                                      &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 {}