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 glib;
6 use glib::object::Cast;
7 use glib::object::IsA;
8 use glib::signal::connect_raw;
9 use glib::signal::SignalHandlerId;
10 use glib::translate::*;
11 use glib::GString;
12 use glib_sys;
13 use gtk_sys;
14 use std::boxed::Box as Box_;
15 use std::fmt;
16 use std::mem::transmute;
17 use TreeIter;
18 use TreeModelFlags;
19 use TreePath;
20 
21 glib_wrapper! {
22     pub struct TreeModel(Interface<gtk_sys::GtkTreeModel>);
23 
24     match fn {
25         get_type => || gtk_sys::gtk_tree_model_get_type(),
26     }
27 }
28 
29 pub const NONE_TREE_MODEL: Option<&TreeModel> = None;
30 
31 pub trait TreeModelExt: 'static {
foreach<P: FnMut(&TreeModel, &TreePath, &TreeIter) -> bool>(&self, func: P)32     fn foreach<P: FnMut(&TreeModel, &TreePath, &TreeIter) -> bool>(&self, func: P);
33 
34     //fn get(&self, iter: &TreeIter, : /*Unknown conversion*//*Unimplemented*/Fundamental: VarArgs);
35 
get_column_type(&self, index_: i32) -> glib::types::Type36     fn get_column_type(&self, index_: i32) -> glib::types::Type;
37 
get_flags(&self) -> TreeModelFlags38     fn get_flags(&self) -> TreeModelFlags;
39 
get_iter(&self, path: &TreePath) -> Option<TreeIter>40     fn get_iter(&self, path: &TreePath) -> Option<TreeIter>;
41 
get_iter_first(&self) -> Option<TreeIter>42     fn get_iter_first(&self) -> Option<TreeIter>;
43 
get_iter_from_string(&self, path_string: &str) -> Option<TreeIter>44     fn get_iter_from_string(&self, path_string: &str) -> Option<TreeIter>;
45 
get_n_columns(&self) -> i3246     fn get_n_columns(&self) -> i32;
47 
get_path(&self, iter: &TreeIter) -> Option<TreePath>48     fn get_path(&self, iter: &TreeIter) -> Option<TreePath>;
49 
get_string_from_iter(&self, iter: &TreeIter) -> Option<GString>50     fn get_string_from_iter(&self, iter: &TreeIter) -> Option<GString>;
51 
52     //fn get_valist(&self, iter: &TreeIter, var_args: /*Unknown conversion*//*Unimplemented*/Unsupported);
53 
get_value(&self, iter: &TreeIter, column: i32) -> glib::Value54     fn get_value(&self, iter: &TreeIter, column: i32) -> glib::Value;
55 
iter_children(&self, parent: Option<&TreeIter>) -> Option<TreeIter>56     fn iter_children(&self, parent: Option<&TreeIter>) -> Option<TreeIter>;
57 
iter_has_child(&self, iter: &TreeIter) -> bool58     fn iter_has_child(&self, iter: &TreeIter) -> bool;
59 
iter_n_children(&self, iter: Option<&TreeIter>) -> i3260     fn iter_n_children(&self, iter: Option<&TreeIter>) -> i32;
61 
iter_next(&self, iter: &TreeIter) -> bool62     fn iter_next(&self, iter: &TreeIter) -> bool;
63 
iter_nth_child(&self, parent: Option<&TreeIter>, n: i32) -> Option<TreeIter>64     fn iter_nth_child(&self, parent: Option<&TreeIter>, n: i32) -> Option<TreeIter>;
65 
iter_parent(&self, child: &TreeIter) -> Option<TreeIter>66     fn iter_parent(&self, child: &TreeIter) -> Option<TreeIter>;
67 
iter_previous(&self, iter: &TreeIter) -> bool68     fn iter_previous(&self, iter: &TreeIter) -> bool;
69 
row_changed(&self, path: &TreePath, iter: &TreeIter)70     fn row_changed(&self, path: &TreePath, iter: &TreeIter);
71 
row_deleted(&self, path: &TreePath)72     fn row_deleted(&self, path: &TreePath);
73 
row_has_child_toggled(&self, path: &TreePath, iter: &TreeIter)74     fn row_has_child_toggled(&self, path: &TreePath, iter: &TreeIter);
75 
row_inserted(&self, path: &TreePath, iter: &TreeIter)76     fn row_inserted(&self, path: &TreePath, iter: &TreeIter);
77 
rows_reordered_with_length( &self, path: &TreePath, iter: Option<&TreeIter>, new_order: &[i32], )78     fn rows_reordered_with_length(
79         &self,
80         path: &TreePath,
81         iter: Option<&TreeIter>,
82         new_order: &[i32],
83     );
84 
sort_new_with_model(&self) -> Option<TreeModel>85     fn sort_new_with_model(&self) -> Option<TreeModel>;
86 
connect_row_changed<F: Fn(&Self, &TreePath, &TreeIter) + 'static>( &self, f: F, ) -> SignalHandlerId87     fn connect_row_changed<F: Fn(&Self, &TreePath, &TreeIter) + 'static>(
88         &self,
89         f: F,
90     ) -> SignalHandlerId;
91 
connect_row_deleted<F: Fn(&Self, &TreePath) + 'static>(&self, f: F) -> SignalHandlerId92     fn connect_row_deleted<F: Fn(&Self, &TreePath) + 'static>(&self, f: F) -> SignalHandlerId;
93 
connect_row_has_child_toggled<F: Fn(&Self, &TreePath, &TreeIter) + 'static>( &self, f: F, ) -> SignalHandlerId94     fn connect_row_has_child_toggled<F: Fn(&Self, &TreePath, &TreeIter) + 'static>(
95         &self,
96         f: F,
97     ) -> SignalHandlerId;
98 
connect_row_inserted<F: Fn(&Self, &TreePath, &TreeIter) + 'static>( &self, f: F, ) -> SignalHandlerId99     fn connect_row_inserted<F: Fn(&Self, &TreePath, &TreeIter) + 'static>(
100         &self,
101         f: F,
102     ) -> SignalHandlerId;
103 
104     //fn connect_rows_reordered<Unsupported or ignored types>(&self, f: F) -> SignalHandlerId;
105 }
106 
107 impl<O: IsA<TreeModel>> TreeModelExt for O {
foreach<P: FnMut(&TreeModel, &TreePath, &TreeIter) -> bool>(&self, func: P)108     fn foreach<P: FnMut(&TreeModel, &TreePath, &TreeIter) -> bool>(&self, func: P) {
109         let func_data: P = func;
110         unsafe extern "C" fn func_func<P: FnMut(&TreeModel, &TreePath, &TreeIter) -> bool>(
111             model: *mut gtk_sys::GtkTreeModel,
112             path: *mut gtk_sys::GtkTreePath,
113             iter: *mut gtk_sys::GtkTreeIter,
114             data: glib_sys::gpointer,
115         ) -> glib_sys::gboolean {
116             let model = from_glib_borrow(model);
117             let path = from_glib_borrow(path);
118             let iter = from_glib_borrow(iter);
119             let callback: *mut P = data as *const _ as usize as *mut P;
120             let res = (*callback)(&model, &path, &iter);
121             res.to_glib()
122         }
123         let func = Some(func_func::<P> as _);
124         let super_callback0: &P = &func_data;
125         unsafe {
126             gtk_sys::gtk_tree_model_foreach(
127                 self.as_ref().to_glib_none().0,
128                 func,
129                 super_callback0 as *const _ as usize as *mut _,
130             );
131         }
132     }
133 
134     //fn get(&self, iter: &TreeIter, : /*Unknown conversion*//*Unimplemented*/Fundamental: VarArgs) {
135     //    unsafe { TODO: call gtk_sys:gtk_tree_model_get() }
136     //}
137 
get_column_type(&self, index_: i32) -> glib::types::Type138     fn get_column_type(&self, index_: i32) -> glib::types::Type {
139         unsafe {
140             from_glib(gtk_sys::gtk_tree_model_get_column_type(
141                 self.as_ref().to_glib_none().0,
142                 index_,
143             ))
144         }
145     }
146 
get_flags(&self) -> TreeModelFlags147     fn get_flags(&self) -> TreeModelFlags {
148         unsafe {
149             from_glib(gtk_sys::gtk_tree_model_get_flags(
150                 self.as_ref().to_glib_none().0,
151             ))
152         }
153     }
154 
get_iter(&self, path: &TreePath) -> Option<TreeIter>155     fn get_iter(&self, path: &TreePath) -> Option<TreeIter> {
156         unsafe {
157             let mut iter = TreeIter::uninitialized();
158             let ret = from_glib(gtk_sys::gtk_tree_model_get_iter(
159                 self.as_ref().to_glib_none().0,
160                 iter.to_glib_none_mut().0,
161                 mut_override(path.to_glib_none().0),
162             ));
163             if ret {
164                 Some(iter)
165             } else {
166                 None
167             }
168         }
169     }
170 
get_iter_first(&self) -> Option<TreeIter>171     fn get_iter_first(&self) -> Option<TreeIter> {
172         unsafe {
173             let mut iter = TreeIter::uninitialized();
174             let ret = from_glib(gtk_sys::gtk_tree_model_get_iter_first(
175                 self.as_ref().to_glib_none().0,
176                 iter.to_glib_none_mut().0,
177             ));
178             if ret {
179                 Some(iter)
180             } else {
181                 None
182             }
183         }
184     }
185 
get_iter_from_string(&self, path_string: &str) -> Option<TreeIter>186     fn get_iter_from_string(&self, path_string: &str) -> Option<TreeIter> {
187         unsafe {
188             let mut iter = TreeIter::uninitialized();
189             let ret = from_glib(gtk_sys::gtk_tree_model_get_iter_from_string(
190                 self.as_ref().to_glib_none().0,
191                 iter.to_glib_none_mut().0,
192                 path_string.to_glib_none().0,
193             ));
194             if ret {
195                 Some(iter)
196             } else {
197                 None
198             }
199         }
200     }
201 
get_n_columns(&self) -> i32202     fn get_n_columns(&self) -> i32 {
203         unsafe { gtk_sys::gtk_tree_model_get_n_columns(self.as_ref().to_glib_none().0) }
204     }
205 
get_path(&self, iter: &TreeIter) -> Option<TreePath>206     fn get_path(&self, iter: &TreeIter) -> Option<TreePath> {
207         unsafe {
208             from_glib_full(gtk_sys::gtk_tree_model_get_path(
209                 self.as_ref().to_glib_none().0,
210                 mut_override(iter.to_glib_none().0),
211             ))
212         }
213     }
214 
get_string_from_iter(&self, iter: &TreeIter) -> Option<GString>215     fn get_string_from_iter(&self, iter: &TreeIter) -> Option<GString> {
216         unsafe {
217             from_glib_full(gtk_sys::gtk_tree_model_get_string_from_iter(
218                 self.as_ref().to_glib_none().0,
219                 mut_override(iter.to_glib_none().0),
220             ))
221         }
222     }
223 
224     //fn get_valist(&self, iter: &TreeIter, var_args: /*Unknown conversion*//*Unimplemented*/Unsupported) {
225     //    unsafe { TODO: call gtk_sys:gtk_tree_model_get_valist() }
226     //}
227 
get_value(&self, iter: &TreeIter, column: i32) -> glib::Value228     fn get_value(&self, iter: &TreeIter, column: i32) -> glib::Value {
229         unsafe {
230             let mut value = glib::Value::uninitialized();
231             gtk_sys::gtk_tree_model_get_value(
232                 self.as_ref().to_glib_none().0,
233                 mut_override(iter.to_glib_none().0),
234                 column,
235                 value.to_glib_none_mut().0,
236             );
237             value
238         }
239     }
240 
iter_children(&self, parent: Option<&TreeIter>) -> Option<TreeIter>241     fn iter_children(&self, parent: Option<&TreeIter>) -> Option<TreeIter> {
242         unsafe {
243             let mut iter = TreeIter::uninitialized();
244             let ret = from_glib(gtk_sys::gtk_tree_model_iter_children(
245                 self.as_ref().to_glib_none().0,
246                 iter.to_glib_none_mut().0,
247                 mut_override(parent.to_glib_none().0),
248             ));
249             if ret {
250                 Some(iter)
251             } else {
252                 None
253             }
254         }
255     }
256 
iter_has_child(&self, iter: &TreeIter) -> bool257     fn iter_has_child(&self, iter: &TreeIter) -> bool {
258         unsafe {
259             from_glib(gtk_sys::gtk_tree_model_iter_has_child(
260                 self.as_ref().to_glib_none().0,
261                 mut_override(iter.to_glib_none().0),
262             ))
263         }
264     }
265 
iter_n_children(&self, iter: Option<&TreeIter>) -> i32266     fn iter_n_children(&self, iter: Option<&TreeIter>) -> i32 {
267         unsafe {
268             gtk_sys::gtk_tree_model_iter_n_children(
269                 self.as_ref().to_glib_none().0,
270                 mut_override(iter.to_glib_none().0),
271             )
272         }
273     }
274 
iter_next(&self, iter: &TreeIter) -> bool275     fn iter_next(&self, iter: &TreeIter) -> bool {
276         unsafe {
277             from_glib(gtk_sys::gtk_tree_model_iter_next(
278                 self.as_ref().to_glib_none().0,
279                 mut_override(iter.to_glib_none().0),
280             ))
281         }
282     }
283 
iter_nth_child(&self, parent: Option<&TreeIter>, n: i32) -> Option<TreeIter>284     fn iter_nth_child(&self, parent: Option<&TreeIter>, n: i32) -> Option<TreeIter> {
285         unsafe {
286             let mut iter = TreeIter::uninitialized();
287             let ret = from_glib(gtk_sys::gtk_tree_model_iter_nth_child(
288                 self.as_ref().to_glib_none().0,
289                 iter.to_glib_none_mut().0,
290                 mut_override(parent.to_glib_none().0),
291                 n,
292             ));
293             if ret {
294                 Some(iter)
295             } else {
296                 None
297             }
298         }
299     }
300 
iter_parent(&self, child: &TreeIter) -> Option<TreeIter>301     fn iter_parent(&self, child: &TreeIter) -> Option<TreeIter> {
302         unsafe {
303             let mut iter = TreeIter::uninitialized();
304             let ret = from_glib(gtk_sys::gtk_tree_model_iter_parent(
305                 self.as_ref().to_glib_none().0,
306                 iter.to_glib_none_mut().0,
307                 mut_override(child.to_glib_none().0),
308             ));
309             if ret {
310                 Some(iter)
311             } else {
312                 None
313             }
314         }
315     }
316 
iter_previous(&self, iter: &TreeIter) -> bool317     fn iter_previous(&self, iter: &TreeIter) -> bool {
318         unsafe {
319             from_glib(gtk_sys::gtk_tree_model_iter_previous(
320                 self.as_ref().to_glib_none().0,
321                 mut_override(iter.to_glib_none().0),
322             ))
323         }
324     }
325 
row_changed(&self, path: &TreePath, iter: &TreeIter)326     fn row_changed(&self, path: &TreePath, iter: &TreeIter) {
327         unsafe {
328             gtk_sys::gtk_tree_model_row_changed(
329                 self.as_ref().to_glib_none().0,
330                 mut_override(path.to_glib_none().0),
331                 mut_override(iter.to_glib_none().0),
332             );
333         }
334     }
335 
row_deleted(&self, path: &TreePath)336     fn row_deleted(&self, path: &TreePath) {
337         unsafe {
338             gtk_sys::gtk_tree_model_row_deleted(
339                 self.as_ref().to_glib_none().0,
340                 mut_override(path.to_glib_none().0),
341             );
342         }
343     }
344 
row_has_child_toggled(&self, path: &TreePath, iter: &TreeIter)345     fn row_has_child_toggled(&self, path: &TreePath, iter: &TreeIter) {
346         unsafe {
347             gtk_sys::gtk_tree_model_row_has_child_toggled(
348                 self.as_ref().to_glib_none().0,
349                 mut_override(path.to_glib_none().0),
350                 mut_override(iter.to_glib_none().0),
351             );
352         }
353     }
354 
row_inserted(&self, path: &TreePath, iter: &TreeIter)355     fn row_inserted(&self, path: &TreePath, iter: &TreeIter) {
356         unsafe {
357             gtk_sys::gtk_tree_model_row_inserted(
358                 self.as_ref().to_glib_none().0,
359                 mut_override(path.to_glib_none().0),
360                 mut_override(iter.to_glib_none().0),
361             );
362         }
363     }
364 
rows_reordered_with_length( &self, path: &TreePath, iter: Option<&TreeIter>, new_order: &[i32], )365     fn rows_reordered_with_length(
366         &self,
367         path: &TreePath,
368         iter: Option<&TreeIter>,
369         new_order: &[i32],
370     ) {
371         let length = new_order.len() as i32;
372         unsafe {
373             gtk_sys::gtk_tree_model_rows_reordered_with_length(
374                 self.as_ref().to_glib_none().0,
375                 mut_override(path.to_glib_none().0),
376                 mut_override(iter.to_glib_none().0),
377                 new_order.to_glib_none().0,
378                 length,
379             );
380         }
381     }
382 
sort_new_with_model(&self) -> Option<TreeModel>383     fn sort_new_with_model(&self) -> Option<TreeModel> {
384         unsafe {
385             from_glib_full(gtk_sys::gtk_tree_model_sort_new_with_model(
386                 self.as_ref().to_glib_none().0,
387             ))
388         }
389     }
390 
connect_row_changed<F: Fn(&Self, &TreePath, &TreeIter) + 'static>( &self, f: F, ) -> SignalHandlerId391     fn connect_row_changed<F: Fn(&Self, &TreePath, &TreeIter) + 'static>(
392         &self,
393         f: F,
394     ) -> SignalHandlerId {
395         unsafe extern "C" fn row_changed_trampoline<P, F: Fn(&P, &TreePath, &TreeIter) + 'static>(
396             this: *mut gtk_sys::GtkTreeModel,
397             path: *mut gtk_sys::GtkTreePath,
398             iter: *mut gtk_sys::GtkTreeIter,
399             f: glib_sys::gpointer,
400         ) where
401             P: IsA<TreeModel>,
402         {
403             let f: &F = &*(f as *const F);
404             f(
405                 &TreeModel::from_glib_borrow(this).unsafe_cast(),
406                 &from_glib_borrow(path),
407                 &from_glib_borrow(iter),
408             )
409         }
410         unsafe {
411             let f: Box_<F> = Box_::new(f);
412             connect_raw(
413                 self.as_ptr() as *mut _,
414                 b"row-changed\0".as_ptr() as *const _,
415                 Some(transmute(row_changed_trampoline::<Self, F> as usize)),
416                 Box_::into_raw(f),
417             )
418         }
419     }
420 
connect_row_deleted<F: Fn(&Self, &TreePath) + 'static>(&self, f: F) -> SignalHandlerId421     fn connect_row_deleted<F: Fn(&Self, &TreePath) + 'static>(&self, f: F) -> SignalHandlerId {
422         unsafe extern "C" fn row_deleted_trampoline<P, F: Fn(&P, &TreePath) + 'static>(
423             this: *mut gtk_sys::GtkTreeModel,
424             path: *mut gtk_sys::GtkTreePath,
425             f: glib_sys::gpointer,
426         ) where
427             P: IsA<TreeModel>,
428         {
429             let f: &F = &*(f as *const F);
430             f(
431                 &TreeModel::from_glib_borrow(this).unsafe_cast(),
432                 &from_glib_borrow(path),
433             )
434         }
435         unsafe {
436             let f: Box_<F> = Box_::new(f);
437             connect_raw(
438                 self.as_ptr() as *mut _,
439                 b"row-deleted\0".as_ptr() as *const _,
440                 Some(transmute(row_deleted_trampoline::<Self, F> as usize)),
441                 Box_::into_raw(f),
442             )
443         }
444     }
445 
connect_row_has_child_toggled<F: Fn(&Self, &TreePath, &TreeIter) + 'static>( &self, f: F, ) -> SignalHandlerId446     fn connect_row_has_child_toggled<F: Fn(&Self, &TreePath, &TreeIter) + 'static>(
447         &self,
448         f: F,
449     ) -> SignalHandlerId {
450         unsafe extern "C" fn row_has_child_toggled_trampoline<
451             P,
452             F: Fn(&P, &TreePath, &TreeIter) + 'static,
453         >(
454             this: *mut gtk_sys::GtkTreeModel,
455             path: *mut gtk_sys::GtkTreePath,
456             iter: *mut gtk_sys::GtkTreeIter,
457             f: glib_sys::gpointer,
458         ) where
459             P: IsA<TreeModel>,
460         {
461             let f: &F = &*(f as *const F);
462             f(
463                 &TreeModel::from_glib_borrow(this).unsafe_cast(),
464                 &from_glib_borrow(path),
465                 &from_glib_borrow(iter),
466             )
467         }
468         unsafe {
469             let f: Box_<F> = Box_::new(f);
470             connect_raw(
471                 self.as_ptr() as *mut _,
472                 b"row-has-child-toggled\0".as_ptr() as *const _,
473                 Some(transmute(
474                     row_has_child_toggled_trampoline::<Self, F> as usize,
475                 )),
476                 Box_::into_raw(f),
477             )
478         }
479     }
480 
connect_row_inserted<F: Fn(&Self, &TreePath, &TreeIter) + 'static>( &self, f: F, ) -> SignalHandlerId481     fn connect_row_inserted<F: Fn(&Self, &TreePath, &TreeIter) + 'static>(
482         &self,
483         f: F,
484     ) -> SignalHandlerId {
485         unsafe extern "C" fn row_inserted_trampoline<P, F: Fn(&P, &TreePath, &TreeIter) + 'static>(
486             this: *mut gtk_sys::GtkTreeModel,
487             path: *mut gtk_sys::GtkTreePath,
488             iter: *mut gtk_sys::GtkTreeIter,
489             f: glib_sys::gpointer,
490         ) where
491             P: IsA<TreeModel>,
492         {
493             let f: &F = &*(f as *const F);
494             f(
495                 &TreeModel::from_glib_borrow(this).unsafe_cast(),
496                 &from_glib_borrow(path),
497                 &from_glib_borrow(iter),
498             )
499         }
500         unsafe {
501             let f: Box_<F> = Box_::new(f);
502             connect_raw(
503                 self.as_ptr() as *mut _,
504                 b"row-inserted\0".as_ptr() as *const _,
505                 Some(transmute(row_inserted_trampoline::<Self, F> as usize)),
506                 Box_::into_raw(f),
507             )
508         }
509     }
510 
511     //fn connect_rows_reordered<Unsupported or ignored types>(&self, f: F) -> SignalHandlerId {
512     //    Unimplemented new_order: *.Pointer
513     //}
514 }
515 
516 impl fmt::Display for TreeModel {
fmt(&self, f: &mut fmt::Formatter) -> fmt::Result517     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
518         write!(f, "TreeModel")
519     }
520 }
521