// This file was generated by gir (https://github.com/gtk-rs/gir)
// from gir-files (https://github.com/gtk-rs/gir-files.git)
// DO NOT EDIT

use crate::Buildable;
use crate::TreeDragDest;
use crate::TreeDragSource;
use crate::TreeIter;
use crate::TreeModel;
use crate::TreeSortable;
use glib::translate::*;
use std::fmt;

glib::wrapper! {
    /// A tree-like data structure that can be used with the GtkTreeView
    ///
    /// 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 and drop][gtk3-GtkTreeView-drag-and-drop]
    /// interfaces.
    ///
    /// # 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:
    ///
    /// ```text
    /// <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. `iter` 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
    /// [`set()`][Self::set()] or [`set_value()`][Self::set_value()].
    /// ## `parent`
    /// A valid [`TreeIter`][crate::TreeIter]
    ///
    /// # Returns
    ///
    ///
    /// ## `iter`
    /// An unset [`TreeIter`][crate::TreeIter] to set to the appended row
    #[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`
    #[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. `iter` 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 [`set()`][Self::set()] or
    /// [`set_value()`][Self::set_value()].
    /// ## `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
    #[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.
    ///
    /// `iter` 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
    /// [`set()`][Self::set()] or [`set_value()`][Self::set_value()].
    /// ## `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
    #[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.
    ///
    /// `iter` 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
    /// [`set()`][Self::set()] or [`set_value()`][Self::set_value()].
    /// ## `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
    #[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
        }
    }

    /// Returns [`true`] if `iter` is an ancestor of `descendant`. That is, `iter` is the
    /// parent (or grandparent or great-grandparent) of `descendant`.
    /// ## `iter`
    /// A valid [`TreeIter`][crate::TreeIter]
    /// ## `descendant`
    /// A valid [`TreeIter`][crate::TreeIter]
    ///
    /// # Returns
    ///
    /// [`true`], if `iter` is an ancestor of `descendant`
    #[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 `iter`. This will be 0 for anything on the root level, 1
    /// for anything down a level, etc.
    /// ## `iter`
    /// A valid [`TreeIter`][crate::TreeIter]
    ///
    /// # Returns
    ///
    /// The depth of `iter`
    #[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.
    /// ## `iter`
    /// the iterator to check
    ///
    /// # Returns
    ///
    /// [`true`] if the iter is valid, [`false`] if the iter is invalid.
    #[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.
    /// ## `iter`
    /// A [`TreeIter`][crate::TreeIter].
    /// ## `position`
    /// A [`TreeIter`][crate::TreeIter].
    #[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.
    /// ## `iter`
    /// A [`TreeIter`][crate::TreeIter]
    /// ## `position`
    /// A [`TreeIter`][crate::TreeIter]
    #[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. `iter` 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 [`set()`][Self::set()] or [`set_value()`][Self::set_value()].
    /// ## `parent`
    /// A valid [`TreeIter`][crate::TreeIter]
    ///
    /// # Returns
    ///
    ///
    /// ## `iter`
    /// An unset [`TreeIter`][crate::TreeIter] to set to the prepended row
    #[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.
    /// ## `iter`
    /// A valid [`TreeIter`][crate::TreeIter]
    ///
    /// # Returns
    ///
    /// [`true`] if `iter` is still valid, [`false`] if not.
    #[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.
    /// ## `a`
    /// A [`TreeIter`][crate::TreeIter].
    /// ## `b`
    /// Another [`TreeIter`][crate::TreeIter].
    #[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),
            );
        }
    }
}

impl fmt::Display for TreeStore {
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        f.write_str("TreeStore")
    }
}