1 // This file was generated by gir (https://github.com/gtk-rs/gir)
2 // from gir-files (https://github.com/gtk-rs/gir-files)
3 // DO NOT EDIT
4 
5 use crate::TreeIter;
6 use crate::TreeModelFlags;
7 use crate::TreePath;
8 use glib::object::Cast;
9 use glib::object::IsA;
10 use glib::signal::connect_raw;
11 use glib::signal::SignalHandlerId;
12 use glib::translate::*;
13 use std::boxed::Box as Box_;
14 use std::fmt;
15 use std::mem::transmute;
16 
17 glib::wrapper! {
18     #[doc(alias = "GtkTreeModel")]
19     pub struct TreeModel(Interface<ffi::GtkTreeModel, ffi::GtkTreeModelIface>);
20 
21     match fn {
22         type_ => || ffi::gtk_tree_model_get_type(),
23     }
24 }
25 
26 pub const NONE_TREE_MODEL: Option<&TreeModel> = None;
27 
28 pub trait TreeModelExt: 'static {
29     #[doc(alias = "gtk_tree_model_foreach")]
foreach<P: FnMut(&TreeModel, &TreePath, &TreeIter) -> bool>(&self, func: P)30     fn foreach<P: FnMut(&TreeModel, &TreePath, &TreeIter) -> bool>(&self, func: P);
31 
32     //#[doc(alias = "gtk_tree_model_get")]
33     //fn get(&self, iter: &TreeIter, : /*Unknown conversion*//*Unimplemented*/Fundamental: VarArgs);
34 
35     #[doc(alias = "gtk_tree_model_get_column_type")]
36     #[doc(alias = "get_column_type")]
column_type(&self, index_: i32) -> glib::types::Type37     fn column_type(&self, index_: i32) -> glib::types::Type;
38 
39     #[doc(alias = "gtk_tree_model_get_flags")]
40     #[doc(alias = "get_flags")]
flags(&self) -> TreeModelFlags41     fn flags(&self) -> TreeModelFlags;
42 
43     #[doc(alias = "gtk_tree_model_get_iter")]
44     #[doc(alias = "get_iter")]
iter(&self, path: &TreePath) -> Option<TreeIter>45     fn iter(&self, path: &TreePath) -> Option<TreeIter>;
46 
47     #[doc(alias = "gtk_tree_model_get_iter_first")]
48     #[doc(alias = "get_iter_first")]
iter_first(&self) -> Option<TreeIter>49     fn iter_first(&self) -> Option<TreeIter>;
50 
51     #[doc(alias = "gtk_tree_model_get_iter_from_string")]
52     #[doc(alias = "get_iter_from_string")]
iter_from_string(&self, path_string: &str) -> Option<TreeIter>53     fn iter_from_string(&self, path_string: &str) -> Option<TreeIter>;
54 
55     #[doc(alias = "gtk_tree_model_get_n_columns")]
56     #[doc(alias = "get_n_columns")]
n_columns(&self) -> i3257     fn n_columns(&self) -> i32;
58 
59     #[doc(alias = "gtk_tree_model_get_path")]
60     #[doc(alias = "get_path")]
path(&self, iter: &TreeIter) -> Option<TreePath>61     fn path(&self, iter: &TreeIter) -> Option<TreePath>;
62 
63     #[doc(alias = "gtk_tree_model_get_string_from_iter")]
64     #[doc(alias = "get_string_from_iter")]
string_from_iter(&self, iter: &TreeIter) -> Option<glib::GString>65     fn string_from_iter(&self, iter: &TreeIter) -> Option<glib::GString>;
66 
67     //#[doc(alias = "gtk_tree_model_get_valist")]
68     //#[doc(alias = "get_valist")]
69     //fn valist(&self, iter: &TreeIter, var_args: /*Unknown conversion*//*Unimplemented*/Unsupported);
70 
71     #[doc(alias = "gtk_tree_model_get_value")]
72     #[doc(alias = "get_value")]
value(&self, iter: &TreeIter, column: i32) -> glib::Value73     fn value(&self, iter: &TreeIter, column: i32) -> glib::Value;
74 
75     #[doc(alias = "gtk_tree_model_iter_children")]
iter_children(&self, parent: Option<&TreeIter>) -> Option<TreeIter>76     fn iter_children(&self, parent: Option<&TreeIter>) -> Option<TreeIter>;
77 
78     #[doc(alias = "gtk_tree_model_iter_has_child")]
iter_has_child(&self, iter: &TreeIter) -> bool79     fn iter_has_child(&self, iter: &TreeIter) -> bool;
80 
81     #[doc(alias = "gtk_tree_model_iter_n_children")]
iter_n_children(&self, iter: Option<&TreeIter>) -> i3282     fn iter_n_children(&self, iter: Option<&TreeIter>) -> i32;
83 
84     #[doc(alias = "gtk_tree_model_iter_next")]
iter_next(&self, iter: &TreeIter) -> bool85     fn iter_next(&self, iter: &TreeIter) -> bool;
86 
87     #[doc(alias = "gtk_tree_model_iter_nth_child")]
iter_nth_child(&self, parent: Option<&TreeIter>, n: i32) -> Option<TreeIter>88     fn iter_nth_child(&self, parent: Option<&TreeIter>, n: i32) -> Option<TreeIter>;
89 
90     #[doc(alias = "gtk_tree_model_iter_parent")]
iter_parent(&self, child: &TreeIter) -> Option<TreeIter>91     fn iter_parent(&self, child: &TreeIter) -> Option<TreeIter>;
92 
93     #[doc(alias = "gtk_tree_model_iter_previous")]
iter_previous(&self, iter: &TreeIter) -> bool94     fn iter_previous(&self, iter: &TreeIter) -> bool;
95 
96     #[doc(alias = "gtk_tree_model_row_changed")]
row_changed(&self, path: &TreePath, iter: &TreeIter)97     fn row_changed(&self, path: &TreePath, iter: &TreeIter);
98 
99     #[doc(alias = "gtk_tree_model_row_deleted")]
row_deleted(&self, path: &TreePath)100     fn row_deleted(&self, path: &TreePath);
101 
102     #[doc(alias = "gtk_tree_model_row_has_child_toggled")]
row_has_child_toggled(&self, path: &TreePath, iter: &TreeIter)103     fn row_has_child_toggled(&self, path: &TreePath, iter: &TreeIter);
104 
105     #[doc(alias = "gtk_tree_model_row_inserted")]
row_inserted(&self, path: &TreePath, iter: &TreeIter)106     fn row_inserted(&self, path: &TreePath, iter: &TreeIter);
107 
108     #[doc(alias = "gtk_tree_model_rows_reordered_with_length")]
rows_reordered_with_length( &self, path: &TreePath, iter: Option<&TreeIter>, new_order: &[i32], )109     fn rows_reordered_with_length(
110         &self,
111         path: &TreePath,
112         iter: Option<&TreeIter>,
113         new_order: &[i32],
114     );
115 
116     #[doc(alias = "row-changed")]
connect_row_changed<F: Fn(&Self, &TreePath, &TreeIter) + 'static>( &self, f: F, ) -> SignalHandlerId117     fn connect_row_changed<F: Fn(&Self, &TreePath, &TreeIter) + 'static>(
118         &self,
119         f: F,
120     ) -> SignalHandlerId;
121 
122     #[doc(alias = "row-deleted")]
connect_row_deleted<F: Fn(&Self, &TreePath) + 'static>(&self, f: F) -> SignalHandlerId123     fn connect_row_deleted<F: Fn(&Self, &TreePath) + 'static>(&self, f: F) -> SignalHandlerId;
124 
125     #[doc(alias = "row-has-child-toggled")]
connect_row_has_child_toggled<F: Fn(&Self, &TreePath, &TreeIter) + 'static>( &self, f: F, ) -> SignalHandlerId126     fn connect_row_has_child_toggled<F: Fn(&Self, &TreePath, &TreeIter) + 'static>(
127         &self,
128         f: F,
129     ) -> SignalHandlerId;
130 
131     #[doc(alias = "row-inserted")]
connect_row_inserted<F: Fn(&Self, &TreePath, &TreeIter) + 'static>( &self, f: F, ) -> SignalHandlerId132     fn connect_row_inserted<F: Fn(&Self, &TreePath, &TreeIter) + 'static>(
133         &self,
134         f: F,
135     ) -> SignalHandlerId;
136 
137     //#[doc(alias = "rows-reordered")]
138     //fn connect_rows_reordered<Unsupported or ignored types>(&self, f: F) -> SignalHandlerId;
139 }
140 
141 impl<O: IsA<TreeModel>> TreeModelExt for O {
foreach<P: FnMut(&TreeModel, &TreePath, &TreeIter) -> bool>(&self, func: P)142     fn foreach<P: FnMut(&TreeModel, &TreePath, &TreeIter) -> bool>(&self, func: P) {
143         let func_data: P = func;
144         unsafe extern "C" fn func_func<P: FnMut(&TreeModel, &TreePath, &TreeIter) -> bool>(
145             model: *mut ffi::GtkTreeModel,
146             path: *mut ffi::GtkTreePath,
147             iter: *mut ffi::GtkTreeIter,
148             data: glib::ffi::gpointer,
149         ) -> glib::ffi::gboolean {
150             let model = from_glib_borrow(model);
151             let path = from_glib_borrow(path);
152             let iter = from_glib_borrow(iter);
153             let callback: *mut P = data as *const _ as usize as *mut P;
154             let res = (*callback)(&model, &path, &iter);
155             res.into_glib()
156         }
157         let func = Some(func_func::<P> as _);
158         let super_callback0: &P = &func_data;
159         unsafe {
160             ffi::gtk_tree_model_foreach(
161                 self.as_ref().to_glib_none().0,
162                 func,
163                 super_callback0 as *const _ as usize as *mut _,
164             );
165         }
166     }
167 
168     //fn get(&self, iter: &TreeIter, : /*Unknown conversion*//*Unimplemented*/Fundamental: VarArgs) {
169     //    unsafe { TODO: call ffi:gtk_tree_model_get() }
170     //}
171 
column_type(&self, index_: i32) -> glib::types::Type172     fn column_type(&self, index_: i32) -> glib::types::Type {
173         unsafe {
174             from_glib(ffi::gtk_tree_model_get_column_type(
175                 self.as_ref().to_glib_none().0,
176                 index_,
177             ))
178         }
179     }
180 
flags(&self) -> TreeModelFlags181     fn flags(&self) -> TreeModelFlags {
182         unsafe {
183             from_glib(ffi::gtk_tree_model_get_flags(
184                 self.as_ref().to_glib_none().0,
185             ))
186         }
187     }
188 
iter(&self, path: &TreePath) -> Option<TreeIter>189     fn iter(&self, path: &TreePath) -> Option<TreeIter> {
190         unsafe {
191             let mut iter = TreeIter::uninitialized();
192             let ret = from_glib(ffi::gtk_tree_model_get_iter(
193                 self.as_ref().to_glib_none().0,
194                 iter.to_glib_none_mut().0,
195                 mut_override(path.to_glib_none().0),
196             ));
197             if ret {
198                 Some(iter)
199             } else {
200                 None
201             }
202         }
203     }
204 
iter_first(&self) -> Option<TreeIter>205     fn iter_first(&self) -> Option<TreeIter> {
206         unsafe {
207             let mut iter = TreeIter::uninitialized();
208             let ret = from_glib(ffi::gtk_tree_model_get_iter_first(
209                 self.as_ref().to_glib_none().0,
210                 iter.to_glib_none_mut().0,
211             ));
212             if ret {
213                 Some(iter)
214             } else {
215                 None
216             }
217         }
218     }
219 
iter_from_string(&self, path_string: &str) -> Option<TreeIter>220     fn iter_from_string(&self, path_string: &str) -> Option<TreeIter> {
221         unsafe {
222             let mut iter = TreeIter::uninitialized();
223             let ret = from_glib(ffi::gtk_tree_model_get_iter_from_string(
224                 self.as_ref().to_glib_none().0,
225                 iter.to_glib_none_mut().0,
226                 path_string.to_glib_none().0,
227             ));
228             if ret {
229                 Some(iter)
230             } else {
231                 None
232             }
233         }
234     }
235 
n_columns(&self) -> i32236     fn n_columns(&self) -> i32 {
237         unsafe { ffi::gtk_tree_model_get_n_columns(self.as_ref().to_glib_none().0) }
238     }
239 
path(&self, iter: &TreeIter) -> Option<TreePath>240     fn path(&self, iter: &TreeIter) -> Option<TreePath> {
241         unsafe {
242             from_glib_full(ffi::gtk_tree_model_get_path(
243                 self.as_ref().to_glib_none().0,
244                 mut_override(iter.to_glib_none().0),
245             ))
246         }
247     }
248 
string_from_iter(&self, iter: &TreeIter) -> Option<glib::GString>249     fn string_from_iter(&self, iter: &TreeIter) -> Option<glib::GString> {
250         unsafe {
251             from_glib_full(ffi::gtk_tree_model_get_string_from_iter(
252                 self.as_ref().to_glib_none().0,
253                 mut_override(iter.to_glib_none().0),
254             ))
255         }
256     }
257 
258     //fn valist(&self, iter: &TreeIter, var_args: /*Unknown conversion*//*Unimplemented*/Unsupported) {
259     //    unsafe { TODO: call ffi:gtk_tree_model_get_valist() }
260     //}
261 
value(&self, iter: &TreeIter, column: i32) -> glib::Value262     fn value(&self, iter: &TreeIter, column: i32) -> glib::Value {
263         unsafe {
264             let mut value = glib::Value::uninitialized();
265             ffi::gtk_tree_model_get_value(
266                 self.as_ref().to_glib_none().0,
267                 mut_override(iter.to_glib_none().0),
268                 column,
269                 value.to_glib_none_mut().0,
270             );
271             value
272         }
273     }
274 
iter_children(&self, parent: Option<&TreeIter>) -> Option<TreeIter>275     fn iter_children(&self, parent: Option<&TreeIter>) -> Option<TreeIter> {
276         unsafe {
277             let mut iter = TreeIter::uninitialized();
278             let ret = from_glib(ffi::gtk_tree_model_iter_children(
279                 self.as_ref().to_glib_none().0,
280                 iter.to_glib_none_mut().0,
281                 mut_override(parent.to_glib_none().0),
282             ));
283             if ret {
284                 Some(iter)
285             } else {
286                 None
287             }
288         }
289     }
290 
iter_has_child(&self, iter: &TreeIter) -> bool291     fn iter_has_child(&self, iter: &TreeIter) -> bool {
292         unsafe {
293             from_glib(ffi::gtk_tree_model_iter_has_child(
294                 self.as_ref().to_glib_none().0,
295                 mut_override(iter.to_glib_none().0),
296             ))
297         }
298     }
299 
iter_n_children(&self, iter: Option<&TreeIter>) -> i32300     fn iter_n_children(&self, iter: Option<&TreeIter>) -> i32 {
301         unsafe {
302             ffi::gtk_tree_model_iter_n_children(
303                 self.as_ref().to_glib_none().0,
304                 mut_override(iter.to_glib_none().0),
305             )
306         }
307     }
308 
iter_next(&self, iter: &TreeIter) -> bool309     fn iter_next(&self, iter: &TreeIter) -> bool {
310         unsafe {
311             from_glib(ffi::gtk_tree_model_iter_next(
312                 self.as_ref().to_glib_none().0,
313                 mut_override(iter.to_glib_none().0),
314             ))
315         }
316     }
317 
iter_nth_child(&self, parent: Option<&TreeIter>, n: i32) -> Option<TreeIter>318     fn iter_nth_child(&self, parent: Option<&TreeIter>, n: i32) -> Option<TreeIter> {
319         unsafe {
320             let mut iter = TreeIter::uninitialized();
321             let ret = from_glib(ffi::gtk_tree_model_iter_nth_child(
322                 self.as_ref().to_glib_none().0,
323                 iter.to_glib_none_mut().0,
324                 mut_override(parent.to_glib_none().0),
325                 n,
326             ));
327             if ret {
328                 Some(iter)
329             } else {
330                 None
331             }
332         }
333     }
334 
iter_parent(&self, child: &TreeIter) -> Option<TreeIter>335     fn iter_parent(&self, child: &TreeIter) -> Option<TreeIter> {
336         unsafe {
337             let mut iter = TreeIter::uninitialized();
338             let ret = from_glib(ffi::gtk_tree_model_iter_parent(
339                 self.as_ref().to_glib_none().0,
340                 iter.to_glib_none_mut().0,
341                 mut_override(child.to_glib_none().0),
342             ));
343             if ret {
344                 Some(iter)
345             } else {
346                 None
347             }
348         }
349     }
350 
iter_previous(&self, iter: &TreeIter) -> bool351     fn iter_previous(&self, iter: &TreeIter) -> bool {
352         unsafe {
353             from_glib(ffi::gtk_tree_model_iter_previous(
354                 self.as_ref().to_glib_none().0,
355                 mut_override(iter.to_glib_none().0),
356             ))
357         }
358     }
359 
row_changed(&self, path: &TreePath, iter: &TreeIter)360     fn row_changed(&self, path: &TreePath, iter: &TreeIter) {
361         unsafe {
362             ffi::gtk_tree_model_row_changed(
363                 self.as_ref().to_glib_none().0,
364                 mut_override(path.to_glib_none().0),
365                 mut_override(iter.to_glib_none().0),
366             );
367         }
368     }
369 
row_deleted(&self, path: &TreePath)370     fn row_deleted(&self, path: &TreePath) {
371         unsafe {
372             ffi::gtk_tree_model_row_deleted(
373                 self.as_ref().to_glib_none().0,
374                 mut_override(path.to_glib_none().0),
375             );
376         }
377     }
378 
row_has_child_toggled(&self, path: &TreePath, iter: &TreeIter)379     fn row_has_child_toggled(&self, path: &TreePath, iter: &TreeIter) {
380         unsafe {
381             ffi::gtk_tree_model_row_has_child_toggled(
382                 self.as_ref().to_glib_none().0,
383                 mut_override(path.to_glib_none().0),
384                 mut_override(iter.to_glib_none().0),
385             );
386         }
387     }
388 
row_inserted(&self, path: &TreePath, iter: &TreeIter)389     fn row_inserted(&self, path: &TreePath, iter: &TreeIter) {
390         unsafe {
391             ffi::gtk_tree_model_row_inserted(
392                 self.as_ref().to_glib_none().0,
393                 mut_override(path.to_glib_none().0),
394                 mut_override(iter.to_glib_none().0),
395             );
396         }
397     }
398 
rows_reordered_with_length( &self, path: &TreePath, iter: Option<&TreeIter>, new_order: &[i32], )399     fn rows_reordered_with_length(
400         &self,
401         path: &TreePath,
402         iter: Option<&TreeIter>,
403         new_order: &[i32],
404     ) {
405         let length = new_order.len() as i32;
406         unsafe {
407             ffi::gtk_tree_model_rows_reordered_with_length(
408                 self.as_ref().to_glib_none().0,
409                 mut_override(path.to_glib_none().0),
410                 mut_override(iter.to_glib_none().0),
411                 new_order.to_glib_none().0,
412                 length,
413             );
414         }
415     }
416 
connect_row_changed<F: Fn(&Self, &TreePath, &TreeIter) + 'static>( &self, f: F, ) -> SignalHandlerId417     fn connect_row_changed<F: Fn(&Self, &TreePath, &TreeIter) + 'static>(
418         &self,
419         f: F,
420     ) -> SignalHandlerId {
421         unsafe extern "C" fn row_changed_trampoline<
422             P: IsA<TreeModel>,
423             F: Fn(&P, &TreePath, &TreeIter) + 'static,
424         >(
425             this: *mut ffi::GtkTreeModel,
426             path: *mut ffi::GtkTreePath,
427             iter: *mut ffi::GtkTreeIter,
428             f: glib::ffi::gpointer,
429         ) {
430             let f: &F = &*(f as *const F);
431             f(
432                 TreeModel::from_glib_borrow(this).unsafe_cast_ref(),
433                 &from_glib_borrow(path),
434                 &from_glib_borrow(iter),
435             )
436         }
437         unsafe {
438             let f: Box_<F> = Box_::new(f);
439             connect_raw(
440                 self.as_ptr() as *mut _,
441                 b"row-changed\0".as_ptr() as *const _,
442                 Some(transmute::<_, unsafe extern "C" fn()>(
443                     row_changed_trampoline::<Self, F> as *const (),
444                 )),
445                 Box_::into_raw(f),
446             )
447         }
448     }
449 
connect_row_deleted<F: Fn(&Self, &TreePath) + 'static>(&self, f: F) -> SignalHandlerId450     fn connect_row_deleted<F: Fn(&Self, &TreePath) + 'static>(&self, f: F) -> SignalHandlerId {
451         unsafe extern "C" fn row_deleted_trampoline<
452             P: IsA<TreeModel>,
453             F: Fn(&P, &TreePath) + 'static,
454         >(
455             this: *mut ffi::GtkTreeModel,
456             path: *mut ffi::GtkTreePath,
457             f: glib::ffi::gpointer,
458         ) {
459             let f: &F = &*(f as *const F);
460             f(
461                 TreeModel::from_glib_borrow(this).unsafe_cast_ref(),
462                 &from_glib_borrow(path),
463             )
464         }
465         unsafe {
466             let f: Box_<F> = Box_::new(f);
467             connect_raw(
468                 self.as_ptr() as *mut _,
469                 b"row-deleted\0".as_ptr() as *const _,
470                 Some(transmute::<_, unsafe extern "C" fn()>(
471                     row_deleted_trampoline::<Self, F> as *const (),
472                 )),
473                 Box_::into_raw(f),
474             )
475         }
476     }
477 
connect_row_has_child_toggled<F: Fn(&Self, &TreePath, &TreeIter) + 'static>( &self, f: F, ) -> SignalHandlerId478     fn connect_row_has_child_toggled<F: Fn(&Self, &TreePath, &TreeIter) + 'static>(
479         &self,
480         f: F,
481     ) -> SignalHandlerId {
482         unsafe extern "C" fn row_has_child_toggled_trampoline<
483             P: IsA<TreeModel>,
484             F: Fn(&P, &TreePath, &TreeIter) + 'static,
485         >(
486             this: *mut ffi::GtkTreeModel,
487             path: *mut ffi::GtkTreePath,
488             iter: *mut ffi::GtkTreeIter,
489             f: glib::ffi::gpointer,
490         ) {
491             let f: &F = &*(f as *const F);
492             f(
493                 TreeModel::from_glib_borrow(this).unsafe_cast_ref(),
494                 &from_glib_borrow(path),
495                 &from_glib_borrow(iter),
496             )
497         }
498         unsafe {
499             let f: Box_<F> = Box_::new(f);
500             connect_raw(
501                 self.as_ptr() as *mut _,
502                 b"row-has-child-toggled\0".as_ptr() as *const _,
503                 Some(transmute::<_, unsafe extern "C" fn()>(
504                     row_has_child_toggled_trampoline::<Self, F> as *const (),
505                 )),
506                 Box_::into_raw(f),
507             )
508         }
509     }
510 
connect_row_inserted<F: Fn(&Self, &TreePath, &TreeIter) + 'static>( &self, f: F, ) -> SignalHandlerId511     fn connect_row_inserted<F: Fn(&Self, &TreePath, &TreeIter) + 'static>(
512         &self,
513         f: F,
514     ) -> SignalHandlerId {
515         unsafe extern "C" fn row_inserted_trampoline<
516             P: IsA<TreeModel>,
517             F: Fn(&P, &TreePath, &TreeIter) + 'static,
518         >(
519             this: *mut ffi::GtkTreeModel,
520             path: *mut ffi::GtkTreePath,
521             iter: *mut ffi::GtkTreeIter,
522             f: glib::ffi::gpointer,
523         ) {
524             let f: &F = &*(f as *const F);
525             f(
526                 TreeModel::from_glib_borrow(this).unsafe_cast_ref(),
527                 &from_glib_borrow(path),
528                 &from_glib_borrow(iter),
529             )
530         }
531         unsafe {
532             let f: Box_<F> = Box_::new(f);
533             connect_raw(
534                 self.as_ptr() as *mut _,
535                 b"row-inserted\0".as_ptr() as *const _,
536                 Some(transmute::<_, unsafe extern "C" fn()>(
537                     row_inserted_trampoline::<Self, F> as *const (),
538                 )),
539                 Box_::into_raw(f),
540             )
541         }
542     }
543 
544     //fn connect_rows_reordered<Unsupported or ignored types>(&self, f: F) -> SignalHandlerId {
545     //    Unimplemented new_order: *.Pointer
546     //}
547 }
548 
549 impl fmt::Display for TreeModel {
fmt(&self, f: &mut fmt::Formatter) -> fmt::Result550     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
551         f.write_str("TreeModel")
552     }
553 }
554