gtk/
tree_sortable.rs

1// Copyright 2013-2015, The Gtk-rs Project Developers.
2// See the COPYRIGHT file at the top-level directory of this distribution.
3// Licensed under the MIT license, see the LICENSE file or <http://opensource.org/licenses/MIT>
4
5use glib::object::{Cast, IsA};
6use glib::translate::*;
7use gtk_sys;
8use std::cmp::Ordering;
9use std::fmt;
10use std::mem;
11use SortType;
12
13use glib_sys::gpointer;
14use gtk_sys::{GtkTreeIter, GtkTreeModel};
15use {TreeIter, TreeModel, TreeSortable};
16
17#[derive(Clone, Copy, Debug, Eq, PartialEq, Ord, PartialOrd, Hash)]
18pub enum SortColumn {
19    Default,
20    Index(u32),
21}
22
23#[doc(hidden)]
24impl ToGlib for SortColumn {
25    type GlibType = i32;
26
27    #[inline]
28    fn to_glib(&self) -> i32 {
29        match *self {
30            SortColumn::Default => gtk_sys::GTK_TREE_SORTABLE_DEFAULT_SORT_COLUMN_ID,
31            SortColumn::Index(x) => {
32                assert!(x <= i32::max_value() as u32, "column index is too big");
33                x as i32
34            }
35        }
36    }
37}
38
39#[doc(hidden)]
40impl FromGlib<i32> for SortColumn {
41    #[inline]
42    fn from_glib(val: i32) -> SortColumn {
43        skip_assert_initialized!();
44        match val {
45            gtk_sys::GTK_TREE_SORTABLE_DEFAULT_SORT_COLUMN_ID => SortColumn::Default,
46            x => {
47                assert!(x >= 0, "invalid column index");
48                SortColumn::Index(x as u32)
49            }
50        }
51    }
52}
53
54impl fmt::Display for SortColumn {
55    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
56        write!(
57            f,
58            "SortColumn::{}",
59            match *self {
60                SortColumn::Default => "Default",
61                SortColumn::Index(_) => "Index",
62            }
63        )
64    }
65}
66
67pub trait TreeSortableExtManual: 'static {
68    fn set_default_sort_func<F>(&self, sort_func: F)
69    where
70        F: Fn(&Self, &TreeIter, &TreeIter) -> Ordering + 'static;
71    fn set_sort_func<F>(&self, sort_column_id: SortColumn, sort_func: F)
72    where
73        F: Fn(&Self, &TreeIter, &TreeIter) -> Ordering + 'static;
74    fn get_sort_column_id(&self) -> Option<(SortColumn, SortType)>;
75    fn set_sort_column_id(&self, sort_column_id: SortColumn, order: SortType);
76    fn set_unsorted(&self);
77}
78
79fn into_raw<F, T>(func: F) -> gpointer
80where
81    F: Fn(&T, &TreeIter, &TreeIter) -> Ordering + 'static,
82{
83    skip_assert_initialized!();
84    let func: Box<F> = Box::new(func);
85    Box::into_raw(func) as gpointer
86}
87
88impl<O: IsA<TreeSortable>> TreeSortableExtManual for O {
89    #[inline]
90    fn get_sort_column_id(&self) -> Option<(SortColumn, SortType)> {
91        unsafe {
92            let mut sort_column_id = mem::uninitialized();
93            let mut order = mem::uninitialized();
94            gtk_sys::gtk_tree_sortable_get_sort_column_id(
95                self.as_ref().to_glib_none().0,
96                &mut sort_column_id,
97                &mut order,
98            );
99            if sort_column_id != gtk_sys::GTK_TREE_SORTABLE_UNSORTED_SORT_COLUMN_ID {
100                Some((from_glib(sort_column_id), from_glib(order)))
101            } else {
102                None
103            }
104        }
105    }
106
107    fn set_default_sort_func<F>(&self, sort_func: F)
108    where
109        F: Fn(&Self, &TreeIter, &TreeIter) -> Ordering + 'static,
110    {
111        unsafe extern "C" fn trampoline<T, F: Fn(&T, &TreeIter, &TreeIter) -> Ordering>(
112            this: *mut GtkTreeModel,
113            iter: *mut GtkTreeIter,
114            iter2: *mut GtkTreeIter,
115            f: gpointer,
116        ) -> i32
117        where
118            T: IsA<TreeSortable>,
119        {
120            let f: &F = &*(f as *const F);
121            f(
122                &TreeModel::from_glib_none(this).unsafe_cast(),
123                &from_glib_borrow(iter),
124                &from_glib_borrow(iter2),
125            )
126            .to_glib()
127        }
128        unsafe extern "C" fn destroy_closure<T, F: Fn(&T, &TreeIter, &TreeIter) -> Ordering>(
129            ptr: gpointer,
130        ) {
131            Box::<F>::from_raw(ptr as *mut _);
132        }
133        unsafe {
134            gtk_sys::gtk_tree_sortable_set_default_sort_func(
135                self.as_ref().to_glib_none().0,
136                Some(trampoline::<Self, F>),
137                into_raw(sort_func),
138                Some(destroy_closure::<Self, F>),
139            )
140        }
141    }
142
143    #[inline]
144    fn set_sort_column_id(&self, sort_column_id: SortColumn, order: SortType) {
145        unsafe {
146            gtk_sys::gtk_tree_sortable_set_sort_column_id(
147                self.as_ref().to_glib_none().0,
148                sort_column_id.to_glib(),
149                order.to_glib(),
150            );
151        }
152    }
153
154    fn set_unsorted(&self) {
155        unsafe {
156            gtk_sys::gtk_tree_sortable_set_sort_column_id(
157                self.as_ref().to_glib_none().0,
158                gtk_sys::GTK_TREE_SORTABLE_UNSORTED_SORT_COLUMN_ID,
159                SortType::Ascending.to_glib(),
160            );
161        }
162    }
163
164    fn set_sort_func<F>(&self, sort_column_id: SortColumn, sort_func: F)
165    where
166        F: Fn(&Self, &TreeIter, &TreeIter) -> Ordering + 'static,
167    {
168        unsafe extern "C" fn trampoline<T, F: Fn(&T, &TreeIter, &TreeIter) -> Ordering>(
169            this: *mut GtkTreeModel,
170            iter: *mut GtkTreeIter,
171            iter2: *mut GtkTreeIter,
172            f: gpointer,
173        ) -> i32
174        where
175            T: IsA<TreeSortable>,
176        {
177            let f: &F = &*(f as *const F);
178            f(
179                &TreeModel::from_glib_none(this).unsafe_cast(),
180                &from_glib_borrow(iter),
181                &from_glib_borrow(iter2),
182            )
183            .to_glib()
184        }
185        unsafe extern "C" fn destroy_closure<T, F: Fn(&T, &TreeIter, &TreeIter) -> Ordering>(
186            ptr: gpointer,
187        ) {
188            Box::<F>::from_raw(ptr as *mut _);
189        }
190        unsafe {
191            gtk_sys::gtk_tree_sortable_set_sort_func(
192                self.as_ref().to_glib_none().0,
193                sort_column_id.to_glib(),
194                Some(trampoline::<Self, F>),
195                into_raw(sort_func),
196                Some(destroy_closure::<Self, F>),
197            )
198        }
199    }
200}