Home | History | Annotate | Download | only in gio
      1 /* GIO - GLib Input, Output and Streaming Library
      2  *
      3  * Copyright (C) 2006-2007 Red Hat, Inc.
      4  *
      5  * This library is free software; you can redistribute it and/or
      6  * modify it under the terms of the GNU Lesser General Public
      7  * License as published by the Free Software Foundation; either
      8  * version 2 of the License, or (at your option) any later version.
      9  *
     10  * This library is distributed in the hope that it will be useful,
     11  * but WITHOUT ANY WARRANTY; without even the implied warranty of
     12  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
     13  * Lesser General Public License for more details.
     14  *
     15  * You should have received a copy of the GNU Lesser General
     16  * Public License along with this library; if not, write to the
     17  * Free Software Foundation, Inc., 59 Temple Place, Suite 330,
     18  * Boston, MA 02111-1307, USA.
     19  *
     20  * Author: Alexander Larsson <alexl (at) redhat.com>
     21  */
     22 
     23 #include "config.h"
     24 #include "gappinfo.h"
     25 #include "glibintl.h"
     26 #include <gioerror.h>
     27 #include <gfile.h>
     28 
     29 #include "gioalias.h"
     30 
     31 /**
     32  * SECTION:gappinfo
     33  * @short_description: Application information and launch contexts
     34  * @include: gio/gio.h
     35  *
     36  * #GAppInfo and #GAppLaunchContext are used for describing and launching
     37  * applications installed on the system.
     38  *
     39  * As of GLib 2.20, URIs will always be converted to POSIX paths
     40  * (using g_file_get_path()) when using g_app_info_launch() even if
     41  * the application requested an URI and not a POSIX path. For example
     42  * for an desktop-file based application with Exec key <literal>totem
     43  * %%U</literal> and a single URI,
     44  * <literal>sftp://foo/file.avi</literal>, then
     45  * <literal>/home/user/.gvfs/sftp on foo/file.avi</literal> will be
     46  * passed. This will only work if a set of suitable GIO extensions
     47  * (such as gvfs 2.26 compiled with FUSE support), is available and
     48  * operational; if this is not the case, the URI will be passed
     49  * unmodified to the application. Some URIs, such as
     50  * <literal>mailto:</literal>, of course cannot be mapped to a POSIX
     51  * path (in gvfs there's no FUSE mount for it); such URIs will be
     52  * passed unmodified to the application.
     53  *
     54  * Specifically for gvfs 2.26 and later, the POSIX URI will be mapped
     55  * back to the GIO URI in the #GFile constructors (since gvfs
     56  * implements the #GVfs extension point). As such, if the application
     57  * needs to examine the URI, it needs to use g_file_get_uri() or
     58  * similar on #GFile. In other words, an application cannot assume
     59  * that the URI passed to e.g. g_file_new_for_commandline_arg() is
     60  * equal to the result of g_file_get_uri(). The following snippet
     61  * illustrates this:
     62  *
     63  * <programlisting>
     64  * GFile *f;
     65  * char *uri;
     66  *
     67  * file = g_file_new_for_commandline_arg (uri_from_commandline);
     68  *
     69  * uri = g_file_get_uri (file);
     70  * strcmp (uri, uri_from_commandline) == 0; // FALSE
     71  * g_free (uri);
     72  *
     73  * if (g_file_has_uri_scheme (file, "cdda"))
     74  *   {
     75  *     // do something special with uri
     76  *   }
     77  * g_object_unref (file);
     78  * </programlisting>
     79  *
     80  * This code will work when both <literal>cdda://sr0/Track
     81  * 1.wav</literal> and <literal>/home/user/.gvfs/cdda on sr0/Track
     82  * 1.wav</literal> is passed to the application. It should be noted
     83  * that it's generally not safe for applications to rely on the format
     84  * of a particular URIs. Different launcher applications (e.g. file
     85  * managers) may have different ideas of what a given URI means.
     86  *
     87  **/
     88 
     89 static void g_app_info_base_init (gpointer g_class);
     90 static void g_app_info_class_init (gpointer g_class,
     91 				   gpointer class_data);
     92 
     93 
     94 GType
     95 g_app_info_get_type (void)
     96 {
     97   static volatile gsize g_define_type_id__volatile = 0;
     98 
     99   if (g_once_init_enter (&g_define_type_id__volatile))
    100     {
    101      const GTypeInfo app_info_info =
    102       {
    103         sizeof (GAppInfoIface), /* class_size */
    104 	g_app_info_base_init,   /* base_init */
    105 	NULL,		/* base_finalize */
    106 	g_app_info_class_init,
    107 	NULL,		/* class_finalize */
    108 	NULL,		/* class_data */
    109 	0,
    110 	0,              /* n_preallocs */
    111 	NULL
    112       };
    113       GType g_define_type_id =
    114 	g_type_register_static (G_TYPE_INTERFACE, I_("GAppInfo"),
    115 				&app_info_info, 0);
    116 
    117       g_type_interface_add_prerequisite (g_define_type_id, G_TYPE_OBJECT);
    118 
    119       g_once_init_leave (&g_define_type_id__volatile, g_define_type_id);
    120     }
    121 
    122   return g_define_type_id__volatile;
    123 }
    124 
    125 static void
    126 g_app_info_class_init (gpointer g_class,
    127 		       gpointer class_data)
    128 {
    129 }
    130 
    131 static void
    132 g_app_info_base_init (gpointer g_class)
    133 {
    134 }
    135 
    136 
    137 /**
    138  * g_app_info_dup:
    139  * @appinfo: a #GAppInfo.
    140  *
    141  * Creates a duplicate of a #GAppInfo.
    142  *
    143  * Returns: a duplicate of @appinfo.
    144  **/
    145 GAppInfo *
    146 g_app_info_dup (GAppInfo *appinfo)
    147 {
    148   GAppInfoIface *iface;
    149 
    150   g_return_val_if_fail (G_IS_APP_INFO (appinfo), NULL);
    151 
    152   iface = G_APP_INFO_GET_IFACE (appinfo);
    153 
    154   return (* iface->dup) (appinfo);
    155 }
    156 
    157 /**
    158  * g_app_info_equal:
    159  * @appinfo1: the first #GAppInfo.
    160  * @appinfo2: the second #GAppInfo.
    161  *
    162  * Checks if two #GAppInfos are equal.
    163  *
    164  * Returns: %TRUE if @appinfo1 is equal to @appinfo2. %FALSE otherwise.
    165  **/
    166 gboolean
    167 g_app_info_equal (GAppInfo *appinfo1,
    168 		  GAppInfo *appinfo2)
    169 {
    170   GAppInfoIface *iface;
    171 
    172   g_return_val_if_fail (G_IS_APP_INFO (appinfo1), FALSE);
    173   g_return_val_if_fail (G_IS_APP_INFO (appinfo2), FALSE);
    174 
    175   if (G_TYPE_FROM_INSTANCE (appinfo1) != G_TYPE_FROM_INSTANCE (appinfo2))
    176     return FALSE;
    177 
    178   iface = G_APP_INFO_GET_IFACE (appinfo1);
    179 
    180   return (* iface->equal) (appinfo1, appinfo2);
    181 }
    182 
    183 /**
    184  * g_app_info_get_id:
    185  * @appinfo: a #GAppInfo.
    186  *
    187  * Gets the ID of an application. An id is a string that
    188  * identifies the application. The exact format of the id is
    189  * platform dependent. For instance, on Unix this is the
    190  * desktop file id from the xdg menu specification.
    191  *
    192  * Note that the returned ID may be %NULL, depending on how
    193  * the @appinfo has been constructed.
    194  *
    195  * Returns: a string containing the application's ID.
    196  **/
    197 const char *
    198 g_app_info_get_id (GAppInfo *appinfo)
    199 {
    200   GAppInfoIface *iface;
    201 
    202   g_return_val_if_fail (G_IS_APP_INFO (appinfo), NULL);
    203 
    204   iface = G_APP_INFO_GET_IFACE (appinfo);
    205 
    206   return (* iface->get_id) (appinfo);
    207 }
    208 
    209 /**
    210  * g_app_info_get_name:
    211  * @appinfo: a #GAppInfo.
    212  *
    213  * Gets the installed name of the application.
    214  *
    215  * Returns: the name of the application for @appinfo.
    216  **/
    217 const char *
    218 g_app_info_get_name (GAppInfo *appinfo)
    219 {
    220   GAppInfoIface *iface;
    221 
    222   g_return_val_if_fail (G_IS_APP_INFO (appinfo), NULL);
    223 
    224   iface = G_APP_INFO_GET_IFACE (appinfo);
    225 
    226   return (* iface->get_name) (appinfo);
    227 }
    228 
    229 /**
    230  * g_app_info_get_description:
    231  * @appinfo: a #GAppInfo.
    232  *
    233  * Gets a human-readable description of an installed application.
    234  *
    235  * Returns: a string containing a description of the
    236  * application @appinfo, or %NULL if none.
    237  **/
    238 const char *
    239 g_app_info_get_description (GAppInfo *appinfo)
    240 {
    241   GAppInfoIface *iface;
    242 
    243   g_return_val_if_fail (G_IS_APP_INFO (appinfo), NULL);
    244 
    245   iface = G_APP_INFO_GET_IFACE (appinfo);
    246 
    247   return (* iface->get_description) (appinfo);
    248 }
    249 
    250 /**
    251  * g_app_info_get_executable:
    252  * @appinfo: a #GAppInfo
    253  *
    254  * Gets the executable's name for the installed application.
    255  *
    256  * Returns: a string containing the @appinfo's application
    257  * binary's name
    258  **/
    259 const char *
    260 g_app_info_get_executable (GAppInfo *appinfo)
    261 {
    262   GAppInfoIface *iface;
    263 
    264   g_return_val_if_fail (G_IS_APP_INFO (appinfo), NULL);
    265 
    266   iface = G_APP_INFO_GET_IFACE (appinfo);
    267 
    268   return (* iface->get_executable) (appinfo);
    269 }
    270 
    271 
    272 /**
    273  * g_app_info_get_commandline:
    274  * @appinfo: a #GAppInfo
    275  *
    276  * Gets the commandline with which the application will be
    277  * started.
    278  *
    279  * Returns: a string containing the @appinfo's commandline,
    280  *     or %NULL if this information is not available
    281  *
    282  * Since: 2.20
    283  **/
    284 const char *
    285 g_app_info_get_commandline (GAppInfo *appinfo)
    286 {
    287   GAppInfoIface *iface;
    288 
    289   g_return_val_if_fail (G_IS_APP_INFO (appinfo), NULL);
    290 
    291   iface = G_APP_INFO_GET_IFACE (appinfo);
    292 
    293   if (iface->get_commandline)
    294     return (* iface->get_commandline) (appinfo);
    295 
    296   return NULL;
    297 }
    298 
    299 /**
    300  * g_app_info_set_as_default_for_type:
    301  * @appinfo: a #GAppInfo.
    302  * @content_type: the content type.
    303  * @error: a #GError.
    304  *
    305  * Sets the application as the default handler for a given type.
    306  *
    307  * Returns: %TRUE on success, %FALSE on error.
    308  **/
    309 gboolean
    310 g_app_info_set_as_default_for_type (GAppInfo    *appinfo,
    311 				    const char  *content_type,
    312 				    GError     **error)
    313 {
    314   GAppInfoIface *iface;
    315 
    316   g_return_val_if_fail (G_IS_APP_INFO (appinfo), FALSE);
    317   g_return_val_if_fail (content_type != NULL, FALSE);
    318 
    319   iface = G_APP_INFO_GET_IFACE (appinfo);
    320 
    321   return (* iface->set_as_default_for_type) (appinfo, content_type, error);
    322 }
    323 
    324 
    325 /**
    326  * g_app_info_set_as_default_for_extension:
    327  * @appinfo: a #GAppInfo.
    328  * @extension: a string containing the file extension (without the dot).
    329  * @error: a #GError.
    330  *
    331  * Sets the application as the default handler for the given file extention.
    332  *
    333  * Returns: %TRUE on success, %FALSE on error.
    334  **/
    335 gboolean
    336 g_app_info_set_as_default_for_extension (GAppInfo    *appinfo,
    337 					 const char  *extension,
    338 					 GError     **error)
    339 {
    340   GAppInfoIface *iface;
    341 
    342   g_return_val_if_fail (G_IS_APP_INFO (appinfo), FALSE);
    343   g_return_val_if_fail (extension != NULL, FALSE);
    344 
    345   iface = G_APP_INFO_GET_IFACE (appinfo);
    346 
    347   if (iface->set_as_default_for_extension)
    348     return (* iface->set_as_default_for_extension) (appinfo, extension, error);
    349 
    350   g_set_error_literal (error, G_IO_ERROR, G_IO_ERROR_NOT_SUPPORTED,
    351                        "g_app_info_set_as_default_for_extension not supported yet");
    352   return FALSE;
    353 }
    354 
    355 
    356 /**
    357  * g_app_info_add_supports_type:
    358  * @appinfo: a #GAppInfo.
    359  * @content_type: a string.
    360  * @error: a #GError.
    361  *
    362  * Adds a content type to the application information to indicate the
    363  * application is capable of opening files with the given content type.
    364  *
    365  * Returns: %TRUE on success, %FALSE on error.
    366  **/
    367 gboolean
    368 g_app_info_add_supports_type (GAppInfo    *appinfo,
    369 			      const char  *content_type,
    370 			      GError     **error)
    371 {
    372   GAppInfoIface *iface;
    373 
    374   g_return_val_if_fail (G_IS_APP_INFO (appinfo), FALSE);
    375   g_return_val_if_fail (content_type != NULL, FALSE);
    376 
    377   iface = G_APP_INFO_GET_IFACE (appinfo);
    378 
    379   if (iface->add_supports_type)
    380     return (* iface->add_supports_type) (appinfo, content_type, error);
    381 
    382   g_set_error_literal (error, G_IO_ERROR,
    383                        G_IO_ERROR_NOT_SUPPORTED,
    384                        "g_app_info_add_supports_type not supported yet");
    385 
    386   return FALSE;
    387 }
    388 
    389 
    390 /**
    391  * g_app_info_can_remove_supports_type:
    392  * @appinfo: a #GAppInfo.
    393  *
    394  * Checks if a supported content type can be removed from an application.
    395  *
    396  * Returns: %TRUE if it is possible to remove supported
    397  *     content types from a given @appinfo, %FALSE if not.
    398  **/
    399 gboolean
    400 g_app_info_can_remove_supports_type (GAppInfo *appinfo)
    401 {
    402   GAppInfoIface *iface;
    403 
    404   g_return_val_if_fail (G_IS_APP_INFO (appinfo), FALSE);
    405 
    406   iface = G_APP_INFO_GET_IFACE (appinfo);
    407 
    408   if (iface->can_remove_supports_type)
    409     return (* iface->can_remove_supports_type) (appinfo);
    410 
    411   return FALSE;
    412 }
    413 
    414 
    415 /**
    416  * g_app_info_remove_supports_type:
    417  * @appinfo: a #GAppInfo.
    418  * @content_type: a string.
    419  * @error: a #GError.
    420  *
    421  * Removes a supported type from an application, if possible.
    422  *
    423  * Returns: %TRUE on success, %FALSE on error.
    424  **/
    425 gboolean
    426 g_app_info_remove_supports_type (GAppInfo    *appinfo,
    427 				 const char  *content_type,
    428 				 GError     **error)
    429 {
    430   GAppInfoIface *iface;
    431 
    432   g_return_val_if_fail (G_IS_APP_INFO (appinfo), FALSE);
    433   g_return_val_if_fail (content_type != NULL, FALSE);
    434 
    435   iface = G_APP_INFO_GET_IFACE (appinfo);
    436 
    437   if (iface->remove_supports_type)
    438     return (* iface->remove_supports_type) (appinfo, content_type, error);
    439 
    440   g_set_error_literal (error, G_IO_ERROR,
    441                        G_IO_ERROR_NOT_SUPPORTED,
    442                        "g_app_info_remove_supports_type not supported yet");
    443 
    444   return FALSE;
    445 }
    446 
    447 
    448 /**
    449  * g_app_info_get_icon:
    450  * @appinfo: a #GAppInfo.
    451  *
    452  * Gets the icon for the application.
    453  *
    454  * Returns: the default #GIcon for @appinfo.
    455  **/
    456 GIcon *
    457 g_app_info_get_icon (GAppInfo *appinfo)
    458 {
    459   GAppInfoIface *iface;
    460 
    461   g_return_val_if_fail (G_IS_APP_INFO (appinfo), NULL);
    462 
    463   iface = G_APP_INFO_GET_IFACE (appinfo);
    464 
    465   return (* iface->get_icon) (appinfo);
    466 }
    467 
    468 
    469 /**
    470  * g_app_info_launch:
    471  * @appinfo: a #GAppInfo
    472  * @files: a #GList of #GFile objects
    473  * @launch_context: a #GAppLaunchContext or %NULL
    474  * @error: a #GError
    475  *
    476  * Launches the application. Passes @files to the launched application
    477  * as arguments, using the optional @launch_context to get information
    478  * about the details of the launcher (like what screen it is on).
    479  * On error, @error will be set accordingly.
    480  *
    481  * To lauch the application without arguments pass a %NULL @files list.
    482  *
    483  * Note that even if the launch is successful the application launched
    484  * can fail to start if it runs into problems during startup. There is
    485  * no way to detect this.
    486  *
    487  * Some URIs can be changed when passed through a GFile (for instance
    488  * unsupported uris with strange formats like mailto:), so if you have
    489  * a textual uri you want to pass in as argument, consider using
    490  * g_app_info_launch_uris() instead.
    491  *
    492  * Returns: %TRUE on successful launch, %FALSE otherwise.
    493  **/
    494 gboolean
    495 g_app_info_launch (GAppInfo           *appinfo,
    496 		   GList              *files,
    497 		   GAppLaunchContext  *launch_context,
    498 		   GError            **error)
    499 {
    500   GAppInfoIface *iface;
    501 
    502   g_return_val_if_fail (G_IS_APP_INFO (appinfo), FALSE);
    503 
    504   iface = G_APP_INFO_GET_IFACE (appinfo);
    505 
    506   return (* iface->launch) (appinfo, files, launch_context, error);
    507 }
    508 
    509 
    510 /**
    511  * g_app_info_supports_uris:
    512  * @appinfo: a #GAppInfo.
    513  *
    514  * Checks if the application supports reading files and directories from URIs.
    515  *
    516  * Returns: %TRUE if the @appinfo supports URIs.
    517  **/
    518 gboolean
    519 g_app_info_supports_uris (GAppInfo *appinfo)
    520 {
    521   GAppInfoIface *iface;
    522 
    523   g_return_val_if_fail (G_IS_APP_INFO (appinfo), FALSE);
    524 
    525   iface = G_APP_INFO_GET_IFACE (appinfo);
    526 
    527   return (* iface->supports_uris) (appinfo);
    528 }
    529 
    530 
    531 /**
    532  * g_app_info_supports_files:
    533  * @appinfo: a #GAppInfo.
    534  *
    535  * Checks if the application accepts files as arguments.
    536  *
    537  * Returns: %TRUE if the @appinfo supports files.
    538  **/
    539 gboolean
    540 g_app_info_supports_files (GAppInfo *appinfo)
    541 {
    542   GAppInfoIface *iface;
    543 
    544   g_return_val_if_fail (G_IS_APP_INFO (appinfo), FALSE);
    545 
    546   iface = G_APP_INFO_GET_IFACE (appinfo);
    547 
    548   return (* iface->supports_files) (appinfo);
    549 }
    550 
    551 
    552 /**
    553  * g_app_info_launch_uris:
    554  * @appinfo: a #GAppInfo
    555  * @uris: a #GList containing URIs to launch.
    556  * @launch_context: a #GAppLaunchContext or %NULL
    557  * @error: a #GError
    558  *
    559  * Launches the application. Passes @uris to the launched application
    560  * as arguments, using the optional @launch_context to get information
    561  * about the details of the launcher (like what screen it is on).
    562  * On error, @error will be set accordingly.
    563  *
    564  * To lauch the application without arguments pass a %NULL @uris list.
    565  *
    566  * Note that even if the launch is successful the application launched
    567  * can fail to start if it runs into problems during startup. There is
    568  * no way to detect this.
    569  *
    570  * Returns: %TRUE on successful launch, %FALSE otherwise.
    571  **/
    572 gboolean
    573 g_app_info_launch_uris (GAppInfo           *appinfo,
    574 			GList              *uris,
    575 			GAppLaunchContext  *launch_context,
    576 			GError            **error)
    577 {
    578   GAppInfoIface *iface;
    579 
    580   g_return_val_if_fail (G_IS_APP_INFO (appinfo), FALSE);
    581 
    582   iface = G_APP_INFO_GET_IFACE (appinfo);
    583 
    584   return (* iface->launch_uris) (appinfo, uris, launch_context, error);
    585 }
    586 
    587 
    588 /**
    589  * g_app_info_should_show:
    590  * @appinfo: a #GAppInfo.
    591  *
    592  * Checks if the application info should be shown in menus that
    593  * list available applications.
    594  *
    595  * Returns: %TRUE if the @appinfo should be shown, %FALSE otherwise.
    596  **/
    597 gboolean
    598 g_app_info_should_show (GAppInfo *appinfo)
    599 {
    600   GAppInfoIface *iface;
    601 
    602   g_return_val_if_fail (G_IS_APP_INFO (appinfo), FALSE);
    603 
    604   iface = G_APP_INFO_GET_IFACE (appinfo);
    605 
    606   return (* iface->should_show) (appinfo);
    607 }
    608 
    609 /**
    610  * g_app_info_launch_default_for_uri:
    611  * @uri: the uri to show
    612  * @launch_context: an optional #GAppLaunchContext.
    613  * @error: a #GError.
    614  *
    615  * Utility function that launches the default application
    616  * registered to handle the specified uri. Synchronous I/O
    617  * is done on the uri to detect the type of the file if
    618  * required.
    619  *
    620  * Returns: %TRUE on success, %FALSE on error.
    621  **/
    622 gboolean
    623 g_app_info_launch_default_for_uri (const char         *uri,
    624 				   GAppLaunchContext  *launch_context,
    625 				   GError            **error)
    626 {
    627   GAppInfo *app_info;
    628   GFile *file;
    629   GList l;
    630   gboolean res;
    631 
    632   file = g_file_new_for_uri (uri);
    633   app_info = g_file_query_default_handler (file, NULL, error);
    634   g_object_unref (file);
    635   if (app_info == NULL)
    636     return FALSE;
    637 
    638   /* Use the uri, not the GFile, as the GFile roundtrip may
    639    * affect the uri which we don't want (for instance for a
    640    * mailto: uri).
    641    */
    642   l.data = (char *)uri;
    643   l.next = l.prev = NULL;
    644   res = g_app_info_launch_uris (app_info, &l,
    645 				launch_context, error);
    646 
    647   g_object_unref (app_info);
    648 
    649   return res;
    650 }
    651 
    652 /**
    653  * g_app_info_can_delete:
    654  * @appinfo: a #GAppInfo
    655  *
    656  * Obtains the information whether the GAppInfo can be deleted.
    657  * See g_app_info_delete().
    658  *
    659  * Returns: %TRUE if @appinfo can be deleted
    660  *
    661  * Since: 2.20
    662  */
    663 gboolean
    664 g_app_info_can_delete (GAppInfo *appinfo)
    665 {
    666   GAppInfoIface *iface;
    667 
    668   g_return_val_if_fail (G_IS_APP_INFO (appinfo), FALSE);
    669 
    670   iface = G_APP_INFO_GET_IFACE (appinfo);
    671 
    672   if (iface->can_delete)
    673     return (* iface->can_delete) (appinfo);
    674 
    675   return FALSE;
    676 }
    677 
    678 
    679 /**
    680  * g_app_info_delete:
    681  * @appinfo: a #GAppInfo
    682  *
    683  * Tries to delete an #GAppInfo.
    684  *
    685  * On some platforms, there may be a difference between user-defined
    686  * #GAppInfo<!-- -->s which can be deleted, and system-wide ones which
    687  * cannot. See g_app_info_can_delete().
    688  *
    689  * Returns: %TRUE if @appinfo has been deleted
    690  *
    691  * Since: 2.20
    692  */
    693 gboolean
    694 g_app_info_delete (GAppInfo *appinfo)
    695 {
    696   GAppInfoIface *iface;
    697 
    698   g_return_val_if_fail (G_IS_APP_INFO (appinfo), FALSE);
    699 
    700   iface = G_APP_INFO_GET_IFACE (appinfo);
    701 
    702   if (iface->do_delete)
    703     return (* iface->do_delete) (appinfo);
    704 
    705   return FALSE;
    706 }
    707 
    708 
    709 G_DEFINE_TYPE (GAppLaunchContext, g_app_launch_context, G_TYPE_OBJECT);
    710 
    711 /**
    712  * g_app_launch_context_new:
    713  *
    714  * Creates a new application launch context. This is not normally used,
    715  * instead you instantiate a subclass of this, such as #GdkAppLaunchContext.
    716  *
    717  * Returns: a #GAppLaunchContext.
    718  **/
    719 GAppLaunchContext *
    720 g_app_launch_context_new (void)
    721 {
    722   return g_object_new (G_TYPE_APP_LAUNCH_CONTEXT, NULL);
    723 }
    724 
    725 static void
    726 g_app_launch_context_class_init (GAppLaunchContextClass *klass)
    727 {
    728 }
    729 
    730 static void
    731 g_app_launch_context_init (GAppLaunchContext *launch_context)
    732 {
    733 }
    734 
    735 /**
    736  * g_app_launch_context_get_display:
    737  * @context: a #GAppLaunchContext
    738  * @info: a #GAppInfo
    739  * @files: a #GList of #GFile objects
    740  *
    741  * Gets the display string for the display. This is used to ensure new
    742  * applications are started on the same display as the launching
    743  * application.
    744  *
    745  * Returns: a display string for the display.
    746  **/
    747 char *
    748 g_app_launch_context_get_display (GAppLaunchContext *context,
    749 				  GAppInfo          *info,
    750 				  GList             *files)
    751 {
    752   GAppLaunchContextClass *class;
    753 
    754   g_return_val_if_fail (G_IS_APP_LAUNCH_CONTEXT (context), NULL);
    755   g_return_val_if_fail (G_IS_APP_INFO (info), NULL);
    756 
    757   class = G_APP_LAUNCH_CONTEXT_GET_CLASS (context);
    758 
    759   if (class->get_display == NULL)
    760     return NULL;
    761 
    762   return class->get_display (context, info, files);
    763 }
    764 
    765 /**
    766  * g_app_launch_context_get_startup_notify_id:
    767  * @context: a #GAppLaunchContext
    768  * @info: a #GAppInfo
    769  * @files: a #GList of of #GFile objects
    770  *
    771  * Initiates startup notification for the application and returns the
    772  * DESKTOP_STARTUP_ID for the launched operation, if supported.
    773  *
    774  * Startup notification IDs are defined in the <ulink
    775  * url="http://standards.freedesktop.org/startup-notification-spec/startup-notification-latest.txt">
    776  * FreeDesktop.Org Startup Notifications standard</ulink>.
    777  *
    778  * Returns: a startup notification ID for the application, or %NULL if
    779  *     not supported.
    780  **/
    781 char *
    782 g_app_launch_context_get_startup_notify_id (GAppLaunchContext *context,
    783 					    GAppInfo          *info,
    784 					    GList             *files)
    785 {
    786   GAppLaunchContextClass *class;
    787 
    788   g_return_val_if_fail (G_IS_APP_LAUNCH_CONTEXT (context), NULL);
    789   g_return_val_if_fail (G_IS_APP_INFO (info), NULL);
    790 
    791   class = G_APP_LAUNCH_CONTEXT_GET_CLASS (context);
    792 
    793   if (class->get_startup_notify_id == NULL)
    794     return NULL;
    795 
    796   return class->get_startup_notify_id (context, info, files);
    797 }
    798 
    799 
    800 /**
    801  * g_app_launch_context_launch_failed:
    802  * @context: a #GAppLaunchContext.
    803  * @startup_notify_id: the startup notification id that was returned by g_app_launch_context_get_startup_notify_id().
    804  *
    805  * Called when an application has failed to launch, so that it can cancel
    806  * the application startup notification started in g_app_launch_context_get_startup_notify_id().
    807  *
    808  **/
    809 void
    810 g_app_launch_context_launch_failed (GAppLaunchContext *context,
    811 				    const char        *startup_notify_id)
    812 {
    813   GAppLaunchContextClass *class;
    814 
    815   g_return_if_fail (G_IS_APP_LAUNCH_CONTEXT (context));
    816   g_return_if_fail (startup_notify_id != NULL);
    817 
    818   class = G_APP_LAUNCH_CONTEXT_GET_CLASS (context);
    819 
    820   if (class->launch_failed != NULL)
    821     class->launch_failed (context, startup_notify_id);
    822 }
    823 
    824 
    825 #define __G_APP_INFO_C__
    826 #include "gioaliasdef.c"
    827