// 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 gtk_tree_row_reference_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.
    ///
    /// # Deprecated since 4.10
    ///
    /// ## `model`
    /// a [`TreeModel`][crate::TreeModel]
    /// ## `path`
    /// a valid [`TreePath`][crate::TreePath] to monitor
    ///
    /// # Returns
    ///
    /// a newly allocated [`TreeRowReference`][crate::TreeRowReference]
    #[cfg_attr(feature = "v4_10", deprecated = "Since 4.10")]
    #[allow(deprecated)]
    #[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 gtk_tree_row_reference_new(), it
    /// does not listen to the model for changes. The creator of
    /// the row reference must do this explicitly using
    /// gtk_tree_row_reference_inserted(), gtk_tree_row_reference_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.
    ///
    /// # Deprecated since 4.10
    ///
    /// ## `proxy`
    /// a proxy `GObject`
    /// ## `model`
    /// a [`TreeModel`][crate::TreeModel]
    /// ## `path`
    /// a valid [`TreePath`][crate::TreePath] to monitor
    ///
    /// # Returns
    ///
    /// a newly allocated [`TreeRowReference`][crate::TreeRowReference]
    #[cfg_attr(feature = "v4_10", deprecated = "Since 4.10")]
    #[allow(deprecated)]
    #[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.
    ///
    /// # Deprecated since 4.10
    ///
    ///
    /// # Returns
    ///
    /// the model
    #[cfg_attr(feature = "v4_10", deprecated = "Since 4.10")]
    #[allow(deprecated)]
    #[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.
    ///
    /// # Deprecated since 4.10
    ///
    ///
    /// # Returns
    ///
    /// a current path
    #[cfg_attr(feature = "v4_10", deprecated = "Since 4.10")]
    #[allow(deprecated)]
    #[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.
    ///
    /// # Deprecated since 4.10
    ///
    ///
    /// # Returns
    ///
    /// [`true`] if @self points to a valid path
    #[cfg_attr(feature = "v4_10", deprecated = "Since 4.10")]
    #[allow(deprecated)]
    #[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
    /// gtk_tree_row_reference_new_proxy() know that the
    /// model emitted the ::row-deleted signal.
    ///
    /// # Deprecated since 4.10
    ///
    /// ## `proxy`
    /// a `GObject`
    /// ## `path`
    /// the path position that was deleted
    #[cfg_attr(feature = "v4_10", deprecated = "Since 4.10")]
    #[allow(deprecated)]
    #[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
    /// gtk_tree_row_reference_new_proxy() know that the
    /// model emitted the ::row-inserted signal.
    ///
    /// # Deprecated since 4.10
    ///
    /// ## `proxy`
    /// a `GObject`
    /// ## `path`
    /// the row position that was inserted
    #[cfg_attr(feature = "v4_10", deprecated = "Since 4.10")]
    #[allow(deprecated)]
    #[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),
            );
        }
    }
}