gio/auto/app_info.rs
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175 176 177 178 179 180 181 182 183 184 185 186 187 188 189 190 191 192 193 194 195 196 197 198 199 200 201 202 203 204 205 206 207 208 209 210 211 212 213 214 215 216 217 218 219 220 221 222 223 224 225 226 227 228 229 230 231 232 233 234 235 236 237 238 239 240 241 242 243 244 245 246 247 248 249 250 251 252 253 254 255 256 257 258 259 260 261 262 263 264 265 266 267 268 269 270 271 272 273 274 275 276 277 278 279 280 281 282 283 284 285 286 287 288 289 290 291 292 293 294 295 296 297 298 299 300 301 302 303 304 305 306 307 308 309 310 311 312 313 314 315 316 317 318 319 320 321 322 323 324 325 326 327 328 329 330 331 332 333 334 335 336 337 338 339 340 341 342 343 344 345 346 347 348 349 350 351 352 353 354 355 356 357 358 359 360 361 362 363 364 365 366 367 368 369 370 371 372 373 374 375 376 377 378 379 380 381 382 383 384 385 386 387 388 389 390 391 392 393 394 395 396 397 398 399 400 401 402 403 404 405 406 407 408 409 410 411 412 413 414 415 416 417 418 419 420 421 422 423 424 425 426 427 428 429 430 431 432 433 434 435 436 437 438 439 440 441 442 443 444 445 446 447 448 449 450 451 452 453 454 455 456 457 458 459 460 461 462 463 464 465 466 467 468 469 470 471 472 473 474 475 476 477 478 479 480 481 482 483 484 485 486 487 488 489 490 491 492 493 494 495 496 497 498 499 500 501 502 503 504 505 506 507 508 509 510 511 512 513 514 515 516 517 518 519 520 521 522 523 524 525 526 527 528 529 530 531 532 533 534 535 536 537 538 539 540 541 542 543 544 545 546 547 548 549 550 551 552 553 554 555 556 557 558 559 560 561 562 563 564 565 566 567 568 569 570 571 572 573 574 575 576 577 578 579 580 581 582 583 584 585 586 587 588 589 590 591 592 593 594 595 596 597 598 599 600 601 602 603 604 605 606 607 608 609 610 611 612 613 614 615 616 617 618 619 620 621 622 623 624 625 626 627 628 629 630 631 632 633 634 635 636 637 638 639 640 641 642 643 644 645 646 647 648 649 650 651 652 653 654 655 656 657 658 659 660 661 662 663 664 665 666 667 668 669 670 671 672 673 674 675 676 677 678 679 680 681 682 683 684 685 686 687 688 689 690 691 692 693 694 695 696 697 698 699 700 701 702 703 704 705 706 707 708 709 710 711 712 713 714 715 716 717 718 719 720 721 722 723 724 725 726 727 728 729 730 731 732 733 734 735 736 737 738 739 740 741 742 743 744 745 746 747 748 749 750 751 752 753 754 755 756 757 758 759 760 761 762 763 764 765 766 767 768 769 770 771 772 773 774 775 776 777 778 779 780 781 782 783 784 785 786 787 788 789 790 791 792 793 794 795 796 797 798 799 800 801 802 803 804 805 806 807 808 809 810 811 812 813 814 815 816 817 818 819 820 821 822 823 824 825 826 827 828 829 830 831 832 833 834 835 836 837 838 839 840 841 842 843 844 845 846 847 848 849 850 851 852 853 854 855 856 857 858 859 860 861 862 863 864 865 866 867 868 869 870 871 872 873 874 875 876 877 878 879 880 881 882 883 884 885 886 887 888 889 890 891 892 893 894 895 896 897 898 899 900 901 902 903 904 905 906 907 908 909 910 911 912 913 914 915 916 917 918 919 920 921 922 923 924 925 926 927 928 929 930 931 932 933 934 935 936 937 938 939 940 941 942 943 944 945 946 947 948 949 950 951 952 953 954 955 956 957 958 959 960 961 962 963 964 965 966 967 968 969 970 971 972 973 974 975 976 977 978 979 980 981 982 983 984 985 986 987 988 989 990 991 992 993 994 995 996 997 998 999 1000 1001 1002 1003 1004 1005 1006 1007 1008 1009 1010 1011 1012 1013 1014 1015 1016 1017 1018 1019 1020 1021 1022 1023 1024 1025 1026 1027 1028 1029 1030 1031 1032
// This file was generated by gir (https://github.com/gtk-rs/gir)
// from gir-files (https://github.com/gtk-rs/gir-files)
// DO NOT EDIT
use crate::{ffi, AppInfoCreateFlags, AppLaunchContext, AsyncResult, Cancellable, File, Icon};
use glib::{prelude::*, translate::*};
use std::{boxed::Box as Box_, pin::Pin};
glib::wrapper! {
/// Information about an installed application and methods to launch
/// it (with file arguments).
///
/// `GAppInfo` and `GAppLaunchContext` are used for describing and launching
/// applications installed on the system.
///
/// As of GLib 2.20, URIs will always be converted to POSIX paths
/// (using [`FileExt::path()`][crate::prelude::FileExt::path()]) when using [`AppInfoExt::launch()`][crate::prelude::AppInfoExt::launch()]
/// even if the application requested an URI and not a POSIX path. For example
/// for a desktop-file based application with the following Exec key:
///
/// ```text
/// Exec=totem %U
/// ```
///
/// and a single URI, `sftp://foo/file.avi`, then
/// `/home/user/.gvfs/sftp on foo/file.avi` will be passed. This will only work
/// if a set of suitable GIO extensions (such as GVfs 2.26 compiled with FUSE
/// support), is available and operational; if this is not the case, the URI
/// will be passed unmodified to the application. Some URIs, such as `mailto:`,
/// of course cannot be mapped to a POSIX path (in GVfs there’s no FUSE mount
/// for it); such URIs will be passed unmodified to the application.
///
/// Specifically for GVfs 2.26 and later, the POSIX URI will be mapped
/// back to the GIO URI in the [`File`][crate::File] constructors (since GVfs
/// implements the GVfs extension point). As such, if the application
/// needs to examine the URI, it needs to use [`FileExt::uri()`][crate::prelude::FileExt::uri()]
/// or similar on [`File`][crate::File]. In other words, an application cannot
/// assume that the URI passed to e.g. [`File::for_commandline_arg()`][crate::File::for_commandline_arg()]
/// is equal to the result of [`FileExt::uri()`][crate::prelude::FileExt::uri()]. The following snippet
/// illustrates this:
///
/// **⚠️ The following code is in c ⚠️**
///
/// ```c
/// GFile *f;
/// char *uri;
///
/// file = g_file_new_for_commandline_arg (uri_from_commandline);
///
/// uri = g_file_get_uri (file);
/// strcmp (uri, uri_from_commandline) == 0;
/// g_free (uri);
///
/// if (g_file_has_uri_scheme (file, "cdda"))
/// {
/// // do something special with uri
/// }
/// g_object_unref (file);
/// ```
///
/// This code will work when both `cdda://sr0/Track 1.wav` and
/// `/home/user/.gvfs/cdda on sr0/Track 1.wav` is passed to the
/// application. It should be noted that it’s generally not safe
/// for applications to rely on the format of a particular URIs.
/// Different launcher applications (e.g. file managers) may have
/// different ideas of what a given URI means.
///
/// # Implements
///
/// [`AppInfoExt`][trait@crate::prelude::AppInfoExt], [`AppInfoExtManual`][trait@crate::prelude::AppInfoExtManual]
#[doc(alias = "GAppInfo")]
pub struct AppInfo(Interface<ffi::GAppInfo, ffi::GAppInfoIface>);
match fn {
type_ => || ffi::g_app_info_get_type(),
}
}
impl AppInfo {
pub const NONE: Option<&'static AppInfo> = None;
/// Creates a new [`AppInfo`][crate::AppInfo] from the given information.
///
/// Note that for @commandline, the quoting rules of the `Exec` key of the
/// [freedesktop.org Desktop Entry Specification](http://freedesktop.org/Standards/desktop-entry-spec)
/// are applied. For example, if the @commandline contains
/// percent-encoded URIs, the percent-character must be doubled in order to prevent it from
/// being swallowed by `Exec` key unquoting. See
/// [the specification](https://specifications.freedesktop.org/desktop-entry-spec/latest/ar01s07.html)
/// for exact quoting rules.
/// ## `commandline`
/// the command line to use
/// ## `application_name`
/// the application name, or `NULL` to use @commandline
/// ## `flags`
/// flags that can specify details of the created [`AppInfo`][crate::AppInfo]
///
/// # Returns
///
/// new [`AppInfo`][crate::AppInfo] for given command.
#[doc(alias = "g_app_info_create_from_commandline")]
pub fn create_from_commandline(
commandline: impl AsRef<std::ffi::OsStr>,
application_name: Option<&str>,
flags: AppInfoCreateFlags,
) -> Result<AppInfo, glib::Error> {
unsafe {
let mut error = std::ptr::null_mut();
let ret = ffi::g_app_info_create_from_commandline(
commandline.as_ref().to_glib_none().0,
application_name.to_glib_none().0,
flags.into_glib(),
&mut error,
);
if error.is_null() {
Ok(from_glib_full(ret))
} else {
Err(from_glib_full(error))
}
}
}
/// Gets a list of all of the applications currently registered
/// on this system.
///
/// For desktop files, this includes applications that have
/// [`NoDisplay=true`](https://specifications.freedesktop.org/desktop-entry-spec/latest/ar01s06.html#key-nodisplay)
/// set or are excluded from display by means of
/// [`OnlyShowIn`](https://specifications.freedesktop.org/desktop-entry-spec/latest/ar01s06.html#key-onlyshowin)
/// or [`NotShowIn`](https://specifications.freedesktop.org/desktop-entry-spec/latest/ar01s06.html#key-notshowin).
/// See [`AppInfoExt::should_show()`][crate::prelude::AppInfoExt::should_show()].
///
/// The returned list does not include applications which have the
/// [`Hidden` key](https://specifications.freedesktop.org/desktop-entry-spec/latest/ar01s06.html#key-hidden)
/// set.
///
/// # Returns
///
/// a newly allocated
/// list of references to [`AppInfo`][crate::AppInfo]s.
#[doc(alias = "g_app_info_get_all")]
#[doc(alias = "get_all")]
pub fn all() -> Vec<AppInfo> {
unsafe { FromGlibPtrContainer::from_glib_full(ffi::g_app_info_get_all()) }
}
/// Gets a list of all [`AppInfo`][crate::AppInfo]s for a given content type,
/// including the recommended and fallback [`AppInfo`][crate::AppInfo]s. See
/// [`recommended_for_type()`][Self::recommended_for_type()] and
/// [`fallback_for_type()`][Self::fallback_for_type()].
/// ## `content_type`
/// the content type to find a [`AppInfo`][crate::AppInfo] for
///
/// # Returns
///
/// list of
/// [`AppInfo`][crate::AppInfo]s for given @content_type.
#[doc(alias = "g_app_info_get_all_for_type")]
#[doc(alias = "get_all_for_type")]
pub fn all_for_type(content_type: &str) -> Vec<AppInfo> {
unsafe {
FromGlibPtrContainer::from_glib_full(ffi::g_app_info_get_all_for_type(
content_type.to_glib_none().0,
))
}
}
/// Gets the default [`AppInfo`][crate::AppInfo] for a given content type.
/// ## `content_type`
/// the content type to find a [`AppInfo`][crate::AppInfo] for
/// ## `must_support_uris`
/// if `TRUE`, the [`AppInfo`][crate::AppInfo] is expected to
/// support URIs
///
/// # Returns
///
/// [`AppInfo`][crate::AppInfo] for given
/// @content_type or `NULL` on error.
#[doc(alias = "g_app_info_get_default_for_type")]
#[doc(alias = "get_default_for_type")]
pub fn default_for_type(content_type: &str, must_support_uris: bool) -> Option<AppInfo> {
unsafe {
from_glib_full(ffi::g_app_info_get_default_for_type(
content_type.to_glib_none().0,
must_support_uris.into_glib(),
))
}
}
/// Asynchronously gets the default [`AppInfo`][crate::AppInfo] for a given content
/// type.
/// ## `content_type`
/// the content type to find a [`AppInfo`][crate::AppInfo] for
/// ## `must_support_uris`
/// if `TRUE`, the [`AppInfo`][crate::AppInfo] is expected to
/// support URIs
/// ## `cancellable`
/// a [`Cancellable`][crate::Cancellable]
/// ## `callback`
/// a [type@Gio.AsyncReadyCallback] to call
/// when the request is done
#[cfg(feature = "v2_74")]
#[cfg_attr(docsrs, doc(cfg(feature = "v2_74")))]
#[doc(alias = "g_app_info_get_default_for_type_async")]
#[doc(alias = "get_default_for_type_async")]
pub fn default_for_type_async<P: FnOnce(Result<AppInfo, glib::Error>) + 'static>(
content_type: &str,
must_support_uris: bool,
cancellable: Option<&impl IsA<Cancellable>>,
callback: P,
) {
let main_context = glib::MainContext::ref_thread_default();
let is_main_context_owner = main_context.is_owner();
let has_acquired_main_context = (!is_main_context_owner)
.then(|| main_context.acquire().ok())
.flatten();
assert!(
is_main_context_owner || has_acquired_main_context.is_some(),
"Async operations only allowed if the thread is owning the MainContext"
);
let user_data: Box_<glib::thread_guard::ThreadGuard<P>> =
Box_::new(glib::thread_guard::ThreadGuard::new(callback));
unsafe extern "C" fn default_for_type_async_trampoline<
P: FnOnce(Result<AppInfo, glib::Error>) + 'static,
>(
_source_object: *mut glib::gobject_ffi::GObject,
res: *mut crate::ffi::GAsyncResult,
user_data: glib::ffi::gpointer,
) {
let mut error = std::ptr::null_mut();
let ret = ffi::g_app_info_get_default_for_type_finish(res, &mut error);
let result = if error.is_null() {
Ok(from_glib_full(ret))
} else {
Err(from_glib_full(error))
};
let callback: Box_<glib::thread_guard::ThreadGuard<P>> =
Box_::from_raw(user_data as *mut _);
let callback: P = callback.into_inner();
callback(result);
}
let callback = default_for_type_async_trampoline::<P>;
unsafe {
ffi::g_app_info_get_default_for_type_async(
content_type.to_glib_none().0,
must_support_uris.into_glib(),
cancellable.map(|p| p.as_ref()).to_glib_none().0,
Some(callback),
Box_::into_raw(user_data) as *mut _,
);
}
}
#[cfg(feature = "v2_74")]
#[cfg_attr(docsrs, doc(cfg(feature = "v2_74")))]
pub fn default_for_type_future(
content_type: &str,
must_support_uris: bool,
) -> Pin<Box_<dyn std::future::Future<Output = Result<AppInfo, glib::Error>> + 'static>> {
let content_type = String::from(content_type);
Box_::pin(crate::GioFuture::new(
&(),
move |_obj, cancellable, send| {
Self::default_for_type_async(
&content_type,
must_support_uris,
Some(cancellable),
move |res| {
send.resolve(res);
},
);
},
))
}
/// Gets the default application for handling URIs with the given URI scheme.
///
/// A URI scheme is the initial part of the URI, up to but not including the `:`.
/// For example, `http`, `ftp` or `sip`.
/// ## `uri_scheme`
/// a string containing a URI scheme.
///
/// # Returns
///
/// [`AppInfo`][crate::AppInfo] for given
/// @uri_scheme or `NULL` on error.
#[doc(alias = "g_app_info_get_default_for_uri_scheme")]
#[doc(alias = "get_default_for_uri_scheme")]
pub fn default_for_uri_scheme(uri_scheme: &str) -> Option<AppInfo> {
unsafe {
from_glib_full(ffi::g_app_info_get_default_for_uri_scheme(
uri_scheme.to_glib_none().0,
))
}
}
/// Asynchronously gets the default application for handling URIs with
/// the given URI scheme. A URI scheme is the initial part
/// of the URI, up to but not including the `:`, e.g. `http`,
/// `ftp` or `sip`.
/// ## `uri_scheme`
/// a string containing a URI scheme.
/// ## `cancellable`
/// a [`Cancellable`][crate::Cancellable]
/// ## `callback`
/// a [type@Gio.AsyncReadyCallback] to call
/// when the request is done
#[cfg(feature = "v2_74")]
#[cfg_attr(docsrs, doc(cfg(feature = "v2_74")))]
#[doc(alias = "g_app_info_get_default_for_uri_scheme_async")]
#[doc(alias = "get_default_for_uri_scheme_async")]
pub fn default_for_uri_scheme_async<P: FnOnce(Result<AppInfo, glib::Error>) + 'static>(
uri_scheme: &str,
cancellable: Option<&impl IsA<Cancellable>>,
callback: P,
) {
let main_context = glib::MainContext::ref_thread_default();
let is_main_context_owner = main_context.is_owner();
let has_acquired_main_context = (!is_main_context_owner)
.then(|| main_context.acquire().ok())
.flatten();
assert!(
is_main_context_owner || has_acquired_main_context.is_some(),
"Async operations only allowed if the thread is owning the MainContext"
);
let user_data: Box_<glib::thread_guard::ThreadGuard<P>> =
Box_::new(glib::thread_guard::ThreadGuard::new(callback));
unsafe extern "C" fn default_for_uri_scheme_async_trampoline<
P: FnOnce(Result<AppInfo, glib::Error>) + 'static,
>(
_source_object: *mut glib::gobject_ffi::GObject,
res: *mut crate::ffi::GAsyncResult,
user_data: glib::ffi::gpointer,
) {
let mut error = std::ptr::null_mut();
let ret = ffi::g_app_info_get_default_for_uri_scheme_finish(res, &mut error);
let result = if error.is_null() {
Ok(from_glib_full(ret))
} else {
Err(from_glib_full(error))
};
let callback: Box_<glib::thread_guard::ThreadGuard<P>> =
Box_::from_raw(user_data as *mut _);
let callback: P = callback.into_inner();
callback(result);
}
let callback = default_for_uri_scheme_async_trampoline::<P>;
unsafe {
ffi::g_app_info_get_default_for_uri_scheme_async(
uri_scheme.to_glib_none().0,
cancellable.map(|p| p.as_ref()).to_glib_none().0,
Some(callback),
Box_::into_raw(user_data) as *mut _,
);
}
}
#[cfg(feature = "v2_74")]
#[cfg_attr(docsrs, doc(cfg(feature = "v2_74")))]
pub fn default_for_uri_scheme_future(
uri_scheme: &str,
) -> Pin<Box_<dyn std::future::Future<Output = Result<AppInfo, glib::Error>> + 'static>> {
let uri_scheme = String::from(uri_scheme);
Box_::pin(crate::GioFuture::new(
&(),
move |_obj, cancellable, send| {
Self::default_for_uri_scheme_async(&uri_scheme, Some(cancellable), move |res| {
send.resolve(res);
});
},
))
}
/// Gets a list of fallback [`AppInfo`][crate::AppInfo]s for a given content type, i.e.
/// those applications which claim to support the given content type by MIME
/// type subclassing and not directly.
/// ## `content_type`
/// the content type to find a [`AppInfo`][crate::AppInfo] for
///
/// # Returns
///
/// list of [`AppInfo`][crate::AppInfo]s
/// for given @content_type or `NULL` on error.
#[doc(alias = "g_app_info_get_fallback_for_type")]
#[doc(alias = "get_fallback_for_type")]
pub fn fallback_for_type(content_type: &str) -> Vec<AppInfo> {
unsafe {
FromGlibPtrContainer::from_glib_full(ffi::g_app_info_get_fallback_for_type(
content_type.to_glib_none().0,
))
}
}
/// Gets a list of recommended [`AppInfo`][crate::AppInfo]s for a given content type,
/// i.e. those applications which claim to support the given content type
/// exactly, and not by MIME type subclassing.
///
/// Note that the first application of the list is the last used one, i.e.
/// the last one for which [`AppInfoExt::set_as_last_used_for_type()`][crate::prelude::AppInfoExt::set_as_last_used_for_type()] has
/// been called.
/// ## `content_type`
/// the content type to find a [`AppInfo`][crate::AppInfo] for
///
/// # Returns
///
/// list of
/// [`AppInfo`][crate::AppInfo]s for given @content_type or `NULL` on error.
#[doc(alias = "g_app_info_get_recommended_for_type")]
#[doc(alias = "get_recommended_for_type")]
pub fn recommended_for_type(content_type: &str) -> Vec<AppInfo> {
unsafe {
FromGlibPtrContainer::from_glib_full(ffi::g_app_info_get_recommended_for_type(
content_type.to_glib_none().0,
))
}
}
/// Utility function that launches the default application registered to handle
/// the specified uri. Synchronous I/O is done on the uri to detect the type of
/// the file if required.
///
/// The D-Bus–activated applications don’t have to be started if your application
/// terminates too soon after this function. To prevent this, use
/// [`launch_default_for_uri_async()`][Self::launch_default_for_uri_async()] instead.
/// ## `uri`
/// the uri to show
/// ## `context`
/// optional launch context
///
/// # Returns
///
/// `TRUE` on success, `FALSE` on error.
#[doc(alias = "g_app_info_launch_default_for_uri")]
pub fn launch_default_for_uri(
uri: &str,
context: Option<&impl IsA<AppLaunchContext>>,
) -> Result<(), glib::Error> {
unsafe {
let mut error = std::ptr::null_mut();
let is_ok = ffi::g_app_info_launch_default_for_uri(
uri.to_glib_none().0,
context.map(|p| p.as_ref()).to_glib_none().0,
&mut error,
);
debug_assert_eq!(is_ok == glib::ffi::GFALSE, !error.is_null());
if error.is_null() {
Ok(())
} else {
Err(from_glib_full(error))
}
}
}
/// Async version of [`launch_default_for_uri()`][Self::launch_default_for_uri()].
///
/// This version is useful if you are interested in receiving error information
/// in the case where the application is sandboxed and the portal may present an
/// application chooser dialog to the user.
///
/// This is also useful if you want to be sure that the D-Bus–activated
/// applications are really started before termination and if you are interested
/// in receiving error information from their activation.
/// ## `uri`
/// the uri to show
/// ## `context`
/// optional launch context
/// ## `cancellable`
/// a [`Cancellable`][crate::Cancellable]
/// ## `callback`
/// a [type@Gio.AsyncReadyCallback] to call
/// when the request is done
#[doc(alias = "g_app_info_launch_default_for_uri_async")]
pub fn launch_default_for_uri_async<P: FnOnce(Result<(), glib::Error>) + 'static>(
uri: &str,
context: Option<&impl IsA<AppLaunchContext>>,
cancellable: Option<&impl IsA<Cancellable>>,
callback: P,
) {
let main_context = glib::MainContext::ref_thread_default();
let is_main_context_owner = main_context.is_owner();
let has_acquired_main_context = (!is_main_context_owner)
.then(|| main_context.acquire().ok())
.flatten();
assert!(
is_main_context_owner || has_acquired_main_context.is_some(),
"Async operations only allowed if the thread is owning the MainContext"
);
let user_data: Box_<glib::thread_guard::ThreadGuard<P>> =
Box_::new(glib::thread_guard::ThreadGuard::new(callback));
unsafe extern "C" fn launch_default_for_uri_async_trampoline<
P: FnOnce(Result<(), glib::Error>) + 'static,
>(
_source_object: *mut glib::gobject_ffi::GObject,
res: *mut crate::ffi::GAsyncResult,
user_data: glib::ffi::gpointer,
) {
let mut error = std::ptr::null_mut();
let _ = ffi::g_app_info_launch_default_for_uri_finish(res, &mut error);
let result = if error.is_null() {
Ok(())
} else {
Err(from_glib_full(error))
};
let callback: Box_<glib::thread_guard::ThreadGuard<P>> =
Box_::from_raw(user_data as *mut _);
let callback: P = callback.into_inner();
callback(result);
}
let callback = launch_default_for_uri_async_trampoline::<P>;
unsafe {
ffi::g_app_info_launch_default_for_uri_async(
uri.to_glib_none().0,
context.map(|p| p.as_ref()).to_glib_none().0,
cancellable.map(|p| p.as_ref()).to_glib_none().0,
Some(callback),
Box_::into_raw(user_data) as *mut _,
);
}
}
pub fn launch_default_for_uri_future(
uri: &str,
context: Option<&(impl IsA<AppLaunchContext> + Clone + 'static)>,
) -> Pin<Box_<dyn std::future::Future<Output = Result<(), glib::Error>> + 'static>> {
let uri = String::from(uri);
let context = context.map(ToOwned::to_owned);
Box_::pin(crate::GioFuture::new(
&(),
move |_obj, cancellable, send| {
Self::launch_default_for_uri_async(
&uri,
context.as_ref().map(::std::borrow::Borrow::borrow),
Some(cancellable),
move |res| {
send.resolve(res);
},
);
},
))
}
/// Removes all changes to the type associations done by
/// [`AppInfoExt::set_as_default_for_type()`][crate::prelude::AppInfoExt::set_as_default_for_type()],
/// [`AppInfoExt::set_as_default_for_extension()`][crate::prelude::AppInfoExt::set_as_default_for_extension()],
/// [`AppInfoExt::add_supports_type()`][crate::prelude::AppInfoExt::add_supports_type()] or
/// [`AppInfoExt::remove_supports_type()`][crate::prelude::AppInfoExt::remove_supports_type()].
/// ## `content_type`
/// a content type
#[doc(alias = "g_app_info_reset_type_associations")]
pub fn reset_type_associations(content_type: &str) {
unsafe {
ffi::g_app_info_reset_type_associations(content_type.to_glib_none().0);
}
}
}
/// Trait containing all [`struct@AppInfo`] methods.
///
/// # Implementors
///
/// [`AppInfo`][struct@crate::AppInfo], [`DesktopAppInfo`][struct@crate::DesktopAppInfo]
pub trait AppInfoExt: IsA<AppInfo> + 'static {
/// Adds a content type to the application information to indicate the
/// application is capable of opening files with the given content type.
/// ## `content_type`
/// a string.
///
/// # Returns
///
/// `TRUE` on success, `FALSE` on error.
#[doc(alias = "g_app_info_add_supports_type")]
fn add_supports_type(&self, content_type: &str) -> Result<(), glib::Error> {
unsafe {
let mut error = std::ptr::null_mut();
let is_ok = ffi::g_app_info_add_supports_type(
self.as_ref().to_glib_none().0,
content_type.to_glib_none().0,
&mut error,
);
debug_assert_eq!(is_ok == glib::ffi::GFALSE, !error.is_null());
if error.is_null() {
Ok(())
} else {
Err(from_glib_full(error))
}
}
}
/// Obtains the information whether the [`AppInfo`][crate::AppInfo] can be deleted.
/// See [`delete()`][Self::delete()].
///
/// # Returns
///
/// `TRUE` if @self can be deleted
#[doc(alias = "g_app_info_can_delete")]
fn can_delete(&self) -> bool {
unsafe { from_glib(ffi::g_app_info_can_delete(self.as_ref().to_glib_none().0)) }
}
/// Checks if a supported content type can be removed from an application.
///
/// # Returns
///
/// `TRUE` if it is possible to remove supported content types from a
/// given @self, `FALSE` if not.
#[doc(alias = "g_app_info_can_remove_supports_type")]
fn can_remove_supports_type(&self) -> bool {
unsafe {
from_glib(ffi::g_app_info_can_remove_supports_type(
self.as_ref().to_glib_none().0,
))
}
}
/// Tries to delete a [`AppInfo`][crate::AppInfo].
///
/// On some platforms, there may be a difference between user-defined
/// [`AppInfo`][crate::AppInfo]s which can be deleted, and system-wide ones which cannot.
/// See [`can_delete()`][Self::can_delete()].
///
/// # Returns
///
/// `TRUE` if @self has been deleted
#[doc(alias = "g_app_info_delete")]
fn delete(&self) -> bool {
unsafe { from_glib(ffi::g_app_info_delete(self.as_ref().to_glib_none().0)) }
}
/// Creates a duplicate of a [`AppInfo`][crate::AppInfo].
///
/// # Returns
///
/// a duplicate of @self.
#[doc(alias = "g_app_info_dup")]
#[must_use]
fn dup(&self) -> AppInfo {
unsafe { from_glib_full(ffi::g_app_info_dup(self.as_ref().to_glib_none().0)) }
}
#[doc(alias = "g_app_info_equal")]
fn equal(&self, appinfo2: &impl IsA<AppInfo>) -> bool {
unsafe {
from_glib(ffi::g_app_info_equal(
self.as_ref().to_glib_none().0,
appinfo2.as_ref().to_glib_none().0,
))
}
}
/// Gets the commandline with which the application will be
/// started.
///
/// # Returns
///
/// a string containing the @self’s
/// commandline, or `NULL` if this information is not available
#[doc(alias = "g_app_info_get_commandline")]
#[doc(alias = "get_commandline")]
fn commandline(&self) -> Option<std::path::PathBuf> {
unsafe {
from_glib_none(ffi::g_app_info_get_commandline(
self.as_ref().to_glib_none().0,
))
}
}
/// Gets a human-readable description of an installed application.
///
/// # Returns
///
/// a string containing a description of the
/// application @self, or `NULL` if none.
#[doc(alias = "g_app_info_get_description")]
#[doc(alias = "get_description")]
fn description(&self) -> Option<glib::GString> {
unsafe {
from_glib_none(ffi::g_app_info_get_description(
self.as_ref().to_glib_none().0,
))
}
}
/// Gets the display name of the application. The display name is often more
/// descriptive to the user than the name itself.
///
/// # Returns
///
/// the display name of the application for @self, or the name if
/// no display name is available.
#[doc(alias = "g_app_info_get_display_name")]
#[doc(alias = "get_display_name")]
fn display_name(&self) -> glib::GString {
unsafe {
from_glib_none(ffi::g_app_info_get_display_name(
self.as_ref().to_glib_none().0,
))
}
}
/// Gets the executable’s name for the installed application.
///
/// This is intended to be used for debugging or labelling what program is going
/// to be run. To launch the executable, use [`launch()`][Self::launch()] and related
/// functions, rather than spawning the return value from this function.
///
/// # Returns
///
/// a string containing the @self’s application
/// binaries name
#[doc(alias = "g_app_info_get_executable")]
#[doc(alias = "get_executable")]
fn executable(&self) -> std::path::PathBuf {
unsafe {
from_glib_none(ffi::g_app_info_get_executable(
self.as_ref().to_glib_none().0,
))
}
}
/// Gets the icon for the application.
///
/// # Returns
///
/// the default [`Icon`][crate::Icon] for
/// @self or `NULL` if there is no default icon.
#[doc(alias = "g_app_info_get_icon")]
#[doc(alias = "get_icon")]
fn icon(&self) -> Option<Icon> {
unsafe { from_glib_none(ffi::g_app_info_get_icon(self.as_ref().to_glib_none().0)) }
}
/// Gets the ID of an application. An id is a string that identifies the
/// application. The exact format of the id is platform dependent. For instance,
/// on Unix this is the desktop file id from the xdg menu specification.
///
/// Note that the returned ID may be `NULL`, depending on how the @self has
/// been constructed.
///
/// # Returns
///
/// a string containing the application’s ID.
#[doc(alias = "g_app_info_get_id")]
#[doc(alias = "get_id")]
fn id(&self) -> Option<glib::GString> {
unsafe { from_glib_none(ffi::g_app_info_get_id(self.as_ref().to_glib_none().0)) }
}
/// Gets the installed name of the application.
///
/// # Returns
///
/// the name of the application for @self.
#[doc(alias = "g_app_info_get_name")]
#[doc(alias = "get_name")]
fn name(&self) -> glib::GString {
unsafe { from_glib_none(ffi::g_app_info_get_name(self.as_ref().to_glib_none().0)) }
}
/// Retrieves the list of content types that @app_info claims to support.
/// If this information is not provided by the environment, this function
/// will return `NULL`.
///
/// This function does not take in consideration associations added with
/// [`add_supports_type()`][Self::add_supports_type()], but only those exported directly by
/// the application.
///
/// # Returns
///
///
/// a list of content types.
#[doc(alias = "g_app_info_get_supported_types")]
#[doc(alias = "get_supported_types")]
fn supported_types(&self) -> Vec<glib::GString> {
unsafe {
FromGlibPtrContainer::from_glib_none(ffi::g_app_info_get_supported_types(
self.as_ref().to_glib_none().0,
))
}
}
/// Launches the application. Passes @files to the launched application
/// as arguments, using the optional @context to get information
/// about the details of the launcher (like what screen it is on).
/// On error, @error will be set accordingly.
///
/// To launch the application without arguments pass a `NULL` @files list.
///
/// Note that even if the launch is successful the application launched
/// can fail to start if it runs into problems during startup. There is
/// no way to detect this.
///
/// Some URIs can be changed when passed through a GFile (for instance
/// unsupported URIs with strange formats like mailto:), so if you have
/// a textual URI you want to pass in as argument, consider using
/// [`launch_uris()`][Self::launch_uris()] instead.
///
/// The launched application inherits the environment of the launching
/// process, but it can be modified with [`AppLaunchContextExt::setenv()`][crate::prelude::AppLaunchContextExt::setenv()]
/// and [`AppLaunchContextExt::unsetenv()`][crate::prelude::AppLaunchContextExt::unsetenv()].
///
/// On UNIX, this function sets the `GIO_LAUNCHED_DESKTOP_FILE`
/// environment variable with the path of the launched desktop file and
/// `GIO_LAUNCHED_DESKTOP_FILE_PID` to the process id of the launched
/// process. This can be used to ignore `GIO_LAUNCHED_DESKTOP_FILE`,
/// should it be inherited by further processes. The `DISPLAY`,
/// `XDG_ACTIVATION_TOKEN` and `DESKTOP_STARTUP_ID` environment
/// variables are also set, based on information provided in @context.
/// ## `files`
/// a list of [`File`][crate::File] objects
/// ## `context`
/// the launch context
///
/// # Returns
///
/// `TRUE` on successful launch, `FALSE` otherwise.
#[doc(alias = "g_app_info_launch")]
fn launch(
&self,
files: &[File],
context: Option<&impl IsA<AppLaunchContext>>,
) -> Result<(), glib::Error> {
unsafe {
let mut error = std::ptr::null_mut();
let is_ok = ffi::g_app_info_launch(
self.as_ref().to_glib_none().0,
files.to_glib_none().0,
context.map(|p| p.as_ref()).to_glib_none().0,
&mut error,
);
debug_assert_eq!(is_ok == glib::ffi::GFALSE, !error.is_null());
if error.is_null() {
Ok(())
} else {
Err(from_glib_full(error))
}
}
}
/// Launches the application. This passes the @uris to the launched application
/// as arguments, using the optional @context to get information
/// about the details of the launcher (like what screen it is on).
/// On error, @error will be set accordingly. If the application only supports
/// one URI per invocation as part of their command-line, multiple instances
/// of the application will be spawned.
///
/// To launch the application without arguments pass a `NULL` @uris list.
///
/// Note that even if the launch is successful the application launched
/// can fail to start if it runs into problems during startup. There is
/// no way to detect this.
/// ## `uris`
/// a list of URIs to launch.
/// ## `context`
/// the launch context
///
/// # Returns
///
/// `TRUE` on successful launch, `FALSE` otherwise.
#[doc(alias = "g_app_info_launch_uris")]
fn launch_uris(
&self,
uris: &[&str],
context: Option<&impl IsA<AppLaunchContext>>,
) -> Result<(), glib::Error> {
unsafe {
let mut error = std::ptr::null_mut();
let is_ok = ffi::g_app_info_launch_uris(
self.as_ref().to_glib_none().0,
uris.to_glib_none().0,
context.map(|p| p.as_ref()).to_glib_none().0,
&mut error,
);
debug_assert_eq!(is_ok == glib::ffi::GFALSE, !error.is_null());
if error.is_null() {
Ok(())
} else {
Err(from_glib_full(error))
}
}
}
/// Removes a supported type from an application, if possible.
/// ## `content_type`
/// a string.
///
/// # Returns
///
/// `TRUE` on success, `FALSE` on error.
#[doc(alias = "g_app_info_remove_supports_type")]
fn remove_supports_type(&self, content_type: &str) -> Result<(), glib::Error> {
unsafe {
let mut error = std::ptr::null_mut();
let is_ok = ffi::g_app_info_remove_supports_type(
self.as_ref().to_glib_none().0,
content_type.to_glib_none().0,
&mut error,
);
debug_assert_eq!(is_ok == glib::ffi::GFALSE, !error.is_null());
if error.is_null() {
Ok(())
} else {
Err(from_glib_full(error))
}
}
}
/// Sets the application as the default handler for the given file extension.
/// ## `extension`
/// a string containing the file extension (without
/// the dot).
///
/// # Returns
///
/// `TRUE` on success, `FALSE` on error.
#[doc(alias = "g_app_info_set_as_default_for_extension")]
fn set_as_default_for_extension(
&self,
extension: impl AsRef<std::path::Path>,
) -> Result<(), glib::Error> {
unsafe {
let mut error = std::ptr::null_mut();
let is_ok = ffi::g_app_info_set_as_default_for_extension(
self.as_ref().to_glib_none().0,
extension.as_ref().to_glib_none().0,
&mut error,
);
debug_assert_eq!(is_ok == glib::ffi::GFALSE, !error.is_null());
if error.is_null() {
Ok(())
} else {
Err(from_glib_full(error))
}
}
}
/// Sets the application as the default handler for a given type.
/// ## `content_type`
/// the content type.
///
/// # Returns
///
/// `TRUE` on success, `FALSE` on error.
#[doc(alias = "g_app_info_set_as_default_for_type")]
fn set_as_default_for_type(&self, content_type: &str) -> Result<(), glib::Error> {
unsafe {
let mut error = std::ptr::null_mut();
let is_ok = ffi::g_app_info_set_as_default_for_type(
self.as_ref().to_glib_none().0,
content_type.to_glib_none().0,
&mut error,
);
debug_assert_eq!(is_ok == glib::ffi::GFALSE, !error.is_null());
if error.is_null() {
Ok(())
} else {
Err(from_glib_full(error))
}
}
}
/// Sets the application as the last used application for a given type. This
/// will make the application appear as first in the list returned by
/// [`AppInfo::recommended_for_type()`][crate::AppInfo::recommended_for_type()], regardless of the default
/// application for that content type.
/// ## `content_type`
/// the content type.
///
/// # Returns
///
/// `TRUE` on success, `FALSE` on error.
#[doc(alias = "g_app_info_set_as_last_used_for_type")]
fn set_as_last_used_for_type(&self, content_type: &str) -> Result<(), glib::Error> {
unsafe {
let mut error = std::ptr::null_mut();
let is_ok = ffi::g_app_info_set_as_last_used_for_type(
self.as_ref().to_glib_none().0,
content_type.to_glib_none().0,
&mut error,
);
debug_assert_eq!(is_ok == glib::ffi::GFALSE, !error.is_null());
if error.is_null() {
Ok(())
} else {
Err(from_glib_full(error))
}
}
}
/// Checks if the application info should be shown in menus that
/// list available applications.
///
/// # Returns
///
/// `TRUE` if the @self should be shown, `FALSE` otherwise.
#[doc(alias = "g_app_info_should_show")]
fn should_show(&self) -> bool {
unsafe { from_glib(ffi::g_app_info_should_show(self.as_ref().to_glib_none().0)) }
}
/// Checks if the application accepts files as arguments.
///
/// # Returns
///
/// `TRUE` if the @self supports files.
#[doc(alias = "g_app_info_supports_files")]
fn supports_files(&self) -> bool {
unsafe {
from_glib(ffi::g_app_info_supports_files(
self.as_ref().to_glib_none().0,
))
}
}
/// Checks if the application supports reading files and directories from URIs.
///
/// # Returns
///
/// `TRUE` if the @self supports URIs.
#[doc(alias = "g_app_info_supports_uris")]
fn supports_uris(&self) -> bool {
unsafe {
from_glib(ffi::g_app_info_supports_uris(
self.as_ref().to_glib_none().0,
))
}
}
}
impl<O: IsA<AppInfo>> AppInfoExt for O {}