Package ch.bailu.gtk.gio

Class AppInfo

java.lang.Object
ch.bailu.gtk.type.Type
ch.bailu.gtk.type.Pointer
ch.bailu.gtk.gobject.Object
ch.bailu.gtk.type.Interface
ch.bailu.gtk.gio.AppInfo
All Implemented Interfaces:
PointerInterface
public class AppInfo extends Interface
#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 g_file_get_path()) when using g_app_info_launch() even if
the application requested an URI and not a POSIX path. For example
for a desktop-file based application with Exec key `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 #GFile constructors (since gvfs
implements the #GVfs extension point). As such, if the application
needs to examine the URI, it needs to use g_file_get_uri() or
similar on #GFile. In other words, an application cannot assume
that the URI passed to e.g. g_file_new_for_commandline_arg() is
equal to the result of g_file_get_uri(). The following snippet
illustrates this: 
 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.

https://docs.gtk.org/gio/iface.AppInfo.html

  • Constructor Details

  • Method Details

    • getClassHandler

      public static ClassHandler getClassHandler()

    • addSupportsType

      public boolean addSupportsType(@Nonnull Str content_type) throws AllocationError
      Adds a content type to the application information to indicate the
      application is capable of opening files with the given content type.
      Parameters:
      content_type - a string.
      Returns:
      %TRUE on success, %FALSE on error.
      Throws:
      AllocationError

    • addSupportsType

      public boolean addSupportsType(String content_type) throws AllocationError
      Adds a content type to the application information to indicate the
      application is capable of opening files with the given content type.
      Parameters:
      content_type - a string.
      Returns:
      %TRUE on success, %FALSE on error.
      Throws:
      AllocationError

    • canDelete

      public boolean canDelete()
      Obtains the information whether the #GAppInfo can be deleted.
      See g_app_info_delete().
      Returns:
      %TRUE if @appinfo can be deleted

    • canRemoveSupportsType

      public boolean canRemoveSupportsType()
      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 @appinfo, %FALSE if not.

    • delete

      public boolean delete()
      Tries to delete a #GAppInfo.

      On some platforms, there may be a difference between user-defined
      #GAppInfos which can be deleted, and system-wide ones which cannot.
      See g_app_info_can_delete().
      Returns:
      %TRUE if @appinfo has been deleted

    • dup

      public AppInfo dup()
      Creates a duplicate of a #GAppInfo.
      Returns:
      a duplicate of @appinfo.

    • equal

      public boolean equal(@Nonnull AppInfo appinfo2)
      Checks if two #GAppInfos are equal.

      Note that the check *may not* compare each individual
      field, and only does an identity check. In case detecting changes in the
      contents is needed, program code must additionally compare relevant fields.
      Parameters:
      appinfo2 - the second #GAppInfo.
      Returns:
      %TRUE if @appinfo1 is equal to @appinfo2. %FALSE otherwise.

    • getCommandline

      public Str getCommandline()
      Gets the commandline with which the application will be
      started.
      Returns:
      a string containing the @appinfo's commandline, or %NULL if this information is not available

    • getDescription

      public Str getDescription()
      Gets a human-readable description of an installed application.
      Returns:
      a string containing a description of the application @appinfo, or %NULL if none.

    • getDisplayName

      public Str getDisplayName()
      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 @appinfo, or the name if no display name is available.

    • getExecutable

      public Str getExecutable()
      Gets the executable's name for the installed application.
      Returns:
      a string containing the @appinfo's application binaries name

    • getIcon

      public Icon getIcon()
      Gets the icon for the application.
      Returns:
      the default #GIcon for @appinfo or %NULL if there is no default icon.

    • getId

      public Str getId()
      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 @appinfo has been constructed.
      Returns:
      a string containing the application's ID.

    • getName

      public Str getName()
      Gets the installed name of the application.
      Returns:
      the name of the application for @appinfo.

    • getSupportedTypes

      public Strs getSupportedTypes()
      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
      g_app_info_add_supports_type(), but only those exported directly by
      the application.
      Returns:
      a list of content types.

    • launch

      public boolean launch(@Nullable List files, @Nullable AppLaunchContext context) throws AllocationError
      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
      g_app_info_launch_uris() instead.

      The launched application inherits the environment of the launching
      process, but it can be modified with g_app_launch_context_setenv()
      and g_app_launch_context_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` and
      `DESKTOP_STARTUP_ID` environment variables are also set, based
      on information provided in @context.
      Parameters:
      files - a #GList of #GFile objects
      context - a #GAppLaunchContext or %NULL
      Returns:
      %TRUE on successful launch, %FALSE otherwise.
      Throws:
      AllocationError

    • launchUris

      public boolean launchUris(@Nullable List uris, @Nullable AppLaunchContext context) throws AllocationError
      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.
      Parameters:
      uris - a #GList containing URIs to launch.
      context - a #GAppLaunchContext or %NULL
      Returns:
      %TRUE on successful launch, %FALSE otherwise.
      Throws:
      AllocationError

    • launchUrisAsync

      public void launchUrisAsync(@Nullable List uris, @Nullable AppLaunchContext context, @Nullable Cancellable cancellable, AppInfo.OnAsyncReadyCallback callback, @Nullable Pointer user_data)
      Async version of g_app_info_launch_uris().

      The @callback is invoked immediately after the application launch, but it
      waits for activation in case of D-Bus–activated applications and also provides
      extended error information for sandboxed applications, see notes for
      g_app_info_launch_default_for_uri_async().
      Parameters:
      uris - a #GList containing URIs to launch.
      context - a #GAppLaunchContext or %NULL
      cancellable - a #GCancellable
      callback - a #GAsyncReadyCallback to call when the request is done
      user_data - data to pass to @callback

    • launchUrisFinish

      public boolean launchUrisFinish(@Nonnull AsyncResult result) throws AllocationError
      Finishes a g_app_info_launch_uris_async() operation.
      Parameters:
      result - a #GAsyncResult
      Returns:
      %TRUE on successful launch, %FALSE otherwise.
      Throws:
      AllocationError

    • removeSupportsType

      public boolean removeSupportsType(@Nonnull Str content_type) throws AllocationError
      Removes a supported type from an application, if possible.
      Parameters:
      content_type - a string.
      Returns:
      %TRUE on success, %FALSE on error.
      Throws:
      AllocationError

    • removeSupportsType

      public boolean removeSupportsType(String content_type) throws AllocationError
      Removes a supported type from an application, if possible.
      Parameters:
      content_type - a string.
      Returns:
      %TRUE on success, %FALSE on error.
      Throws:
      AllocationError

    • setAsDefaultForExtension

      public boolean setAsDefaultForExtension(@Nonnull Str extension) throws AllocationError
      Sets the application as the default handler for the given file extension.
      Parameters:
      extension - a string containing the file extension (without the dot).
      Returns:
      %TRUE on success, %FALSE on error.
      Throws:
      AllocationError

    • setAsDefaultForExtension

      public boolean setAsDefaultForExtension(String extension) throws AllocationError
      Sets the application as the default handler for the given file extension.
      Parameters:
      extension - a string containing the file extension (without the dot).
      Returns:
      %TRUE on success, %FALSE on error.
      Throws:
      AllocationError

    • setAsDefaultForType

      public boolean setAsDefaultForType(@Nonnull Str content_type) throws AllocationError
      Sets the application as the default handler for a given type.
      Parameters:
      content_type - the content type.
      Returns:
      %TRUE on success, %FALSE on error.
      Throws:
      AllocationError

    • setAsDefaultForType

      public boolean setAsDefaultForType(String content_type) throws AllocationError
      Sets the application as the default handler for a given type.
      Parameters:
      content_type - the content type.
      Returns:
      %TRUE on success, %FALSE on error.
      Throws:
      AllocationError

    • setAsLastUsedForType

      public boolean setAsLastUsedForType(@Nonnull Str content_type) throws AllocationError
      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 g_app_info_get_recommended_for_type(), regardless of the default
      application for that content type.
      Parameters:
      content_type - the content type.
      Returns:
      %TRUE on success, %FALSE on error.
      Throws:
      AllocationError

    • setAsLastUsedForType

      public boolean setAsLastUsedForType(String content_type) throws AllocationError
      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 g_app_info_get_recommended_for_type(), regardless of the default
      application for that content type.
      Parameters:
      content_type - the content type.
      Returns:
      %TRUE on success, %FALSE on error.
      Throws:
      AllocationError

    • shouldShow

      public boolean shouldShow()
      Checks if the application info should be shown in menus that
      list available applications.
      Returns:
      %TRUE if the @appinfo should be shown, %FALSE otherwise.

    • supportsFiles

      public boolean supportsFiles()
      Checks if the application accepts files as arguments.
      Returns:
      %TRUE if the @appinfo supports files.

    • supportsUris

      public boolean supportsUris()
      Checks if the application supports reading files and directories from URIs.
      Returns:
      %TRUE if the @appinfo supports URIs.

    • createFromCommandline

      public static AppInfo createFromCommandline(@Nonnull Str commandline, @Nullable Str application_name, int flags) throws AllocationError
      Creates a new #GAppInfo 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 for exact quoting rules.
      Parameters:
      commandline - the commandline to use
      application_name - the application name, or %NULL to use @commandline
      flags - flags that can specify details of the created #GAppInfo
      Returns:
      new #GAppInfo for given command.
      Throws:
      AllocationError

    • getAll

      public static List getAll()
      Gets a list of all of the applications currently registered
      on this system.

      For desktop files, this includes applications that have
      `NoDisplay=true` set or are excluded from display by means
      of `OnlyShowIn` or `NotShowIn`. See g_app_info_should_show().
      The returned list does not include applications which have
      the `Hidden` key set.
      Returns:
      a newly allocated #GList of references to #GAppInfos.

    • getAllForType

      public static List getAllForType(@Nonnull Str content_type)
      Gets a list of all #GAppInfos for a given content type,
      including the recommended and fallback #GAppInfos. See
      g_app_info_get_recommended_for_type() and
      g_app_info_get_fallback_for_type().
      Parameters:
      content_type - the content type to find a #GAppInfo for
      Returns:
      #GList of #GAppInfos for given @content_type or %NULL on error.

    • getDefaultForType

      public static AppInfo getDefaultForType(@Nonnull Str content_type, boolean must_support_uris)
      Gets the default #GAppInfo for a given content type.
      Parameters:
      content_type - the content type to find a #GAppInfo for
      must_support_uris - if %TRUE, the #GAppInfo is expected to support URIs
      Returns:
      #GAppInfo for given @content_type or %NULL on error.

    • getDefaultForTypeAsync

      public static void getDefaultForTypeAsync(@Nonnull Str content_type, boolean must_support_uris, @Nullable Cancellable cancellable, AppInfo.OnAsyncReadyCallback callback, @Nullable Pointer user_data)
      Asynchronously gets the default #GAppInfo for a given content type.
      Parameters:
      content_type - the content type to find a #GAppInfo for
      must_support_uris - if %TRUE, the #GAppInfo is expected to support URIs
      cancellable - optional #GCancellable object, %NULL to ignore
      callback - a #GAsyncReadyCallback to call when the request is done
      user_data - data to pass to @callback

    • getDefaultForTypeFinish

      public static AppInfo getDefaultForTypeFinish(@Nonnull AsyncResult result) throws AllocationError
      Finishes a default #GAppInfo lookup started by
      g_app_info_get_default_for_type_async().

      If no #GAppInfo is found, then @error will be set to %G_IO_ERROR_NOT_FOUND.
      Parameters:
      result - a #GAsyncResult
      Returns:
      #GAppInfo for given @content_type or %NULL on error.
      Throws:
      AllocationError

    • getDefaultForUriScheme

      public static AppInfo getDefaultForUriScheme(@Nonnull Str uri_scheme)
      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".
      Parameters:
      uri_scheme - a string containing a URI scheme.
      Returns:
      #GAppInfo for given @uri_scheme or %NULL on error.

    • getDefaultForUriSchemeAsync

      public static void getDefaultForUriSchemeAsync(@Nonnull Str uri_scheme, @Nullable Cancellable cancellable, AppInfo.OnAsyncReadyCallback callback, @Nullable Pointer user_data)
      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".
      Parameters:
      uri_scheme - a string containing a URI scheme.
      cancellable - optional #GCancellable object, %NULL to ignore
      callback - a #GAsyncReadyCallback to call when the request is done
      user_data - data to pass to @callback

    • getDefaultForUriSchemeFinish

      public static AppInfo getDefaultForUriSchemeFinish(@Nonnull AsyncResult result) throws AllocationError
      Finishes a default #GAppInfo lookup started by
      g_app_info_get_default_for_uri_scheme_async().

      If no #GAppInfo is found, then @error will be set to %G_IO_ERROR_NOT_FOUND.
      Parameters:
      result - a #GAsyncResult
      Returns:
      #GAppInfo for given @uri_scheme or %NULL on error.
      Throws:
      AllocationError

    • getFallbackForType

      public static List getFallbackForType(@Nonnull Str content_type)
      Gets a list of fallback #GAppInfos for a given content type, i.e.
      those applications which claim to support the given content type
      by MIME type subclassing and not directly.
      Parameters:
      content_type - the content type to find a #GAppInfo for
      Returns:
      #GList of #GAppInfos for given @content_type or %NULL on error.

    • getRecommendedForType

      public static List getRecommendedForType(@Nonnull Str content_type)
      Gets a list of recommended #GAppInfos 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 g_app_info_set_as_last_used_for_type() has been
      called.
      Parameters:
      content_type - the content type to find a #GAppInfo for
      Returns:
      #GList of #GAppInfos for given @content_type or %NULL on error.

    • launchDefaultForUri

      public static boolean launchDefaultForUri(@Nonnull Str uri, @Nullable AppLaunchContext context) throws AllocationError
      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
      g_app_info_launch_default_for_uri_async() instead.
      Parameters:
      uri - the uri to show
      context - an optional #GAppLaunchContext
      Returns:
      %TRUE on success, %FALSE on error.
      Throws:
      AllocationError

    • launchDefaultForUriAsync

      public static void launchDefaultForUriAsync(@Nonnull Str uri, @Nullable AppLaunchContext context, @Nullable Cancellable cancellable, AppInfo.OnAsyncReadyCallback callback, @Nullable Pointer user_data)
      Async version of g_app_info_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.
      Parameters:
      uri - the uri to show
      context - an optional #GAppLaunchContext
      cancellable - a #GCancellable
      callback - a #GAsyncReadyCallback to call when the request is done
      user_data - data to pass to @callback

    • launchDefaultForUriFinish

      public static boolean launchDefaultForUriFinish(@Nonnull AsyncResult result) throws AllocationError
      Finishes an asynchronous launch-default-for-uri operation.
      Parameters:
      result - a #GAsyncResult
      Returns:
      %TRUE if the launch was successful, %FALSE if @error is set
      Throws:
      AllocationError

    • resetTypeAssociations

      public static void resetTypeAssociations(@Nonnull Str content_type)
      Removes all changes to the type associations done by
      g_app_info_set_as_default_for_type(),
      g_app_info_set_as_default_for_extension(),
      g_app_info_add_supports_type() or
      g_app_info_remove_supports_type().
      Parameters:
      content_type - a content type

    • getTypeID

      public static long getTypeID()

    • getParentTypeID

      public static long getParentTypeID()

    • getTypeSize

      public static TypeSystem.TypeSize getTypeSize()

    • getParentTypeSize

      public static TypeSystem.TypeSize getParentTypeSize()

    • getInstanceSize

      public static int getInstanceSize()