gtk/auto/
tree_model.rs

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
5use glib;
6use glib::object::Cast;
7use glib::object::IsA;
8use glib::signal::connect_raw;
9use glib::signal::SignalHandlerId;
10use glib::translate::*;
11use glib::GString;
12use glib_sys;
13use gtk_sys;
14use std::boxed::Box as Box_;
15use std::fmt;
16use std::mem::transmute;
17use TreeIter;
18use TreeModelFlags;
19use TreePath;
20
21glib_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
29pub const NONE_TREE_MODEL: Option<&TreeModel> = None;
30
31pub trait TreeModelExt: 'static {
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
36    fn get_column_type(&self, index_: i32) -> glib::types::Type;
37
38    fn get_flags(&self) -> TreeModelFlags;
39
40    fn get_iter(&self, path: &TreePath) -> Option<TreeIter>;
41
42    fn get_iter_first(&self) -> Option<TreeIter>;
43
44    fn get_iter_from_string(&self, path_string: &str) -> Option<TreeIter>;
45
46    fn get_n_columns(&self) -> i32;
47
48    fn get_path(&self, iter: &TreeIter) -> Option<TreePath>;
49
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
54    fn get_value(&self, iter: &TreeIter, column: i32) -> glib::Value;
55
56    fn iter_children(&self, parent: Option<&TreeIter>) -> Option<TreeIter>;
57
58    fn iter_has_child(&self, iter: &TreeIter) -> bool;
59
60    fn iter_n_children(&self, iter: Option<&TreeIter>) -> i32;
61
62    fn iter_next(&self, iter: &TreeIter) -> bool;
63
64    fn iter_nth_child(&self, parent: Option<&TreeIter>, n: i32) -> Option<TreeIter>;
65
66    fn iter_parent(&self, child: &TreeIter) -> Option<TreeIter>;
67
68    fn iter_previous(&self, iter: &TreeIter) -> bool;
69
70    fn row_changed(&self, path: &TreePath, iter: &TreeIter);
71
72    fn row_deleted(&self, path: &TreePath);
73
74    fn row_has_child_toggled(&self, path: &TreePath, iter: &TreeIter);
75
76    fn row_inserted(&self, path: &TreePath, iter: &TreeIter);
77
78    fn rows_reordered_with_length(
79        &self,
80        path: &TreePath,
81        iter: Option<&TreeIter>,
82        new_order: &[i32],
83    );
84
85    fn sort_new_with_model(&self) -> Option<TreeModel>;
86
87    fn connect_row_changed<F: Fn(&Self, &TreePath, &TreeIter) + 'static>(
88        &self,
89        f: F,
90    ) -> SignalHandlerId;
91
92    fn connect_row_deleted<F: Fn(&Self, &TreePath) + 'static>(&self, f: F) -> SignalHandlerId;
93
94    fn connect_row_has_child_toggled<F: Fn(&Self, &TreePath, &TreeIter) + 'static>(
95        &self,
96        f: F,
97    ) -> SignalHandlerId;
98
99    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
107impl<O: IsA<TreeModel>> TreeModelExt for O {
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
138    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
147    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
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
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
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
202    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
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
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
228    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
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
257    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
266    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
275    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
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
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
317    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
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
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
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
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
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
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
391    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
421    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
446    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
481    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
516impl fmt::Display for TreeModel {
517    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
518        write!(f, "TreeModel")
519    }
520}