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