gtk/auto/

tree_row_reference.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::{TreeModel, TreePath};
use glib::{prelude::*, translate::*};

glib::wrapper! {
    /// A GtkTreeRowReference tracks model changes so that it always refers to the
    /// same row (a [`TreePath`][crate::TreePath] refers to a position, not a fixed row). Create a
    /// new GtkTreeRowReference with [`new()`][Self::new()].
    #[derive(Debug, PartialEq, Eq, PartialOrd, Ord, Hash)]
    pub struct TreeRowReference(Boxed<ffi::GtkTreeRowReference>);

    match fn {
        copy => |ptr| ffi::gtk_tree_row_reference_copy(mut_override(ptr)),
        free => |ptr| ffi::gtk_tree_row_reference_free(ptr),
        type_ => || ffi::gtk_tree_row_reference_get_type(),
    }
}

impl TreeRowReference {
    /// Creates a row reference based on `path`.
    ///
    /// This reference will keep pointing to the node pointed to
    /// by `path`, so long as it exists. Any changes that occur on `model` are
    /// propagated, and the path is updated appropriately. If
    /// `path` isn’t a valid path in `model`, then [`None`] is returned.
    /// ## `model`
    /// a [`TreeModel`][crate::TreeModel]
    /// ## `path`
    /// a valid [`TreePath`][crate::TreePath]-struct to monitor
    ///
    /// # Returns
    ///
    /// a newly allocated [`TreeRowReference`][crate::TreeRowReference], or [`None`]
    #[doc(alias = "gtk_tree_row_reference_new")]
    pub fn new(model: &impl IsA<TreeModel>, path: &TreePath) -> Option<TreeRowReference> {
        skip_assert_initialized!();
        unsafe {
            from_glib_full(ffi::gtk_tree_row_reference_new(
                model.as_ref().to_glib_none().0,
                mut_override(path.to_glib_none().0),
            ))
        }
    }

    /// You do not need to use this function.
    ///
    /// Creates a row reference based on `path`.
    ///
    /// This reference will keep pointing to the node pointed to
    /// by `path`, so long as it exists. If `path` isn’t a valid
    /// path in `model`, then [`None`] is returned. However, unlike
    /// references created with [`new()`][Self::new()], it
    /// does not listen to the model for changes. The creator of
    /// the row reference must do this explicitly using
    /// [`inserted()`][Self::inserted()], [`deleted()`][Self::deleted()],
    /// `gtk_tree_row_reference_reordered()`.
    ///
    /// These functions must be called exactly once per proxy when the
    /// corresponding signal on the model is emitted. This single call
    /// updates all row references for that proxy. Since built-in GTK+
    /// objects like [`TreeView`][crate::TreeView] already use this mechanism internally,
    /// using them as the proxy object will produce unpredictable results.
    /// Further more, passing the same object as `model` and `proxy`
    /// doesn’t work for reasons of internal implementation.
    ///
    /// This type of row reference is primarily meant by structures that
    /// need to carefully monitor exactly when a row reference updates
    /// itself, and is not generally needed by most applications.
    /// ## `proxy`
    /// a proxy [`glib::Object`][crate::glib::Object]
    /// ## `model`
    /// a [`TreeModel`][crate::TreeModel]
    /// ## `path`
    /// a valid [`TreePath`][crate::TreePath]-struct to monitor
    ///
    /// # Returns
    ///
    /// a newly allocated [`TreeRowReference`][crate::TreeRowReference], or [`None`]
    #[doc(alias = "gtk_tree_row_reference_new_proxy")]
    pub fn new_proxy(
        proxy: &impl IsA<glib::Object>,
        model: &impl IsA<TreeModel>,
        path: &TreePath,
    ) -> Option<TreeRowReference> {
        skip_assert_initialized!();
        unsafe {
            from_glib_full(ffi::gtk_tree_row_reference_new_proxy(
                proxy.as_ref().to_glib_none().0,
                model.as_ref().to_glib_none().0,
                mut_override(path.to_glib_none().0),
            ))
        }
    }

    /// Returns the model that the row reference is monitoring.
    ///
    /// # Returns
    ///
    /// the model
    #[doc(alias = "gtk_tree_row_reference_get_model")]
    #[doc(alias = "get_model")]
    pub fn model(&self) -> TreeModel {
        unsafe {
            from_glib_none(ffi::gtk_tree_row_reference_get_model(mut_override(
                self.to_glib_none().0,
            )))
        }
    }

    /// Returns a path that the row reference currently points to,
    /// or [`None`] if the path pointed to is no longer valid.
    ///
    /// # Returns
    ///
    /// a current path, or [`None`]
    #[doc(alias = "gtk_tree_row_reference_get_path")]
    #[doc(alias = "get_path")]
    pub fn path(&self) -> Option<TreePath> {
        unsafe {
            from_glib_full(ffi::gtk_tree_row_reference_get_path(mut_override(
                self.to_glib_none().0,
            )))
        }
    }

    /// Returns [`true`] if the `self` is non-[`None`] and refers to
    /// a current valid path.
    ///
    /// # Returns
    ///
    /// [`true`] if `self` points to a valid path
    #[doc(alias = "gtk_tree_row_reference_valid")]
    pub fn valid(&self) -> bool {
        unsafe {
            from_glib(ffi::gtk_tree_row_reference_valid(mut_override(
                self.to_glib_none().0,
            )))
        }
    }

    /// Lets a set of row reference created by
    /// [`new_proxy()`][Self::new_proxy()] know that the
    /// model emitted the [`row-deleted`][struct@crate::TreeModel#row-deleted] signal.
    /// ## `proxy`
    /// a [`glib::Object`][crate::glib::Object]
    /// ## `path`
    /// the path position that was deleted
    #[doc(alias = "gtk_tree_row_reference_deleted")]
    pub fn deleted(proxy: &impl IsA<glib::Object>, path: &TreePath) {
        assert_initialized_main_thread!();
        unsafe {
            ffi::gtk_tree_row_reference_deleted(
                proxy.as_ref().to_glib_none().0,
                mut_override(path.to_glib_none().0),
            );
        }
    }

    /// Lets a set of row reference created by
    /// [`new_proxy()`][Self::new_proxy()] know that the
    /// model emitted the [`row-inserted`][struct@crate::TreeModel#row-inserted] signal.
    /// ## `proxy`
    /// a [`glib::Object`][crate::glib::Object]
    /// ## `path`
    /// the row position that was inserted
    #[doc(alias = "gtk_tree_row_reference_inserted")]
    pub fn inserted(proxy: &impl IsA<glib::Object>, path: &TreePath) {
        assert_initialized_main_thread!();
        unsafe {
            ffi::gtk_tree_row_reference_inserted(
                proxy.as_ref().to_glib_none().0,
                mut_override(path.to_glib_none().0),
            );
        }
    }

    //#[doc(alias = "gtk_tree_row_reference_reordered")]
    //pub fn reordered(proxy: &impl IsA<glib::Object>, path: &mut TreePath, iter: &mut TreeIter, new_order: &[i32]) {
    //    unsafe { TODO: call ffi:gtk_tree_row_reference_reordered() }
    //}
}