1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175 176 177 178 179 180 181 182 183 184 185 186
// 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; use crate::TreePath; use glib::object::IsA; use glib::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<P: IsA<TreeModel>>(model: &P, 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<P: IsA<glib::Object>, Q: IsA<TreeModel>>( proxy: &P, model: &Q, 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 `signal::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<P: IsA<glib::Object>>(proxy: &P, 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 `signal::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<P: IsA<glib::Object>>(proxy: &P, 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<P: IsA<glib::Object>>(proxy: &P, path: &mut TreePath, iter: &mut TreeIter, new_order: &[i32]) { // unsafe { TODO: call ffi:gtk_tree_row_reference_reordered() } //} }