gtk/auto/

tree_store.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::{Buildable, TreeDragDest, TreeDragSource, TreeIter, TreeModel, TreeSortable};
use glib::{prelude::*, translate::*};
use std::fmt;

glib::wrapper! {
    /// 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 consequentially,
    /// 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:
    ///
    ///
    ///
    /// **⚠️ The following code is in xml ⚠️**
    ///
    /// ```xml
    /// <object class="GtkTreeStore">
    ///   <columns>
    ///     <column type="gchararray"/>
    ///     <column type="gchararray"/>
    ///     <column type="gint"/>
    ///   </columns>
    /// </object>
    /// ```
    ///
    /// # Implements
    ///
    /// [`TreeStoreExt`][trait@crate::prelude::TreeStoreExt], [`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], [`TreeStoreExtManual`][trait@crate::prelude::TreeStoreExtManual], [`BuildableExtManual`][trait@crate::prelude::BuildableExtManual], [`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 {
    pub const NONE: Option<&'static TreeStore> = None;

    //#[doc(alias = "gtk_tree_store_new")]
    //pub fn new(n_columns: i32, : /*Unknown conversion*//*Unimplemented*/Basic: VarArgs) -> TreeStore {
    //    unsafe { TODO: call ffi:gtk_tree_store_new() }
    //}

    //#[doc(alias = "gtk_tree_store_newv")]
    //pub fn newv(types: /*Unimplemented*/&CArray TypeId { ns_id: 0, id: 30 }) -> TreeStore {
    //    unsafe { TODO: call ffi:gtk_tree_store_newv() }
    //}
}

mod sealed {
    pub trait Sealed {}
    impl<T: super::IsA<super::TreeStore>> Sealed for T {}
}

/// Trait containing all [`struct@TreeStore`] methods.
///
/// # Implementors
///
/// [`TreeStore`][struct@crate::TreeStore]
pub trait TreeStoreExt: IsA<TreeStore> + sealed::Sealed + 'static {
    /// 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
    /// [`TreeStoreExtManual::set()`][crate::prelude::TreeStoreExtManual::set()] or [`TreeStoreExtManual::set_value()`][crate::prelude::TreeStoreExtManual::set_value()].
    /// ## `parent`
    /// A valid [`TreeIter`][crate::TreeIter], or [`None`]
    ///
    /// # Returns
    ///
    ///
    /// ## `iter`
    /// An unset [`TreeIter`][crate::TreeIter] to set to the appended row
    #[doc(alias = "gtk_tree_store_append")]
    fn append(&self, parent: Option<&TreeIter>) -> TreeIter {
        unsafe {
            let mut iter = TreeIter::uninitialized();
            ffi::gtk_tree_store_append(
                self.as_ref().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")]
    fn clear(&self) {
        unsafe {
            ffi::gtk_tree_store_clear(self.as_ref().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 [`TreeStoreExtManual::set()`][crate::prelude::TreeStoreExtManual::set()] or
    /// [`TreeStoreExtManual::set_value()`][crate::prelude::TreeStoreExtManual::set_value()].
    /// ## `parent`
    /// A valid [`TreeIter`][crate::TreeIter], or [`None`]
    /// ## `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")]
    fn insert(&self, parent: Option<&TreeIter>, position: i32) -> TreeIter {
        unsafe {
            let mut iter = TreeIter::uninitialized();
            ffi::gtk_tree_store_insert(
                self.as_ref().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
    /// [`TreeStoreExtManual::set()`][crate::prelude::TreeStoreExtManual::set()] or [`TreeStoreExtManual::set_value()`][crate::prelude::TreeStoreExtManual::set_value()].
    /// ## `parent`
    /// A valid [`TreeIter`][crate::TreeIter], or [`None`]
    /// ## `sibling`
    /// A valid [`TreeIter`][crate::TreeIter], or [`None`]
    ///
    /// # Returns
    ///
    ///
    /// ## `iter`
    /// An unset [`TreeIter`][crate::TreeIter] to set to the new row
    #[doc(alias = "gtk_tree_store_insert_after")]
    fn insert_after(&self, parent: Option<&TreeIter>, sibling: Option<&TreeIter>) -> TreeIter {
        unsafe {
            let mut iter = TreeIter::uninitialized();
            ffi::gtk_tree_store_insert_after(
                self.as_ref().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
    /// [`TreeStoreExtManual::set()`][crate::prelude::TreeStoreExtManual::set()] or [`TreeStoreExtManual::set_value()`][crate::prelude::TreeStoreExtManual::set_value()].
    /// ## `parent`
    /// A valid [`TreeIter`][crate::TreeIter], or [`None`]
    /// ## `sibling`
    /// A valid [`TreeIter`][crate::TreeIter], or [`None`]
    ///
    /// # Returns
    ///
    ///
    /// ## `iter`
    /// An unset [`TreeIter`][crate::TreeIter] to set to the new row
    #[doc(alias = "gtk_tree_store_insert_before")]
    fn insert_before(&self, parent: Option<&TreeIter>, sibling: Option<&TreeIter>) -> TreeIter {
        unsafe {
            let mut iter = TreeIter::uninitialized();
            ffi::gtk_tree_store_insert_before(
                self.as_ref().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
        }
    }

    //#[doc(alias = "gtk_tree_store_insert_with_values")]
    //fn insert_with_values(&self, parent: Option<&TreeIter>, position: i32, : /*Unknown conversion*//*Unimplemented*/Basic: VarArgs) -> TreeIter {
    //    unsafe { TODO: call ffi:gtk_tree_store_insert_with_values() }
    //}

    //#[doc(alias = "gtk_tree_store_insert_with_valuesv")]
    //fn insert_with_valuesv(&self, parent: Option<&TreeIter>, position: i32, columns: &[i32], values: &[&glib::Value]) -> TreeIter {
    //    unsafe { TODO: call ffi:gtk_tree_store_insert_with_valuesv() }
    //}

    /// 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")]
    fn is_ancestor(&self, iter: &TreeIter, descendant: &TreeIter) -> bool {
        unsafe {
            from_glib(ffi::gtk_tree_store_is_ancestor(
                self.as_ref().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")]
    fn iter_depth(&self, iter: &TreeIter) -> i32 {
        unsafe {
            ffi::gtk_tree_store_iter_depth(
                self.as_ref().to_glib_none().0,
                mut_override(iter.to_glib_none().0),
            )
        }
    }

    /// WARNING: This function is slow. Only use it for debugging and/or testing
    /// purposes.
    ///
    /// Checks if the given iter is a valid iter for this [`TreeStore`][crate::TreeStore].
    /// ## `iter`
    /// A [`TreeIter`][crate::TreeIter].
    ///
    /// # Returns
    ///
    /// [`true`] if the iter is valid, [`false`] if the iter is invalid.
    #[doc(alias = "gtk_tree_store_iter_is_valid")]
    fn iter_is_valid(&self, iter: &TreeIter) -> bool {
        unsafe {
            from_glib(ffi::gtk_tree_store_iter_is_valid(
                self.as_ref().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")]
    fn move_after(&self, iter: &TreeIter, position: Option<&TreeIter>) {
        unsafe {
            ffi::gtk_tree_store_move_after(
                self.as_ref().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] or [`None`].
    #[doc(alias = "gtk_tree_store_move_before")]
    fn move_before(&self, iter: &TreeIter, position: Option<&TreeIter>) {
        unsafe {
            ffi::gtk_tree_store_move_before(
                self.as_ref().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 [`TreeStoreExtManual::set()`][crate::prelude::TreeStoreExtManual::set()] or [`TreeStoreExtManual::set_value()`][crate::prelude::TreeStoreExtManual::set_value()].
    /// ## `parent`
    /// A valid [`TreeIter`][crate::TreeIter], or [`None`]
    ///
    /// # Returns
    ///
    ///
    /// ## `iter`
    /// An unset [`TreeIter`][crate::TreeIter] to set to the prepended row
    #[doc(alias = "gtk_tree_store_prepend")]
    fn prepend(&self, parent: Option<&TreeIter>) -> TreeIter {
        unsafe {
            let mut iter = TreeIter::uninitialized();
            ffi::gtk_tree_store_prepend(
                self.as_ref().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")]
    fn remove(&self, iter: &TreeIter) -> bool {
        unsafe {
            from_glib(ffi::gtk_tree_store_remove(
                self.as_ref().to_glib_none().0,
                mut_override(iter.to_glib_none().0),
            ))
        }
    }

    //#[doc(alias = "gtk_tree_store_set_column_types")]
    //fn set_column_types(&self, types: /*Unimplemented*/&CArray TypeId { ns_id: 0, id: 30 }) {
    //    unsafe { TODO: call ffi:gtk_tree_store_set_column_types() }
    //}

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

    //#[doc(alias = "gtk_tree_store_set_valuesv")]
    //fn set_valuesv(&self, iter: &TreeIter, columns: &[i32], values: &[&glib::Value]) {
    //    unsafe { TODO: call ffi:gtk_tree_store_set_valuesv() }
    //}

    /// 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")]
    fn swap(&self, a: &TreeIter, b: &TreeIter) {
        unsafe {
            ffi::gtk_tree_store_swap(
                self.as_ref().to_glib_none().0,
                mut_override(a.to_glib_none().0),
                mut_override(b.to_glib_none().0),
            );
        }
    }
}

impl<O: IsA<TreeStore>> TreeStoreExt for O {}

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