static gboolean panel_app_info_launch_uris (GAppInfo *appinfo, GList *uris, GdkScreen *screen, guint32 timestamp, GError **error) { GdkAppLaunchContext *context; GError *local_error; GdkDisplay *display; g_return_val_if_fail (G_IS_APP_INFO (appinfo), FALSE); g_return_val_if_fail (GDK_IS_SCREEN (screen), FALSE); g_return_val_if_fail (error == NULL || *error == NULL, FALSE); display = gdk_screen_get_display (screen); context = gdk_display_get_app_launch_context (display); gdk_app_launch_context_set_screen (context, screen); gdk_app_launch_context_set_timestamp (context, timestamp); local_error = NULL; g_app_info_launch_uris (appinfo, uris, (GAppLaunchContext *) context, &local_error); g_object_unref (context); return _panel_launch_handle_error (g_app_info_get_name (appinfo), screen, local_error, error); }
NS_IMETHODIMP nsGIOMimeApp::Launch(const nsACString& aUri) { char *uri = strdup(PromiseFlatCString(aUri).get()); if (!uri) return NS_ERROR_OUT_OF_MEMORY; GList *uris = g_list_append(NULL, uri); if (!uris) { g_free(uri); return NS_ERROR_OUT_OF_MEMORY; } GError *error = NULL; gboolean result = g_app_info_launch_uris(mApp, uris, NULL, &error); g_free(uri); g_list_free(uris); if (!result) { g_warning("Cannot launch application: %s", error->message); g_error_free(error); return NS_ERROR_FAILURE; } return NS_OK; }
gboolean panel_app_info_launch_uris (GAppInfo *appinfo, GList *uris, GdkScreen *screen, guint32 timestamp, GError **error) { GdkAppLaunchContext *context; GError *local_error; gboolean retval; g_return_val_if_fail (G_IS_APP_INFO (appinfo), FALSE); g_return_val_if_fail (GDK_IS_SCREEN (screen), FALSE); g_return_val_if_fail (error == NULL || *error == NULL, FALSE); context = gdk_app_launch_context_new (); gdk_app_launch_context_set_screen (context, screen); gdk_app_launch_context_set_timestamp (context, timestamp); local_error = NULL; retval = g_app_info_launch_uris (appinfo, uris, (GAppLaunchContext *) context, &local_error); g_object_unref (context); if ((local_error == NULL) && (retval == TRUE)) return TRUE; return _panel_launch_handle_error (g_app_info_get_name (appinfo), screen, local_error, error); }
static void on_open_with_easytag (NautilusMenuItem *item, gpointer data) { GList *files; GDesktopAppInfo *appinfo; files = g_object_get_data (G_OBJECT (item), "files"); appinfo = g_desktop_app_info_new ("easytag.desktop"); if (appinfo) { GdkAppLaunchContext *context; GList *l; GList *uris = NULL; for (l = files; l != NULL; l = g_list_next (l)) { uris = g_list_append (uris, nautilus_file_info_get_uri (l->data)); } context = gdk_display_get_app_launch_context (gdk_display_get_default ()); g_app_info_launch_uris (G_APP_INFO (appinfo), uris, G_APP_LAUNCH_CONTEXT (context), NULL); } }
/** * g_app_info_launch_default_for_uri: * @uri: the uri to show * @launch_context: an optional #GAppLaunchContext. * @error: a #GError. * * 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. * * Returns: %TRUE on success, %FALSE on error. **/ gboolean g_app_info_launch_default_for_uri (const char *uri, GAppLaunchContext *launch_context, GError **error) { GAppInfo *app_info; GFile *file; GList l; gboolean res; file = g_file_new_for_uri (uri); app_info = g_file_query_default_handler (file, NULL, error); g_object_unref (file); if (app_info == NULL) return FALSE; /* Use the uri, not the GFile, as the GFile roundtrip may * affect the uri which we don't want (for instance for a * mailto: uri). */ l.data = (char *)uri; l.next = l.prev = NULL; res = g_app_info_launch_uris (app_info, &l, launch_context, error); g_object_unref (app_info); return res; }
void open_file_with_application (GFile *file) { GAppInfo *application; gchar *primary; GFileInfo *info; gchar *uri_scheme; const char *content; gboolean local = FALSE; info = g_file_query_info (file, G_FILE_ATTRIBUTE_STANDARD_CONTENT_TYPE, G_FILE_QUERY_INFO_NONE, NULL, NULL); if (!info) return; uri_scheme = g_file_get_uri_scheme (file); if (g_ascii_strcasecmp(uri_scheme,"file") == 0) local = TRUE; content = g_file_info_get_content_type (info); application = g_app_info_get_default_for_type (content, TRUE); if (!application) { primary = g_strdup_printf (_("Could not open folder \"%s\""), g_file_get_basename (file)); message (primary, _("There is no installed viewer capable " "of displaying the folder."), GTK_MESSAGE_ERROR, baobab.window); g_free (primary); } else { GList *uris = NULL; gchar *uri; uri = g_file_get_uri (file); uris = g_list_append (uris, uri); g_app_info_launch_uris (application, uris, NULL, NULL); g_list_free (uris); g_free (uri); } g_free (uri_scheme); if (application) g_object_unref (application); g_object_unref (info); }
gboolean fm_launch_desktop_entry(GAppLaunchContext* ctx, const char* file_or_id, GList* uris, GError** err) { GKeyFile* kf = g_key_file_new(); gboolean loaded; gboolean ret = FALSE; if(g_path_is_absolute(file_or_id)) loaded = g_key_file_load_from_file(kf, file_or_id, 0, err); else { char* tmp = g_strconcat("applications/", file_or_id, NULL); loaded = g_key_file_load_from_data_dirs(kf, tmp, NULL, 0, err); g_free(tmp); } if(loaded) { GList* _uris = NULL; GAppInfo* app = NULL; char* type = g_key_file_get_string(kf, G_KEY_FILE_DESKTOP_GROUP, "Type", NULL); if(type) { if(strcmp(type, "Application") == 0) app = g_desktop_app_info_new_from_keyfile(kf); else if(strcmp(type, "Link") == 0) { char* url = g_key_file_get_string(kf, G_KEY_FILE_DESKTOP_GROUP, "URL", NULL); if(url) { char* scheme = g_uri_parse_scheme(url); if(scheme) { /* Damn! this actually relies on gconf to work. */ /* FIXME: use our own way to get a usable browser later. */ app = g_app_info_get_default_for_uri_scheme(scheme); uris = _uris = g_list_prepend(NULL, url); g_free(scheme); } } } else if(strcmp(type, "Directory") == 0) { /* FIXME: how should this work? It's not defined in the spec. */ } if(app) ret = g_app_info_launch_uris(app, uris, ctx, err); } } g_key_file_free(kf); return ret; }
static gboolean _app_info_launch_uris (GAppInfo *appinfo, GList *uris, GAppLaunchContext *launch_context, GError **error) { OlAppInfo *info = OL_APP_INFO (appinfo); /* TODO: implement launching. */ GAppInfo* app = g_app_info_create_from_commandline (info->cmdline, "", 0, NULL); gboolean ret = g_app_info_launch_uris (app, uris, launch_context, error); g_object_unref (G_OBJECT (app)); return ret; }
/** * g_app_info_launch_default_for_uri: * @uri: the uri to show * @launch_context: (allow-none): an optional #GAppLaunchContext. * @error: a #GError. * * 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. * * Returns: %TRUE on success, %FALSE on error. **/ gboolean g_app_info_launch_default_for_uri (const char *uri, GAppLaunchContext *launch_context, GError **error) { char *uri_scheme; GAppInfo *app_info = NULL; GList l; gboolean res; /* g_file_query_default_handler() calls * g_app_info_get_default_for_uri_scheme() too, but we have to do it * here anyway in case GFile can't parse @uri correctly. */ uri_scheme = g_uri_parse_scheme (uri); if (uri_scheme && uri_scheme[0] != '\0') app_info = g_app_info_get_default_for_uri_scheme (uri_scheme); g_free (uri_scheme); if (!app_info) { GFile *file; file = g_file_new_for_uri (uri); app_info = g_file_query_default_handler (file, NULL, error); g_object_unref (file); if (app_info == NULL) return FALSE; /* We still use the original @uri rather than calling * g_file_get_uri(), because GFile might have modified the URI * in ways we don't want (eg, removing the fragment identifier * from a file: URI). */ } l.data = (char *)uri; l.next = l.prev = NULL; res = g_app_info_launch_uris (app_info, &l, launch_context, error); g_object_unref (app_info); return res; }
NS_IMETHODIMP nsGIOMimeApp::Launch(const nsACString& aUri) { GList uris = { 0 }; PromiseFlatCString flatUri(aUri); uris.data = const_cast<char*>(flatUri.get()); GError *error = NULL; gboolean result = g_app_info_launch_uris(mApp, &uris, NULL, &error); if (!result) { g_warning("Cannot launch application: %s", error->message); g_error_free(error); return NS_ERROR_FAILURE; } return NS_OK; }
gboolean photos_glib_app_info_launch_uri (GAppInfo *appinfo, const gchar *uri, GAppLaunchContext *launch_context, GError **error) { GList *uris = NULL; gboolean ret_val; g_return_val_if_fail (G_IS_APP_INFO (appinfo), FALSE); g_return_val_if_fail (uri != NULL && uri[0] != '\0', FALSE); g_return_val_if_fail (launch_context == NULL || G_IS_APP_LAUNCH_CONTEXT (launch_context), FALSE); g_return_val_if_fail (error == NULL || *error == NULL, FALSE); uris = g_list_prepend (uris, g_strdup (uri)); ret_val = g_app_info_launch_uris (appinfo, uris, launch_context, error); g_list_free_full (uris, g_free); return ret_val; }
static void activate_open_with_application_item (GtkMenuItem *menuitem, gpointer data) { GthBrowser *browser = data; GList *items; GList *file_list; GList *uris; GList *scan; GAppInfo *appinfo; GdkAppLaunchContext *context; GError *error = NULL; items = gth_file_selection_get_selected (GTH_FILE_SELECTION (gth_browser_get_file_list_view (browser))); file_list = gth_file_list_get_files (GTH_FILE_LIST (gth_browser_get_file_list (browser)), items); uris = NULL; for (scan = file_list; scan; scan = scan->next) { GthFileData *file_data = scan->data; uris = g_list_prepend (uris, g_file_get_uri (file_data->file)); } uris = g_list_reverse (uris); appinfo = g_object_get_data (G_OBJECT (menuitem), "appinfo"); g_return_if_fail (G_IS_APP_INFO (appinfo)); context = gdk_display_get_app_launch_context (gtk_widget_get_display (GTK_WIDGET (browser))); gdk_app_launch_context_set_timestamp (context, 0); gdk_app_launch_context_set_icon (context, g_app_info_get_icon (appinfo)); if (! g_app_info_launch_uris (appinfo, uris, G_APP_LAUNCH_CONTEXT (context), &error)) { _gtk_error_dialog_from_gerror_show (GTK_WINDOW (browser), _("Could not perform the operation"), error); g_clear_error (&error); } g_object_unref (context); g_list_free (uris); _g_object_list_unref (file_list); _gtk_tree_path_list_free (items); }
gboolean panel_show_uri_force_mime_type (GdkScreen *screen, const gchar *uri, const gchar *mime_type, guint32 timestamp, GError **error) { GFile *file; GAppInfo *appinfo; gboolean ret; GdkDisplay *display; GdkAppLaunchContext *context; GList *uris; g_return_val_if_fail (GDK_IS_SCREEN (screen), FALSE); g_return_val_if_fail (uri != NULL, FALSE); g_return_val_if_fail (mime_type != NULL, FALSE); g_return_val_if_fail (error == NULL || *error == NULL, FALSE); file = g_file_new_for_uri (uri); appinfo = g_app_info_get_default_for_type (mime_type, !g_file_is_native (file)); g_object_unref (file); if (appinfo == NULL) { /* no application for the mime type, so let's fallback on * automatic detection */ return panel_show_uri (screen, uri, timestamp, error); } uris = g_list_append (NULL, (gpointer)uri); display = gdk_screen_get_display (screen); context = gdk_display_get_app_launch_context (display); ret = g_app_info_launch_uris (appinfo, uris, G_APP_LAUNCH_CONTEXT(context), error); g_object_unref (context); g_list_free (uris); g_object_unref (appinfo); return ret; }
static void on_open_in_easytag (NautilusMenuItem *item, gpointer data) { NautilusFileInfo *dir; GDesktopAppInfo *appinfo; dir = g_object_get_data (G_OBJECT (item), "dir"); appinfo = g_desktop_app_info_new ("easytag.desktop"); if (appinfo) { GdkAppLaunchContext *context; GList *uris = NULL; uris = g_list_append (uris, nautilus_file_info_get_uri (dir)); context = gdk_display_get_app_launch_context (gdk_display_get_default ()); g_app_info_launch_uris (G_APP_INFO (appinfo), uris, G_APP_LAUNCH_CONTEXT (context), NULL); } }
static bool launch_gthumb_import (MpdStorageDeviceTile *self, GError **error) { MpdStorageDeviceTilePrivate *priv = GET_PRIVATE (self); GAppInfo *appinfo; GList uris = { NULL, }; appinfo = (GAppInfo *) g_desktop_app_info_new ("gthumb-import.desktop"); if (NULL == appinfo) { *error = g_error_new (MPD_STORAGE_DEVICE_TILE_ERROR, 0, "%s : Failed to open \"gthumb-import.desktop\"", G_STRLOC); return false; } uris.data = priv->mount_point; g_debug ("gthumb-imported.desktop %s", priv->mount_point); return g_app_info_launch_uris (appinfo, &uris, NULL, error); }
static gboolean diagnostics_label_activate_link_cb (GtkLabel *label, const gchar *uri, gpointer user_data) { GisFinishedPage *self = GIS_FINISHED_PAGE (user_data); GisFinishedPagePrivate *priv = gis_finished_page_get_instance_private (self); g_autoptr(GList) uris = g_list_prepend (NULL, (gchar *) uri); g_autoptr(GError) error = NULL; /* We cannot rely on the default handler, because the FBE session is * configured to associate a dummy handler (namely `/bin/true`) with all MIME * types. So, explicitly launch gedit. (If it's not installed, there should * be no link in this label, and this handler should not be connected.) */ g_return_val_if_fail (priv->gedit != NULL, FALSE); if (g_app_info_launch_uris (G_APP_INFO (priv->gedit), uris, NULL, &error)) return TRUE; g_warning ("Failed to launch gedit for %s: %s", uri, error->message); return FALSE; }
void nemo_launch_application_by_uri (GAppInfo *application, GList *uris, GtkWindow *parent_window) { char *uri; GList *locations, *l; GFile *location; NemoFile *file; gboolean result; GError *error; GdkDisplay *display; GdkAppLaunchContext *launch_context; NemoIconInfo *icon; int count, total; g_assert (uris != NULL); /* count the number of uris with local paths */ count = 0; total = g_list_length (uris); locations = NULL; for (l = uris; l != NULL; l = l->next) { uri = l->data; location = g_file_new_for_uri (uri); if (g_file_is_native (location)) { count++; } locations = g_list_prepend (locations, location); } locations = g_list_reverse (locations); if (parent_window != NULL) { display = gtk_widget_get_display (GTK_WIDGET (parent_window)); } else { display = gdk_display_get_default (); } launch_context = gdk_display_get_app_launch_context (display); if (parent_window != NULL) { gdk_app_launch_context_set_screen (launch_context, gtk_window_get_screen (parent_window)); } file = nemo_file_get_by_uri (uris->data); icon = nemo_file_get_icon (file, 48, gtk_widget_get_scale_factor (GTK_WIDGET (parent_window)), 0); nemo_file_unref (file); if (icon) { gdk_app_launch_context_set_icon_name (launch_context, nemo_icon_info_get_used_name (icon)); g_object_unref (icon); } error = NULL; if (count == total) { /* All files are local, so we can use g_app_info_launch () with * the file list we constructed before. */ result = g_app_info_launch (application, locations, G_APP_LAUNCH_CONTEXT (launch_context), &error); } else { /* Some files are non local, better use g_app_info_launch_uris (). */ result = g_app_info_launch_uris (application, uris, G_APP_LAUNCH_CONTEXT (launch_context), &error); } g_object_unref (launch_context); if (result) { for (l = uris; l != NULL; l = l->next) { file = nemo_file_get_by_uri (l->data); nemo_recent_add_file (file, application); nemo_file_unref (file); } } g_list_free_full (locations, g_object_unref); }
gboolean open_file_with_filemanager (GtkWidget * window, const gchar * file) { GDesktopAppInfo * d_app_info; GKeyFile * key_file; GdkAppLaunchContext * ctx = NULL; GList * list = NULL; GAppInfo * g_app_info; GFile * g_file; gchar * command; gchar * contents; gchar * uri; gboolean result = TRUE; uri = g_filename_to_uri (file, NULL, NULL); list = g_list_prepend (list, uri); g_file = g_file_new_for_path (file); g_app_info = g_file_query_default_handler (g_file, NULL, NULL); if (strcmp (g_app_info_get_executable (g_app_info), "nautilus") == 0) { command = g_strconcat ("nautilus ", "--sm-disable ", "--no-desktop ", "--no-default-window ", NULL); } else { command = g_strconcat (g_app_info_get_executable (g_app_info), " ", NULL); } contents = g_strdup_printf ("[Desktop Entry]\n" "Name=Nautilus\n" "Icon=file-manager\n" "Exec=%s\n" "Terminal=false\n" "StartupNotify=true\n" "Type=Application\n", command); key_file = g_key_file_new (); g_key_file_load_from_data (key_file, contents, strlen(contents), G_KEY_FILE_NONE, NULL); d_app_info = g_desktop_app_info_new_from_keyfile (key_file); if (d_app_info != NULL) { ctx = gdk_app_launch_context_new (); gdk_app_launch_context_set_screen (ctx, gtk_widget_get_screen (window)); result = g_app_info_launch_uris (G_APP_INFO (d_app_info), list, G_APP_LAUNCH_CONTEXT (ctx), NULL); } else { result = FALSE; } g_object_unref (g_app_info); g_object_unref (d_app_info); g_object_unref (g_file); g_object_unref (ctx); g_key_file_free (key_file); g_list_free (list); g_free (contents); g_free (command); g_free (uri); return result; }
static gboolean activate_panel (GnomeControlCenter *shell, const gchar *id, const gchar **argv, const gchar *desktop_file, const gchar *name, GIcon *gicon) { GDesktopAppInfo *appinfo; GdkAppLaunchContext *context; GdkScreen *screen; GdkDisplay *display; GError *error; appinfo = g_desktop_app_info_new_from_filename (desktop_file); screen = gtk_widget_get_screen (shell->priv->window); display = gdk_screen_get_display (screen); context = gdk_display_get_app_launch_context (display); gdk_app_launch_context_set_screen (context, screen); gdk_app_launch_context_set_timestamp (context, gtk_get_current_event_time ()); error = NULL; g_app_info_launch_uris (G_APP_INFO (appinfo), NULL, (GAppLaunchContext *) context, &error); if (error) { g_printerr ("Could not launch '%s': %s\n", id, error->message); g_clear_error (&error); } g_object_unref (context); g_object_unref (appinfo); #if 0 GnomeControlCenterPrivate *priv = shell->priv; GType panel_type = G_TYPE_INVALID; GList *panels, *l; GtkWidget *box; const gchar *icon_name; /* check if there is an plugin that implements this panel */ panels = g_io_extension_point_get_extensions (priv->extension_point); if (!desktop_file) return FALSE; if (!id) return FALSE; for (l = panels; l != NULL; l = l->next) { GIOExtension *extension; const gchar *name; extension = l->data; name = g_io_extension_get_name (extension); if (!g_strcmp0 (name, id)) { panel_type = g_io_extension_get_type (extension); break; } } if (panel_type == G_TYPE_INVALID) { g_warning ("Could not find the loadable module for panel '%s'", id); return FALSE; } /* create the panel plugin */ priv->current_panel = g_object_new (panel_type, "shell", shell, "argv", argv, NULL); cc_shell_set_active_panel (CC_SHELL (shell), CC_PANEL (priv->current_panel)); gtk_widget_show (priv->current_panel); gtk_lock_button_set_permission (GTK_LOCK_BUTTON (priv->lock_button), cc_panel_get_permission (CC_PANEL (priv->current_panel))); box = gtk_alignment_new (0, 0, 1, 1); gtk_alignment_set_padding (GTK_ALIGNMENT (box), 6, 6, 6, 6); gtk_container_add (GTK_CONTAINER (box), priv->current_panel); gtk_widget_set_name (box, id); notebook_add_page (priv->notebook, box); /* switch to the new panel */ gtk_widget_show (box); notebook_select_page (priv->notebook, box); /* set the title of the window */ icon_name = get_icon_name_from_g_icon (gicon); gtk_window_set_role (GTK_WINDOW (priv->window), id); gtk_window_set_title (GTK_WINDOW (priv->window), name); gtk_window_set_default_icon_name (icon_name); gtk_window_set_icon_name (GTK_WINDOW (priv->window), icon_name); priv->current_panel_box = box; #endif return TRUE; }
static gboolean exo_open_uri (const gchar *uri, GError **error) { GFile *file; gchar *scheme; GFileInfo *file_info; gboolean succeed = FALSE; gboolean retval = FALSE; GFileType file_type; const gchar *content_type; GAppInfo *app_info; gchar *path; const gchar *executable; GList fake_list; const gchar * const *schemes; GError *err = NULL; guint i; g_return_val_if_fail (uri != NULL, FALSE); g_return_val_if_fail (error == NULL || *error == NULL, FALSE); #ifndef NDEBUG schemes = g_vfs_get_supported_uri_schemes (g_vfs_get_default ()); scheme = g_strjoinv (", ", (gchar **) schemes); g_debug ("vfs supported schemes: %s", scheme); g_free (scheme); #endif file = g_file_new_for_uri (uri); scheme = g_file_get_uri_scheme (file); /* try to launch common schemes for know preferred applications */ if (scheme != NULL && exo_open_uri_known_category (uri, scheme, &retval)) { g_free (scheme); return retval; } /* handle the uri as a file, maybe we succeed... */ file_info = g_file_query_info (file, G_FILE_ATTRIBUTE_STANDARD_TYPE "," G_FILE_ATTRIBUTE_STANDARD_CONTENT_TYPE, G_FILE_QUERY_INFO_NONE, NULL, &err); if (file_info != NULL) { file_type = g_file_info_get_file_type (file_info); if (file_type == G_FILE_TYPE_DIRECTORY) { #ifndef NDEBUG g_debug ("file is directory, use filemanager"); #endif /* directories should go fine with a file manager */ retval = exo_open_launch_category ("FileManager", uri); succeed = TRUE; } else { content_type = g_file_info_get_content_type (file_info); #ifndef NDEBUG g_debug ("content type=%s", content_type); #endif if (G_LIKELY (content_type)) { /* try to find a suitable application for this content type */ path = g_file_get_path (file); app_info = g_app_info_get_default_for_type (content_type, path == NULL); g_free (path); if (app_info != NULL) { /* make sure we don't loop somehow */ executable = g_app_info_get_executable (app_info); #ifndef NDEBUG g_debug ("default executable=%s", executable); #endif if (executable == NULL || strcmp (executable, "exo-open") != 0) { fake_list.data = (gpointer) uri; fake_list.prev = fake_list.next = NULL; /* launch it */ retval = g_app_info_launch_uris (app_info, &fake_list, NULL, &err); succeed = TRUE; } g_object_unref (G_OBJECT (app_info)); } } } g_object_unref (G_OBJECT (file_info)); } else if (err != NULL && scheme != NULL && err->code == G_IO_ERROR_NOT_MOUNTED) { /* check if the scheme is supported by gio */ schemes = g_vfs_get_supported_uri_schemes (g_vfs_get_default ()); if (G_LIKELY (schemes != NULL)) { for (i = 0; schemes[i] != NULL; i++) { /* found scheme, open in file manager */ if (strcmp (scheme, schemes[i]) == 0) { retval = succeed = exo_open_launch_category ("FileManager", uri); break; } } } } g_object_unref (G_OBJECT (file)); /* our last try... */ if (!succeed) { #ifndef NDEBUG g_debug ("nothing worked, try ftp(s) or gtk_show_uri()"); #endif /* try ftp uris if the file manager/gio failed to recognize it */ if (scheme != NULL && (strcmp (scheme, "ftp") == 0 || strcmp (scheme, "ftps") == 0)) retval = exo_open_launch_category ("WebBrowser", uri); else retval = gtk_show_uri (NULL, uri, 0, error); } g_free (scheme); if (!retval && error != NULL) *error = err; else if (err != NULL) g_error_free (err); return retval; }
static void ev_spawn (const char *uri, GdkScreen *screen, EvLinkDest *dest, EvWindowRunMode mode, const gchar *search_string, guint timestamp) { GString *cmd; gchar *path, *cmdline; GAppInfo *app; GdkAppLaunchContext *ctx; GError *error = NULL; cmd = g_string_new (NULL); #ifdef G_OS_WIN32 { gchar *dir; dir = g_win32_get_package_installation_directory_of_module (NULL); path = g_build_filename (dir, "bin", "atril", NULL); g_free (dir); } #else path = g_build_filename (BINDIR, "atril", NULL); #endif g_string_append_printf (cmd, " %s", path); g_free (path); /* Page label */ if (dest) { const gchar *page_label; page_label = ev_link_dest_get_page_label (dest); if (page_label) g_string_append_printf (cmd, " --page-label=%s", page_label); else g_string_append_printf (cmd, " --page-label=%d", ev_link_dest_get_page (dest)); } /* Find string */ if (search_string) { g_string_append_printf (cmd, " --find=%s", search_string); } /* Mode */ switch (mode) { case EV_WINDOW_MODE_FULLSCREEN: g_string_append (cmd, " -f"); break; case EV_WINDOW_MODE_PRESENTATION: g_string_append (cmd, " -s"); break; default: break; } cmdline = g_string_free (cmd, FALSE); app = g_app_info_create_from_commandline (cmdline, NULL, 0, &error); if (app != NULL) { GList uri_list; GList *uris = NULL; #if GTK_CHECK_VERSION (3, 0, 0) ctx = gdk_display_get_app_launch_context (gdk_screen_get_display (screen)); #else ctx = gdk_app_launch_context_new (); gdk_app_launch_context_set_display (ctx, gdk_screen_get_display (screen)); #endif gdk_app_launch_context_set_screen (ctx, screen); gdk_app_launch_context_set_timestamp (ctx, timestamp); if (uri) { uri_list.data = (gchar *)uri; uri_list.prev = uri_list.next = NULL; uris = &uri_list; } g_app_info_launch_uris (app, uris, G_APP_LAUNCH_CONTEXT (ctx), &error); g_object_unref (app); g_object_unref (ctx); } if (error != NULL) { g_warning ("Error launching atril %s: %s\n", uri, error->message); g_error_free (error); } g_free (cmdline); }
/** * shell_doc_system_open: * @system: A #ShellDocSystem * @info: A #GtkRecentInfo * @workspace: Open on this workspace, or -1 for default * * Launch the default application associated with the mime type of * @info, using its uri. */ void shell_doc_system_open (ShellDocSystem *system, GtkRecentInfo *info, int workspace) { GFile *file; GAppInfo *app_info; gboolean needs_uri; GAppLaunchContext *context; context = shell_global_create_app_launch_context (shell_global_get ()); if (workspace != -1) gdk_app_launch_context_set_desktop ((GdkAppLaunchContext *)context, workspace); file = g_file_new_for_uri (gtk_recent_info_get_uri (info)); needs_uri = g_file_get_path (file) == NULL; g_object_unref (file); app_info = g_app_info_get_default_for_type (gtk_recent_info_get_mime_type (info), needs_uri); if (app_info != NULL) { GList *uris; uris = g_list_prepend (NULL, (gpointer)gtk_recent_info_get_uri (info)); g_app_info_launch_uris (app_info, uris, context, NULL); g_list_free (uris); } else { char *app_name; const char *app_exec; char *app_exec_quoted; guint count; time_t time; app_name = gtk_recent_info_last_application (info); if (gtk_recent_info_get_application_info (info, app_name, &app_exec, &count, &time)) { GRegex *regex; /* TODO: Change this once better support for creating GAppInfo is added to GtkRecentInfo, as right now this relies on the fact that the file uri is already a part of appExec, so we don't supply any files to app_info.launch(). The 'command line' passed to create_from_command_line is allowed to contain '%<something>' macros that are expanded to file name / icon name, etc, so we need to escape % as %% */ regex = g_regex_new ("%", 0, 0, NULL); app_exec_quoted = g_regex_replace (regex, app_exec, -1, 0, "%%", 0, NULL); g_regex_unref (regex); app_info = g_app_info_create_from_commandline (app_exec_quoted, NULL, 0, NULL); g_free (app_exec_quoted); /* The point of passing an app launch context to launch() is mostly to get startup notification and associated benefits like the app appearing on the right desktop; but it doesn't really work for now because with the way we create the appInfo we aren't reading the application's desktop file, and thus don't find the StartupNotify=true in it. So, despite passing the app launch context, no startup notification occurs. */ g_app_info_launch (app_info, NULL, context, NULL); } g_free (app_name); } g_object_unref (context); }
static gboolean totem_disc_recorder_plugin_start_burning (TotemDiscRecorderPlugin *pi, const char *path, gboolean copy) { GtkWindow *main_window; GdkScreen *screen; GdkDisplay *display; gchar *command_line; GList *uris; GAppInfo *info; GdkAppLaunchContext *context; GError *error = NULL; char *xid_arg; main_window = totem_object_get_main_window (pi->priv->totem); screen = gtk_widget_get_screen (GTK_WIDGET (main_window)); display = gdk_display_get_default (); /* Build a command line to use */ xid_arg = NULL; #ifdef GDK_WINDOWING_X11 if (GDK_IS_X11_DISPLAY (display)) xid_arg = g_strdup_printf ("-x %d", (int) gdk_x11_window_get_xid (gtk_widget_get_window (GTK_WIDGET (main_window)))); #endif /* GDK_WINDOWING_X11 */ g_object_unref (main_window); if (copy != FALSE) command_line = g_strdup_printf ("brasero %s -c", xid_arg ? xid_arg : ""); else command_line = g_strdup_printf ("brasero %s -r", xid_arg ? xid_arg : ""); /* Build the app info */ info = g_app_info_create_from_commandline (command_line, NULL, G_APP_INFO_CREATE_SUPPORTS_URIS | G_APP_INFO_CREATE_SUPPORTS_STARTUP_NOTIFICATION, &error); g_free (command_line); if (error != NULL) goto error; /* Create a launch context and launch it */ context = gdk_display_get_app_launch_context (gtk_widget_get_display (GTK_WIDGET (main_window))); gdk_app_launch_context_set_screen (context, screen); uris = g_list_prepend (NULL, (gpointer) path); g_app_info_launch_uris (info, uris, G_APP_LAUNCH_CONTEXT (context), &error); g_list_free (uris); g_object_unref (info); g_object_unref (context); if (error != NULL) goto error; return TRUE; error: main_window = totem_object_get_main_window (pi->priv->totem); if (copy != FALSE) totem_interface_error (_("The video disc could not be duplicated."), error->message, main_window); else totem_interface_error (_("The movie could not be recorded."), error->message, main_window); g_error_free (error); g_object_unref (main_window); return FALSE; }
gboolean fm_launch_files(GAppLaunchContext* ctx, GList* file_infos, FmFileLauncher* launcher, gpointer user_data) { GList* l; GHashTable* hash = g_hash_table_new_full(g_str_hash, g_str_equal, NULL, NULL); GList* folders = NULL; FmFileInfo* fi; GError* err = NULL; GAppInfo* app; for(l = file_infos; l; l=l->next) { GList* fis; fi = (FmFileInfo*)l->data; if(fm_file_info_is_dir(fi)) folders = g_list_prepend(folders, fi); else { /* FIXME: handle shortcuts, such as the items in menu:// */ if(fm_path_is_native(fi->path)) { char* filename; if(fm_file_info_is_desktop_entry(fi)) { /* if it's a desktop entry file, directly launch it. */ filename = fm_path_to_str(fi->path); if(!fm_launch_desktop_entry(ctx, filename, NULL, &err)) { if(launcher->error) launcher->error(ctx, err, user_data); g_error_free(err); err = NULL; } continue; } else if(fm_file_info_is_executable_type(fi)) { /* if it's an executable file, directly execute it. */ filename = fm_path_to_str(fi->path); /* FIXME: we need to use eaccess/euidaccess here. */ if(g_file_test(filename, G_FILE_TEST_IS_EXECUTABLE)) { app = g_app_info_create_from_commandline(filename, NULL, 0, NULL); if(app) { if(!g_app_info_launch(app, NULL, ctx, &err)) { if(launcher->error) launcher->error(ctx, err, user_data); g_error_free(err); err = NULL; } g_object_unref(app); continue; } } g_free(filename); } } else /* not a native path */ { if(fm_file_info_is_shortcut(fi) && !fm_file_info_is_dir(fi)) { /* FIXME: special handling for shortcuts */ if(fm_path_is_xdg_menu(fi->path) && fi->target) { if(!fm_launch_desktop_entry(ctx, fi->target, NULL, &err)) { if(launcher->error) launcher->error(ctx, err, user_data); g_error_free(err); err = NULL; } continue; } } } if(fi->type && fi->type->type) { fis = g_hash_table_lookup(hash, fi->type->type); fis = g_list_prepend(fis, fi); g_hash_table_insert(hash, fi->type->type, fis); } } } if(g_hash_table_size(hash) > 0) { GHashTableIter it; const char* type; GList* fis; g_hash_table_iter_init(&it, hash); while(g_hash_table_iter_next(&it, &type, &fis)) { GAppInfo* app = g_app_info_get_default_for_type(type, FALSE); if(!app) { if(launcher->get_app) { FmMimeType* mime_type = ((FmFileInfo*)fis->data)->type; app = launcher->get_app(fis, mime_type, user_data, NULL); } } if(app) { for(l=fis; l; l=l->next) { char* uri; fi = (FmFileInfo*)l->data; uri = fm_path_to_uri(fi->path); l->data = uri; } fis = g_list_reverse(fis); g_app_info_launch_uris(app, fis, ctx, err); /* free URI strings */ g_list_foreach(fis, (GFunc)g_free, NULL); g_object_unref(app); } g_list_free(fis); } } g_hash_table_destroy(hash); if(folders) { folders = g_list_reverse(folders); if(launcher->open_folder) { launcher->open_folder(ctx, folders, user_data, &err); if(err) { if(launcher->error) launcher->error(ctx, err, user_data); g_error_free(err); err = NULL; } } g_list_free(folders); } return TRUE; }
void caja_launch_application_by_uri (GAppInfo *application, GList *uris, GtkWindow *parent_window) { char *uri, *uri_scheme; GList *locations, *l; GFile *location; CajaFile *file; gboolean result; GError *error; GdkAppLaunchContext *launch_context; CajaIconInfo *icon; int count, total; g_assert (uris != NULL); /* count the number of uris with local paths */ count = 0; total = g_list_length (uris); locations = NULL; for (l = uris; l != NULL; l = l->next) { uri = l->data; location = g_file_new_for_uri (uri); if (g_file_is_native (location)) { count++; } locations = g_list_prepend (locations, location); } locations = g_list_reverse (locations); launch_context = gdk_app_launch_context_new (); if (parent_window) gdk_app_launch_context_set_screen (launch_context, gtk_window_get_screen (parent_window)); file = caja_file_get_by_uri (uris->data); icon = caja_file_get_icon (file, 48, 0); caja_file_unref (file); if (icon) { gdk_app_launch_context_set_icon_name (launch_context, caja_icon_info_get_used_name (icon)); g_object_unref (icon); } error = NULL; if (count == total) { /* All files are local, so we can use g_app_info_launch () with * the file list we constructed before. */ result = g_app_info_launch (application, locations, G_APP_LAUNCH_CONTEXT (launch_context), &error); } else { /* Some files are non local, better use g_app_info_launch_uris (). */ result = g_app_info_launch_uris (application, uris, G_APP_LAUNCH_CONTEXT (launch_context), &error); } g_object_unref (launch_context); if (!result) { if (error->domain == G_IO_ERROR && error->code == G_IO_ERROR_NOT_SUPPORTED) { uri_scheme = g_uri_parse_scheme (uris->data); application_cannot_open_location (application, file, uri_scheme, parent_window); g_free (uri_scheme); } else { #ifdef NEW_MIME_COMPLETE caja_program_chooser_show_invalid_message (MATE_VFS_MIME_ACTION_TYPE_APPLICATION, file, parent_window); #else g_warning ("Cannot open app: %s\n", error->message); #endif } g_error_free (error); } else { for (l = uris; l != NULL; l = l->next) { file = caja_file_get_by_uri (l->data); caja_recent_add_file (file, application); caja_file_unref (file); } } g_list_free_full (locations, g_object_unref); }
void caja_launch_desktop_file (GdkScreen *screen, const char *desktop_file_uri, const GList *parameter_uris, GtkWindow *parent_window) { GError *error; char *message, *desktop_file_path; const GList *p; GList *files; int total, count; GFile *file, *desktop_file; GDesktopAppInfo *app_info; GdkAppLaunchContext *context; /* Don't allow command execution from remote locations * to partially mitigate the security * risk of executing arbitrary commands. */ desktop_file = g_file_new_for_uri (desktop_file_uri); desktop_file_path = g_file_get_path (desktop_file); if (!g_file_is_native (desktop_file)) { g_free (desktop_file_path); g_object_unref (desktop_file); eel_show_error_dialog (_("Sorry, but you cannot execute commands from " "a remote site."), _("This is disabled due to security considerations."), parent_window); return; } g_object_unref (desktop_file); app_info = g_desktop_app_info_new_from_filename (desktop_file_path); g_free (desktop_file_path); if (app_info == NULL) { eel_show_error_dialog (_("There was an error launching the application."), NULL, parent_window); return; } /* count the number of uris with local paths */ count = 0; total = g_list_length ((GList *) parameter_uris); files = NULL; for (p = parameter_uris; p != NULL; p = p->next) { file = g_file_new_for_uri ((const char *) p->data); if (g_file_is_native (file)) { count++; } files = g_list_prepend (files, file); } /* check if this app only supports local files */ if (g_app_info_supports_files (G_APP_INFO (app_info)) && !g_app_info_supports_uris (G_APP_INFO (app_info)) && parameter_uris != NULL) { if (count == 0) { /* all files are non-local */ eel_show_error_dialog (_("This drop target only supports local files."), _("To open non-local files copy them to a local folder and then" " drop them again."), parent_window); g_list_free_full (files, g_object_unref); g_object_unref (app_info); return; } else if (count != total) { /* some files are non-local */ eel_show_warning_dialog (_("This drop target only supports local files."), _("To open non-local files copy them to a local folder and then" " drop them again. The local files you dropped have already been opened."), parent_window); } } error = NULL; context = gdk_app_launch_context_new (); /* TODO: Ideally we should accept a timestamp here instead of using GDK_CURRENT_TIME */ gdk_app_launch_context_set_timestamp (context, GDK_CURRENT_TIME); gdk_app_launch_context_set_screen (context, gtk_window_get_screen (parent_window)); if (count == total) { /* All files are local, so we can use g_app_info_launch () with * the file list we constructed before. */ g_app_info_launch (G_APP_INFO (app_info), files, G_APP_LAUNCH_CONTEXT (context), &error); } else { /* Some files are non local, better use g_app_info_launch_uris (). */ g_app_info_launch_uris (G_APP_INFO (app_info), (GList *) parameter_uris, G_APP_LAUNCH_CONTEXT (context), &error); } if (error != NULL) { message = g_strconcat (_("Details: "), error->message, NULL); eel_show_error_dialog (_("There was an error launching the application."), message, parent_window); g_error_free (error); g_free (message); } g_list_free_full (files, g_object_unref); g_object_unref (context); g_object_unref (app_info); }