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
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
// 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 glib::{
    prelude::*,
    signal::{connect_raw, SignalHandlerId},
    translate::*,
};
use std::boxed::Box as Box_;

glib::wrapper! {
    /// [`TreeListRow`][crate::TreeListRow] is used by [`TreeListModel`][crate::TreeListModel] to represent items.
    ///
    /// It allows navigating the model as a tree and modify the state of rows.
    ///
    /// [`TreeListRow`][crate::TreeListRow] instances are created by a [`TreeListModel`][crate::TreeListModel] only
    /// when the [`passthrough`][struct@crate::TreeListModel#passthrough] property is not set.
    ///
    /// There are various support objects that can make use of [`TreeListRow`][crate::TreeListRow]
    /// objects, such as the [`TreeExpander`][crate::TreeExpander] widget that allows displaying
    /// an icon to expand or collapse a row or [`TreeListRowSorter`][crate::TreeListRowSorter] that
    /// makes it possible to sort trees properly.
    ///
    /// ## Properties
    ///
    ///
    /// #### `children`
    ///  The model holding the row's children.
    ///
    /// Readable
    ///
    ///
    /// #### `depth`
    ///  The depth in the tree of this row.
    ///
    /// Readable
    ///
    ///
    /// #### `expandable`
    ///  If this row can ever be expanded.
    ///
    /// Readable
    ///
    ///
    /// #### `expanded`
    ///  If this row is currently expanded.
    ///
    /// Readable | Writeable
    ///
    ///
    /// #### `item`
    ///  The item held in this row.
    ///
    /// Readable
    ///
    /// # Implements
    ///
    /// [`trait@glib::ObjectExt`]
    #[doc(alias = "GtkTreeListRow")]
    pub struct TreeListRow(Object<ffi::GtkTreeListRow, ffi::GtkTreeListRowClass>);

    match fn {
        type_ => || ffi::gtk_tree_list_row_get_type(),
    }
}

impl TreeListRow {
    /// If @self is not expanded or @position is greater than the
    /// number of children, [`None`] is returned.
    /// ## `position`
    /// position of the child to get
    ///
    /// # Returns
    ///
    /// the child in @position
    #[doc(alias = "gtk_tree_list_row_get_child_row")]
    #[doc(alias = "get_child_row")]
    #[must_use]
    pub fn child_row(&self, position: u32) -> Option<TreeListRow> {
        unsafe {
            from_glib_full(ffi::gtk_tree_list_row_get_child_row(
                self.to_glib_none().0,
                position,
            ))
        }
    }

    /// If the row is expanded, gets the model holding the children of @self.
    ///
    /// This model is the model created by the
    /// `callback::Gtk::TreeListModelCreateModelFunc
    /// and contains the original items, no matter what value
    /// [`passthrough`][struct@crate::TreeListModel#passthrough] is set to.
    ///
    /// # Returns
    ///
    /// The model containing the children
    #[doc(alias = "gtk_tree_list_row_get_children")]
    #[doc(alias = "get_children")]
    pub fn children(&self) -> Option<gio::ListModel> {
        unsafe { from_glib_none(ffi::gtk_tree_list_row_get_children(self.to_glib_none().0)) }
    }

    /// Gets the depth of this row.
    ///
    /// Rows that correspond to items in the root model have a depth
    /// of zero, rows corresponding to items of models of direct children
    /// of the root model have a depth of 1 and so on.
    ///
    /// The depth of a row never changes until the row is removed from its model
    /// at which point it will forever return 0.
    ///
    /// # Returns
    ///
    /// The depth of this row
    #[doc(alias = "gtk_tree_list_row_get_depth")]
    #[doc(alias = "get_depth")]
    pub fn depth(&self) -> u32 {
        unsafe { ffi::gtk_tree_list_row_get_depth(self.to_glib_none().0) }
    }

    /// Gets if a row is currently expanded.
    ///
    /// # Returns
    ///
    /// [`true`] if the row is expanded
    #[doc(alias = "gtk_tree_list_row_get_expanded")]
    #[doc(alias = "get_expanded")]
    pub fn is_expanded(&self) -> bool {
        unsafe { from_glib(ffi::gtk_tree_list_row_get_expanded(self.to_glib_none().0)) }
    }

    /// Gets the item corresponding to this row,
    ///
    /// # Returns
    ///
    /// The item
    ///   of this row. This function is only marked as nullable for backwards
    ///   compatibility reasons.
    #[doc(alias = "gtk_tree_list_row_get_item")]
    #[doc(alias = "get_item")]
    pub fn item(&self) -> Option<glib::Object> {
        unsafe { from_glib_full(ffi::gtk_tree_list_row_get_item(self.to_glib_none().0)) }
    }

    /// Gets the row representing the parent for @self.
    ///
    /// That is the row that would need to be collapsed
    /// to make this row disappear.
    ///
    /// If @self is a row corresponding to the root model,
    /// [`None`] is returned.
    ///
    /// The value returned by this function never changes
    /// until the row is removed from its model at which point
    /// it will forever return [`None`].
    ///
    /// # Returns
    ///
    /// The parent of @self
    #[doc(alias = "gtk_tree_list_row_get_parent")]
    #[doc(alias = "get_parent")]
    #[must_use]
    pub fn parent(&self) -> Option<TreeListRow> {
        unsafe { from_glib_full(ffi::gtk_tree_list_row_get_parent(self.to_glib_none().0)) }
    }

    /// Returns the position in the [`TreeListModel`][crate::TreeListModel] that @self occupies
    /// at the moment.
    ///
    /// # Returns
    ///
    /// The position in the model
    #[doc(alias = "gtk_tree_list_row_get_position")]
    #[doc(alias = "get_position")]
    pub fn position(&self) -> u32 {
        unsafe { ffi::gtk_tree_list_row_get_position(self.to_glib_none().0) }
    }

    /// Checks if a row can be expanded.
    ///
    /// This does not mean that the row is actually expanded,
    /// this can be checked with [`is_expanded()`][Self::is_expanded()].
    ///
    /// If a row is expandable never changes until the row is removed
    /// from its model at which point it will forever return [`false`].
    ///
    /// # Returns
    ///
    /// [`true`] if the row is expandable
    #[doc(alias = "gtk_tree_list_row_is_expandable")]
    pub fn is_expandable(&self) -> bool {
        unsafe { from_glib(ffi::gtk_tree_list_row_is_expandable(self.to_glib_none().0)) }
    }

    /// Expands or collapses a row.
    ///
    /// If a row is expanded, the model of calling the
    /// `callback::Gtk::TreeListModelCreateModelFunc for the row's
    /// item will be inserted after this row. If a row is collapsed,
    /// those items will be removed from the model.
    ///
    /// If the row is not expandable, this function does nothing.
    /// ## `expanded`
    /// [`true`] if the row should be expanded
    #[doc(alias = "gtk_tree_list_row_set_expanded")]
    pub fn set_expanded(&self, expanded: bool) {
        unsafe {
            ffi::gtk_tree_list_row_set_expanded(self.to_glib_none().0, expanded.into_glib());
        }
    }

    #[doc(alias = "children")]
    pub fn connect_children_notify<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId {
        unsafe extern "C" fn notify_children_trampoline<F: Fn(&TreeListRow) + 'static>(
            this: *mut ffi::GtkTreeListRow,
            _param_spec: glib::ffi::gpointer,
            f: glib::ffi::gpointer,
        ) {
            let f: &F = &*(f as *const F);
            f(&from_glib_borrow(this))
        }
        unsafe {
            let f: Box_<F> = Box_::new(f);
            connect_raw(
                self.as_ptr() as *mut _,
                b"notify::children\0".as_ptr() as *const _,
                Some(std::mem::transmute::<_, unsafe extern "C" fn()>(
                    notify_children_trampoline::<F> as *const (),
                )),
                Box_::into_raw(f),
            )
        }
    }

    #[doc(alias = "depth")]
    pub fn connect_depth_notify<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId {
        unsafe extern "C" fn notify_depth_trampoline<F: Fn(&TreeListRow) + 'static>(
            this: *mut ffi::GtkTreeListRow,
            _param_spec: glib::ffi::gpointer,
            f: glib::ffi::gpointer,
        ) {
            let f: &F = &*(f as *const F);
            f(&from_glib_borrow(this))
        }
        unsafe {
            let f: Box_<F> = Box_::new(f);
            connect_raw(
                self.as_ptr() as *mut _,
                b"notify::depth\0".as_ptr() as *const _,
                Some(std::mem::transmute::<_, unsafe extern "C" fn()>(
                    notify_depth_trampoline::<F> as *const (),
                )),
                Box_::into_raw(f),
            )
        }
    }

    #[doc(alias = "expandable")]
    pub fn connect_expandable_notify<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId {
        unsafe extern "C" fn notify_expandable_trampoline<F: Fn(&TreeListRow) + 'static>(
            this: *mut ffi::GtkTreeListRow,
            _param_spec: glib::ffi::gpointer,
            f: glib::ffi::gpointer,
        ) {
            let f: &F = &*(f as *const F);
            f(&from_glib_borrow(this))
        }
        unsafe {
            let f: Box_<F> = Box_::new(f);
            connect_raw(
                self.as_ptr() as *mut _,
                b"notify::expandable\0".as_ptr() as *const _,
                Some(std::mem::transmute::<_, unsafe extern "C" fn()>(
                    notify_expandable_trampoline::<F> as *const (),
                )),
                Box_::into_raw(f),
            )
        }
    }

    #[doc(alias = "expanded")]
    pub fn connect_expanded_notify<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId {
        unsafe extern "C" fn notify_expanded_trampoline<F: Fn(&TreeListRow) + 'static>(
            this: *mut ffi::GtkTreeListRow,
            _param_spec: glib::ffi::gpointer,
            f: glib::ffi::gpointer,
        ) {
            let f: &F = &*(f as *const F);
            f(&from_glib_borrow(this))
        }
        unsafe {
            let f: Box_<F> = Box_::new(f);
            connect_raw(
                self.as_ptr() as *mut _,
                b"notify::expanded\0".as_ptr() as *const _,
                Some(std::mem::transmute::<_, unsafe extern "C" fn()>(
                    notify_expanded_trampoline::<F> as *const (),
                )),
                Box_::into_raw(f),
            )
        }
    }

    #[doc(alias = "item")]
    pub fn connect_item_notify<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId {
        unsafe extern "C" fn notify_item_trampoline<F: Fn(&TreeListRow) + 'static>(
            this: *mut ffi::GtkTreeListRow,
            _param_spec: glib::ffi::gpointer,
            f: glib::ffi::gpointer,
        ) {
            let f: &F = &*(f as *const F);
            f(&from_glib_borrow(this))
        }
        unsafe {
            let f: Box_<F> = Box_::new(f);
            connect_raw(
                self.as_ptr() as *mut _,
                b"notify::item\0".as_ptr() as *const _,
                Some(std::mem::transmute::<_, unsafe extern "C" fn()>(
                    notify_item_trampoline::<F> as *const (),
                )),
                Box_::into_raw(f),
            )
        }
    }
}