1use 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_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_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 }
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_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_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 }
515
516impl fmt::Display for TreeModel {
517 fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
518 write!(f, "TreeModel")
519 }
520}