1use 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}