gtk/auto/
recent_manager.rs1use glib::object::Cast;
6use glib::object::IsA;
7use glib::signal::connect_raw;
8use glib::signal::SignalHandlerId;
9use glib::translate::*;
10use glib::GString;
11use glib::StaticType;
12use glib::ToValue;
13use glib::Value;
14use glib_sys;
15use gobject_sys;
16use gtk_sys;
17use std::boxed::Box as Box_;
18use std::fmt;
19use std::mem::transmute;
20use std::ptr;
21use Error;
22use RecentData;
23use RecentInfo;
24
25glib_wrapper! {
26 pub struct RecentManager(Object<gtk_sys::GtkRecentManager, gtk_sys::GtkRecentManagerClass, RecentManagerClass>);
27
28 match fn {
29 get_type => || gtk_sys::gtk_recent_manager_get_type(),
30 }
31}
32
33impl RecentManager {
34 pub fn new() -> RecentManager {
35 assert_initialized_main_thread!();
36 unsafe { from_glib_full(gtk_sys::gtk_recent_manager_new()) }
37 }
38
39 pub fn get_default() -> Option<RecentManager> {
40 assert_initialized_main_thread!();
41 unsafe { from_glib_none(gtk_sys::gtk_recent_manager_get_default()) }
42 }
43}
44
45impl Default for RecentManager {
46 fn default() -> Self {
47 Self::new()
48 }
49}
50
51pub struct RecentManagerBuilder {
52 filename: Option<String>,
53}
54
55impl RecentManagerBuilder {
56 pub fn new() -> Self {
57 Self { filename: None }
58 }
59
60 pub fn build(self) -> RecentManager {
61 let mut properties: Vec<(&str, &dyn ToValue)> = vec![];
62 if let Some(ref filename) = self.filename {
63 properties.push(("filename", filename));
64 }
65 glib::Object::new(RecentManager::static_type(), &properties)
66 .expect("object new")
67 .downcast()
68 .expect("downcast")
69 }
70
71 pub fn filename(mut self, filename: &str) -> Self {
72 self.filename = Some(filename.to_string());
73 self
74 }
75}
76
77pub const NONE_RECENT_MANAGER: Option<&RecentManager> = None;
78
79pub trait RecentManagerExt: 'static {
80 fn add_full(&self, uri: &str, recent_data: &RecentData) -> bool;
81
82 fn add_item(&self, uri: &str) -> bool;
83
84 fn get_items(&self) -> Vec<RecentInfo>;
85
86 fn has_item(&self, uri: &str) -> bool;
87
88 fn lookup_item(&self, uri: &str) -> Result<Option<RecentInfo>, Error>;
89
90 fn move_item(&self, uri: &str, new_uri: Option<&str>) -> Result<(), Error>;
91
92 fn purge_items(&self) -> Result<i32, Error>;
93
94 fn remove_item(&self, uri: &str) -> Result<(), Error>;
95
96 fn get_property_filename(&self) -> Option<GString>;
97
98 fn get_property_size(&self) -> i32;
99
100 fn connect_changed<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId;
101
102 fn connect_property_size_notify<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId;
103}
104
105impl<O: IsA<RecentManager>> RecentManagerExt for O {
106 fn add_full(&self, uri: &str, recent_data: &RecentData) -> bool {
107 unsafe {
108 from_glib(gtk_sys::gtk_recent_manager_add_full(
109 self.as_ref().to_glib_none().0,
110 uri.to_glib_none().0,
111 recent_data.to_glib_none().0,
112 ))
113 }
114 }
115
116 fn add_item(&self, uri: &str) -> bool {
117 unsafe {
118 from_glib(gtk_sys::gtk_recent_manager_add_item(
119 self.as_ref().to_glib_none().0,
120 uri.to_glib_none().0,
121 ))
122 }
123 }
124
125 fn get_items(&self) -> Vec<RecentInfo> {
126 unsafe {
127 FromGlibPtrContainer::from_glib_full(gtk_sys::gtk_recent_manager_get_items(
128 self.as_ref().to_glib_none().0,
129 ))
130 }
131 }
132
133 fn has_item(&self, uri: &str) -> bool {
134 unsafe {
135 from_glib(gtk_sys::gtk_recent_manager_has_item(
136 self.as_ref().to_glib_none().0,
137 uri.to_glib_none().0,
138 ))
139 }
140 }
141
142 fn lookup_item(&self, uri: &str) -> Result<Option<RecentInfo>, Error> {
143 unsafe {
144 let mut error = ptr::null_mut();
145 let ret = gtk_sys::gtk_recent_manager_lookup_item(
146 self.as_ref().to_glib_none().0,
147 uri.to_glib_none().0,
148 &mut error,
149 );
150 if error.is_null() {
151 Ok(from_glib_full(ret))
152 } else {
153 Err(from_glib_full(error))
154 }
155 }
156 }
157
158 fn move_item(&self, uri: &str, new_uri: Option<&str>) -> Result<(), Error> {
159 unsafe {
160 let mut error = ptr::null_mut();
161 let _ = gtk_sys::gtk_recent_manager_move_item(
162 self.as_ref().to_glib_none().0,
163 uri.to_glib_none().0,
164 new_uri.to_glib_none().0,
165 &mut error,
166 );
167 if error.is_null() {
168 Ok(())
169 } else {
170 Err(from_glib_full(error))
171 }
172 }
173 }
174
175 fn purge_items(&self) -> Result<i32, Error> {
176 unsafe {
177 let mut error = ptr::null_mut();
178 let ret =
179 gtk_sys::gtk_recent_manager_purge_items(self.as_ref().to_glib_none().0, &mut error);
180 if error.is_null() {
181 Ok(ret)
182 } else {
183 Err(from_glib_full(error))
184 }
185 }
186 }
187
188 fn remove_item(&self, uri: &str) -> Result<(), Error> {
189 unsafe {
190 let mut error = ptr::null_mut();
191 let _ = gtk_sys::gtk_recent_manager_remove_item(
192 self.as_ref().to_glib_none().0,
193 uri.to_glib_none().0,
194 &mut error,
195 );
196 if error.is_null() {
197 Ok(())
198 } else {
199 Err(from_glib_full(error))
200 }
201 }
202 }
203
204 fn get_property_filename(&self) -> Option<GString> {
205 unsafe {
206 let mut value = Value::from_type(<GString as StaticType>::static_type());
207 gobject_sys::g_object_get_property(
208 self.to_glib_none().0 as *mut gobject_sys::GObject,
209 b"filename\0".as_ptr() as *const _,
210 value.to_glib_none_mut().0,
211 );
212 value.get()
213 }
214 }
215
216 fn get_property_size(&self) -> i32 {
217 unsafe {
218 let mut value = Value::from_type(<i32 as StaticType>::static_type());
219 gobject_sys::g_object_get_property(
220 self.to_glib_none().0 as *mut gobject_sys::GObject,
221 b"size\0".as_ptr() as *const _,
222 value.to_glib_none_mut().0,
223 );
224 value.get().unwrap()
225 }
226 }
227
228 fn connect_changed<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId {
229 unsafe extern "C" fn changed_trampoline<P, F: Fn(&P) + 'static>(
230 this: *mut gtk_sys::GtkRecentManager,
231 f: glib_sys::gpointer,
232 ) where
233 P: IsA<RecentManager>,
234 {
235 let f: &F = &*(f as *const F);
236 f(&RecentManager::from_glib_borrow(this).unsafe_cast())
237 }
238 unsafe {
239 let f: Box_<F> = Box_::new(f);
240 connect_raw(
241 self.as_ptr() as *mut _,
242 b"changed\0".as_ptr() as *const _,
243 Some(transmute(changed_trampoline::<Self, F> as usize)),
244 Box_::into_raw(f),
245 )
246 }
247 }
248
249 fn connect_property_size_notify<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId {
250 unsafe extern "C" fn notify_size_trampoline<P, F: Fn(&P) + 'static>(
251 this: *mut gtk_sys::GtkRecentManager,
252 _param_spec: glib_sys::gpointer,
253 f: glib_sys::gpointer,
254 ) where
255 P: IsA<RecentManager>,
256 {
257 let f: &F = &*(f as *const F);
258 f(&RecentManager::from_glib_borrow(this).unsafe_cast())
259 }
260 unsafe {
261 let f: Box_<F> = Box_::new(f);
262 connect_raw(
263 self.as_ptr() as *mut _,
264 b"notify::size\0".as_ptr() as *const _,
265 Some(transmute(notify_size_trampoline::<Self, F> as usize)),
266 Box_::into_raw(f),
267 )
268 }
269 }
270}
271
272impl fmt::Display for RecentManager {
273 fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
274 write!(f, "RecentManager")
275 }
276}