// 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::{Buildable, TreeDragDest, TreeDragSource, TreeIter, TreeModel, TreeSortable};
use glib::translate::*;

glib::wrapper! {
    /// Use [`TreeListModel`][crate::TreeListModel] instead
    /// A tree-like data structure that can be used with the [`TreeView`][crate::TreeView].
    ///
    /// The [`TreeStore`][crate::TreeStore] object is a list model for use with a [`TreeView`][crate::TreeView]
    /// widget. It implements the [`TreeModel`][crate::TreeModel] interface, and consequently,
    /// can use all of the methods available there. It also implements the
    /// [`TreeSortable`][crate::TreeSortable] interface so it can be sorted by the view.
    /// Finally, it also implements the tree [drag][`TreeDragSource`][crate::TreeDragSource]
    /// and [drop][`TreeDragDest`][crate::TreeDragDest] interfaces.
    ///
    /// [`TreeStore`][crate::TreeStore] is deprecated since GTK 4.10, and should not be used in newly
    /// written code. You should use [`TreeListModel`][crate::TreeListModel] for a tree-like model
    /// object.
    ///
    /// ## GtkTreeStore as GtkBuildable
    ///
    /// The GtkTreeStore implementation of the [`Buildable`][crate::Buildable] interface allows
    /// to specify the model columns with a `<columns>` element that may contain
    /// multiple `<column>` elements, each specifying one model column. The “type”
    /// attribute specifies the data type for the column.
    ///
    /// An example of a UI Definition fragment for a tree store:
    ///
    /// ```xml
    /// <object class="GtkTreeStore">
    ///   <columns>
    ///     <column type="gchararray"/>
    ///     <column type="gchararray"/>
    ///     <column type="gint"/>
    ///   </columns>
    /// </object>
    /// ```
    ///
    /// # Implements
    ///
    /// [`trait@glib::ObjectExt`], [`BuildableExt`][trait@crate::prelude::BuildableExt], [`TreeDragDestExt`][trait@crate::prelude::TreeDragDestExt], [`TreeDragSourceExt`][trait@crate::prelude::TreeDragSourceExt], [`TreeModelExt`][trait@crate::prelude::TreeModelExt], [`TreeSortableExt`][trait@crate::prelude::TreeSortableExt], [`TreeModelExtManual`][trait@crate::prelude::TreeModelExtManual], [`TreeSortableExtManual`][trait@crate::prelude::TreeSortableExtManual]
    #[doc(alias = "GtkTreeStore")]
    pub struct TreeStore(Object<ffi::GtkTreeStore, ffi::GtkTreeStoreClass>) @implements Buildable, TreeDragDest, TreeDragSource, TreeModel, TreeSortable;

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

impl TreeStore {
    /// Appends a new row to @self.
    ///
    /// If @parent is non-[`None`], then it will append the new row after the last
    /// child of @parent, otherwise it will append a row to the top level.
    ///
    /// The @iter parameter will be changed to point to this new row. The row will
    /// be empty after this function is called. To fill in values, you need to call
    /// gtk_tree_store_set() or gtk_tree_store_set_value().
    ///
    /// # Deprecated since 4.10
    ///
    /// Use [`TreeListModel`][crate::TreeListModel] instead
    /// ## `parent`
    /// A valid [`TreeIter`][crate::TreeIter]
    ///
    /// # Returns
    ///
    ///
    /// ## `iter`
    /// An unset [`TreeIter`][crate::TreeIter] to set to the appended row
    #[cfg_attr(feature = "v4_10", deprecated = "Since 4.10")]
    #[allow(deprecated)]
    #[doc(alias = "gtk_tree_store_append")]
    pub fn append(&self, parent: Option<&TreeIter>) -> TreeIter {
        unsafe {
            let mut iter = TreeIter::uninitialized();
            ffi::gtk_tree_store_append(
                self.to_glib_none().0,
                iter.to_glib_none_mut().0,
                mut_override(parent.to_glib_none().0),
            );
            iter
        }
    }

    /// Removes all rows from @self
    ///
    /// # Deprecated since 4.10
    ///
    /// Use [`TreeListModel`][crate::TreeListModel] instead
    #[cfg_attr(feature = "v4_10", deprecated = "Since 4.10")]
    #[allow(deprecated)]
    #[doc(alias = "gtk_tree_store_clear")]
    pub fn clear(&self) {
        unsafe {
            ffi::gtk_tree_store_clear(self.to_glib_none().0);
        }
    }

    /// Creates a new row at @position.
    ///
    /// If parent is non-[`None`], then the row will be made a child of @parent.
    /// Otherwise, the row will be created at the toplevel.
    ///
    /// If @position is `-1` or is larger than the number of rows at that level,
    /// then the new row will be inserted to the end of the list.
    ///
    /// The @iter parameter will be changed to point to this new row. The row
    /// will be empty after this function is called. To fill in values, you
    /// need to call gtk_tree_store_set() or gtk_tree_store_set_value().
    ///
    /// # Deprecated since 4.10
    ///
    /// Use [`TreeListModel`][crate::TreeListModel] instead
    /// ## `parent`
    /// A valid [`TreeIter`][crate::TreeIter]
    /// ## `position`
    /// position to insert the new row, or -1 for last
    ///
    /// # Returns
    ///
    ///
    /// ## `iter`
    /// An unset [`TreeIter`][crate::TreeIter] to set to the new row
    #[cfg_attr(feature = "v4_10", deprecated = "Since 4.10")]
    #[allow(deprecated)]
    #[doc(alias = "gtk_tree_store_insert")]
    pub fn insert(&self, parent: Option<&TreeIter>, position: i32) -> TreeIter {
        unsafe {
            let mut iter = TreeIter::uninitialized();
            ffi::gtk_tree_store_insert(
                self.to_glib_none().0,
                iter.to_glib_none_mut().0,
                mut_override(parent.to_glib_none().0),
                position,
            );
            iter
        }
    }

    /// Inserts a new row after @sibling.
    ///
    /// If @sibling is [`None`], then the row will be prepended to @parent’s children.
    ///
    /// If @parent and @sibling are [`None`], then the row will be prepended to the
    /// toplevel.
    ///
    /// If both @sibling and @parent are set, then @parent must be the parent
    /// of @sibling. When @sibling is set, @parent is optional.
    ///
    /// The @iter parameter will be changed to point to this new row. The row will
    /// be empty after this function is called. To fill in values, you need to call
    /// gtk_tree_store_set() or gtk_tree_store_set_value().
    ///
    /// # Deprecated since 4.10
    ///
    /// Use [`TreeListModel`][crate::TreeListModel] instead
    /// ## `parent`
    /// A valid [`TreeIter`][crate::TreeIter]
    /// ## `sibling`
    /// A valid [`TreeIter`][crate::TreeIter]
    ///
    /// # Returns
    ///
    ///
    /// ## `iter`
    /// An unset [`TreeIter`][crate::TreeIter] to set to the new row
    #[cfg_attr(feature = "v4_10", deprecated = "Since 4.10")]
    #[allow(deprecated)]
    #[doc(alias = "gtk_tree_store_insert_after")]
    pub fn insert_after(&self, parent: Option<&TreeIter>, sibling: Option<&TreeIter>) -> TreeIter {
        unsafe {
            let mut iter = TreeIter::uninitialized();
            ffi::gtk_tree_store_insert_after(
                self.to_glib_none().0,
                iter.to_glib_none_mut().0,
                mut_override(parent.to_glib_none().0),
                mut_override(sibling.to_glib_none().0),
            );
            iter
        }
    }

    /// Inserts a new row before @sibling.
    ///
    /// If @sibling is [`None`], then the row will be appended to @parent’s children.
    ///
    /// If @parent and @sibling are [`None`], then the row will be appended to the
    /// toplevel.
    ///
    /// If both @sibling and @parent are set, then @parent must be the parent
    /// of @sibling. When @sibling is set, @parent is optional.
    ///
    /// The @iter parameter will be changed to point to this new row. The row will
    /// be empty after this function is called. To fill in values, you need to call
    /// gtk_tree_store_set() or gtk_tree_store_set_value().
    ///
    /// # Deprecated since 4.10
    ///
    /// Use [`TreeListModel`][crate::TreeListModel] instead
    /// ## `parent`
    /// A valid [`TreeIter`][crate::TreeIter]
    /// ## `sibling`
    /// A valid [`TreeIter`][crate::TreeIter]
    ///
    /// # Returns
    ///
    ///
    /// ## `iter`
    /// An unset [`TreeIter`][crate::TreeIter] to set to the new row
    #[cfg_attr(feature = "v4_10", deprecated = "Since 4.10")]
    #[allow(deprecated)]
    #[doc(alias = "gtk_tree_store_insert_before")]
    pub fn insert_before(&self, parent: Option<&TreeIter>, sibling: Option<&TreeIter>) -> TreeIter {
        unsafe {
            let mut iter = TreeIter::uninitialized();
            ffi::gtk_tree_store_insert_before(
                self.to_glib_none().0,
                iter.to_glib_none_mut().0,
                mut_override(parent.to_glib_none().0),
                mut_override(sibling.to_glib_none().0),
            );
            iter
        }
    }

    /// Checks if @iter is an ancestor of @descendant.
    ///
    /// # Deprecated since 4.10
    ///
    /// Use [`TreeListModel`][crate::TreeListModel] instead
    /// ## `iter`
    /// A valid [`TreeIter`][crate::TreeIter]
    /// ## `descendant`
    /// A valid [`TreeIter`][crate::TreeIter]
    ///
    /// # Returns
    ///
    /// true if @iter is an ancestor of @descendant, and false otherwise
    #[cfg_attr(feature = "v4_10", deprecated = "Since 4.10")]
    #[allow(deprecated)]
    #[doc(alias = "gtk_tree_store_is_ancestor")]
    pub fn is_ancestor(&self, iter: &TreeIter, descendant: &TreeIter) -> bool {
        unsafe {
            from_glib(ffi::gtk_tree_store_is_ancestor(
                self.to_glib_none().0,
                mut_override(iter.to_glib_none().0),
                mut_override(descendant.to_glib_none().0),
            ))
        }
    }

    /// Returns the depth of the position pointed by the iterator
    ///
    /// The depth will be 0 for anything on the root level, 1 for anything down
    /// a level, etc.
    ///
    /// # Deprecated since 4.10
    ///
    /// Use [`TreeListModel`][crate::TreeListModel] instead
    /// ## `iter`
    /// A valid [`TreeIter`][crate::TreeIter]
    ///
    /// # Returns
    ///
    /// The depth of the position pointed by the iterator
    #[cfg_attr(feature = "v4_10", deprecated = "Since 4.10")]
    #[allow(deprecated)]
    #[doc(alias = "gtk_tree_store_iter_depth")]
    pub fn iter_depth(&self, iter: &TreeIter) -> i32 {
        unsafe {
            ffi::gtk_tree_store_iter_depth(
                self.to_glib_none().0,
                mut_override(iter.to_glib_none().0),
            )
        }
    }

    /// Checks if the given iter is a valid iter for this [`TreeStore`][crate::TreeStore].
    ///
    /// This function is slow. Only use it for debugging and/or testing
    /// purposes.
    ///
    /// # Deprecated since 4.10
    ///
    /// Use [`TreeListModel`][crate::TreeListModel] instead
    /// ## `iter`
    /// the iterator to check
    ///
    /// # Returns
    ///
    /// true if the iter is valid, and false otherwise
    #[cfg_attr(feature = "v4_10", deprecated = "Since 4.10")]
    #[allow(deprecated)]
    #[doc(alias = "gtk_tree_store_iter_is_valid")]
    pub fn iter_is_valid(&self, iter: &TreeIter) -> bool {
        unsafe {
            from_glib(ffi::gtk_tree_store_iter_is_valid(
                self.to_glib_none().0,
                mut_override(iter.to_glib_none().0),
            ))
        }
    }

    /// Moves @iter in @self to the position after @position.
    ///
    /// @iter and @position should be in the same level.
    ///
    /// Note that this function only works with unsorted stores.
    ///
    /// If @position is [`None`], @iter will be moved to the start of the level.
    ///
    /// # Deprecated since 4.10
    ///
    /// Use [`TreeListModel`][crate::TreeListModel] instead
    /// ## `iter`
    /// A [`TreeIter`][crate::TreeIter].
    /// ## `position`
    /// A [`TreeIter`][crate::TreeIter].
    #[cfg_attr(feature = "v4_10", deprecated = "Since 4.10")]
    #[allow(deprecated)]
    #[doc(alias = "gtk_tree_store_move_after")]
    pub fn move_after(&self, iter: &TreeIter, position: Option<&TreeIter>) {
        unsafe {
            ffi::gtk_tree_store_move_after(
                self.to_glib_none().0,
                mut_override(iter.to_glib_none().0),
                mut_override(position.to_glib_none().0),
            );
        }
    }

    /// Moves @iter in @self to the position before @position.
    ///
    /// @iter and @position should be in the same level.
    ///
    /// Note that this function only works with unsorted stores.
    ///
    /// If @position is [`None`], @iter will be moved to the end of the level.
    ///
    /// # Deprecated since 4.10
    ///
    /// Use [`TreeListModel`][crate::TreeListModel] instead
    /// ## `iter`
    /// A [`TreeIter`][crate::TreeIter]
    /// ## `position`
    /// A [`TreeIter`][crate::TreeIter]
    #[cfg_attr(feature = "v4_10", deprecated = "Since 4.10")]
    #[allow(deprecated)]
    #[doc(alias = "gtk_tree_store_move_before")]
    pub fn move_before(&self, iter: &TreeIter, position: Option<&TreeIter>) {
        unsafe {
            ffi::gtk_tree_store_move_before(
                self.to_glib_none().0,
                mut_override(iter.to_glib_none().0),
                mut_override(position.to_glib_none().0),
            );
        }
    }

    /// Prepends a new row to @self.
    ///
    /// If @parent is non-[`None`], then it will prepend the new row before the first
    /// child of @parent, otherwise it will prepend a row to the top level. The
    /// `iter` parameter will be changed to point to this new row.  The row will
    /// be empty after this function is called. To fill in values, you need to
    /// call gtk_tree_store_set() or gtk_tree_store_set_value().
    ///
    /// # Deprecated since 4.10
    ///
    /// Use [`TreeListModel`][crate::TreeListModel] instead
    /// ## `parent`
    /// A valid [`TreeIter`][crate::TreeIter]
    ///
    /// # Returns
    ///
    ///
    /// ## `iter`
    /// An unset [`TreeIter`][crate::TreeIter] to set to the prepended row
    #[cfg_attr(feature = "v4_10", deprecated = "Since 4.10")]
    #[allow(deprecated)]
    #[doc(alias = "gtk_tree_store_prepend")]
    pub fn prepend(&self, parent: Option<&TreeIter>) -> TreeIter {
        unsafe {
            let mut iter = TreeIter::uninitialized();
            ffi::gtk_tree_store_prepend(
                self.to_glib_none().0,
                iter.to_glib_none_mut().0,
                mut_override(parent.to_glib_none().0),
            );
            iter
        }
    }

    /// Removes @iter from @self.
    ///
    /// After being removed, @iter is set to the next valid row at that level, or
    /// invalidated if it previously pointed to the last one.
    ///
    /// # Deprecated since 4.10
    ///
    /// Use [`TreeListModel`][crate::TreeListModel] instead
    /// ## `iter`
    /// A valid [`TreeIter`][crate::TreeIter]
    ///
    /// # Returns
    ///
    /// true if @iter is still valid, and false otherwise
    #[cfg_attr(feature = "v4_10", deprecated = "Since 4.10")]
    #[allow(deprecated)]
    #[doc(alias = "gtk_tree_store_remove")]
    pub fn remove(&self, iter: &TreeIter) -> bool {
        unsafe {
            from_glib(ffi::gtk_tree_store_remove(
                self.to_glib_none().0,
                mut_override(iter.to_glib_none().0),
            ))
        }
    }

    /// Swaps @a and @b in the same level of @self.
    ///
    /// Note that this function only works with unsorted stores.
    ///
    /// # Deprecated since 4.10
    ///
    /// Use [`TreeListModel`][crate::TreeListModel] instead
    /// ## `a`
    /// A [`TreeIter`][crate::TreeIter].
    /// ## `b`
    /// Another [`TreeIter`][crate::TreeIter].
    #[cfg_attr(feature = "v4_10", deprecated = "Since 4.10")]
    #[allow(deprecated)]
    #[doc(alias = "gtk_tree_store_swap")]
    pub fn swap(&self, a: &TreeIter, b: &TreeIter) {
        unsafe {
            ffi::gtk_tree_store_swap(
                self.to_glib_none().0,
                mut_override(a.to_glib_none().0),
                mut_override(b.to_glib_none().0),
            );
        }
    }
}