summaryrefslogtreecommitdiffstats
path: root/src/nautilus-program-choosing.c
diff options
context:
space:
mode:
Diffstat (limited to 'src/nautilus-program-choosing.c')
-rw-r--r--src/nautilus-program-choosing.c623
1 files changed, 623 insertions, 0 deletions
diff --git a/src/nautilus-program-choosing.c b/src/nautilus-program-choosing.c
new file mode 100644
index 0000000..47362a3
--- /dev/null
+++ b/src/nautilus-program-choosing.c
@@ -0,0 +1,623 @@
+/* nautilus-program-choosing.c - functions for selecting and activating
+ * programs for opening/viewing particular files.
+ *
+ * Copyright (C) 2000 Eazel, Inc.
+ *
+ * The Gnome Library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Library General Public License as
+ * published by the Free Software Foundation; either version 2 of the
+ * License, or (at your option) any later version.
+ *
+ * The Gnome Library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+ * Library General Public License for more details.
+ *
+ * You should have received a copy of the GNU Library General Public
+ * License along with the Gnome Library; see the file COPYING.LIB. If not,
+ * see <http://www.gnu.org/licenses/>.
+ *
+ * Author: John Sullivan <sullivan@eazel.com>
+ */
+
+#include <config.h>
+#include "nautilus-program-choosing.h"
+
+#include "nautilus-global-preferences.h"
+#include "nautilus-icon-info.h"
+#include "nautilus-ui-utilities.h"
+#include "nautilus-window.h"
+#include <eel/eel-vfs-extensions.h>
+#include <gtk/gtk.h>
+#include <glib/gi18n.h>
+#include <gio/gio.h>
+#include <gio/gdesktopappinfo.h>
+#include <stdlib.h>
+
+#include <gdk/gdk.h>
+
+static void
+add_file_to_recent (NautilusFile *file,
+ GAppInfo *application)
+{
+ GtkRecentData recent_data;
+ char *uri;
+
+ uri = nautilus_file_get_activation_uri (file);
+ if (uri == NULL)
+ {
+ uri = nautilus_file_get_uri (file);
+ }
+
+ /* do not add trash:// etc */
+ if (eel_uri_is_trash (uri) ||
+ eel_uri_is_search (uri) ||
+ eel_uri_is_recent (uri))
+ {
+ g_free (uri);
+ return;
+ }
+
+ recent_data.display_name = NULL;
+ recent_data.description = NULL;
+
+ recent_data.mime_type = nautilus_file_get_mime_type (file);
+ recent_data.app_name = g_strdup (g_get_application_name ());
+ recent_data.app_exec = g_strdup (g_app_info_get_commandline (application));
+
+ recent_data.groups = NULL;
+ recent_data.is_private = FALSE;
+
+ gtk_recent_manager_add_full (gtk_recent_manager_get_default (),
+ uri, &recent_data);
+
+ g_free (recent_data.mime_type);
+ g_free (recent_data.app_name);
+ g_free (recent_data.app_exec);
+
+ g_free (uri);
+}
+void
+nautilus_launch_application_for_mount (GAppInfo *app_info,
+ GMount *mount,
+ GtkWindow *parent_window)
+{
+ GFile *root;
+ NautilusFile *file;
+ GList *files;
+
+ root = g_mount_get_root (mount);
+ file = nautilus_file_get (root);
+ g_object_unref (root);
+
+ files = g_list_append (NULL, file);
+ nautilus_launch_application (app_info,
+ files,
+ parent_window);
+
+ g_list_free_full (files, (GDestroyNotify) nautilus_file_unref);
+}
+
+/**
+ * nautilus_launch_application:
+ *
+ * Fork off a process to launch an application with a given file as a
+ * parameter. Provide a parent window for error dialogs.
+ *
+ * @application: The application to be launched.
+ * @uris: The files whose locations should be passed as a parameter to the application.
+ * @parent_window: A window to use as the parent for any error dialogs.
+ */
+void
+nautilus_launch_application (GAppInfo *application,
+ GList *files,
+ GtkWindow *parent_window)
+{
+ GList *uris, *l;
+
+ uris = NULL;
+ for (l = files; l != NULL; l = l->next)
+ {
+ uris = g_list_prepend (uris, nautilus_file_get_activation_uri (l->data));
+ }
+ uris = g_list_reverse (uris);
+ nautilus_launch_application_by_uri (application, uris,
+ parent_window);
+ g_list_free_full (uris, g_free);
+}
+
+static GdkAppLaunchContext *
+get_launch_context (GtkWindow *parent_window)
+{
+ GdkDisplay *display;
+ GdkAppLaunchContext *launch_context;
+
+ 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));
+ }
+
+ return launch_context;
+}
+
+void
+nautilus_launch_application_by_uri (GAppInfo *application,
+ GList *uris,
+ GtkWindow *parent_window)
+{
+ char *uri;
+ GList *locations, *l;
+ GFile *location;
+ NautilusFile *file;
+ gboolean result;
+ GError *error;
+ g_autoptr (GdkAppLaunchContext) launch_context = NULL;
+ NautilusIconInfo *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 = get_launch_context (parent_window);
+
+ file = nautilus_file_get_by_uri (uris->data);
+ icon = nautilus_file_get_icon (file,
+ 48, gtk_widget_get_scale_factor (GTK_WIDGET (parent_window)),
+ 0);
+ nautilus_file_unref (file);
+ if (icon)
+ {
+ gdk_app_launch_context_set_icon_name (launch_context,
+ nautilus_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);
+ }
+
+ if (result)
+ {
+ for (l = uris; l != NULL; l = l->next)
+ {
+ file = nautilus_file_get_by_uri (l->data);
+ add_file_to_recent (file, application);
+ nautilus_file_unref (file);
+ }
+ }
+
+ g_list_free_full (locations, g_object_unref);
+}
+
+static void
+launch_application_from_command_internal (const gchar *full_command,
+ GdkScreen *screen,
+ gboolean use_terminal)
+{
+ GAppInfoCreateFlags flags;
+ g_autoptr (GError) error = NULL;
+ g_autoptr (GAppInfo) app = NULL;
+
+ flags = G_APP_INFO_CREATE_NONE;
+ if (use_terminal)
+ {
+ flags = G_APP_INFO_CREATE_NEEDS_TERMINAL;
+ }
+
+ app = g_app_info_create_from_commandline (full_command, NULL, flags, &error);
+ if (app != NULL && !(use_terminal && screen == NULL))
+ {
+ GdkDisplay *display;
+ g_autoptr (GdkAppLaunchContext) context = NULL;
+
+ display = gdk_screen_get_display (screen);
+ context = gdk_display_get_app_launch_context (display);
+ gdk_app_launch_context_set_screen (context, screen);
+
+ g_app_info_launch (app, NULL, G_APP_LAUNCH_CONTEXT (context), &error);
+ }
+
+ if (error != NULL)
+ {
+ g_message ("Could not start application: %s", error->message);
+ }
+}
+
+/**
+ * nautilus_launch_application_from_command:
+ *
+ * Fork off a process to launch an application with a given uri as
+ * a parameter.
+ *
+ * @command_string: The application to be launched, with any desired
+ * command-line options.
+ * @...: Passed as parameters to the application after quoting each of them.
+ */
+void
+nautilus_launch_application_from_command (GdkScreen *screen,
+ const char *command_string,
+ gboolean use_terminal,
+ ...)
+{
+ char *full_command, *tmp;
+ char *quoted_parameter;
+ char *parameter;
+ va_list ap;
+
+ full_command = g_strdup (command_string);
+
+ va_start (ap, use_terminal);
+
+ while ((parameter = va_arg (ap, char *)) != NULL)
+ {
+ quoted_parameter = g_shell_quote (parameter);
+ tmp = g_strconcat (full_command, " ", quoted_parameter, NULL);
+ g_free (quoted_parameter);
+
+ g_free (full_command);
+ full_command = tmp;
+ }
+
+ va_end (ap);
+
+ launch_application_from_command_internal (full_command, screen, use_terminal);
+
+ g_free (full_command);
+}
+
+/**
+ * nautilus_launch_application_from_command:
+ *
+ * Fork off a process to launch an application with a given uri as
+ * a parameter.
+ *
+ * @command_string: The application to be launched, with any desired
+ * command-line options.
+ * @parameters: Passed as parameters to the application after quoting each of them.
+ */
+void
+nautilus_launch_application_from_command_array (GdkScreen *screen,
+ const char *command_string,
+ gboolean use_terminal,
+ const char * const *parameters)
+{
+ char *full_command, *tmp;
+ char *quoted_parameter;
+ const char * const *p;
+
+ full_command = g_strdup (command_string);
+
+ if (parameters != NULL)
+ {
+ for (p = parameters; *p != NULL; p++)
+ {
+ quoted_parameter = g_shell_quote (*p);
+ tmp = g_strconcat (full_command, " ", quoted_parameter, NULL);
+ g_free (quoted_parameter);
+
+ g_free (full_command);
+ full_command = tmp;
+ }
+ }
+
+ launch_application_from_command_internal (full_command, screen, use_terminal);
+
+ g_free (full_command);
+}
+
+void
+nautilus_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);
+ show_dialog (_("Sorry, but you cannot execute commands from a remote site."),
+ _("This is disabled due to security considerations."),
+ parent_window,
+ GTK_MESSAGE_ERROR);
+
+ 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)
+ {
+ show_dialog (_("There was an error launching the application."),
+ NULL,
+ parent_window,
+ GTK_MESSAGE_ERROR);
+ 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 */
+ show_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,
+ GTK_MESSAGE_ERROR);
+
+ g_list_free_full (files, g_object_unref);
+ g_object_unref (app_info);
+ return;
+ }
+ else if (count != total)
+ {
+ /* some files are non-local */
+ show_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,
+ GTK_MESSAGE_WARNING);
+ }
+ }
+
+ error = NULL;
+ context = gdk_display_get_app_launch_context (gtk_widget_get_display (GTK_WIDGET (parent_window)));
+ /* 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);
+ show_dialog (_("There was an error launching the application."),
+ message,
+ parent_window,
+ GTK_MESSAGE_ERROR);
+
+ g_error_free (error);
+ g_free (message);
+ }
+
+ g_list_free_full (files, g_object_unref);
+ g_object_unref (context);
+ g_object_unref (app_info);
+}
+
+/* HAX
+ *
+ * TODO: remove everything below once it’s doable from GTK+.
+ *
+ * Context: https://bugzilla.gnome.org/show_bug.cgi?id=781132 and
+ * https://bugzilla.gnome.org/show_bug.cgi?id=779312
+ *
+ * In a sandboxed environment, this is needed to able to get the actual
+ * result of the operation, since gtk_show_uri_on_window () neither blocks
+ * nor returns a useful value.
+ */
+
+static void
+on_launch_default_for_uri (GObject *source,
+ GAsyncResult *result,
+ gpointer data)
+{
+ GTask *task;
+ NautilusWindow *window;
+ gboolean success;
+ GError *error = NULL;
+
+ task = data;
+ window = g_task_get_source_object (task);
+
+ success = g_app_info_launch_default_for_uri_finish (result, &error);
+
+ if (window)
+ {
+ nautilus_window_unexport_handle (window);
+ }
+
+ if (success)
+ {
+ g_task_return_boolean (task, success);
+ }
+ else
+ {
+ g_task_return_error (task, error);
+ }
+
+ /* Reffed in the call to nautilus_window_export_handle */
+ g_object_unref (task);
+}
+
+static void
+on_window_handle_export (NautilusWindow *window,
+ const char *handle_str,
+ guint xid,
+ gpointer user_data)
+{
+ GTask *task = user_data;
+ GAppLaunchContext *context = g_task_get_task_data (task);
+ const char *uri;
+
+ uri = g_object_get_data (G_OBJECT (context), "uri");
+
+ g_app_launch_context_setenv (context, "PARENT_WINDOW_ID", handle_str);
+
+ g_app_info_launch_default_for_uri_async (uri,
+ context,
+ g_task_get_cancellable (task),
+ on_launch_default_for_uri,
+ task);
+}
+
+static void
+launch_default_for_uri_thread_func (GTask *task,
+ gpointer source_object,
+ gpointer task_data,
+ GCancellable *cancellable)
+{
+ GAppLaunchContext *launch_context;
+ const char *uri;
+ gboolean success;
+ GError *error = NULL;
+
+ launch_context = task_data;
+ uri = g_object_get_data (G_OBJECT (launch_context), "uri");
+ success = g_app_info_launch_default_for_uri (uri, launch_context, &error);
+
+ if (success)
+ {
+ g_task_return_boolean (task, success);
+ }
+ else
+ {
+ g_task_return_error (task, error);
+ }
+}
+
+void
+nautilus_launch_default_for_uri_async (const char *uri,
+ GtkWindow *parent_window,
+ GCancellable *cancellable,
+ GAsyncReadyCallback callback,
+ gpointer callback_data)
+{
+ g_autoptr (GdkAppLaunchContext) launch_context = NULL;
+ g_autoptr (GTask) task = NULL;
+
+ g_return_if_fail (uri != NULL);
+
+ launch_context = get_launch_context (parent_window);
+ task = g_task_new (parent_window, cancellable, callback, callback_data);
+
+ gdk_app_launch_context_set_timestamp (launch_context, GDK_CURRENT_TIME);
+
+ g_object_set_data_full (G_OBJECT (launch_context),
+ "uri", g_strdup (uri), g_free);
+ g_task_set_task_data (task,
+ g_object_ref (launch_context), g_object_unref);
+
+ if (parent_window != NULL)
+ {
+ gboolean handle_exported;
+
+ handle_exported = nautilus_window_export_handle (NAUTILUS_WINDOW (parent_window),
+ on_window_handle_export,
+ g_object_ref (task));
+
+ if (handle_exported)
+ {
+ /* Launching will now be handled from the callback */
+ return;
+ }
+ }
+
+ g_task_run_in_thread (task, launch_default_for_uri_thread_func);
+}
+
+gboolean
+nautilus_launch_default_for_uri_finish (GAsyncResult *result,
+ GError **error)
+{
+ g_return_val_if_fail (G_IS_ASYNC_RESULT (result), FALSE);
+
+ return g_task_propagate_boolean (G_TASK (result), error);
+}
+
+/* END OF HAX */