From 873939e8222a778e8f9855944483cb1ee1cb984b Mon Sep 17 00:00:00 2001

From: Bastien Nocera <hadess@hadess.net>

Date: Thu, 6 Feb 2020 15:04:31 +0100

Subject: [PATCH] mime-actions: Group files depending on the opening app

Reinstate the old behaviour which used to look at the files to open,

group them by handling application, and pass a single call to each

application with all the files it could handle.

For the common case where it's a single application handling all the

files, as is usual for handling media files (images, videos, music,

etc.), it changes the launching behaviour from:

application.bin foo.mp3

application.bin foo2.mp3

application.bin foo3.mp3

to:

application.bin foo.mp3 foo2.mp3 foo3.mp3

This however impacts the behaviour of nautilus launching applications

when inside a Flatpak sandbox, as it cannot enumerate and launch

applications itself. As the Flatpak sandbox is a development tool, and

for the sake of expediency, we reverted to the old code path.

Revert "mime-actions: launch default uri handlers when activating files"

This reverts commit f5206a6daf0991d91e885a28bb66795a8ae12a41.

Closes: #117

---

 src/nautilus-mime-actions.c     | 268 +++++++++++++++++++++++---------

 src/nautilus-program-choosing.c | 188 +++-------------------

 src/nautilus-program-choosing.h |   7 -

 3 files changed, 211 insertions(+), 252 deletions(-)

diff --git a/src/nautilus-mime-actions.c b/src/nautilus-mime-actions.c

index 26468c597..4a49828a8 100644

--- a/src/nautilus-mime-actions.c

+++ b/src/nautilus-mime-actions.c

@@ -61,6 +61,12 @@ typedef struct

     char *uri;

 } LaunchLocation;

+typedef struct

+{

+    GAppInfo *application;

+    GList *uris;

+} ApplicationLaunchParameters;

+

 typedef struct

 {

     NautilusWindowSlot *slot;

@@ -80,13 +86,6 @@ typedef struct

     gboolean user_confirmation;

 } ActivateParameters;

-typedef struct

-{

-    ActivateParameters *activation_params;

-    GQueue *uris;

-    GQueue *unhandled_uris;

-} ApplicationLaunchParameters;

-

 /* Microsoft mime types at https://blogs.msdn.microsoft.com/vsofficedeveloper/2008/05/08/office-2007-file-format-mime-types-for-http-content-streaming-2/ */

 struct

 {

@@ -345,19 +344,27 @@ launch_locations_from_file_list (GList *list)

 }

 static ApplicationLaunchParameters *

-application_launch_parameters_new (ActivateParameters *activation_params,

-                                   GQueue             *uris)

+application_launch_parameters_new (GAppInfo *application,

+                                   GList    *uris)

 {

     ApplicationLaunchParameters *result;

     result = g_new0 (ApplicationLaunchParameters, 1);

-    result->activation_params = activation_params;

-    result->uris = uris;

-    result->unhandled_uris = g_queue_new ();

+    result->application = g_object_ref (application);

+    result->uris = g_list_copy_deep (uris, (GCopyFunc) g_strdup, NULL);

     return result;

 }

+static void

+application_launch_parameters_free (ApplicationLaunchParameters *parameters)

+{

+    g_object_unref (parameters->application);

+    g_list_free_full (parameters->uris, g_free);

+

+    g_free (parameters);

+}

+

 static gboolean

 nautilus_mime_actions_check_if_required_attributes_ready (NautilusFile *file)

 {

@@ -792,6 +799,114 @@ nautilus_mime_file_opens_in_external_app (NautilusFile *file)

     return (activation_action == ACTIVATION_ACTION_OPEN_IN_APPLICATION);

 }

+

+static unsigned int

+mime_application_hash (GAppInfo *app)

+{

+    const char *id;

+

+    id = g_app_info_get_id (app);

+

+    if (id == NULL)

+    {

+        return GPOINTER_TO_UINT (app);

+    }

+

+    return g_str_hash (id);

+}

+

+static void

+list_to_parameters_foreach (GAppInfo  *application,

+                            GList     *uris,

+                            GList    **ret)

+{

+    ApplicationLaunchParameters *parameters;

+

+    uris = g_list_reverse (uris);

+

+    parameters = application_launch_parameters_new

+                     (application, uris);

+    *ret = g_list_prepend (*ret, parameters);

+}

+

+

+/**

+ * make_activation_parameters

+ *

+ * Construct a list of ApplicationLaunchParameters from a list of NautilusFiles,

+ * where files that have the same default application are put into the same

+ * launch parameter, and others are put into the unhandled_files list.

+ *

+ * @files: Files to use for construction.

+ * @unhandled_files: Files without any default application will be put here.

+ *

+ * Return value: Newly allocated list of ApplicationLaunchParameters.

+ **/

+static GList *

+make_activation_parameters (GList  *uris,

+                            GList **unhandled_uris)

+{

+    GList *ret, *l, *app_uris;

+    NautilusFile *file;

+    GAppInfo *app, *old_app;

+    GHashTable *app_table;

+    char *uri;

+

+    ret = NULL;

+    *unhandled_uris = NULL;

+

+    app_table = g_hash_table_new_full

+                    ((GHashFunc) mime_application_hash,

+                    (GEqualFunc) g_app_info_equal,

+                    (GDestroyNotify) g_object_unref,

+                    (GDestroyNotify) g_list_free);

+

+    for (l = uris; l != NULL; l = l->next)

+    {

+        uri = l->data;

+        file = nautilus_file_get_by_uri (uri);

+

+        app = nautilus_mime_get_default_application_for_file (file);

+        if (app != NULL)

+        {

+            app_uris = NULL;

+

+            if (g_hash_table_lookup_extended (app_table, app,

+                                              (gpointer *) &old_app,

+                                              (gpointer *) &app_uris))

+            {

+                g_hash_table_steal (app_table, old_app);

+

+                app_uris = g_list_prepend (app_uris, uri);

+

+                g_object_unref (app);

+                app = old_app;

+            }

+            else

+            {

+                app_uris = g_list_prepend (NULL, uri);

+            }

+

+            g_hash_table_insert (app_table, app, app_uris);

+        }

+        else

+        {

+            *unhandled_uris = g_list_prepend (*unhandled_uris, uri);

+        }

+        nautilus_file_unref (file);

+    }

+

+    g_hash_table_foreach (app_table,

+                          (GHFunc) list_to_parameters_foreach,

+                          &ret;;

+

+    g_hash_table_destroy (app_table);

+

+    *unhandled_uris = g_list_reverse (*unhandled_uris);

+

+    return g_list_reverse (ret);

+}

+

 static gboolean

 file_was_cancelled (NautilusFile *file)

 {

@@ -843,16 +958,6 @@ activation_parameters_free (ActivateParameters *parameters)

     g_free (parameters);

 }

-static void

-application_launch_parameters_free (ApplicationLaunchParameters *parameters)

-{

-    g_queue_free (parameters->unhandled_uris);

-    g_queue_free (parameters->uris);

-    activation_parameters_free (parameters->activation_params);

-

-    g_free (parameters);

-}

-

 static void

 cancel_activate_callback (gpointer callback_data)

 {

@@ -1369,55 +1474,22 @@ out:

     show_unhandled_type_error (parameters_install);

 }

-static void

-on_launch_default_for_uri (GObject      *source_object,

-                           GAsyncResult *res,

-                           gpointer      user_data)

-{

-    ApplicationLaunchParameters *params;

-    ActivateParameters *activation_params;

-    char *uri;

-    gboolean sandboxed;

-    GError *error = NULL;

-

-    params = user_data;

-    activation_params = params->activation_params;

-    uri = g_queue_pop_head (params->uris);

-    sandboxed = g_file_test ("/.flatpak-info", G_FILE_TEST_EXISTS);

-

-    nautilus_launch_default_for_uri_finish (res, &error);

-    if (!sandboxed && error != NULL && error->code != G_IO_ERROR_CANCELLED)

-    {

-        g_queue_push_tail (params->unhandled_uris, uri);

-    }

-

-    if (!g_queue_is_empty (params->uris))

-    {

-        nautilus_launch_default_for_uri_async (g_queue_peek_head (params->uris),

-                                               activation_params->parent_window,

-                                               activation_params->cancellable,

-                                               on_launch_default_for_uri,

-                                               params);

-    }

-    else

-    {

-        while ((uri = g_queue_pop_head (params->unhandled_uris)) != NULL)

-        {

-            application_unhandled_uri (activation_params, uri);

-        }

-

-        application_launch_parameters_free (params);

-    }

-}

-

 static void

 activate_files (ActivateParameters *parameters)

 {

     NautilusFile *file;

     NautilusWindowOpenFlags flags;

+    g_autoptr (GList) open_in_app_parameters = NULL;

+    g_autoptr (GList) unhandled_open_in_app_uris = NULL;

+    ApplicationLaunchParameters *one_parameters;

     int count;

     g_autofree char *old_working_dir = NULL;

     GdkScreen *screen;

+    gint num_apps;

+    gint num_unhandled;

+    gint num_files;

+    gboolean open_files;

+    g_autoptr (GQueue) launch_desktop_files = NULL;

     g_autoptr (GQueue) launch_files = NULL;

     g_autoptr (GQueue) launch_in_terminal_files = NULL;

     g_autoptr (GQueue) open_in_app_uris = NULL;

@@ -1612,26 +1684,68 @@ activate_files (ActivateParameters *parameters)

         }

     }

-    if (g_queue_is_empty (open_in_app_uris))

+    if (open_in_app_uris != NULL)

     {

-        activation_parameters_free (parameters);

+        open_in_app_parameters = make_activation_parameters (g_queue_peek_head_link (open_in_app_uris),

+                                                             &unhandled_open_in_app_uris);

     }

-    else

+

+    num_apps = g_list_length (open_in_app_parameters);

+    num_unhandled = g_list_length (unhandled_open_in_app_uris);

+    num_files = g_queue_get_length (open_in_app_uris);

+    open_files = TRUE;

+

+    if (g_queue_is_empty (open_in_app_uris) &&

+        (!parameters->user_confirmation ||

+         num_files + num_unhandled > SILENT_OPEN_LIMIT) &&

+        num_apps > 1)

     {

-        const char *uri;

-        ApplicationLaunchParameters *params;

+        GtkDialog *dialog;

+        char *prompt;

+        g_autofree char *detail = NULL;

+        int response;

-        uri = g_queue_peek_head (open_in_app_uris);

-        params = application_launch_parameters_new (parameters,

-                                                    g_queue_copy (open_in_app_uris));

+        pause_activation_timed_cancel (parameters);

-        gtk_recent_manager_add_item (gtk_recent_manager_get_default (), uri);

-        nautilus_launch_default_for_uri_async (uri,

-                                               parameters->parent_window,

-                                               parameters->cancellable,

-                                               on_launch_default_for_uri,

-                                               params);

+        prompt = _("Are you sure you want to open all files?");

+        detail = g_strdup_printf (ngettext ("This will open %d separate application.",

+                                            "This will open %d separate applications.", num_apps), num_apps);

+        dialog = eel_show_yes_no_dialog (prompt, detail,

+                                         _("_OK"), _("_Cancel"),

+                                         parameters->parent_window);

+        response = gtk_dialog_run (dialog);

+        gtk_widget_destroy (GTK_WIDGET (dialog));

+

+        unpause_activation_timed_cancel (parameters);

+

+        if (response != GTK_RESPONSE_YES)

+        {

+            open_files = FALSE;

+        }

+    }

+

+    if (open_files)

+    {

+        for (l = open_in_app_parameters; l != NULL; l = l->next)

+        {

+            one_parameters = l->data;

+

+            nautilus_launch_application_by_uri (one_parameters->application,

+                                                one_parameters->uris,

+                                                parameters->parent_window);

+            application_launch_parameters_free (one_parameters);

+        }

+

+        for (l = unhandled_open_in_app_uris; l != NULL; l = l->next)

+        {

+            char *uri = l->data;

+

+            /* this does not block */

+            application_unhandled_uri (parameters, uri);

+        }

     }

+

+    activation_parameters_free (parameters);

 }

 static void

diff --git a/src/nautilus-program-choosing.c b/src/nautilus-program-choosing.c

index 47362a3f7..35a4ab73f 100644

--- a/src/nautilus-program-choosing.c

+++ b/src/nautilus-program-choosing.c

@@ -126,32 +126,6 @@ nautilus_launch_application (GAppInfo  *application,

     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,

@@ -163,7 +137,8 @@ nautilus_launch_application_by_uri (GAppInfo  *application,

     NautilusFile *file;

     gboolean result;

     GError *error;

-    g_autoptr (GdkAppLaunchContext) launch_context = NULL;

+    GdkDisplay *display;

+    GdkAppLaunchContext *launch_context;

     NautilusIconInfo *icon;

     int count, total;

@@ -186,7 +161,22 @@ nautilus_launch_application_by_uri (GAppInfo  *application,

     }

     locations = g_list_reverse (locations);

-    launch_context = get_launch_context (parent_window);

+    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 = nautilus_file_get_by_uri (uris->data);

     icon = nautilus_file_get_icon (file,

@@ -222,6 +212,8 @@ nautilus_launch_application_by_uri (GAppInfo  *application,

                                          &error);

     }

+    g_object_unref (launch_context);

+

     if (result)

     {

         for (l = uris; l != NULL; l = l->next)

@@ -480,144 +472,4 @@ nautilus_launch_desktop_file (GdkScreen   *screen,

     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 */

diff --git a/src/nautilus-program-choosing.h b/src/nautilus-program-choosing.h

index 51881ff17..a402b79a2 100644

--- a/src/nautilus-program-choosing.h

+++ b/src/nautilus-program-choosing.h

@@ -51,10 +51,3 @@ void nautilus_launch_desktop_file                   (GdkScreen

                                                      const char                        *desktop_file_uri,

                                                      const GList                       *parameter_uris,

                                                      GtkWindow                         *parent_window);

-void nautilus_launch_default_for_uri_async          (const char                        *uri,

-                                                     GtkWindow                         *parent_window,

-                                                     GCancellable                      *cancellable,

-                                                     GAsyncReadyCallback                callback,

-                                                     gpointer                           callback_data);

-gboolean nautilus_launch_default_for_uri_finish     (GAsyncResult                      *result,

-                                                     GError                           **error);

\ No newline at end of file

-- 

GitLab