1use crate::{
6 ffi, AppInfo, AsyncResult, Cancellable, DriveStartFlags, FileAttributeInfoList, FileCopyFlags,
7 FileCreateFlags, FileEnumerator, FileIOStream, FileInfo, FileInputStream, FileMonitor,
8 FileMonitorFlags, FileOutputStream, FileQueryInfoFlags, FileType, Mount, MountMountFlags,
9 MountOperation, MountUnmountFlags,
10};
11use glib::{prelude::*, translate::*};
12use std::{boxed::Box as Box_, pin::Pin};
13
14glib::wrapper! {
15 #[doc(alias = "GFile")]
16 pub struct File(Interface<ffi::GFile, ffi::GFileIface>);
17
18 match fn {
19 type_ => || ffi::g_file_get_type(),
20 }
21}
22
23impl File {
24 pub const NONE: Option<&'static File> = None;
25
26 #[cfg(feature = "v2_78")]
32 #[cfg_attr(docsrs, doc(cfg(feature = "v2_78")))]
33 #[doc(alias = "g_file_new_build_filenamev")]
34 pub fn new_build_filenamev(args: &[&std::path::Path]) -> File {
35 unsafe { from_glib_full(ffi::g_file_new_build_filenamev(args.to_glib_none().0)) }
36 }
37
38 #[doc(alias = "g_file_new_for_commandline_arg")]
39 #[doc(alias = "new_for_commandline_arg")]
40 pub fn for_commandline_arg(arg: impl AsRef<std::ffi::OsStr>) -> File {
41 unsafe {
42 from_glib_full(ffi::g_file_new_for_commandline_arg(
43 arg.as_ref().to_glib_none().0,
44 ))
45 }
46 }
47
48 #[doc(alias = "g_file_new_for_commandline_arg_and_cwd")]
49 #[doc(alias = "new_for_commandline_arg_and_cwd")]
50 pub fn for_commandline_arg_and_cwd(
51 arg: impl AsRef<std::ffi::OsStr>,
52 cwd: impl AsRef<std::path::Path>,
53 ) -> File {
54 unsafe {
55 from_glib_full(ffi::g_file_new_for_commandline_arg_and_cwd(
56 arg.as_ref().to_glib_none().0,
57 cwd.as_ref().to_glib_none().0,
58 ))
59 }
60 }
61
62 #[doc(alias = "g_file_new_for_path")]
63 #[doc(alias = "new_for_path")]
64 pub fn for_path(path: impl AsRef<std::path::Path>) -> File {
65 unsafe { from_glib_full(ffi::g_file_new_for_path(path.as_ref().to_glib_none().0)) }
66 }
67
68 #[doc(alias = "g_file_new_for_uri")]
69 #[doc(alias = "new_for_uri")]
70 pub fn for_uri(uri: &str) -> File {
71 unsafe { from_glib_full(ffi::g_file_new_for_uri(uri.to_glib_none().0)) }
72 }
73
74 #[doc(alias = "g_file_new_tmp")]
75 pub fn new_tmp(
76 tmpl: Option<impl AsRef<std::path::Path>>,
77 ) -> Result<(File, FileIOStream), glib::Error> {
78 unsafe {
79 let mut iostream = std::ptr::null_mut();
80 let mut error = std::ptr::null_mut();
81 let ret = ffi::g_file_new_tmp(
82 tmpl.as_ref().map(|p| p.as_ref()).to_glib_none().0,
83 &mut iostream,
84 &mut error,
85 );
86 if error.is_null() {
87 Ok((from_glib_full(ret), from_glib_full(iostream)))
88 } else {
89 Err(from_glib_full(error))
90 }
91 }
92 }
93
94 #[doc(alias = "g_file_parse_name")]
95 #[doc(alias = "parse_name")]
96 pub fn for_parse_name(parse_name: &str) -> File {
97 unsafe { from_glib_full(ffi::g_file_parse_name(parse_name.to_glib_none().0)) }
98 }
99}
100
101unsafe impl Send for File {}
102unsafe impl Sync for File {}
103
104pub trait FileExt: IsA<File> + 'static {
105 #[doc(alias = "g_file_append_to")]
106 fn append_to(
107 &self,
108 flags: FileCreateFlags,
109 cancellable: Option<&impl IsA<Cancellable>>,
110 ) -> Result<FileOutputStream, glib::Error> {
111 unsafe {
112 let mut error = std::ptr::null_mut();
113 let ret = ffi::g_file_append_to(
114 self.as_ref().to_glib_none().0,
115 flags.into_glib(),
116 cancellable.map(|p| p.as_ref()).to_glib_none().0,
117 &mut error,
118 );
119 if error.is_null() {
120 Ok(from_glib_full(ret))
121 } else {
122 Err(from_glib_full(error))
123 }
124 }
125 }
126
127 #[doc(alias = "g_file_append_to_async")]
128 fn append_to_async<P: FnOnce(Result<FileOutputStream, glib::Error>) + 'static>(
129 &self,
130 flags: FileCreateFlags,
131 io_priority: glib::Priority,
132 cancellable: Option<&impl IsA<Cancellable>>,
133 callback: P,
134 ) {
135 let main_context = glib::MainContext::ref_thread_default();
136 let is_main_context_owner = main_context.is_owner();
137 let has_acquired_main_context = (!is_main_context_owner)
138 .then(|| main_context.acquire().ok())
139 .flatten();
140 assert!(
141 is_main_context_owner || has_acquired_main_context.is_some(),
142 "Async operations only allowed if the thread is owning the MainContext"
143 );
144
145 let user_data: Box_<glib::thread_guard::ThreadGuard<P>> =
146 Box_::new(glib::thread_guard::ThreadGuard::new(callback));
147 unsafe extern "C" fn append_to_async_trampoline<
148 P: FnOnce(Result<FileOutputStream, glib::Error>) + 'static,
149 >(
150 _source_object: *mut glib::gobject_ffi::GObject,
151 res: *mut crate::ffi::GAsyncResult,
152 user_data: glib::ffi::gpointer,
153 ) {
154 let mut error = std::ptr::null_mut();
155 let ret = ffi::g_file_append_to_finish(_source_object as *mut _, res, &mut error);
156 let result = if error.is_null() {
157 Ok(from_glib_full(ret))
158 } else {
159 Err(from_glib_full(error))
160 };
161 let callback: Box_<glib::thread_guard::ThreadGuard<P>> =
162 Box_::from_raw(user_data as *mut _);
163 let callback: P = callback.into_inner();
164 callback(result);
165 }
166 let callback = append_to_async_trampoline::<P>;
167 unsafe {
168 ffi::g_file_append_to_async(
169 self.as_ref().to_glib_none().0,
170 flags.into_glib(),
171 io_priority.into_glib(),
172 cancellable.map(|p| p.as_ref()).to_glib_none().0,
173 Some(callback),
174 Box_::into_raw(user_data) as *mut _,
175 );
176 }
177 }
178
179 fn append_to_future(
180 &self,
181 flags: FileCreateFlags,
182 io_priority: glib::Priority,
183 ) -> Pin<Box_<dyn std::future::Future<Output = Result<FileOutputStream, glib::Error>> + 'static>>
184 {
185 Box_::pin(crate::GioFuture::new(
186 self,
187 move |obj, cancellable, send| {
188 obj.append_to_async(flags, io_priority, Some(cancellable), move |res| {
189 send.resolve(res);
190 });
191 },
192 ))
193 }
194
195 #[cfg(feature = "v2_68")]
196 #[cfg_attr(docsrs, doc(cfg(feature = "v2_68")))]
197 #[doc(alias = "g_file_build_attribute_list_for_copy")]
198 fn build_attribute_list_for_copy(
199 &self,
200 flags: FileCopyFlags,
201 cancellable: Option<&impl IsA<Cancellable>>,
202 ) -> Result<glib::GString, glib::Error> {
203 unsafe {
204 let mut error = std::ptr::null_mut();
205 let ret = ffi::g_file_build_attribute_list_for_copy(
206 self.as_ref().to_glib_none().0,
207 flags.into_glib(),
208 cancellable.map(|p| p.as_ref()).to_glib_none().0,
209 &mut error,
210 );
211 if error.is_null() {
212 Ok(from_glib_full(ret))
213 } else {
214 Err(from_glib_full(error))
215 }
216 }
217 }
218
219 #[doc(alias = "g_file_copy")]
220 fn copy(
221 &self,
222 destination: &impl IsA<File>,
223 flags: FileCopyFlags,
224 cancellable: Option<&impl IsA<Cancellable>>,
225 progress_callback: Option<&mut dyn FnMut(i64, i64)>,
226 ) -> Result<(), glib::Error> {
227 let mut progress_callback_data: Option<&mut dyn FnMut(i64, i64)> = progress_callback;
228 unsafe extern "C" fn progress_callback_func(
229 current_num_bytes: i64,
230 total_num_bytes: i64,
231 data: glib::ffi::gpointer,
232 ) {
233 let callback = data as *mut Option<&mut dyn FnMut(i64, i64)>;
234 if let Some(ref mut callback) = *callback {
235 callback(current_num_bytes, total_num_bytes)
236 } else {
237 panic!("cannot get closure...")
238 }
239 }
240 let progress_callback = if progress_callback_data.is_some() {
241 Some(progress_callback_func as _)
242 } else {
243 None
244 };
245 let super_callback0: &mut Option<&mut dyn FnMut(i64, i64)> = &mut progress_callback_data;
246 unsafe {
247 let mut error = std::ptr::null_mut();
248 let is_ok = ffi::g_file_copy(
249 self.as_ref().to_glib_none().0,
250 destination.as_ref().to_glib_none().0,
251 flags.into_glib(),
252 cancellable.map(|p| p.as_ref()).to_glib_none().0,
253 progress_callback,
254 super_callback0 as *mut _ as *mut _,
255 &mut error,
256 );
257 debug_assert_eq!(is_ok == glib::ffi::GFALSE, !error.is_null());
258 if error.is_null() {
259 Ok(())
260 } else {
261 Err(from_glib_full(error))
262 }
263 }
264 }
265
266 #[doc(alias = "g_file_copy_attributes")]
267 fn copy_attributes(
268 &self,
269 destination: &impl IsA<File>,
270 flags: FileCopyFlags,
271 cancellable: Option<&impl IsA<Cancellable>>,
272 ) -> Result<(), glib::Error> {
273 unsafe {
274 let mut error = std::ptr::null_mut();
275 let is_ok = ffi::g_file_copy_attributes(
276 self.as_ref().to_glib_none().0,
277 destination.as_ref().to_glib_none().0,
278 flags.into_glib(),
279 cancellable.map(|p| p.as_ref()).to_glib_none().0,
280 &mut error,
281 );
282 debug_assert_eq!(is_ok == glib::ffi::GFALSE, !error.is_null());
283 if error.is_null() {
284 Ok(())
285 } else {
286 Err(from_glib_full(error))
287 }
288 }
289 }
290
291 #[doc(alias = "g_file_create")]
292 fn create(
293 &self,
294 flags: FileCreateFlags,
295 cancellable: Option<&impl IsA<Cancellable>>,
296 ) -> Result<FileOutputStream, glib::Error> {
297 unsafe {
298 let mut error = std::ptr::null_mut();
299 let ret = ffi::g_file_create(
300 self.as_ref().to_glib_none().0,
301 flags.into_glib(),
302 cancellable.map(|p| p.as_ref()).to_glib_none().0,
303 &mut error,
304 );
305 if error.is_null() {
306 Ok(from_glib_full(ret))
307 } else {
308 Err(from_glib_full(error))
309 }
310 }
311 }
312
313 #[doc(alias = "g_file_create_async")]
314 fn create_async<P: FnOnce(Result<FileOutputStream, glib::Error>) + 'static>(
315 &self,
316 flags: FileCreateFlags,
317 io_priority: glib::Priority,
318 cancellable: Option<&impl IsA<Cancellable>>,
319 callback: P,
320 ) {
321 let main_context = glib::MainContext::ref_thread_default();
322 let is_main_context_owner = main_context.is_owner();
323 let has_acquired_main_context = (!is_main_context_owner)
324 .then(|| main_context.acquire().ok())
325 .flatten();
326 assert!(
327 is_main_context_owner || has_acquired_main_context.is_some(),
328 "Async operations only allowed if the thread is owning the MainContext"
329 );
330
331 let user_data: Box_<glib::thread_guard::ThreadGuard<P>> =
332 Box_::new(glib::thread_guard::ThreadGuard::new(callback));
333 unsafe extern "C" fn create_async_trampoline<
334 P: FnOnce(Result<FileOutputStream, glib::Error>) + 'static,
335 >(
336 _source_object: *mut glib::gobject_ffi::GObject,
337 res: *mut crate::ffi::GAsyncResult,
338 user_data: glib::ffi::gpointer,
339 ) {
340 let mut error = std::ptr::null_mut();
341 let ret = ffi::g_file_create_finish(_source_object as *mut _, res, &mut error);
342 let result = if error.is_null() {
343 Ok(from_glib_full(ret))
344 } else {
345 Err(from_glib_full(error))
346 };
347 let callback: Box_<glib::thread_guard::ThreadGuard<P>> =
348 Box_::from_raw(user_data as *mut _);
349 let callback: P = callback.into_inner();
350 callback(result);
351 }
352 let callback = create_async_trampoline::<P>;
353 unsafe {
354 ffi::g_file_create_async(
355 self.as_ref().to_glib_none().0,
356 flags.into_glib(),
357 io_priority.into_glib(),
358 cancellable.map(|p| p.as_ref()).to_glib_none().0,
359 Some(callback),
360 Box_::into_raw(user_data) as *mut _,
361 );
362 }
363 }
364
365 fn create_future(
366 &self,
367 flags: FileCreateFlags,
368 io_priority: glib::Priority,
369 ) -> Pin<Box_<dyn std::future::Future<Output = Result<FileOutputStream, glib::Error>> + 'static>>
370 {
371 Box_::pin(crate::GioFuture::new(
372 self,
373 move |obj, cancellable, send| {
374 obj.create_async(flags, io_priority, Some(cancellable), move |res| {
375 send.resolve(res);
376 });
377 },
378 ))
379 }
380
381 #[doc(alias = "g_file_create_readwrite")]
382 fn create_readwrite(
383 &self,
384 flags: FileCreateFlags,
385 cancellable: Option<&impl IsA<Cancellable>>,
386 ) -> Result<FileIOStream, glib::Error> {
387 unsafe {
388 let mut error = std::ptr::null_mut();
389 let ret = ffi::g_file_create_readwrite(
390 self.as_ref().to_glib_none().0,
391 flags.into_glib(),
392 cancellable.map(|p| p.as_ref()).to_glib_none().0,
393 &mut error,
394 );
395 if error.is_null() {
396 Ok(from_glib_full(ret))
397 } else {
398 Err(from_glib_full(error))
399 }
400 }
401 }
402
403 #[doc(alias = "g_file_create_readwrite_async")]
404 fn create_readwrite_async<P: FnOnce(Result<FileIOStream, glib::Error>) + 'static>(
405 &self,
406 flags: FileCreateFlags,
407 io_priority: glib::Priority,
408 cancellable: Option<&impl IsA<Cancellable>>,
409 callback: P,
410 ) {
411 let main_context = glib::MainContext::ref_thread_default();
412 let is_main_context_owner = main_context.is_owner();
413 let has_acquired_main_context = (!is_main_context_owner)
414 .then(|| main_context.acquire().ok())
415 .flatten();
416 assert!(
417 is_main_context_owner || has_acquired_main_context.is_some(),
418 "Async operations only allowed if the thread is owning the MainContext"
419 );
420
421 let user_data: Box_<glib::thread_guard::ThreadGuard<P>> =
422 Box_::new(glib::thread_guard::ThreadGuard::new(callback));
423 unsafe extern "C" fn create_readwrite_async_trampoline<
424 P: FnOnce(Result<FileIOStream, glib::Error>) + 'static,
425 >(
426 _source_object: *mut glib::gobject_ffi::GObject,
427 res: *mut crate::ffi::GAsyncResult,
428 user_data: glib::ffi::gpointer,
429 ) {
430 let mut error = std::ptr::null_mut();
431 let ret =
432 ffi::g_file_create_readwrite_finish(_source_object as *mut _, res, &mut error);
433 let result = if error.is_null() {
434 Ok(from_glib_full(ret))
435 } else {
436 Err(from_glib_full(error))
437 };
438 let callback: Box_<glib::thread_guard::ThreadGuard<P>> =
439 Box_::from_raw(user_data as *mut _);
440 let callback: P = callback.into_inner();
441 callback(result);
442 }
443 let callback = create_readwrite_async_trampoline::<P>;
444 unsafe {
445 ffi::g_file_create_readwrite_async(
446 self.as_ref().to_glib_none().0,
447 flags.into_glib(),
448 io_priority.into_glib(),
449 cancellable.map(|p| p.as_ref()).to_glib_none().0,
450 Some(callback),
451 Box_::into_raw(user_data) as *mut _,
452 );
453 }
454 }
455
456 fn create_readwrite_future(
457 &self,
458 flags: FileCreateFlags,
459 io_priority: glib::Priority,
460 ) -> Pin<Box_<dyn std::future::Future<Output = Result<FileIOStream, glib::Error>> + 'static>>
461 {
462 Box_::pin(crate::GioFuture::new(
463 self,
464 move |obj, cancellable, send| {
465 obj.create_readwrite_async(flags, io_priority, Some(cancellable), move |res| {
466 send.resolve(res);
467 });
468 },
469 ))
470 }
471
472 #[doc(alias = "g_file_delete")]
473 fn delete(&self, cancellable: Option<&impl IsA<Cancellable>>) -> Result<(), glib::Error> {
474 unsafe {
475 let mut error = std::ptr::null_mut();
476 let is_ok = ffi::g_file_delete(
477 self.as_ref().to_glib_none().0,
478 cancellable.map(|p| p.as_ref()).to_glib_none().0,
479 &mut error,
480 );
481 debug_assert_eq!(is_ok == glib::ffi::GFALSE, !error.is_null());
482 if error.is_null() {
483 Ok(())
484 } else {
485 Err(from_glib_full(error))
486 }
487 }
488 }
489
490 #[doc(alias = "g_file_delete_async")]
491 fn delete_async<P: FnOnce(Result<(), glib::Error>) + 'static>(
492 &self,
493 io_priority: glib::Priority,
494 cancellable: Option<&impl IsA<Cancellable>>,
495 callback: P,
496 ) {
497 let main_context = glib::MainContext::ref_thread_default();
498 let is_main_context_owner = main_context.is_owner();
499 let has_acquired_main_context = (!is_main_context_owner)
500 .then(|| main_context.acquire().ok())
501 .flatten();
502 assert!(
503 is_main_context_owner || has_acquired_main_context.is_some(),
504 "Async operations only allowed if the thread is owning the MainContext"
505 );
506
507 let user_data: Box_<glib::thread_guard::ThreadGuard<P>> =
508 Box_::new(glib::thread_guard::ThreadGuard::new(callback));
509 unsafe extern "C" fn delete_async_trampoline<
510 P: FnOnce(Result<(), glib::Error>) + 'static,
511 >(
512 _source_object: *mut glib::gobject_ffi::GObject,
513 res: *mut crate::ffi::GAsyncResult,
514 user_data: glib::ffi::gpointer,
515 ) {
516 let mut error = std::ptr::null_mut();
517 ffi::g_file_delete_finish(_source_object as *mut _, res, &mut error);
518 let result = if error.is_null() {
519 Ok(())
520 } else {
521 Err(from_glib_full(error))
522 };
523 let callback: Box_<glib::thread_guard::ThreadGuard<P>> =
524 Box_::from_raw(user_data as *mut _);
525 let callback: P = callback.into_inner();
526 callback(result);
527 }
528 let callback = delete_async_trampoline::<P>;
529 unsafe {
530 ffi::g_file_delete_async(
531 self.as_ref().to_glib_none().0,
532 io_priority.into_glib(),
533 cancellable.map(|p| p.as_ref()).to_glib_none().0,
534 Some(callback),
535 Box_::into_raw(user_data) as *mut _,
536 );
537 }
538 }
539
540 fn delete_future(
541 &self,
542 io_priority: glib::Priority,
543 ) -> Pin<Box_<dyn std::future::Future<Output = Result<(), glib::Error>> + 'static>> {
544 Box_::pin(crate::GioFuture::new(
545 self,
546 move |obj, cancellable, send| {
547 obj.delete_async(io_priority, Some(cancellable), move |res| {
548 send.resolve(res);
549 });
550 },
551 ))
552 }
553
554 #[doc(alias = "g_file_dup")]
555 #[must_use]
556 fn dup(&self) -> File {
557 unsafe { from_glib_full(ffi::g_file_dup(self.as_ref().to_glib_none().0)) }
558 }
559
560 #[doc(alias = "g_file_eject_mountable_with_operation")]
561 fn eject_mountable_with_operation<P: FnOnce(Result<(), glib::Error>) + 'static>(
562 &self,
563 flags: MountUnmountFlags,
564 mount_operation: Option<&impl IsA<MountOperation>>,
565 cancellable: Option<&impl IsA<Cancellable>>,
566 callback: P,
567 ) {
568 let main_context = glib::MainContext::ref_thread_default();
569 let is_main_context_owner = main_context.is_owner();
570 let has_acquired_main_context = (!is_main_context_owner)
571 .then(|| main_context.acquire().ok())
572 .flatten();
573 assert!(
574 is_main_context_owner || has_acquired_main_context.is_some(),
575 "Async operations only allowed if the thread is owning the MainContext"
576 );
577
578 let user_data: Box_<glib::thread_guard::ThreadGuard<P>> =
579 Box_::new(glib::thread_guard::ThreadGuard::new(callback));
580 unsafe extern "C" fn eject_mountable_with_operation_trampoline<
581 P: FnOnce(Result<(), glib::Error>) + 'static,
582 >(
583 _source_object: *mut glib::gobject_ffi::GObject,
584 res: *mut crate::ffi::GAsyncResult,
585 user_data: glib::ffi::gpointer,
586 ) {
587 let mut error = std::ptr::null_mut();
588 ffi::g_file_eject_mountable_with_operation_finish(
589 _source_object as *mut _,
590 res,
591 &mut error,
592 );
593 let result = if error.is_null() {
594 Ok(())
595 } else {
596 Err(from_glib_full(error))
597 };
598 let callback: Box_<glib::thread_guard::ThreadGuard<P>> =
599 Box_::from_raw(user_data as *mut _);
600 let callback: P = callback.into_inner();
601 callback(result);
602 }
603 let callback = eject_mountable_with_operation_trampoline::<P>;
604 unsafe {
605 ffi::g_file_eject_mountable_with_operation(
606 self.as_ref().to_glib_none().0,
607 flags.into_glib(),
608 mount_operation.map(|p| p.as_ref()).to_glib_none().0,
609 cancellable.map(|p| p.as_ref()).to_glib_none().0,
610 Some(callback),
611 Box_::into_raw(user_data) as *mut _,
612 );
613 }
614 }
615
616 fn eject_mountable_with_operation_future(
617 &self,
618 flags: MountUnmountFlags,
619 mount_operation: Option<&(impl IsA<MountOperation> + Clone + 'static)>,
620 ) -> Pin<Box_<dyn std::future::Future<Output = Result<(), glib::Error>> + 'static>> {
621 let mount_operation = mount_operation.map(ToOwned::to_owned);
622 Box_::pin(crate::GioFuture::new(
623 self,
624 move |obj, cancellable, send| {
625 obj.eject_mountable_with_operation(
626 flags,
627 mount_operation.as_ref().map(::std::borrow::Borrow::borrow),
628 Some(cancellable),
629 move |res| {
630 send.resolve(res);
631 },
632 );
633 },
634 ))
635 }
636
637 #[doc(alias = "g_file_enumerate_children")]
638 fn enumerate_children(
639 &self,
640 attributes: &str,
641 flags: FileQueryInfoFlags,
642 cancellable: Option<&impl IsA<Cancellable>>,
643 ) -> Result<FileEnumerator, glib::Error> {
644 unsafe {
645 let mut error = std::ptr::null_mut();
646 let ret = ffi::g_file_enumerate_children(
647 self.as_ref().to_glib_none().0,
648 attributes.to_glib_none().0,
649 flags.into_glib(),
650 cancellable.map(|p| p.as_ref()).to_glib_none().0,
651 &mut error,
652 );
653 if error.is_null() {
654 Ok(from_glib_full(ret))
655 } else {
656 Err(from_glib_full(error))
657 }
658 }
659 }
660
661 #[doc(alias = "g_file_equal")]
662 fn equal(&self, file2: &impl IsA<File>) -> bool {
663 unsafe {
664 from_glib(ffi::g_file_equal(
665 self.as_ref().to_glib_none().0,
666 file2.as_ref().to_glib_none().0,
667 ))
668 }
669 }
670
671 #[doc(alias = "g_file_find_enclosing_mount")]
672 fn find_enclosing_mount(
673 &self,
674 cancellable: Option<&impl IsA<Cancellable>>,
675 ) -> Result<Mount, glib::Error> {
676 unsafe {
677 let mut error = std::ptr::null_mut();
678 let ret = ffi::g_file_find_enclosing_mount(
679 self.as_ref().to_glib_none().0,
680 cancellable.map(|p| p.as_ref()).to_glib_none().0,
681 &mut error,
682 );
683 if error.is_null() {
684 Ok(from_glib_full(ret))
685 } else {
686 Err(from_glib_full(error))
687 }
688 }
689 }
690
691 #[doc(alias = "g_file_get_basename")]
692 #[doc(alias = "get_basename")]
693 fn basename(&self) -> Option<std::path::PathBuf> {
694 unsafe { from_glib_full(ffi::g_file_get_basename(self.as_ref().to_glib_none().0)) }
695 }
696
697 #[doc(alias = "g_file_get_child")]
698 #[doc(alias = "get_child")]
699 #[must_use]
700 fn child(&self, name: impl AsRef<std::path::Path>) -> File {
701 unsafe {
702 from_glib_full(ffi::g_file_get_child(
703 self.as_ref().to_glib_none().0,
704 name.as_ref().to_glib_none().0,
705 ))
706 }
707 }
708
709 #[doc(alias = "g_file_get_child_for_display_name")]
710 #[doc(alias = "get_child_for_display_name")]
711 fn child_for_display_name(&self, display_name: &str) -> Result<File, glib::Error> {
712 unsafe {
713 let mut error = std::ptr::null_mut();
714 let ret = ffi::g_file_get_child_for_display_name(
715 self.as_ref().to_glib_none().0,
716 display_name.to_glib_none().0,
717 &mut error,
718 );
719 if error.is_null() {
720 Ok(from_glib_full(ret))
721 } else {
722 Err(from_glib_full(error))
723 }
724 }
725 }
726
727 #[doc(alias = "g_file_get_parent")]
728 #[doc(alias = "get_parent")]
729 #[must_use]
730 fn parent(&self) -> Option<File> {
731 unsafe { from_glib_full(ffi::g_file_get_parent(self.as_ref().to_glib_none().0)) }
732 }
733
734 #[doc(alias = "g_file_get_parse_name")]
735 #[doc(alias = "get_parse_name")]
736 fn parse_name(&self) -> glib::GString {
737 unsafe { from_glib_full(ffi::g_file_get_parse_name(self.as_ref().to_glib_none().0)) }
738 }
739
740 #[doc(alias = "g_file_get_path")]
741 #[doc(alias = "get_path")]
742 fn path(&self) -> Option<std::path::PathBuf> {
743 unsafe { from_glib_full(ffi::g_file_get_path(self.as_ref().to_glib_none().0)) }
744 }
745
746 #[doc(alias = "g_file_get_relative_path")]
747 #[doc(alias = "get_relative_path")]
748 fn relative_path(&self, descendant: &impl IsA<File>) -> Option<std::path::PathBuf> {
749 unsafe {
750 from_glib_full(ffi::g_file_get_relative_path(
751 self.as_ref().to_glib_none().0,
752 descendant.as_ref().to_glib_none().0,
753 ))
754 }
755 }
756
757 #[doc(alias = "g_file_get_uri")]
758 #[doc(alias = "get_uri")]
759 fn uri(&self) -> glib::GString {
760 unsafe { from_glib_full(ffi::g_file_get_uri(self.as_ref().to_glib_none().0)) }
761 }
762
763 #[doc(alias = "g_file_get_uri_scheme")]
764 #[doc(alias = "get_uri_scheme")]
765 fn uri_scheme(&self) -> Option<glib::GString> {
766 unsafe { from_glib_full(ffi::g_file_get_uri_scheme(self.as_ref().to_glib_none().0)) }
767 }
768
769 #[doc(alias = "g_file_has_parent")]
770 fn has_parent(&self, parent: Option<&impl IsA<File>>) -> bool {
771 unsafe {
772 from_glib(ffi::g_file_has_parent(
773 self.as_ref().to_glib_none().0,
774 parent.map(|p| p.as_ref()).to_glib_none().0,
775 ))
776 }
777 }
778
779 #[doc(alias = "g_file_has_prefix")]
780 fn has_prefix(&self, prefix: &impl IsA<File>) -> bool {
781 unsafe {
782 from_glib(ffi::g_file_has_prefix(
783 self.as_ref().to_glib_none().0,
784 prefix.as_ref().to_glib_none().0,
785 ))
786 }
787 }
788
789 #[doc(alias = "g_file_has_uri_scheme")]
790 fn has_uri_scheme(&self, uri_scheme: &str) -> bool {
791 unsafe {
792 from_glib(ffi::g_file_has_uri_scheme(
793 self.as_ref().to_glib_none().0,
794 uri_scheme.to_glib_none().0,
795 ))
796 }
797 }
798
799 #[doc(alias = "g_file_is_native")]
800 fn is_native(&self) -> bool {
801 unsafe { from_glib(ffi::g_file_is_native(self.as_ref().to_glib_none().0)) }
802 }
803
804 #[doc(alias = "g_file_load_bytes")]
805 fn load_bytes(
806 &self,
807 cancellable: Option<&impl IsA<Cancellable>>,
808 ) -> Result<(glib::Bytes, Option<glib::GString>), glib::Error> {
809 unsafe {
810 let mut etag_out = std::ptr::null_mut();
811 let mut error = std::ptr::null_mut();
812 let ret = ffi::g_file_load_bytes(
813 self.as_ref().to_glib_none().0,
814 cancellable.map(|p| p.as_ref()).to_glib_none().0,
815 &mut etag_out,
816 &mut error,
817 );
818 if error.is_null() {
819 Ok((from_glib_full(ret), from_glib_full(etag_out)))
820 } else {
821 Err(from_glib_full(error))
822 }
823 }
824 }
825
826 #[doc(alias = "g_file_load_bytes_async")]
827 fn load_bytes_async<
828 P: FnOnce(Result<(glib::Bytes, Option<glib::GString>), glib::Error>) + 'static,
829 >(
830 &self,
831 cancellable: Option<&impl IsA<Cancellable>>,
832 callback: P,
833 ) {
834 let main_context = glib::MainContext::ref_thread_default();
835 let is_main_context_owner = main_context.is_owner();
836 let has_acquired_main_context = (!is_main_context_owner)
837 .then(|| main_context.acquire().ok())
838 .flatten();
839 assert!(
840 is_main_context_owner || has_acquired_main_context.is_some(),
841 "Async operations only allowed if the thread is owning the MainContext"
842 );
843
844 let user_data: Box_<glib::thread_guard::ThreadGuard<P>> =
845 Box_::new(glib::thread_guard::ThreadGuard::new(callback));
846 unsafe extern "C" fn load_bytes_async_trampoline<
847 P: FnOnce(Result<(glib::Bytes, Option<glib::GString>), glib::Error>) + 'static,
848 >(
849 _source_object: *mut glib::gobject_ffi::GObject,
850 res: *mut crate::ffi::GAsyncResult,
851 user_data: glib::ffi::gpointer,
852 ) {
853 let mut error = std::ptr::null_mut();
854 let mut etag_out = std::ptr::null_mut();
855 let ret = ffi::g_file_load_bytes_finish(
856 _source_object as *mut _,
857 res,
858 &mut etag_out,
859 &mut error,
860 );
861 let result = if error.is_null() {
862 Ok((from_glib_full(ret), from_glib_full(etag_out)))
863 } else {
864 Err(from_glib_full(error))
865 };
866 let callback: Box_<glib::thread_guard::ThreadGuard<P>> =
867 Box_::from_raw(user_data as *mut _);
868 let callback: P = callback.into_inner();
869 callback(result);
870 }
871 let callback = load_bytes_async_trampoline::<P>;
872 unsafe {
873 ffi::g_file_load_bytes_async(
874 self.as_ref().to_glib_none().0,
875 cancellable.map(|p| p.as_ref()).to_glib_none().0,
876 Some(callback),
877 Box_::into_raw(user_data) as *mut _,
878 );
879 }
880 }
881
882 fn load_bytes_future(
883 &self,
884 ) -> Pin<
885 Box_<
886 dyn std::future::Future<
887 Output = Result<(glib::Bytes, Option<glib::GString>), glib::Error>,
888 > + 'static,
889 >,
890 > {
891 Box_::pin(crate::GioFuture::new(
892 self,
893 move |obj, cancellable, send| {
894 obj.load_bytes_async(Some(cancellable), move |res| {
895 send.resolve(res);
896 });
897 },
898 ))
899 }
900
901 #[doc(alias = "g_file_make_directory")]
902 fn make_directory(
903 &self,
904 cancellable: Option<&impl IsA<Cancellable>>,
905 ) -> Result<(), glib::Error> {
906 unsafe {
907 let mut error = std::ptr::null_mut();
908 let is_ok = ffi::g_file_make_directory(
909 self.as_ref().to_glib_none().0,
910 cancellable.map(|p| p.as_ref()).to_glib_none().0,
911 &mut error,
912 );
913 debug_assert_eq!(is_ok == glib::ffi::GFALSE, !error.is_null());
914 if error.is_null() {
915 Ok(())
916 } else {
917 Err(from_glib_full(error))
918 }
919 }
920 }
921
922 #[doc(alias = "g_file_make_directory_async")]
923 fn make_directory_async<P: FnOnce(Result<(), glib::Error>) + 'static>(
924 &self,
925 io_priority: glib::Priority,
926 cancellable: Option<&impl IsA<Cancellable>>,
927 callback: P,
928 ) {
929 let main_context = glib::MainContext::ref_thread_default();
930 let is_main_context_owner = main_context.is_owner();
931 let has_acquired_main_context = (!is_main_context_owner)
932 .then(|| main_context.acquire().ok())
933 .flatten();
934 assert!(
935 is_main_context_owner || has_acquired_main_context.is_some(),
936 "Async operations only allowed if the thread is owning the MainContext"
937 );
938
939 let user_data: Box_<glib::thread_guard::ThreadGuard<P>> =
940 Box_::new(glib::thread_guard::ThreadGuard::new(callback));
941 unsafe extern "C" fn make_directory_async_trampoline<
942 P: FnOnce(Result<(), glib::Error>) + 'static,
943 >(
944 _source_object: *mut glib::gobject_ffi::GObject,
945 res: *mut crate::ffi::GAsyncResult,
946 user_data: glib::ffi::gpointer,
947 ) {
948 let mut error = std::ptr::null_mut();
949 ffi::g_file_make_directory_finish(_source_object as *mut _, res, &mut error);
950 let result = if error.is_null() {
951 Ok(())
952 } else {
953 Err(from_glib_full(error))
954 };
955 let callback: Box_<glib::thread_guard::ThreadGuard<P>> =
956 Box_::from_raw(user_data as *mut _);
957 let callback: P = callback.into_inner();
958 callback(result);
959 }
960 let callback = make_directory_async_trampoline::<P>;
961 unsafe {
962 ffi::g_file_make_directory_async(
963 self.as_ref().to_glib_none().0,
964 io_priority.into_glib(),
965 cancellable.map(|p| p.as_ref()).to_glib_none().0,
966 Some(callback),
967 Box_::into_raw(user_data) as *mut _,
968 );
969 }
970 }
971
972 fn make_directory_future(
973 &self,
974 io_priority: glib::Priority,
975 ) -> Pin<Box_<dyn std::future::Future<Output = Result<(), glib::Error>> + 'static>> {
976 Box_::pin(crate::GioFuture::new(
977 self,
978 move |obj, cancellable, send| {
979 obj.make_directory_async(io_priority, Some(cancellable), move |res| {
980 send.resolve(res);
981 });
982 },
983 ))
984 }
985
986 #[doc(alias = "g_file_make_directory_with_parents")]
987 fn make_directory_with_parents(
988 &self,
989 cancellable: Option<&impl IsA<Cancellable>>,
990 ) -> Result<(), glib::Error> {
991 unsafe {
992 let mut error = std::ptr::null_mut();
993 let is_ok = ffi::g_file_make_directory_with_parents(
994 self.as_ref().to_glib_none().0,
995 cancellable.map(|p| p.as_ref()).to_glib_none().0,
996 &mut error,
997 );
998 debug_assert_eq!(is_ok == glib::ffi::GFALSE, !error.is_null());
999 if error.is_null() {
1000 Ok(())
1001 } else {
1002 Err(from_glib_full(error))
1003 }
1004 }
1005 }
1006
1007 #[doc(alias = "g_file_make_symbolic_link")]
1008 fn make_symbolic_link(
1009 &self,
1010 symlink_value: impl AsRef<std::path::Path>,
1011 cancellable: Option<&impl IsA<Cancellable>>,
1012 ) -> Result<(), glib::Error> {
1013 unsafe {
1014 let mut error = std::ptr::null_mut();
1015 let is_ok = ffi::g_file_make_symbolic_link(
1016 self.as_ref().to_glib_none().0,
1017 symlink_value.as_ref().to_glib_none().0,
1018 cancellable.map(|p| p.as_ref()).to_glib_none().0,
1019 &mut error,
1020 );
1021 debug_assert_eq!(is_ok == glib::ffi::GFALSE, !error.is_null());
1022 if error.is_null() {
1023 Ok(())
1024 } else {
1025 Err(from_glib_full(error))
1026 }
1027 }
1028 }
1029
1030 #[doc(alias = "g_file_monitor")]
1031 fn monitor(
1032 &self,
1033 flags: FileMonitorFlags,
1034 cancellable: Option<&impl IsA<Cancellable>>,
1035 ) -> Result<FileMonitor, glib::Error> {
1036 unsafe {
1037 let mut error = std::ptr::null_mut();
1038 let ret = ffi::g_file_monitor(
1039 self.as_ref().to_glib_none().0,
1040 flags.into_glib(),
1041 cancellable.map(|p| p.as_ref()).to_glib_none().0,
1042 &mut error,
1043 );
1044 if error.is_null() {
1045 Ok(from_glib_full(ret))
1046 } else {
1047 Err(from_glib_full(error))
1048 }
1049 }
1050 }
1051
1052 #[doc(alias = "g_file_monitor_directory")]
1053 fn monitor_directory(
1054 &self,
1055 flags: FileMonitorFlags,
1056 cancellable: Option<&impl IsA<Cancellable>>,
1057 ) -> Result<FileMonitor, glib::Error> {
1058 unsafe {
1059 let mut error = std::ptr::null_mut();
1060 let ret = ffi::g_file_monitor_directory(
1061 self.as_ref().to_glib_none().0,
1062 flags.into_glib(),
1063 cancellable.map(|p| p.as_ref()).to_glib_none().0,
1064 &mut error,
1065 );
1066 if error.is_null() {
1067 Ok(from_glib_full(ret))
1068 } else {
1069 Err(from_glib_full(error))
1070 }
1071 }
1072 }
1073
1074 #[doc(alias = "g_file_monitor_file")]
1075 fn monitor_file(
1076 &self,
1077 flags: FileMonitorFlags,
1078 cancellable: Option<&impl IsA<Cancellable>>,
1079 ) -> Result<FileMonitor, glib::Error> {
1080 unsafe {
1081 let mut error = std::ptr::null_mut();
1082 let ret = ffi::g_file_monitor_file(
1083 self.as_ref().to_glib_none().0,
1084 flags.into_glib(),
1085 cancellable.map(|p| p.as_ref()).to_glib_none().0,
1086 &mut error,
1087 );
1088 if error.is_null() {
1089 Ok(from_glib_full(ret))
1090 } else {
1091 Err(from_glib_full(error))
1092 }
1093 }
1094 }
1095
1096 #[doc(alias = "g_file_mount_enclosing_volume")]
1097 fn mount_enclosing_volume<P: FnOnce(Result<(), glib::Error>) + 'static>(
1098 &self,
1099 flags: MountMountFlags,
1100 mount_operation: Option<&impl IsA<MountOperation>>,
1101 cancellable: Option<&impl IsA<Cancellable>>,
1102 callback: P,
1103 ) {
1104 let main_context = glib::MainContext::ref_thread_default();
1105 let is_main_context_owner = main_context.is_owner();
1106 let has_acquired_main_context = (!is_main_context_owner)
1107 .then(|| main_context.acquire().ok())
1108 .flatten();
1109 assert!(
1110 is_main_context_owner || has_acquired_main_context.is_some(),
1111 "Async operations only allowed if the thread is owning the MainContext"
1112 );
1113
1114 let user_data: Box_<glib::thread_guard::ThreadGuard<P>> =
1115 Box_::new(glib::thread_guard::ThreadGuard::new(callback));
1116 unsafe extern "C" fn mount_enclosing_volume_trampoline<
1117 P: FnOnce(Result<(), glib::Error>) + 'static,
1118 >(
1119 _source_object: *mut glib::gobject_ffi::GObject,
1120 res: *mut crate::ffi::GAsyncResult,
1121 user_data: glib::ffi::gpointer,
1122 ) {
1123 let mut error = std::ptr::null_mut();
1124 ffi::g_file_mount_enclosing_volume_finish(_source_object as *mut _, res, &mut error);
1125 let result = if error.is_null() {
1126 Ok(())
1127 } else {
1128 Err(from_glib_full(error))
1129 };
1130 let callback: Box_<glib::thread_guard::ThreadGuard<P>> =
1131 Box_::from_raw(user_data as *mut _);
1132 let callback: P = callback.into_inner();
1133 callback(result);
1134 }
1135 let callback = mount_enclosing_volume_trampoline::<P>;
1136 unsafe {
1137 ffi::g_file_mount_enclosing_volume(
1138 self.as_ref().to_glib_none().0,
1139 flags.into_glib(),
1140 mount_operation.map(|p| p.as_ref()).to_glib_none().0,
1141 cancellable.map(|p| p.as_ref()).to_glib_none().0,
1142 Some(callback),
1143 Box_::into_raw(user_data) as *mut _,
1144 );
1145 }
1146 }
1147
1148 fn mount_enclosing_volume_future(
1149 &self,
1150 flags: MountMountFlags,
1151 mount_operation: Option<&(impl IsA<MountOperation> + Clone + 'static)>,
1152 ) -> Pin<Box_<dyn std::future::Future<Output = Result<(), glib::Error>> + 'static>> {
1153 let mount_operation = mount_operation.map(ToOwned::to_owned);
1154 Box_::pin(crate::GioFuture::new(
1155 self,
1156 move |obj, cancellable, send| {
1157 obj.mount_enclosing_volume(
1158 flags,
1159 mount_operation.as_ref().map(::std::borrow::Borrow::borrow),
1160 Some(cancellable),
1161 move |res| {
1162 send.resolve(res);
1163 },
1164 );
1165 },
1166 ))
1167 }
1168
1169 #[doc(alias = "g_file_mount_mountable")]
1170 fn mount_mountable<P: FnOnce(Result<File, glib::Error>) + 'static>(
1171 &self,
1172 flags: MountMountFlags,
1173 mount_operation: Option<&impl IsA<MountOperation>>,
1174 cancellable: Option<&impl IsA<Cancellable>>,
1175 callback: P,
1176 ) {
1177 let main_context = glib::MainContext::ref_thread_default();
1178 let is_main_context_owner = main_context.is_owner();
1179 let has_acquired_main_context = (!is_main_context_owner)
1180 .then(|| main_context.acquire().ok())
1181 .flatten();
1182 assert!(
1183 is_main_context_owner || has_acquired_main_context.is_some(),
1184 "Async operations only allowed if the thread is owning the MainContext"
1185 );
1186
1187 let user_data: Box_<glib::thread_guard::ThreadGuard<P>> =
1188 Box_::new(glib::thread_guard::ThreadGuard::new(callback));
1189 unsafe extern "C" fn mount_mountable_trampoline<
1190 P: FnOnce(Result<File, glib::Error>) + 'static,
1191 >(
1192 _source_object: *mut glib::gobject_ffi::GObject,
1193 res: *mut crate::ffi::GAsyncResult,
1194 user_data: glib::ffi::gpointer,
1195 ) {
1196 let mut error = std::ptr::null_mut();
1197 let ret = ffi::g_file_mount_mountable_finish(_source_object as *mut _, res, &mut error);
1198 let result = if error.is_null() {
1199 Ok(from_glib_full(ret))
1200 } else {
1201 Err(from_glib_full(error))
1202 };
1203 let callback: Box_<glib::thread_guard::ThreadGuard<P>> =
1204 Box_::from_raw(user_data as *mut _);
1205 let callback: P = callback.into_inner();
1206 callback(result);
1207 }
1208 let callback = mount_mountable_trampoline::<P>;
1209 unsafe {
1210 ffi::g_file_mount_mountable(
1211 self.as_ref().to_glib_none().0,
1212 flags.into_glib(),
1213 mount_operation.map(|p| p.as_ref()).to_glib_none().0,
1214 cancellable.map(|p| p.as_ref()).to_glib_none().0,
1215 Some(callback),
1216 Box_::into_raw(user_data) as *mut _,
1217 );
1218 }
1219 }
1220
1221 fn mount_mountable_future(
1222 &self,
1223 flags: MountMountFlags,
1224 mount_operation: Option<&(impl IsA<MountOperation> + Clone + 'static)>,
1225 ) -> Pin<Box_<dyn std::future::Future<Output = Result<File, glib::Error>> + 'static>> {
1226 let mount_operation = mount_operation.map(ToOwned::to_owned);
1227 Box_::pin(crate::GioFuture::new(
1228 self,
1229 move |obj, cancellable, send| {
1230 obj.mount_mountable(
1231 flags,
1232 mount_operation.as_ref().map(::std::borrow::Borrow::borrow),
1233 Some(cancellable),
1234 move |res| {
1235 send.resolve(res);
1236 },
1237 );
1238 },
1239 ))
1240 }
1241
1242 #[doc(alias = "g_file_move")]
1243 #[doc(alias = "move")]
1244 fn move_(
1245 &self,
1246 destination: &impl IsA<File>,
1247 flags: FileCopyFlags,
1248 cancellable: Option<&impl IsA<Cancellable>>,
1249 progress_callback: Option<&mut dyn FnMut(i64, i64)>,
1250 ) -> Result<(), glib::Error> {
1251 let mut progress_callback_data: Option<&mut dyn FnMut(i64, i64)> = progress_callback;
1252 unsafe extern "C" fn progress_callback_func(
1253 current_num_bytes: i64,
1254 total_num_bytes: i64,
1255 data: glib::ffi::gpointer,
1256 ) {
1257 let callback = data as *mut Option<&mut dyn FnMut(i64, i64)>;
1258 if let Some(ref mut callback) = *callback {
1259 callback(current_num_bytes, total_num_bytes)
1260 } else {
1261 panic!("cannot get closure...")
1262 }
1263 }
1264 let progress_callback = if progress_callback_data.is_some() {
1265 Some(progress_callback_func as _)
1266 } else {
1267 None
1268 };
1269 let super_callback0: &mut Option<&mut dyn FnMut(i64, i64)> = &mut progress_callback_data;
1270 unsafe {
1271 let mut error = std::ptr::null_mut();
1272 let is_ok = ffi::g_file_move(
1273 self.as_ref().to_glib_none().0,
1274 destination.as_ref().to_glib_none().0,
1275 flags.into_glib(),
1276 cancellable.map(|p| p.as_ref()).to_glib_none().0,
1277 progress_callback,
1278 super_callback0 as *mut _ as *mut _,
1279 &mut error,
1280 );
1281 debug_assert_eq!(is_ok == glib::ffi::GFALSE, !error.is_null());
1282 if error.is_null() {
1283 Ok(())
1284 } else {
1285 Err(from_glib_full(error))
1286 }
1287 }
1288 }
1289
1290 #[doc(alias = "g_file_open_readwrite")]
1291 fn open_readwrite(
1292 &self,
1293 cancellable: Option<&impl IsA<Cancellable>>,
1294 ) -> Result<FileIOStream, glib::Error> {
1295 unsafe {
1296 let mut error = std::ptr::null_mut();
1297 let ret = ffi::g_file_open_readwrite(
1298 self.as_ref().to_glib_none().0,
1299 cancellable.map(|p| p.as_ref()).to_glib_none().0,
1300 &mut error,
1301 );
1302 if error.is_null() {
1303 Ok(from_glib_full(ret))
1304 } else {
1305 Err(from_glib_full(error))
1306 }
1307 }
1308 }
1309
1310 #[doc(alias = "g_file_open_readwrite_async")]
1311 fn open_readwrite_async<P: FnOnce(Result<FileIOStream, glib::Error>) + 'static>(
1312 &self,
1313 io_priority: glib::Priority,
1314 cancellable: Option<&impl IsA<Cancellable>>,
1315 callback: P,
1316 ) {
1317 let main_context = glib::MainContext::ref_thread_default();
1318 let is_main_context_owner = main_context.is_owner();
1319 let has_acquired_main_context = (!is_main_context_owner)
1320 .then(|| main_context.acquire().ok())
1321 .flatten();
1322 assert!(
1323 is_main_context_owner || has_acquired_main_context.is_some(),
1324 "Async operations only allowed if the thread is owning the MainContext"
1325 );
1326
1327 let user_data: Box_<glib::thread_guard::ThreadGuard<P>> =
1328 Box_::new(glib::thread_guard::ThreadGuard::new(callback));
1329 unsafe extern "C" fn open_readwrite_async_trampoline<
1330 P: FnOnce(Result<FileIOStream, glib::Error>) + 'static,
1331 >(
1332 _source_object: *mut glib::gobject_ffi::GObject,
1333 res: *mut crate::ffi::GAsyncResult,
1334 user_data: glib::ffi::gpointer,
1335 ) {
1336 let mut error = std::ptr::null_mut();
1337 let ret = ffi::g_file_open_readwrite_finish(_source_object as *mut _, res, &mut error);
1338 let result = if error.is_null() {
1339 Ok(from_glib_full(ret))
1340 } else {
1341 Err(from_glib_full(error))
1342 };
1343 let callback: Box_<glib::thread_guard::ThreadGuard<P>> =
1344 Box_::from_raw(user_data as *mut _);
1345 let callback: P = callback.into_inner();
1346 callback(result);
1347 }
1348 let callback = open_readwrite_async_trampoline::<P>;
1349 unsafe {
1350 ffi::g_file_open_readwrite_async(
1351 self.as_ref().to_glib_none().0,
1352 io_priority.into_glib(),
1353 cancellable.map(|p| p.as_ref()).to_glib_none().0,
1354 Some(callback),
1355 Box_::into_raw(user_data) as *mut _,
1356 );
1357 }
1358 }
1359
1360 fn open_readwrite_future(
1361 &self,
1362 io_priority: glib::Priority,
1363 ) -> Pin<Box_<dyn std::future::Future<Output = Result<FileIOStream, glib::Error>> + 'static>>
1364 {
1365 Box_::pin(crate::GioFuture::new(
1366 self,
1367 move |obj, cancellable, send| {
1368 obj.open_readwrite_async(io_priority, Some(cancellable), move |res| {
1369 send.resolve(res);
1370 });
1371 },
1372 ))
1373 }
1374
1375 #[doc(alias = "g_file_peek_path")]
1376 fn peek_path(&self) -> Option<std::path::PathBuf> {
1377 unsafe { from_glib_none(ffi::g_file_peek_path(self.as_ref().to_glib_none().0)) }
1378 }
1379
1380 #[doc(alias = "g_file_poll_mountable")]
1381 fn poll_mountable<P: FnOnce(Result<(), glib::Error>) + 'static>(
1382 &self,
1383 cancellable: Option<&impl IsA<Cancellable>>,
1384 callback: P,
1385 ) {
1386 let main_context = glib::MainContext::ref_thread_default();
1387 let is_main_context_owner = main_context.is_owner();
1388 let has_acquired_main_context = (!is_main_context_owner)
1389 .then(|| main_context.acquire().ok())
1390 .flatten();
1391 assert!(
1392 is_main_context_owner || has_acquired_main_context.is_some(),
1393 "Async operations only allowed if the thread is owning the MainContext"
1394 );
1395
1396 let user_data: Box_<glib::thread_guard::ThreadGuard<P>> =
1397 Box_::new(glib::thread_guard::ThreadGuard::new(callback));
1398 unsafe extern "C" fn poll_mountable_trampoline<
1399 P: FnOnce(Result<(), glib::Error>) + 'static,
1400 >(
1401 _source_object: *mut glib::gobject_ffi::GObject,
1402 res: *mut crate::ffi::GAsyncResult,
1403 user_data: glib::ffi::gpointer,
1404 ) {
1405 let mut error = std::ptr::null_mut();
1406 ffi::g_file_poll_mountable_finish(_source_object as *mut _, res, &mut error);
1407 let result = if error.is_null() {
1408 Ok(())
1409 } else {
1410 Err(from_glib_full(error))
1411 };
1412 let callback: Box_<glib::thread_guard::ThreadGuard<P>> =
1413 Box_::from_raw(user_data as *mut _);
1414 let callback: P = callback.into_inner();
1415 callback(result);
1416 }
1417 let callback = poll_mountable_trampoline::<P>;
1418 unsafe {
1419 ffi::g_file_poll_mountable(
1420 self.as_ref().to_glib_none().0,
1421 cancellable.map(|p| p.as_ref()).to_glib_none().0,
1422 Some(callback),
1423 Box_::into_raw(user_data) as *mut _,
1424 );
1425 }
1426 }
1427
1428 fn poll_mountable_future(
1429 &self,
1430 ) -> Pin<Box_<dyn std::future::Future<Output = Result<(), glib::Error>> + 'static>> {
1431 Box_::pin(crate::GioFuture::new(
1432 self,
1433 move |obj, cancellable, send| {
1434 obj.poll_mountable(Some(cancellable), move |res| {
1435 send.resolve(res);
1436 });
1437 },
1438 ))
1439 }
1440
1441 #[doc(alias = "g_file_query_default_handler")]
1442 fn query_default_handler(
1443 &self,
1444 cancellable: Option<&impl IsA<Cancellable>>,
1445 ) -> Result<AppInfo, glib::Error> {
1446 unsafe {
1447 let mut error = std::ptr::null_mut();
1448 let ret = ffi::g_file_query_default_handler(
1449 self.as_ref().to_glib_none().0,
1450 cancellable.map(|p| p.as_ref()).to_glib_none().0,
1451 &mut error,
1452 );
1453 if error.is_null() {
1454 Ok(from_glib_full(ret))
1455 } else {
1456 Err(from_glib_full(error))
1457 }
1458 }
1459 }
1460
1461 #[cfg(feature = "v2_60")]
1462 #[cfg_attr(docsrs, doc(cfg(feature = "v2_60")))]
1463 #[doc(alias = "g_file_query_default_handler_async")]
1464 fn query_default_handler_async<P: FnOnce(Result<AppInfo, glib::Error>) + 'static>(
1465 &self,
1466 io_priority: glib::Priority,
1467 cancellable: Option<&impl IsA<Cancellable>>,
1468 callback: P,
1469 ) {
1470 let main_context = glib::MainContext::ref_thread_default();
1471 let is_main_context_owner = main_context.is_owner();
1472 let has_acquired_main_context = (!is_main_context_owner)
1473 .then(|| main_context.acquire().ok())
1474 .flatten();
1475 assert!(
1476 is_main_context_owner || has_acquired_main_context.is_some(),
1477 "Async operations only allowed if the thread is owning the MainContext"
1478 );
1479
1480 let user_data: Box_<glib::thread_guard::ThreadGuard<P>> =
1481 Box_::new(glib::thread_guard::ThreadGuard::new(callback));
1482 unsafe extern "C" fn query_default_handler_async_trampoline<
1483 P: FnOnce(Result<AppInfo, glib::Error>) + 'static,
1484 >(
1485 _source_object: *mut glib::gobject_ffi::GObject,
1486 res: *mut crate::ffi::GAsyncResult,
1487 user_data: glib::ffi::gpointer,
1488 ) {
1489 let mut error = std::ptr::null_mut();
1490 let ret =
1491 ffi::g_file_query_default_handler_finish(_source_object as *mut _, res, &mut error);
1492 let result = if error.is_null() {
1493 Ok(from_glib_full(ret))
1494 } else {
1495 Err(from_glib_full(error))
1496 };
1497 let callback: Box_<glib::thread_guard::ThreadGuard<P>> =
1498 Box_::from_raw(user_data as *mut _);
1499 let callback: P = callback.into_inner();
1500 callback(result);
1501 }
1502 let callback = query_default_handler_async_trampoline::<P>;
1503 unsafe {
1504 ffi::g_file_query_default_handler_async(
1505 self.as_ref().to_glib_none().0,
1506 io_priority.into_glib(),
1507 cancellable.map(|p| p.as_ref()).to_glib_none().0,
1508 Some(callback),
1509 Box_::into_raw(user_data) as *mut _,
1510 );
1511 }
1512 }
1513
1514 #[cfg(feature = "v2_60")]
1515 #[cfg_attr(docsrs, doc(cfg(feature = "v2_60")))]
1516 fn query_default_handler_future(
1517 &self,
1518 io_priority: glib::Priority,
1519 ) -> Pin<Box_<dyn std::future::Future<Output = Result<AppInfo, glib::Error>> + 'static>> {
1520 Box_::pin(crate::GioFuture::new(
1521 self,
1522 move |obj, cancellable, send| {
1523 obj.query_default_handler_async(io_priority, Some(cancellable), move |res| {
1524 send.resolve(res);
1525 });
1526 },
1527 ))
1528 }
1529
1530 #[doc(alias = "g_file_query_exists")]
1531 fn query_exists(&self, cancellable: Option<&impl IsA<Cancellable>>) -> bool {
1532 unsafe {
1533 from_glib(ffi::g_file_query_exists(
1534 self.as_ref().to_glib_none().0,
1535 cancellable.map(|p| p.as_ref()).to_glib_none().0,
1536 ))
1537 }
1538 }
1539
1540 #[doc(alias = "g_file_query_file_type")]
1541 fn query_file_type(
1542 &self,
1543 flags: FileQueryInfoFlags,
1544 cancellable: Option<&impl IsA<Cancellable>>,
1545 ) -> FileType {
1546 unsafe {
1547 from_glib(ffi::g_file_query_file_type(
1548 self.as_ref().to_glib_none().0,
1549 flags.into_glib(),
1550 cancellable.map(|p| p.as_ref()).to_glib_none().0,
1551 ))
1552 }
1553 }
1554
1555 #[doc(alias = "g_file_query_filesystem_info")]
1556 fn query_filesystem_info(
1557 &self,
1558 attributes: &str,
1559 cancellable: Option<&impl IsA<Cancellable>>,
1560 ) -> Result<FileInfo, glib::Error> {
1561 unsafe {
1562 let mut error = std::ptr::null_mut();
1563 let ret = ffi::g_file_query_filesystem_info(
1564 self.as_ref().to_glib_none().0,
1565 attributes.to_glib_none().0,
1566 cancellable.map(|p| p.as_ref()).to_glib_none().0,
1567 &mut error,
1568 );
1569 if error.is_null() {
1570 Ok(from_glib_full(ret))
1571 } else {
1572 Err(from_glib_full(error))
1573 }
1574 }
1575 }
1576
1577 #[doc(alias = "g_file_query_filesystem_info_async")]
1578 fn query_filesystem_info_async<P: FnOnce(Result<FileInfo, glib::Error>) + 'static>(
1579 &self,
1580 attributes: &str,
1581 io_priority: glib::Priority,
1582 cancellable: Option<&impl IsA<Cancellable>>,
1583 callback: P,
1584 ) {
1585 let main_context = glib::MainContext::ref_thread_default();
1586 let is_main_context_owner = main_context.is_owner();
1587 let has_acquired_main_context = (!is_main_context_owner)
1588 .then(|| main_context.acquire().ok())
1589 .flatten();
1590 assert!(
1591 is_main_context_owner || has_acquired_main_context.is_some(),
1592 "Async operations only allowed if the thread is owning the MainContext"
1593 );
1594
1595 let user_data: Box_<glib::thread_guard::ThreadGuard<P>> =
1596 Box_::new(glib::thread_guard::ThreadGuard::new(callback));
1597 unsafe extern "C" fn query_filesystem_info_async_trampoline<
1598 P: FnOnce(Result<FileInfo, glib::Error>) + 'static,
1599 >(
1600 _source_object: *mut glib::gobject_ffi::GObject,
1601 res: *mut crate::ffi::GAsyncResult,
1602 user_data: glib::ffi::gpointer,
1603 ) {
1604 let mut error = std::ptr::null_mut();
1605 let ret =
1606 ffi::g_file_query_filesystem_info_finish(_source_object as *mut _, res, &mut error);
1607 let result = if error.is_null() {
1608 Ok(from_glib_full(ret))
1609 } else {
1610 Err(from_glib_full(error))
1611 };
1612 let callback: Box_<glib::thread_guard::ThreadGuard<P>> =
1613 Box_::from_raw(user_data as *mut _);
1614 let callback: P = callback.into_inner();
1615 callback(result);
1616 }
1617 let callback = query_filesystem_info_async_trampoline::<P>;
1618 unsafe {
1619 ffi::g_file_query_filesystem_info_async(
1620 self.as_ref().to_glib_none().0,
1621 attributes.to_glib_none().0,
1622 io_priority.into_glib(),
1623 cancellable.map(|p| p.as_ref()).to_glib_none().0,
1624 Some(callback),
1625 Box_::into_raw(user_data) as *mut _,
1626 );
1627 }
1628 }
1629
1630 fn query_filesystem_info_future(
1631 &self,
1632 attributes: &str,
1633 io_priority: glib::Priority,
1634 ) -> Pin<Box_<dyn std::future::Future<Output = Result<FileInfo, glib::Error>> + 'static>> {
1635 let attributes = String::from(attributes);
1636 Box_::pin(crate::GioFuture::new(
1637 self,
1638 move |obj, cancellable, send| {
1639 obj.query_filesystem_info_async(
1640 &attributes,
1641 io_priority,
1642 Some(cancellable),
1643 move |res| {
1644 send.resolve(res);
1645 },
1646 );
1647 },
1648 ))
1649 }
1650
1651 #[doc(alias = "g_file_query_info")]
1652 fn query_info(
1653 &self,
1654 attributes: &str,
1655 flags: FileQueryInfoFlags,
1656 cancellable: Option<&impl IsA<Cancellable>>,
1657 ) -> Result<FileInfo, glib::Error> {
1658 unsafe {
1659 let mut error = std::ptr::null_mut();
1660 let ret = ffi::g_file_query_info(
1661 self.as_ref().to_glib_none().0,
1662 attributes.to_glib_none().0,
1663 flags.into_glib(),
1664 cancellable.map(|p| p.as_ref()).to_glib_none().0,
1665 &mut error,
1666 );
1667 if error.is_null() {
1668 Ok(from_glib_full(ret))
1669 } else {
1670 Err(from_glib_full(error))
1671 }
1672 }
1673 }
1674
1675 #[doc(alias = "g_file_query_info_async")]
1676 fn query_info_async<P: FnOnce(Result<FileInfo, glib::Error>) + 'static>(
1677 &self,
1678 attributes: &str,
1679 flags: FileQueryInfoFlags,
1680 io_priority: glib::Priority,
1681 cancellable: Option<&impl IsA<Cancellable>>,
1682 callback: P,
1683 ) {
1684 let main_context = glib::MainContext::ref_thread_default();
1685 let is_main_context_owner = main_context.is_owner();
1686 let has_acquired_main_context = (!is_main_context_owner)
1687 .then(|| main_context.acquire().ok())
1688 .flatten();
1689 assert!(
1690 is_main_context_owner || has_acquired_main_context.is_some(),
1691 "Async operations only allowed if the thread is owning the MainContext"
1692 );
1693
1694 let user_data: Box_<glib::thread_guard::ThreadGuard<P>> =
1695 Box_::new(glib::thread_guard::ThreadGuard::new(callback));
1696 unsafe extern "C" fn query_info_async_trampoline<
1697 P: FnOnce(Result<FileInfo, glib::Error>) + 'static,
1698 >(
1699 _source_object: *mut glib::gobject_ffi::GObject,
1700 res: *mut crate::ffi::GAsyncResult,
1701 user_data: glib::ffi::gpointer,
1702 ) {
1703 let mut error = std::ptr::null_mut();
1704 let ret = ffi::g_file_query_info_finish(_source_object as *mut _, res, &mut error);
1705 let result = if error.is_null() {
1706 Ok(from_glib_full(ret))
1707 } else {
1708 Err(from_glib_full(error))
1709 };
1710 let callback: Box_<glib::thread_guard::ThreadGuard<P>> =
1711 Box_::from_raw(user_data as *mut _);
1712 let callback: P = callback.into_inner();
1713 callback(result);
1714 }
1715 let callback = query_info_async_trampoline::<P>;
1716 unsafe {
1717 ffi::g_file_query_info_async(
1718 self.as_ref().to_glib_none().0,
1719 attributes.to_glib_none().0,
1720 flags.into_glib(),
1721 io_priority.into_glib(),
1722 cancellable.map(|p| p.as_ref()).to_glib_none().0,
1723 Some(callback),
1724 Box_::into_raw(user_data) as *mut _,
1725 );
1726 }
1727 }
1728
1729 fn query_info_future(
1730 &self,
1731 attributes: &str,
1732 flags: FileQueryInfoFlags,
1733 io_priority: glib::Priority,
1734 ) -> Pin<Box_<dyn std::future::Future<Output = Result<FileInfo, glib::Error>> + 'static>> {
1735 let attributes = String::from(attributes);
1736 Box_::pin(crate::GioFuture::new(
1737 self,
1738 move |obj, cancellable, send| {
1739 obj.query_info_async(
1740 &attributes,
1741 flags,
1742 io_priority,
1743 Some(cancellable),
1744 move |res| {
1745 send.resolve(res);
1746 },
1747 );
1748 },
1749 ))
1750 }
1751
1752 #[doc(alias = "g_file_query_settable_attributes")]
1753 fn query_settable_attributes(
1754 &self,
1755 cancellable: Option<&impl IsA<Cancellable>>,
1756 ) -> Result<FileAttributeInfoList, glib::Error> {
1757 unsafe {
1758 let mut error = std::ptr::null_mut();
1759 let ret = ffi::g_file_query_settable_attributes(
1760 self.as_ref().to_glib_none().0,
1761 cancellable.map(|p| p.as_ref()).to_glib_none().0,
1762 &mut error,
1763 );
1764 if error.is_null() {
1765 Ok(from_glib_full(ret))
1766 } else {
1767 Err(from_glib_full(error))
1768 }
1769 }
1770 }
1771
1772 #[doc(alias = "g_file_query_writable_namespaces")]
1773 fn query_writable_namespaces(
1774 &self,
1775 cancellable: Option<&impl IsA<Cancellable>>,
1776 ) -> Result<FileAttributeInfoList, glib::Error> {
1777 unsafe {
1778 let mut error = std::ptr::null_mut();
1779 let ret = ffi::g_file_query_writable_namespaces(
1780 self.as_ref().to_glib_none().0,
1781 cancellable.map(|p| p.as_ref()).to_glib_none().0,
1782 &mut error,
1783 );
1784 if error.is_null() {
1785 Ok(from_glib_full(ret))
1786 } else {
1787 Err(from_glib_full(error))
1788 }
1789 }
1790 }
1791
1792 #[doc(alias = "g_file_read")]
1793 fn read(
1794 &self,
1795 cancellable: Option<&impl IsA<Cancellable>>,
1796 ) -> Result<FileInputStream, glib::Error> {
1797 unsafe {
1798 let mut error = std::ptr::null_mut();
1799 let ret = ffi::g_file_read(
1800 self.as_ref().to_glib_none().0,
1801 cancellable.map(|p| p.as_ref()).to_glib_none().0,
1802 &mut error,
1803 );
1804 if error.is_null() {
1805 Ok(from_glib_full(ret))
1806 } else {
1807 Err(from_glib_full(error))
1808 }
1809 }
1810 }
1811
1812 #[doc(alias = "g_file_read_async")]
1813 fn read_async<P: FnOnce(Result<FileInputStream, glib::Error>) + 'static>(
1814 &self,
1815 io_priority: glib::Priority,
1816 cancellable: Option<&impl IsA<Cancellable>>,
1817 callback: P,
1818 ) {
1819 let main_context = glib::MainContext::ref_thread_default();
1820 let is_main_context_owner = main_context.is_owner();
1821 let has_acquired_main_context = (!is_main_context_owner)
1822 .then(|| main_context.acquire().ok())
1823 .flatten();
1824 assert!(
1825 is_main_context_owner || has_acquired_main_context.is_some(),
1826 "Async operations only allowed if the thread is owning the MainContext"
1827 );
1828
1829 let user_data: Box_<glib::thread_guard::ThreadGuard<P>> =
1830 Box_::new(glib::thread_guard::ThreadGuard::new(callback));
1831 unsafe extern "C" fn read_async_trampoline<
1832 P: FnOnce(Result<FileInputStream, glib::Error>) + 'static,
1833 >(
1834 _source_object: *mut glib::gobject_ffi::GObject,
1835 res: *mut crate::ffi::GAsyncResult,
1836 user_data: glib::ffi::gpointer,
1837 ) {
1838 let mut error = std::ptr::null_mut();
1839 let ret = ffi::g_file_read_finish(_source_object as *mut _, res, &mut error);
1840 let result = if error.is_null() {
1841 Ok(from_glib_full(ret))
1842 } else {
1843 Err(from_glib_full(error))
1844 };
1845 let callback: Box_<glib::thread_guard::ThreadGuard<P>> =
1846 Box_::from_raw(user_data as *mut _);
1847 let callback: P = callback.into_inner();
1848 callback(result);
1849 }
1850 let callback = read_async_trampoline::<P>;
1851 unsafe {
1852 ffi::g_file_read_async(
1853 self.as_ref().to_glib_none().0,
1854 io_priority.into_glib(),
1855 cancellable.map(|p| p.as_ref()).to_glib_none().0,
1856 Some(callback),
1857 Box_::into_raw(user_data) as *mut _,
1858 );
1859 }
1860 }
1861
1862 fn read_future(
1863 &self,
1864 io_priority: glib::Priority,
1865 ) -> Pin<Box_<dyn std::future::Future<Output = Result<FileInputStream, glib::Error>> + 'static>>
1866 {
1867 Box_::pin(crate::GioFuture::new(
1868 self,
1869 move |obj, cancellable, send| {
1870 obj.read_async(io_priority, Some(cancellable), move |res| {
1871 send.resolve(res);
1872 });
1873 },
1874 ))
1875 }
1876
1877 #[doc(alias = "g_file_replace")]
1878 fn replace(
1879 &self,
1880 etag: Option<&str>,
1881 make_backup: bool,
1882 flags: FileCreateFlags,
1883 cancellable: Option<&impl IsA<Cancellable>>,
1884 ) -> Result<FileOutputStream, glib::Error> {
1885 unsafe {
1886 let mut error = std::ptr::null_mut();
1887 let ret = ffi::g_file_replace(
1888 self.as_ref().to_glib_none().0,
1889 etag.to_glib_none().0,
1890 make_backup.into_glib(),
1891 flags.into_glib(),
1892 cancellable.map(|p| p.as_ref()).to_glib_none().0,
1893 &mut error,
1894 );
1895 if error.is_null() {
1896 Ok(from_glib_full(ret))
1897 } else {
1898 Err(from_glib_full(error))
1899 }
1900 }
1901 }
1902
1903 #[doc(alias = "g_file_replace_async")]
1904 fn replace_async<P: FnOnce(Result<FileOutputStream, glib::Error>) + 'static>(
1905 &self,
1906 etag: Option<&str>,
1907 make_backup: bool,
1908 flags: FileCreateFlags,
1909 io_priority: glib::Priority,
1910 cancellable: Option<&impl IsA<Cancellable>>,
1911 callback: P,
1912 ) {
1913 let main_context = glib::MainContext::ref_thread_default();
1914 let is_main_context_owner = main_context.is_owner();
1915 let has_acquired_main_context = (!is_main_context_owner)
1916 .then(|| main_context.acquire().ok())
1917 .flatten();
1918 assert!(
1919 is_main_context_owner || has_acquired_main_context.is_some(),
1920 "Async operations only allowed if the thread is owning the MainContext"
1921 );
1922
1923 let user_data: Box_<glib::thread_guard::ThreadGuard<P>> =
1924 Box_::new(glib::thread_guard::ThreadGuard::new(callback));
1925 unsafe extern "C" fn replace_async_trampoline<
1926 P: FnOnce(Result<FileOutputStream, glib::Error>) + 'static,
1927 >(
1928 _source_object: *mut glib::gobject_ffi::GObject,
1929 res: *mut crate::ffi::GAsyncResult,
1930 user_data: glib::ffi::gpointer,
1931 ) {
1932 let mut error = std::ptr::null_mut();
1933 let ret = ffi::g_file_replace_finish(_source_object as *mut _, res, &mut error);
1934 let result = if error.is_null() {
1935 Ok(from_glib_full(ret))
1936 } else {
1937 Err(from_glib_full(error))
1938 };
1939 let callback: Box_<glib::thread_guard::ThreadGuard<P>> =
1940 Box_::from_raw(user_data as *mut _);
1941 let callback: P = callback.into_inner();
1942 callback(result);
1943 }
1944 let callback = replace_async_trampoline::<P>;
1945 unsafe {
1946 ffi::g_file_replace_async(
1947 self.as_ref().to_glib_none().0,
1948 etag.to_glib_none().0,
1949 make_backup.into_glib(),
1950 flags.into_glib(),
1951 io_priority.into_glib(),
1952 cancellable.map(|p| p.as_ref()).to_glib_none().0,
1953 Some(callback),
1954 Box_::into_raw(user_data) as *mut _,
1955 );
1956 }
1957 }
1958
1959 fn replace_future(
1960 &self,
1961 etag: Option<&str>,
1962 make_backup: bool,
1963 flags: FileCreateFlags,
1964 io_priority: glib::Priority,
1965 ) -> Pin<Box_<dyn std::future::Future<Output = Result<FileOutputStream, glib::Error>> + 'static>>
1966 {
1967 let etag = etag.map(ToOwned::to_owned);
1968 Box_::pin(crate::GioFuture::new(
1969 self,
1970 move |obj, cancellable, send| {
1971 obj.replace_async(
1972 etag.as_ref().map(::std::borrow::Borrow::borrow),
1973 make_backup,
1974 flags,
1975 io_priority,
1976 Some(cancellable),
1977 move |res| {
1978 send.resolve(res);
1979 },
1980 );
1981 },
1982 ))
1983 }
1984
1985 #[doc(alias = "g_file_replace_contents")]
1986 fn replace_contents(
1987 &self,
1988 contents: &[u8],
1989 etag: Option<&str>,
1990 make_backup: bool,
1991 flags: FileCreateFlags,
1992 cancellable: Option<&impl IsA<Cancellable>>,
1993 ) -> Result<Option<glib::GString>, glib::Error> {
1994 let length = contents.len() as _;
1995 unsafe {
1996 let mut new_etag = std::ptr::null_mut();
1997 let mut error = std::ptr::null_mut();
1998 let is_ok = ffi::g_file_replace_contents(
1999 self.as_ref().to_glib_none().0,
2000 contents.to_glib_none().0,
2001 length,
2002 etag.to_glib_none().0,
2003 make_backup.into_glib(),
2004 flags.into_glib(),
2005 &mut new_etag,
2006 cancellable.map(|p| p.as_ref()).to_glib_none().0,
2007 &mut error,
2008 );
2009 debug_assert_eq!(is_ok == glib::ffi::GFALSE, !error.is_null());
2010 if error.is_null() {
2011 Ok(from_glib_full(new_etag))
2012 } else {
2013 Err(from_glib_full(error))
2014 }
2015 }
2016 }
2017
2018 #[doc(alias = "g_file_replace_readwrite")]
2024 fn replace_readwrite(
2025 &self,
2026 etag: Option<&str>,
2027 make_backup: bool,
2028 flags: FileCreateFlags,
2029 cancellable: Option<&impl IsA<Cancellable>>,
2030 ) -> Result<FileIOStream, glib::Error> {
2031 unsafe {
2032 let mut error = std::ptr::null_mut();
2033 let ret = ffi::g_file_replace_readwrite(
2034 self.as_ref().to_glib_none().0,
2035 etag.to_glib_none().0,
2036 make_backup.into_glib(),
2037 flags.into_glib(),
2038 cancellable.map(|p| p.as_ref()).to_glib_none().0,
2039 &mut error,
2040 );
2041 if error.is_null() {
2042 Ok(from_glib_full(ret))
2043 } else {
2044 Err(from_glib_full(error))
2045 }
2046 }
2047 }
2048
2049 #[doc(alias = "g_file_replace_readwrite_async")]
2050 fn replace_readwrite_async<P: FnOnce(Result<FileIOStream, glib::Error>) + 'static>(
2051 &self,
2052 etag: Option<&str>,
2053 make_backup: bool,
2054 flags: FileCreateFlags,
2055 io_priority: glib::Priority,
2056 cancellable: Option<&impl IsA<Cancellable>>,
2057 callback: P,
2058 ) {
2059 let main_context = glib::MainContext::ref_thread_default();
2060 let is_main_context_owner = main_context.is_owner();
2061 let has_acquired_main_context = (!is_main_context_owner)
2062 .then(|| main_context.acquire().ok())
2063 .flatten();
2064 assert!(
2065 is_main_context_owner || has_acquired_main_context.is_some(),
2066 "Async operations only allowed if the thread is owning the MainContext"
2067 );
2068
2069 let user_data: Box_<glib::thread_guard::ThreadGuard<P>> =
2070 Box_::new(glib::thread_guard::ThreadGuard::new(callback));
2071 unsafe extern "C" fn replace_readwrite_async_trampoline<
2072 P: FnOnce(Result<FileIOStream, glib::Error>) + 'static,
2073 >(
2074 _source_object: *mut glib::gobject_ffi::GObject,
2075 res: *mut crate::ffi::GAsyncResult,
2076 user_data: glib::ffi::gpointer,
2077 ) {
2078 let mut error = std::ptr::null_mut();
2079 let ret =
2080 ffi::g_file_replace_readwrite_finish(_source_object as *mut _, res, &mut error);
2081 let result = if error.is_null() {
2082 Ok(from_glib_full(ret))
2083 } else {
2084 Err(from_glib_full(error))
2085 };
2086 let callback: Box_<glib::thread_guard::ThreadGuard<P>> =
2087 Box_::from_raw(user_data as *mut _);
2088 let callback: P = callback.into_inner();
2089 callback(result);
2090 }
2091 let callback = replace_readwrite_async_trampoline::<P>;
2092 unsafe {
2093 ffi::g_file_replace_readwrite_async(
2094 self.as_ref().to_glib_none().0,
2095 etag.to_glib_none().0,
2096 make_backup.into_glib(),
2097 flags.into_glib(),
2098 io_priority.into_glib(),
2099 cancellable.map(|p| p.as_ref()).to_glib_none().0,
2100 Some(callback),
2101 Box_::into_raw(user_data) as *mut _,
2102 );
2103 }
2104 }
2105
2106 fn replace_readwrite_future(
2107 &self,
2108 etag: Option<&str>,
2109 make_backup: bool,
2110 flags: FileCreateFlags,
2111 io_priority: glib::Priority,
2112 ) -> Pin<Box_<dyn std::future::Future<Output = Result<FileIOStream, glib::Error>> + 'static>>
2113 {
2114 let etag = etag.map(ToOwned::to_owned);
2115 Box_::pin(crate::GioFuture::new(
2116 self,
2117 move |obj, cancellable, send| {
2118 obj.replace_readwrite_async(
2119 etag.as_ref().map(::std::borrow::Borrow::borrow),
2120 make_backup,
2121 flags,
2122 io_priority,
2123 Some(cancellable),
2124 move |res| {
2125 send.resolve(res);
2126 },
2127 );
2128 },
2129 ))
2130 }
2131
2132 #[doc(alias = "g_file_resolve_relative_path")]
2133 #[must_use]
2134 fn resolve_relative_path(&self, relative_path: impl AsRef<std::path::Path>) -> File {
2135 unsafe {
2136 from_glib_full(ffi::g_file_resolve_relative_path(
2137 self.as_ref().to_glib_none().0,
2138 relative_path.as_ref().to_glib_none().0,
2139 ))
2140 }
2141 }
2142
2143 #[doc(alias = "g_file_set_attribute_byte_string")]
2149 fn set_attribute_byte_string(
2150 &self,
2151 attribute: &str,
2152 value: &str,
2153 flags: FileQueryInfoFlags,
2154 cancellable: Option<&impl IsA<Cancellable>>,
2155 ) -> Result<(), glib::Error> {
2156 unsafe {
2157 let mut error = std::ptr::null_mut();
2158 let is_ok = ffi::g_file_set_attribute_byte_string(
2159 self.as_ref().to_glib_none().0,
2160 attribute.to_glib_none().0,
2161 value.to_glib_none().0,
2162 flags.into_glib(),
2163 cancellable.map(|p| p.as_ref()).to_glib_none().0,
2164 &mut error,
2165 );
2166 debug_assert_eq!(is_ok == glib::ffi::GFALSE, !error.is_null());
2167 if error.is_null() {
2168 Ok(())
2169 } else {
2170 Err(from_glib_full(error))
2171 }
2172 }
2173 }
2174
2175 #[doc(alias = "g_file_set_attribute_int32")]
2176 fn set_attribute_int32(
2177 &self,
2178 attribute: &str,
2179 value: i32,
2180 flags: FileQueryInfoFlags,
2181 cancellable: Option<&impl IsA<Cancellable>>,
2182 ) -> Result<(), glib::Error> {
2183 unsafe {
2184 let mut error = std::ptr::null_mut();
2185 let is_ok = ffi::g_file_set_attribute_int32(
2186 self.as_ref().to_glib_none().0,
2187 attribute.to_glib_none().0,
2188 value,
2189 flags.into_glib(),
2190 cancellable.map(|p| p.as_ref()).to_glib_none().0,
2191 &mut error,
2192 );
2193 debug_assert_eq!(is_ok == glib::ffi::GFALSE, !error.is_null());
2194 if error.is_null() {
2195 Ok(())
2196 } else {
2197 Err(from_glib_full(error))
2198 }
2199 }
2200 }
2201
2202 #[doc(alias = "g_file_set_attribute_int64")]
2203 fn set_attribute_int64(
2204 &self,
2205 attribute: &str,
2206 value: i64,
2207 flags: FileQueryInfoFlags,
2208 cancellable: Option<&impl IsA<Cancellable>>,
2209 ) -> Result<(), glib::Error> {
2210 unsafe {
2211 let mut error = std::ptr::null_mut();
2212 let is_ok = ffi::g_file_set_attribute_int64(
2213 self.as_ref().to_glib_none().0,
2214 attribute.to_glib_none().0,
2215 value,
2216 flags.into_glib(),
2217 cancellable.map(|p| p.as_ref()).to_glib_none().0,
2218 &mut error,
2219 );
2220 debug_assert_eq!(is_ok == glib::ffi::GFALSE, !error.is_null());
2221 if error.is_null() {
2222 Ok(())
2223 } else {
2224 Err(from_glib_full(error))
2225 }
2226 }
2227 }
2228
2229 #[doc(alias = "g_file_set_attribute_string")]
2230 fn set_attribute_string(
2231 &self,
2232 attribute: &str,
2233 value: &str,
2234 flags: FileQueryInfoFlags,
2235 cancellable: Option<&impl IsA<Cancellable>>,
2236 ) -> Result<(), glib::Error> {
2237 unsafe {
2238 let mut error = std::ptr::null_mut();
2239 let is_ok = ffi::g_file_set_attribute_string(
2240 self.as_ref().to_glib_none().0,
2241 attribute.to_glib_none().0,
2242 value.to_glib_none().0,
2243 flags.into_glib(),
2244 cancellable.map(|p| p.as_ref()).to_glib_none().0,
2245 &mut error,
2246 );
2247 debug_assert_eq!(is_ok == glib::ffi::GFALSE, !error.is_null());
2248 if error.is_null() {
2249 Ok(())
2250 } else {
2251 Err(from_glib_full(error))
2252 }
2253 }
2254 }
2255
2256 #[doc(alias = "g_file_set_attribute_uint32")]
2257 fn set_attribute_uint32(
2258 &self,
2259 attribute: &str,
2260 value: u32,
2261 flags: FileQueryInfoFlags,
2262 cancellable: Option<&impl IsA<Cancellable>>,
2263 ) -> Result<(), glib::Error> {
2264 unsafe {
2265 let mut error = std::ptr::null_mut();
2266 let is_ok = ffi::g_file_set_attribute_uint32(
2267 self.as_ref().to_glib_none().0,
2268 attribute.to_glib_none().0,
2269 value,
2270 flags.into_glib(),
2271 cancellable.map(|p| p.as_ref()).to_glib_none().0,
2272 &mut error,
2273 );
2274 debug_assert_eq!(is_ok == glib::ffi::GFALSE, !error.is_null());
2275 if error.is_null() {
2276 Ok(())
2277 } else {
2278 Err(from_glib_full(error))
2279 }
2280 }
2281 }
2282
2283 #[doc(alias = "g_file_set_attribute_uint64")]
2284 fn set_attribute_uint64(
2285 &self,
2286 attribute: &str,
2287 value: u64,
2288 flags: FileQueryInfoFlags,
2289 cancellable: Option<&impl IsA<Cancellable>>,
2290 ) -> Result<(), glib::Error> {
2291 unsafe {
2292 let mut error = std::ptr::null_mut();
2293 let is_ok = ffi::g_file_set_attribute_uint64(
2294 self.as_ref().to_glib_none().0,
2295 attribute.to_glib_none().0,
2296 value,
2297 flags.into_glib(),
2298 cancellable.map(|p| p.as_ref()).to_glib_none().0,
2299 &mut error,
2300 );
2301 debug_assert_eq!(is_ok == glib::ffi::GFALSE, !error.is_null());
2302 if error.is_null() {
2303 Ok(())
2304 } else {
2305 Err(from_glib_full(error))
2306 }
2307 }
2308 }
2309
2310 #[doc(alias = "g_file_set_attributes_async")]
2311 fn set_attributes_async<P: FnOnce(Result<FileInfo, glib::Error>) + 'static>(
2312 &self,
2313 info: &FileInfo,
2314 flags: FileQueryInfoFlags,
2315 io_priority: glib::Priority,
2316 cancellable: Option<&impl IsA<Cancellable>>,
2317 callback: P,
2318 ) {
2319 let main_context = glib::MainContext::ref_thread_default();
2320 let is_main_context_owner = main_context.is_owner();
2321 let has_acquired_main_context = (!is_main_context_owner)
2322 .then(|| main_context.acquire().ok())
2323 .flatten();
2324 assert!(
2325 is_main_context_owner || has_acquired_main_context.is_some(),
2326 "Async operations only allowed if the thread is owning the MainContext"
2327 );
2328
2329 let user_data: Box_<glib::thread_guard::ThreadGuard<P>> =
2330 Box_::new(glib::thread_guard::ThreadGuard::new(callback));
2331 unsafe extern "C" fn set_attributes_async_trampoline<
2332 P: FnOnce(Result<FileInfo, glib::Error>) + 'static,
2333 >(
2334 _source_object: *mut glib::gobject_ffi::GObject,
2335 res: *mut crate::ffi::GAsyncResult,
2336 user_data: glib::ffi::gpointer,
2337 ) {
2338 let mut error = std::ptr::null_mut();
2339 let mut info = std::ptr::null_mut();
2340 ffi::g_file_set_attributes_finish(_source_object as *mut _, res, &mut info, &mut error);
2341 let result = if error.is_null() {
2342 Ok(from_glib_full(info))
2343 } else {
2344 Err(from_glib_full(error))
2345 };
2346 let callback: Box_<glib::thread_guard::ThreadGuard<P>> =
2347 Box_::from_raw(user_data as *mut _);
2348 let callback: P = callback.into_inner();
2349 callback(result);
2350 }
2351 let callback = set_attributes_async_trampoline::<P>;
2352 unsafe {
2353 ffi::g_file_set_attributes_async(
2354 self.as_ref().to_glib_none().0,
2355 info.to_glib_none().0,
2356 flags.into_glib(),
2357 io_priority.into_glib(),
2358 cancellable.map(|p| p.as_ref()).to_glib_none().0,
2359 Some(callback),
2360 Box_::into_raw(user_data) as *mut _,
2361 );
2362 }
2363 }
2364
2365 fn set_attributes_future(
2366 &self,
2367 info: &FileInfo,
2368 flags: FileQueryInfoFlags,
2369 io_priority: glib::Priority,
2370 ) -> Pin<Box_<dyn std::future::Future<Output = Result<FileInfo, glib::Error>> + 'static>> {
2371 let info = info.clone();
2372 Box_::pin(crate::GioFuture::new(
2373 self,
2374 move |obj, cancellable, send| {
2375 obj.set_attributes_async(
2376 &info,
2377 flags,
2378 io_priority,
2379 Some(cancellable),
2380 move |res| {
2381 send.resolve(res);
2382 },
2383 );
2384 },
2385 ))
2386 }
2387
2388 #[doc(alias = "g_file_set_attributes_from_info")]
2389 fn set_attributes_from_info(
2390 &self,
2391 info: &FileInfo,
2392 flags: FileQueryInfoFlags,
2393 cancellable: Option<&impl IsA<Cancellable>>,
2394 ) -> Result<(), glib::Error> {
2395 unsafe {
2396 let mut error = std::ptr::null_mut();
2397 let is_ok = ffi::g_file_set_attributes_from_info(
2398 self.as_ref().to_glib_none().0,
2399 info.to_glib_none().0,
2400 flags.into_glib(),
2401 cancellable.map(|p| p.as_ref()).to_glib_none().0,
2402 &mut error,
2403 );
2404 debug_assert_eq!(is_ok == glib::ffi::GFALSE, !error.is_null());
2405 if error.is_null() {
2406 Ok(())
2407 } else {
2408 Err(from_glib_full(error))
2409 }
2410 }
2411 }
2412
2413 #[doc(alias = "g_file_set_display_name")]
2414 fn set_display_name(
2415 &self,
2416 display_name: &str,
2417 cancellable: Option<&impl IsA<Cancellable>>,
2418 ) -> Result<File, glib::Error> {
2419 unsafe {
2420 let mut error = std::ptr::null_mut();
2421 let ret = ffi::g_file_set_display_name(
2422 self.as_ref().to_glib_none().0,
2423 display_name.to_glib_none().0,
2424 cancellable.map(|p| p.as_ref()).to_glib_none().0,
2425 &mut error,
2426 );
2427 if error.is_null() {
2428 Ok(from_glib_full(ret))
2429 } else {
2430 Err(from_glib_full(error))
2431 }
2432 }
2433 }
2434
2435 #[doc(alias = "g_file_set_display_name_async")]
2436 fn set_display_name_async<P: FnOnce(Result<File, glib::Error>) + 'static>(
2437 &self,
2438 display_name: &str,
2439 io_priority: glib::Priority,
2440 cancellable: Option<&impl IsA<Cancellable>>,
2441 callback: P,
2442 ) {
2443 let main_context = glib::MainContext::ref_thread_default();
2444 let is_main_context_owner = main_context.is_owner();
2445 let has_acquired_main_context = (!is_main_context_owner)
2446 .then(|| main_context.acquire().ok())
2447 .flatten();
2448 assert!(
2449 is_main_context_owner || has_acquired_main_context.is_some(),
2450 "Async operations only allowed if the thread is owning the MainContext"
2451 );
2452
2453 let user_data: Box_<glib::thread_guard::ThreadGuard<P>> =
2454 Box_::new(glib::thread_guard::ThreadGuard::new(callback));
2455 unsafe extern "C" fn set_display_name_async_trampoline<
2456 P: FnOnce(Result<File, glib::Error>) + 'static,
2457 >(
2458 _source_object: *mut glib::gobject_ffi::GObject,
2459 res: *mut crate::ffi::GAsyncResult,
2460 user_data: glib::ffi::gpointer,
2461 ) {
2462 let mut error = std::ptr::null_mut();
2463 let ret =
2464 ffi::g_file_set_display_name_finish(_source_object as *mut _, res, &mut error);
2465 let result = if error.is_null() {
2466 Ok(from_glib_full(ret))
2467 } else {
2468 Err(from_glib_full(error))
2469 };
2470 let callback: Box_<glib::thread_guard::ThreadGuard<P>> =
2471 Box_::from_raw(user_data as *mut _);
2472 let callback: P = callback.into_inner();
2473 callback(result);
2474 }
2475 let callback = set_display_name_async_trampoline::<P>;
2476 unsafe {
2477 ffi::g_file_set_display_name_async(
2478 self.as_ref().to_glib_none().0,
2479 display_name.to_glib_none().0,
2480 io_priority.into_glib(),
2481 cancellable.map(|p| p.as_ref()).to_glib_none().0,
2482 Some(callback),
2483 Box_::into_raw(user_data) as *mut _,
2484 );
2485 }
2486 }
2487
2488 fn set_display_name_future(
2489 &self,
2490 display_name: &str,
2491 io_priority: glib::Priority,
2492 ) -> Pin<Box_<dyn std::future::Future<Output = Result<File, glib::Error>> + 'static>> {
2493 let display_name = String::from(display_name);
2494 Box_::pin(crate::GioFuture::new(
2495 self,
2496 move |obj, cancellable, send| {
2497 obj.set_display_name_async(
2498 &display_name,
2499 io_priority,
2500 Some(cancellable),
2501 move |res| {
2502 send.resolve(res);
2503 },
2504 );
2505 },
2506 ))
2507 }
2508
2509 #[doc(alias = "g_file_start_mountable")]
2510 fn start_mountable<P: FnOnce(Result<(), glib::Error>) + 'static>(
2511 &self,
2512 flags: DriveStartFlags,
2513 start_operation: Option<&impl IsA<MountOperation>>,
2514 cancellable: Option<&impl IsA<Cancellable>>,
2515 callback: P,
2516 ) {
2517 let main_context = glib::MainContext::ref_thread_default();
2518 let is_main_context_owner = main_context.is_owner();
2519 let has_acquired_main_context = (!is_main_context_owner)
2520 .then(|| main_context.acquire().ok())
2521 .flatten();
2522 assert!(
2523 is_main_context_owner || has_acquired_main_context.is_some(),
2524 "Async operations only allowed if the thread is owning the MainContext"
2525 );
2526
2527 let user_data: Box_<glib::thread_guard::ThreadGuard<P>> =
2528 Box_::new(glib::thread_guard::ThreadGuard::new(callback));
2529 unsafe extern "C" fn start_mountable_trampoline<
2530 P: FnOnce(Result<(), glib::Error>) + 'static,
2531 >(
2532 _source_object: *mut glib::gobject_ffi::GObject,
2533 res: *mut crate::ffi::GAsyncResult,
2534 user_data: glib::ffi::gpointer,
2535 ) {
2536 let mut error = std::ptr::null_mut();
2537 ffi::g_file_start_mountable_finish(_source_object as *mut _, res, &mut error);
2538 let result = if error.is_null() {
2539 Ok(())
2540 } else {
2541 Err(from_glib_full(error))
2542 };
2543 let callback: Box_<glib::thread_guard::ThreadGuard<P>> =
2544 Box_::from_raw(user_data as *mut _);
2545 let callback: P = callback.into_inner();
2546 callback(result);
2547 }
2548 let callback = start_mountable_trampoline::<P>;
2549 unsafe {
2550 ffi::g_file_start_mountable(
2551 self.as_ref().to_glib_none().0,
2552 flags.into_glib(),
2553 start_operation.map(|p| p.as_ref()).to_glib_none().0,
2554 cancellable.map(|p| p.as_ref()).to_glib_none().0,
2555 Some(callback),
2556 Box_::into_raw(user_data) as *mut _,
2557 );
2558 }
2559 }
2560
2561 fn start_mountable_future(
2562 &self,
2563 flags: DriveStartFlags,
2564 start_operation: Option<&(impl IsA<MountOperation> + Clone + 'static)>,
2565 ) -> Pin<Box_<dyn std::future::Future<Output = Result<(), glib::Error>> + 'static>> {
2566 let start_operation = start_operation.map(ToOwned::to_owned);
2567 Box_::pin(crate::GioFuture::new(
2568 self,
2569 move |obj, cancellable, send| {
2570 obj.start_mountable(
2571 flags,
2572 start_operation.as_ref().map(::std::borrow::Borrow::borrow),
2573 Some(cancellable),
2574 move |res| {
2575 send.resolve(res);
2576 },
2577 );
2578 },
2579 ))
2580 }
2581
2582 #[doc(alias = "g_file_stop_mountable")]
2583 fn stop_mountable<P: FnOnce(Result<(), glib::Error>) + 'static>(
2584 &self,
2585 flags: MountUnmountFlags,
2586 mount_operation: Option<&impl IsA<MountOperation>>,
2587 cancellable: Option<&impl IsA<Cancellable>>,
2588 callback: P,
2589 ) {
2590 let main_context = glib::MainContext::ref_thread_default();
2591 let is_main_context_owner = main_context.is_owner();
2592 let has_acquired_main_context = (!is_main_context_owner)
2593 .then(|| main_context.acquire().ok())
2594 .flatten();
2595 assert!(
2596 is_main_context_owner || has_acquired_main_context.is_some(),
2597 "Async operations only allowed if the thread is owning the MainContext"
2598 );
2599
2600 let user_data: Box_<glib::thread_guard::ThreadGuard<P>> =
2601 Box_::new(glib::thread_guard::ThreadGuard::new(callback));
2602 unsafe extern "C" fn stop_mountable_trampoline<
2603 P: FnOnce(Result<(), glib::Error>) + 'static,
2604 >(
2605 _source_object: *mut glib::gobject_ffi::GObject,
2606 res: *mut crate::ffi::GAsyncResult,
2607 user_data: glib::ffi::gpointer,
2608 ) {
2609 let mut error = std::ptr::null_mut();
2610 ffi::g_file_stop_mountable_finish(_source_object as *mut _, res, &mut error);
2611 let result = if error.is_null() {
2612 Ok(())
2613 } else {
2614 Err(from_glib_full(error))
2615 };
2616 let callback: Box_<glib::thread_guard::ThreadGuard<P>> =
2617 Box_::from_raw(user_data as *mut _);
2618 let callback: P = callback.into_inner();
2619 callback(result);
2620 }
2621 let callback = stop_mountable_trampoline::<P>;
2622 unsafe {
2623 ffi::g_file_stop_mountable(
2624 self.as_ref().to_glib_none().0,
2625 flags.into_glib(),
2626 mount_operation.map(|p| p.as_ref()).to_glib_none().0,
2627 cancellable.map(|p| p.as_ref()).to_glib_none().0,
2628 Some(callback),
2629 Box_::into_raw(user_data) as *mut _,
2630 );
2631 }
2632 }
2633
2634 fn stop_mountable_future(
2635 &self,
2636 flags: MountUnmountFlags,
2637 mount_operation: Option<&(impl IsA<MountOperation> + Clone + 'static)>,
2638 ) -> Pin<Box_<dyn std::future::Future<Output = Result<(), glib::Error>> + 'static>> {
2639 let mount_operation = mount_operation.map(ToOwned::to_owned);
2640 Box_::pin(crate::GioFuture::new(
2641 self,
2642 move |obj, cancellable, send| {
2643 obj.stop_mountable(
2644 flags,
2645 mount_operation.as_ref().map(::std::borrow::Borrow::borrow),
2646 Some(cancellable),
2647 move |res| {
2648 send.resolve(res);
2649 },
2650 );
2651 },
2652 ))
2653 }
2654
2655 #[doc(alias = "g_file_supports_thread_contexts")]
2656 fn supports_thread_contexts(&self) -> bool {
2657 unsafe {
2658 from_glib(ffi::g_file_supports_thread_contexts(
2659 self.as_ref().to_glib_none().0,
2660 ))
2661 }
2662 }
2663
2664 #[doc(alias = "g_file_trash")]
2665 fn trash(&self, cancellable: Option<&impl IsA<Cancellable>>) -> Result<(), glib::Error> {
2666 unsafe {
2667 let mut error = std::ptr::null_mut();
2668 let is_ok = ffi::g_file_trash(
2669 self.as_ref().to_glib_none().0,
2670 cancellable.map(|p| p.as_ref()).to_glib_none().0,
2671 &mut error,
2672 );
2673 debug_assert_eq!(is_ok == glib::ffi::GFALSE, !error.is_null());
2674 if error.is_null() {
2675 Ok(())
2676 } else {
2677 Err(from_glib_full(error))
2678 }
2679 }
2680 }
2681
2682 #[doc(alias = "g_file_trash_async")]
2683 fn trash_async<P: FnOnce(Result<(), glib::Error>) + 'static>(
2684 &self,
2685 io_priority: glib::Priority,
2686 cancellable: Option<&impl IsA<Cancellable>>,
2687 callback: P,
2688 ) {
2689 let main_context = glib::MainContext::ref_thread_default();
2690 let is_main_context_owner = main_context.is_owner();
2691 let has_acquired_main_context = (!is_main_context_owner)
2692 .then(|| main_context.acquire().ok())
2693 .flatten();
2694 assert!(
2695 is_main_context_owner || has_acquired_main_context.is_some(),
2696 "Async operations only allowed if the thread is owning the MainContext"
2697 );
2698
2699 let user_data: Box_<glib::thread_guard::ThreadGuard<P>> =
2700 Box_::new(glib::thread_guard::ThreadGuard::new(callback));
2701 unsafe extern "C" fn trash_async_trampoline<
2702 P: FnOnce(Result<(), glib::Error>) + 'static,
2703 >(
2704 _source_object: *mut glib::gobject_ffi::GObject,
2705 res: *mut crate::ffi::GAsyncResult,
2706 user_data: glib::ffi::gpointer,
2707 ) {
2708 let mut error = std::ptr::null_mut();
2709 ffi::g_file_trash_finish(_source_object as *mut _, res, &mut error);
2710 let result = if error.is_null() {
2711 Ok(())
2712 } else {
2713 Err(from_glib_full(error))
2714 };
2715 let callback: Box_<glib::thread_guard::ThreadGuard<P>> =
2716 Box_::from_raw(user_data as *mut _);
2717 let callback: P = callback.into_inner();
2718 callback(result);
2719 }
2720 let callback = trash_async_trampoline::<P>;
2721 unsafe {
2722 ffi::g_file_trash_async(
2723 self.as_ref().to_glib_none().0,
2724 io_priority.into_glib(),
2725 cancellable.map(|p| p.as_ref()).to_glib_none().0,
2726 Some(callback),
2727 Box_::into_raw(user_data) as *mut _,
2728 );
2729 }
2730 }
2731
2732 fn trash_future(
2733 &self,
2734 io_priority: glib::Priority,
2735 ) -> Pin<Box_<dyn std::future::Future<Output = Result<(), glib::Error>> + 'static>> {
2736 Box_::pin(crate::GioFuture::new(
2737 self,
2738 move |obj, cancellable, send| {
2739 obj.trash_async(io_priority, Some(cancellable), move |res| {
2740 send.resolve(res);
2741 });
2742 },
2743 ))
2744 }
2745
2746 #[doc(alias = "g_file_unmount_mountable_with_operation")]
2747 fn unmount_mountable_with_operation<P: FnOnce(Result<(), glib::Error>) + 'static>(
2748 &self,
2749 flags: MountUnmountFlags,
2750 mount_operation: Option<&impl IsA<MountOperation>>,
2751 cancellable: Option<&impl IsA<Cancellable>>,
2752 callback: P,
2753 ) {
2754 let main_context = glib::MainContext::ref_thread_default();
2755 let is_main_context_owner = main_context.is_owner();
2756 let has_acquired_main_context = (!is_main_context_owner)
2757 .then(|| main_context.acquire().ok())
2758 .flatten();
2759 assert!(
2760 is_main_context_owner || has_acquired_main_context.is_some(),
2761 "Async operations only allowed if the thread is owning the MainContext"
2762 );
2763
2764 let user_data: Box_<glib::thread_guard::ThreadGuard<P>> =
2765 Box_::new(glib::thread_guard::ThreadGuard::new(callback));
2766 unsafe extern "C" fn unmount_mountable_with_operation_trampoline<
2767 P: FnOnce(Result<(), glib::Error>) + 'static,
2768 >(
2769 _source_object: *mut glib::gobject_ffi::GObject,
2770 res: *mut crate::ffi::GAsyncResult,
2771 user_data: glib::ffi::gpointer,
2772 ) {
2773 let mut error = std::ptr::null_mut();
2774 ffi::g_file_unmount_mountable_with_operation_finish(
2775 _source_object as *mut _,
2776 res,
2777 &mut error,
2778 );
2779 let result = if error.is_null() {
2780 Ok(())
2781 } else {
2782 Err(from_glib_full(error))
2783 };
2784 let callback: Box_<glib::thread_guard::ThreadGuard<P>> =
2785 Box_::from_raw(user_data as *mut _);
2786 let callback: P = callback.into_inner();
2787 callback(result);
2788 }
2789 let callback = unmount_mountable_with_operation_trampoline::<P>;
2790 unsafe {
2791 ffi::g_file_unmount_mountable_with_operation(
2792 self.as_ref().to_glib_none().0,
2793 flags.into_glib(),
2794 mount_operation.map(|p| p.as_ref()).to_glib_none().0,
2795 cancellable.map(|p| p.as_ref()).to_glib_none().0,
2796 Some(callback),
2797 Box_::into_raw(user_data) as *mut _,
2798 );
2799 }
2800 }
2801
2802 fn unmount_mountable_with_operation_future(
2803 &self,
2804 flags: MountUnmountFlags,
2805 mount_operation: Option<&(impl IsA<MountOperation> + Clone + 'static)>,
2806 ) -> Pin<Box_<dyn std::future::Future<Output = Result<(), glib::Error>> + 'static>> {
2807 let mount_operation = mount_operation.map(ToOwned::to_owned);
2808 Box_::pin(crate::GioFuture::new(
2809 self,
2810 move |obj, cancellable, send| {
2811 obj.unmount_mountable_with_operation(
2812 flags,
2813 mount_operation.as_ref().map(::std::borrow::Borrow::borrow),
2814 Some(cancellable),
2815 move |res| {
2816 send.resolve(res);
2817 },
2818 );
2819 },
2820 ))
2821 }
2822}
2823
2824impl<O: IsA<File>> FileExt for O {}