/* 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-recent.h"
#include <eel/eel-stock-dialogs.h>
#include <gtk/gtk.h>
#include <glib/gi18n.h>
#include <gio/gio.h>
#include <gio/gdesktopappinfo.h>
#include <stdlib.h>
#include <gdk/gdk.h>
#include <gdk/gdkx.h>
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);
nautilus_recent_add_file (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);
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_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);
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);
}
/* 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.
*/
#ifdef GDK_WINDOWING_WAYLAND
#include <gdk/gdkwayland.h>
#endif
typedef void (*GtkWindowHandleExported) (GtkWindow *window,
const char *handle,
gpointer user_data);
#ifdef GDK_WINDOWING_WAYLAND
typedef struct
{
GtkWindow *window;
GtkWindowHandleExported callback;
gpointer user_data;
} WaylandWindowHandleExportedData;
static void
wayland_window_handle_exported (GdkWindow *window,
const char *wayland_handle_str,
gpointer user_data)
{
WaylandWindowHandleExportedData *data = user_data;
char *handle_str;
handle_str = g_strdup_printf ("wayland:%s", wayland_handle_str);
data->callback (data->window, handle_str, data->user_data);
g_free (handle_str);
}
#endif
static gboolean
window_export_handle (GtkWindow *window,
GtkWindowHandleExported callback,
gpointer user_data)
{
#ifdef GDK_WINDOWING_X11
if (GDK_IS_X11_DISPLAY (gtk_widget_get_display (GTK_WIDGET (window))))
{
GdkWindow *gdk_window = gtk_widget_get_window (GTK_WIDGET (window));
char *handle_str;
guint32 xid = (guint32) gdk_x11_window_get_xid (gdk_window);
handle_str = g_strdup_printf ("x11:%x", xid);
callback (window, handle_str, user_data);
return TRUE;
}
#endif
#ifdef GDK_WINDOWING_WAYLAND
if (GDK_IS_WAYLAND_DISPLAY (gtk_widget_get_display (GTK_WIDGET (window))))
{
GdkWindow *gdk_window = gtk_widget_get_window (GTK_WIDGET (window));
WaylandWindowHandleExportedData *data;
data = g_new0 (WaylandWindowHandleExportedData, 1);
data->window = window;
data->callback = callback;
data->user_data = user_data;
if (!gdk_wayland_window_export_handle (gdk_window,
wayland_window_handle_exported,
data,
g_free))
{
g_free (data);
return FALSE;
}
else
{
return TRUE;
}
}
#endif
g_warning ("Couldn't export handle, unsupported windowing system");
return FALSE;
}
static void
gtk_window_unexport_handle (GtkWindow *window)
{
#ifdef GDK_WINDOWING_WAYLAND
if (GDK_IS_WAYLAND_DISPLAY (gtk_widget_get_display (GTK_WIDGET (window))))
{
GdkWindow *gdk_window = gtk_widget_get_window (GTK_WIDGET (window));
gdk_wayland_window_unexport_handle (gdk_window);
}
#endif
}
static void
on_launch_default_for_uri (GObject *source,
GAsyncResult *result,
gpointer data)
{
GTask *task;
GtkWindow *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)
{
gtk_window_unexport_handle (window);
}
if (success)
{
g_task_return_boolean (task, success);
}
else
{
g_task_return_error (task, error);
}
/* Reffed in the call to window_export_handle */
g_object_unref (task);
}
static void
on_window_handle_export (GtkWindow *window,
const char *handle_str,
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 = window_export_handle (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 */