No issues found
| Tool | Failure ID | Location | Function | Message | Data |
|---|---|---|---|---|---|
| clang-analyzer | no-output-found | nautilus-mime-actions.c | Message(text='Unable to locate XML output from invoke-clang-analyzer') | None |
1 /* -*- Mode: C; indent-tabs-mode: t; c-basic-offset: 8; tab-width: 8 -*- */
2
3 /* nautilus-mime-actions.c - uri-specific versions of mime action functions
4
5 Copyright (C) 2000, 2001 Eazel, Inc.
6
7 The Gnome Library is free software; you can redistribute it and/or
8 modify it under the terms of the GNU Library General Public License as
9 published by the Free Software Foundation; either version 2 of the
10 License, or (at your option) any later version.
11
12 The Gnome Library is distributed in the hope that it will be useful,
13 but WITHOUT ANY WARRANTY; without even the implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
15 Library General Public License for more details.
16
17 You should have received a copy of the GNU Library General Public
18 License along with the Gnome Library; see the file COPYING.LIB. If not,
19 write to the Free Software Foundation, Inc., 59 Temple Place - Suite 330,
20 Boston, MA 02111-1307, USA.
21
22 Authors: Maciej Stachowiak <mjs@eazel.com>
23 */
24
25 #include <config.h>
26
27 #include "nautilus-mime-actions.h"
28
29 #include "nautilus-window-slot.h"
30
31 #include <eel/eel-glib-extensions.h>
32 #include <eel/eel-stock-dialogs.h>
33 #include <eel/eel-string.h>
34 #include <glib/gi18n.h>
35 #include <glib/gstdio.h>
36 #include <string.h>
37 #include <gdk/gdkx.h>
38
39 #include <libnautilus-private/nautilus-file-attributes.h>
40 #include <libnautilus-private/nautilus-file.h>
41 #include <libnautilus-private/nautilus-file-operations.h>
42 #include <libnautilus-private/nautilus-metadata.h>
43 #include <libnautilus-private/nautilus-program-choosing.h>
44 #include <libnautilus-private/nautilus-desktop-icon-file.h>
45 #include <libnautilus-private/nautilus-global-preferences.h>
46 #include <libnautilus-private/nautilus-signaller.h>
47
48 #define DEBUG_FLAG NAUTILUS_DEBUG_MIME
49 #include <libnautilus-private/nautilus-debug.h>
50
51 typedef enum {
52 ACTIVATION_ACTION_LAUNCH_DESKTOP_FILE,
53 ACTIVATION_ACTION_ASK,
54 ACTIVATION_ACTION_LAUNCH,
55 ACTIVATION_ACTION_LAUNCH_IN_TERMINAL,
56 ACTIVATION_ACTION_OPEN_IN_VIEW,
57 ACTIVATION_ACTION_OPEN_IN_APPLICATION,
58 ACTIVATION_ACTION_DO_NOTHING,
59 } ActivationAction;
60
61 typedef struct {
62 NautilusFile *file;
63 char *uri;
64 } LaunchLocation;
65
66 typedef struct {
67 GAppInfo *application;
68 GList *uris;
69 } ApplicationLaunchParameters;
70
71 typedef struct {
72 NautilusWindowSlot *slot;
73 gpointer window;
74 GtkWindow *parent_window;
75 GCancellable *cancellable;
76 GList *locations;
77 GList *mountables;
78 GList *start_mountables;
79 GList *not_mounted;
80 NautilusWindowOpenFlags flags;
81 char *timed_wait_prompt;
82 gboolean timed_wait_active;
83 NautilusFileListHandle *files_handle;
84 gboolean tried_mounting;
85 char *activation_directory;
86 gboolean user_confirmation;
87 } ActivateParameters;
88
89 /* Number of seconds until cancel dialog shows up */
90 #define DELAY_UNTIL_CANCEL_MSECS 5000
91
92 #define RESPONSE_RUN 1000
93 #define RESPONSE_DISPLAY 1001
94 #define RESPONSE_RUN_IN_TERMINAL 1002
95 #define RESPONSE_MARK_TRUSTED 1003
96
97 #define SILENT_WINDOW_OPEN_LIMIT 5
98 #define SILENT_OPEN_LIMIT 5
99
100 /* This number controls a maximum character count for a URL that is
101 * displayed as part of a dialog. It's fairly arbitrary -- big enough
102 * to allow most "normal" URIs to display in full, but small enough to
103 * prevent the dialog from getting insanely wide.
104 */
105 #define MAX_URI_IN_DIALOG_LENGTH 60
106
107 static void cancel_activate_callback (gpointer callback_data);
108 static void activate_activation_uris_ready_callback (GList *files,
109 gpointer callback_data);
110 static void activation_mount_mountables (ActivateParameters *parameters);
111 static void activation_start_mountables (ActivateParameters *parameters);
112 static void activate_callback (GList *files,
113 gpointer callback_data);
114 static void activation_mount_not_mounted (ActivateParameters *parameters);
115
116
117 static void
118 launch_location_free (LaunchLocation *location)
119 {
120 nautilus_file_unref (location->file);
121 g_free (location->uri);
122 g_free (location);
123 }
124
125 static void
126 launch_location_list_free (GList *list)
127 {
128 g_list_foreach (list, (GFunc)launch_location_free, NULL);
129 g_list_free (list);
130 }
131
132 static GList *
133 get_file_list_for_launch_locations (GList *locations)
134 {
135 GList *files, *l;
136 LaunchLocation *location;
137
138 files = NULL;
139 for (l = locations; l != NULL; l = l->next) {
140 location = l->data;
141
142 files = g_list_prepend (files,
143 nautilus_file_ref (location->file));
144 }
145 return g_list_reverse (files);
146 }
147
148
149 static LaunchLocation *
150 launch_location_from_file (NautilusFile *file)
151 {
152 LaunchLocation *location;
153 location = g_new (LaunchLocation, 1);
154 location->file = nautilus_file_ref (file);
155 location->uri = nautilus_file_get_uri (file);
156
157 return location;
158 }
159
160 static void
161 launch_location_update_from_file (LaunchLocation *location,
162 NautilusFile *file)
163 {
164 nautilus_file_unref (location->file);
165 g_free (location->uri);
166 location->file = nautilus_file_ref (file);
167 location->uri = nautilus_file_get_uri (file);
168 }
169
170 static void
171 launch_location_update_from_uri (LaunchLocation *location,
172 const char *uri)
173 {
174 nautilus_file_unref (location->file);
175 g_free (location->uri);
176 location->file = nautilus_file_get_by_uri (uri);
177 location->uri = g_strdup (uri);
178 }
179
180 static LaunchLocation *
181 find_launch_location_for_file (GList *list,
182 NautilusFile *file)
183 {
184 LaunchLocation *location;
185 GList *l;
186
187 for (l = list; l != NULL; l = l->next) {
188 location = l->data;
189
190 if (location->file == file) {
191 return location;
192 }
193 }
194 return NULL;
195 }
196
197 static GList *
198 launch_locations_from_file_list (GList *list)
199 {
200 GList *new;
201
202 new = NULL;
203 while (list) {
204 new = g_list_prepend (new,
205 launch_location_from_file (list->data));
206 list = list->next;
207 }
208 new = g_list_reverse (new);
209 return new;
210 }
211
212 static ApplicationLaunchParameters *
213 application_launch_parameters_new (GAppInfo *application,
214 GList *uris)
215 {
216 ApplicationLaunchParameters *result;
217
218 result = g_new0 (ApplicationLaunchParameters, 1);
219 result->application = g_object_ref (application);
220 result->uris = eel_g_str_list_copy (uris);
221
222 return result;
223 }
224
225 static void
226 application_launch_parameters_free (ApplicationLaunchParameters *parameters)
227 {
228 g_object_unref (parameters->application);
229 g_list_free_full (parameters->uris, g_free);
230
231 g_free (parameters);
232 }
233
234 static GList*
235 filter_nautilus_handler (GList *apps)
236 {
237 GList *l, *next;
238 GAppInfo *application;
239 const char *id;
240
241 l = apps;
242 while (l != NULL) {
243 application = (GAppInfo *) l->data;
244 next = l->next;
245
246 id = g_app_info_get_id (application);
247 if (id != NULL &&
248 strcmp (id,
249 "nautilus.desktop") == 0) {
250 g_object_unref (application);
251 apps = g_list_delete_link (apps, l);
252 }
253
254 l = next;
255 }
256
257 return apps;
258 }
259
260 static GList*
261 filter_non_uri_apps (GList *apps,
262 gboolean accept_files)
263 {
264 GList *l, *next;
265 GAppInfo *app;
266
267 for (l = apps; l != NULL; l = next) {
268 gboolean support;
269
270 app = l->data;
271 next = l->next;
272 support = g_app_info_supports_uris (app);
273 if (accept_files) {
274 support |= g_app_info_supports_files (app);
275 }
276 if (!support) {
277 apps = g_list_delete_link (apps, l);
278 g_object_unref (app);
279 }
280 }
281 return apps;
282 }
283
284 static gboolean
285 nautilus_mime_actions_check_if_required_attributes_ready (NautilusFile *file)
286 {
287 NautilusFileAttributes attributes;
288 gboolean ready;
289
290 attributes = nautilus_mime_actions_get_required_file_attributes ();
291 ready = nautilus_file_check_if_ready (file, attributes);
292
293 return ready;
294 }
295
296 NautilusFileAttributes
297 nautilus_mime_actions_get_required_file_attributes (void)
298 {
299 return NAUTILUS_FILE_ATTRIBUTE_INFO |
300 NAUTILUS_FILE_ATTRIBUTE_LINK_INFO;
301 }
302
303 static gboolean
304 file_has_local_path (NautilusFile *file)
305 {
306 GFile *location;
307 char *path;
308 gboolean res;
309
310
311 /* Don't only check _is_native, because we want to support
312 using the fuse path */
313 location = nautilus_file_get_location (file);
314 if (g_file_is_native (location)) {
315 res = TRUE;
316 } else {
317 path = g_file_get_path (location);
318
319 res = path != NULL;
320
321 g_free (path);
322 }
323 g_object_unref (location);
324
325 return res;
326 }
327
328 GAppInfo *
329 nautilus_mime_get_default_application_for_file (NautilusFile *file)
330 {
331 GAppInfo *app;
332 char *mime_type;
333 char *uri_scheme;
334
335 if (!nautilus_mime_actions_check_if_required_attributes_ready (file)) {
336 return NULL;
337 }
338
339 mime_type = nautilus_file_get_mime_type (file);
340 app = g_app_info_get_default_for_type (mime_type, !file_has_local_path (file));
341 g_free (mime_type);
342
343 if (app == NULL) {
344 uri_scheme = nautilus_file_get_uri_scheme (file);
345 if (uri_scheme != NULL) {
346 app = g_app_info_get_default_for_uri_scheme (uri_scheme);
347 g_free (uri_scheme);
348 }
349 }
350
351 return app;
352 }
353
354 static int
355 file_compare_by_mime_type (NautilusFile *file_a,
356 NautilusFile *file_b)
357 {
358 char *mime_type_a, *mime_type_b;
359 int ret;
360
361 mime_type_a = nautilus_file_get_mime_type (file_a);
362 mime_type_b = nautilus_file_get_mime_type (file_b);
363
364 ret = strcmp (mime_type_a, mime_type_b);
365
366 g_free (mime_type_a);
367 g_free (mime_type_b);
368
369 return ret;
370 }
371
372 static int
373 file_compare_by_parent_uri (NautilusFile *file_a,
374 NautilusFile *file_b) {
375 char *parent_uri_a, *parent_uri_b;
376 int ret;
377
378 parent_uri_a = nautilus_file_get_parent_uri (file_a);
379 parent_uri_b = nautilus_file_get_parent_uri (file_b);
380
381 ret = strcmp (parent_uri_a, parent_uri_b);
382
383 g_free (parent_uri_a);
384 g_free (parent_uri_b);
385
386 return ret;
387 }
388
389 static int
390 application_compare_by_name (const GAppInfo *app_a,
391 const GAppInfo *app_b)
392 {
393 return g_utf8_collate (g_app_info_get_display_name ((GAppInfo *)app_a),
394 g_app_info_get_display_name ((GAppInfo *)app_b));
395 }
396
397 static int
398 application_compare_by_id (const GAppInfo *app_a,
399 const GAppInfo *app_b)
400 {
401 const char *id_a, *id_b;
402
403 id_a = g_app_info_get_id ((GAppInfo *)app_a);
404 id_b = g_app_info_get_id ((GAppInfo *)app_b);
405
406 if (id_a == NULL && id_b == NULL) {
407 if (g_app_info_equal ((GAppInfo *)app_a, (GAppInfo *)app_b)) {
408 return 0;
409 }
410 if ((gsize)app_a < (gsize) app_b) {
411 return -1;
412 }
413 return 1;
414 }
415
416 if (id_a == NULL) {
417 return -1;
418 }
419
420 if (id_b == NULL) {
421 return 1;
422 }
423
424
425 return strcmp (id_a, id_b);
426 }
427
428 GList *
429 nautilus_mime_get_applications_for_file (NautilusFile *file)
430 {
431 char *mime_type;
432 char *uri_scheme;
433 GList *result;
434 GAppInfo *uri_handler;
435
436 if (!nautilus_mime_actions_check_if_required_attributes_ready (file)) {
437 return NULL;
438 }
439 mime_type = nautilus_file_get_mime_type (file);
440 result = g_app_info_get_all_for_type (mime_type);
441
442 uri_scheme = nautilus_file_get_uri_scheme (file);
443 if (uri_scheme != NULL) {
444 uri_handler = g_app_info_get_default_for_uri_scheme (uri_scheme);
445 if (uri_handler) {
446 result = g_list_prepend (result, uri_handler);
447 }
448 g_free (uri_scheme);
449 }
450
451 /* Filter out non-uri supporting apps */
452 result = filter_non_uri_apps (result, file_has_local_path (file));
453
454 result = g_list_sort (result, (GCompareFunc) application_compare_by_name);
455 g_free (mime_type);
456
457 return filter_nautilus_handler (result);
458 }
459
460 GAppInfo *
461 nautilus_mime_get_default_application_for_files (GList *files)
462 {
463 GList *l, *sorted_files;
464 NautilusFile *file;
465 GAppInfo *app, *one_app;
466
467 g_assert (files != NULL);
468
469 sorted_files = g_list_sort (g_list_copy (files), (GCompareFunc) file_compare_by_mime_type);
470
471 app = NULL;
472 for (l = sorted_files; l != NULL; l = l->next) {
473 file = l->data;
474
475 if (l->prev &&
476 file_compare_by_mime_type (file, l->prev->data) == 0 &&
477 file_compare_by_parent_uri (file, l->prev->data) == 0) {
478 continue;
479 }
480
481 one_app = nautilus_mime_get_default_application_for_file (file);
482 if (one_app == NULL || (app != NULL && !g_app_info_equal (app, one_app))) {
483 if (app) {
484 g_object_unref (app);
485 }
486 if (one_app) {
487 g_object_unref (one_app);
488 }
489 app = NULL;
490 break;
491 }
492
493 if (app == NULL) {
494 app = one_app;
495 } else {
496 g_object_unref (one_app);
497 }
498 }
499
500 g_list_free (sorted_files);
501
502 return app;
503 }
504
505 /* returns an intersection of two mime application lists,
506 * and returns a new list, freeing a, b and all applications
507 * that are not in the intersection set.
508 * The lists are assumed to be pre-sorted by their IDs */
509 static GList *
510 intersect_application_lists (GList *a,
511 GList *b)
512 {
513 GList *l, *m;
514 GList *ret;
515 GAppInfo *a_app, *b_app;
516 int cmp;
517
518 ret = NULL;
519
520 l = a;
521 m = b;
522
523 while (l != NULL && m != NULL) {
524 a_app = (GAppInfo *) l->data;
525 b_app = (GAppInfo *) m->data;
526
527 cmp = application_compare_by_id (a_app, b_app);
528 if (cmp > 0) {
529 g_object_unref (b_app);
530 m = m->next;
531 } else if (cmp < 0) {
532 g_object_unref (a_app);
533 l = l->next;
534 } else {
535 g_object_unref (b_app);
536 ret = g_list_prepend (ret, a_app);
537 l = l->next;
538 m = m->next;
539 }
540 }
541
542 g_list_foreach (l, (GFunc) g_object_unref, NULL);
543 g_list_foreach (m, (GFunc) g_object_unref, NULL);
544
545 g_list_free (a);
546 g_list_free (b);
547
548 return g_list_reverse (ret);
549 }
550
551 GList *
552 nautilus_mime_get_applications_for_files (GList *files)
553 {
554 GList *l, *sorted_files;
555 NautilusFile *file;
556 GList *one_ret, *ret;
557
558 g_assert (files != NULL);
559
560 sorted_files = g_list_sort (g_list_copy (files), (GCompareFunc) file_compare_by_mime_type);
561
562 ret = NULL;
563 for (l = sorted_files; l != NULL; l = l->next) {
564 file = l->data;
565
566 if (l->prev &&
567 file_compare_by_mime_type (file, l->prev->data) == 0 &&
568 file_compare_by_parent_uri (file, l->prev->data) == 0) {
569 continue;
570 }
571
572 one_ret = nautilus_mime_get_applications_for_file (file);
573 one_ret = g_list_sort (one_ret, (GCompareFunc) application_compare_by_id);
574 if (ret != NULL) {
575 ret = intersect_application_lists (ret, one_ret);
576 } else {
577 ret = one_ret;
578 }
579
580 if (ret == NULL) {
581 break;
582 }
583 }
584
585 g_list_free (sorted_files);
586
587 ret = g_list_sort (ret, (GCompareFunc) application_compare_by_name);
588
589 return ret;
590 }
591
592 static void
593 trash_or_delete_files (GtkWindow *parent_window,
594 const GList *files,
595 gboolean delete_if_all_already_in_trash)
596 {
597 GList *locations;
598 const GList *node;
599
600 locations = NULL;
601 for (node = files; node != NULL; node = node->next) {
602 locations = g_list_prepend (locations,
603 nautilus_file_get_location ((NautilusFile *) node->data));
604 }
605
606 locations = g_list_reverse (locations);
607
608 nautilus_file_operations_trash_or_delete (locations,
609 parent_window,
610 NULL, NULL);
611 g_list_free_full (locations, g_object_unref);
612 }
613
614 static void
615 report_broken_symbolic_link (GtkWindow *parent_window, NautilusFile *file)
616 {
617 char *target_path;
618 char *display_name;
619 char *prompt;
620 char *detail;
621 GtkDialog *dialog;
622 GList file_as_list;
623 int response;
624 gboolean can_trash;
625
626 g_assert (nautilus_file_is_broken_symbolic_link (file));
627
628 display_name = nautilus_file_get_display_name (file);
629 can_trash = nautilus_file_can_trash (file) && !nautilus_file_is_in_trash (file);
630
631 if (can_trash) {
632 prompt = g_strdup_printf (_("The link “%s” is broken. Move it to Trash?"), display_name);
633 } else {
634 prompt = g_strdup_printf (_("The link “%s” is broken."), display_name);
635 }
636 g_free (display_name);
637
638 target_path = nautilus_file_get_symbolic_link_target_path (file);
639 if (target_path == NULL) {
640 detail = g_strdup (_("This link cannot be used because it has no target."));
641 } else {
642 detail = g_strdup_printf (_("This link cannot be used because its target "
643 "“%s” doesn't exist."), target_path);
644 }
645
646 if (!can_trash) {
647 eel_run_simple_dialog (GTK_WIDGET (parent_window), FALSE, GTK_MESSAGE_WARNING,
648 prompt, detail, GTK_STOCK_CANCEL, NULL);
649 goto out;
650 }
651
652 dialog = eel_show_yes_no_dialog (prompt, detail, _("Mo_ve to Trash"), GTK_STOCK_CANCEL,
653 parent_window);
654
655 gtk_dialog_set_default_response (dialog, GTK_RESPONSE_CANCEL);
656
657 /* Make this modal to avoid problems with reffing the view & file
658 * to keep them around in case the view changes, which would then
659 * cause the old view not to be destroyed, which would cause its
660 * merged Bonobo items not to be un-merged. Maybe we need to unmerge
661 * explicitly when disconnecting views instead of relying on the
662 * unmerge in Destroy. But since BonoboUIHandler is probably going
663 * to change wildly, I don't want to mess with this now.
664 */
665
666 response = gtk_dialog_run (dialog);
667 gtk_widget_destroy (GTK_WIDGET (dialog));
668
669 if (response == GTK_RESPONSE_YES) {
670 file_as_list.data = file;
671 file_as_list.next = NULL;
672 file_as_list.prev = NULL;
673 trash_or_delete_files (parent_window, &file_as_list, TRUE);
674 }
675
676 out:
677 g_free (prompt);
678 g_free (target_path);
679 g_free (detail);
680 }
681
682 static ActivationAction
683 get_executable_text_file_action (GtkWindow *parent_window, NautilusFile *file)
684 {
685 GtkDialog *dialog;
686 char *file_name;
687 char *prompt;
688 char *detail;
689 int preferences_value;
690 int response;
691
692 g_assert (nautilus_file_contains_text (file));
693
694 preferences_value = g_settings_get_enum (nautilus_preferences,
695 NAUTILUS_PREFERENCES_EXECUTABLE_TEXT_ACTIVATION);
696 switch (preferences_value) {
697 case NAUTILUS_EXECUTABLE_TEXT_LAUNCH:
698 return ACTIVATION_ACTION_LAUNCH;
699 case NAUTILUS_EXECUTABLE_TEXT_DISPLAY:
700 return ACTIVATION_ACTION_OPEN_IN_APPLICATION;
701 case NAUTILUS_EXECUTABLE_TEXT_ASK:
702 break;
703 default:
704 /* Complain non-fatally, since preference data can't be trusted */
705 g_warning ("Unknown value %d for NAUTILUS_PREFERENCES_EXECUTABLE_TEXT_ACTIVATION",
706 preferences_value);
707
708 }
709
710
711 file_name = nautilus_file_get_display_name (file);
712 prompt = g_strdup_printf (_("Do you want to run “%s”, or display its contents?"),
713 file_name);
714 detail = g_strdup_printf (_("“%s” is an executable text file."),
715 file_name);
716 g_free (file_name);
717
718 dialog = eel_create_question_dialog (prompt,
719 detail,
720 _("Run in _Terminal"), RESPONSE_RUN_IN_TERMINAL,
721 _("_Display"), RESPONSE_DISPLAY,
722 parent_window);
723 gtk_dialog_add_button (dialog, GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL);
724 gtk_dialog_add_button (dialog, _("_Run"), RESPONSE_RUN);
725 gtk_dialog_set_default_response (dialog, GTK_RESPONSE_CANCEL);
726 gtk_widget_show (GTK_WIDGET (dialog));
727
728 g_free (prompt);
729 g_free (detail);
730
731 response = gtk_dialog_run (dialog);
732 gtk_widget_destroy (GTK_WIDGET (dialog));
733
734 switch (response) {
735 case RESPONSE_RUN:
736 return ACTIVATION_ACTION_LAUNCH;
737 case RESPONSE_RUN_IN_TERMINAL:
738 return ACTIVATION_ACTION_LAUNCH_IN_TERMINAL;
739 case RESPONSE_DISPLAY:
740 return ACTIVATION_ACTION_OPEN_IN_APPLICATION;
741 default:
742 return ACTIVATION_ACTION_DO_NOTHING;
743 }
744 }
745
746 static ActivationAction
747 get_default_executable_text_file_action (void)
748 {
749 int preferences_value;
750
751 preferences_value = g_settings_get_enum (nautilus_preferences,
752 NAUTILUS_PREFERENCES_EXECUTABLE_TEXT_ACTIVATION);
753 switch (preferences_value) {
754 case NAUTILUS_EXECUTABLE_TEXT_LAUNCH:
755 return ACTIVATION_ACTION_LAUNCH;
756 case NAUTILUS_EXECUTABLE_TEXT_DISPLAY:
757 return ACTIVATION_ACTION_OPEN_IN_APPLICATION;
758 case NAUTILUS_EXECUTABLE_TEXT_ASK:
759 default:
760 return ACTIVATION_ACTION_ASK;
761 }
762 }
763
764 gboolean
765 nautilus_mime_file_opens_in_view (NautilusFile *file)
766 {
767 return (nautilus_file_is_directory (file) ||
768 NAUTILUS_IS_DESKTOP_ICON_FILE (file));
769 }
770
771 static ActivationAction
772 get_activation_action (NautilusFile *file)
773 {
774 ActivationAction action;
775 char *activation_uri;
776
777 if (nautilus_file_is_nautilus_link (file)) {
778 return ACTIVATION_ACTION_LAUNCH_DESKTOP_FILE;
779 }
780
781 activation_uri = nautilus_file_get_activation_uri (file);
782 if (activation_uri == NULL) {
783 activation_uri = nautilus_file_get_uri (file);
784 }
785
786 action = ACTIVATION_ACTION_DO_NOTHING;
787 if (nautilus_file_is_launchable (file)) {
788 char *executable_path;
789
790 action = ACTIVATION_ACTION_LAUNCH;
791
792 executable_path = g_filename_from_uri (activation_uri, NULL, NULL);
793 if (!executable_path) {
794 action = ACTIVATION_ACTION_DO_NOTHING;
795 } else if (nautilus_file_contains_text (file)) {
796 action = get_default_executable_text_file_action ();
797 }
798 g_free (executable_path);
799 }
800
801 if (action == ACTIVATION_ACTION_DO_NOTHING) {
802 if (nautilus_mime_file_opens_in_view (file)) {
803 action = ACTIVATION_ACTION_OPEN_IN_VIEW;
804 } else {
805 action = ACTIVATION_ACTION_OPEN_IN_APPLICATION;
806 }
807 }
808 g_free (activation_uri);
809
810 return action;
811 }
812
813 gboolean
814 nautilus_mime_file_opens_in_external_app (NautilusFile *file)
815 {
816 ActivationAction activation_action;
817
818 activation_action = get_activation_action (file);
819
820 return (activation_action == ACTIVATION_ACTION_OPEN_IN_APPLICATION);
821 }
822
823
824 static unsigned int
825 mime_application_hash (GAppInfo *app)
826 {
827 const char *id;
828
829 id = g_app_info_get_id (app);
830
831 if (id == NULL) {
832 return GPOINTER_TO_UINT(app);
833 }
834
835 return g_str_hash (id);
836 }
837
838 static void
839 list_to_parameters_foreach (GAppInfo *application,
840 GList *uris,
841 GList **ret)
842 {
843 ApplicationLaunchParameters *parameters;
844
845 uris = g_list_reverse (uris);
846
847 parameters = application_launch_parameters_new
848 (application, uris);
849 *ret = g_list_prepend (*ret, parameters);
850 }
851
852
853 /**
854 * make_activation_parameters
855 *
856 * Construct a list of ApplicationLaunchParameters from a list of NautilusFiles,
857 * where files that have the same default application are put into the same
858 * launch parameter, and others are put into the unhandled_files list.
859 *
860 * @files: Files to use for construction.
861 * @unhandled_files: Files without any default application will be put here.
862 *
863 * Return value: Newly allocated list of ApplicationLaunchParameters.
864 **/
865 static GList *
866 make_activation_parameters (GList *uris,
867 GList **unhandled_uris)
868 {
869 GList *ret, *l, *app_uris;
870 NautilusFile *file;
871 GAppInfo *app, *old_app;
872 GHashTable *app_table;
873 char *uri;
874
875 ret = NULL;
876 *unhandled_uris = NULL;
877
878 app_table = g_hash_table_new_full
879 ((GHashFunc) mime_application_hash,
880 (GEqualFunc) g_app_info_equal,
881 (GDestroyNotify) g_object_unref,
882 (GDestroyNotify) g_list_free);
883
884 for (l = uris; l != NULL; l = l->next) {
885 uri = l->data;
886 file = nautilus_file_get_by_uri (uri);
887
888 app = nautilus_mime_get_default_application_for_file (file);
889 if (app != NULL) {
890 app_uris = NULL;
891
892 if (g_hash_table_lookup_extended (app_table, app,
893 (gpointer *) &old_app,
894 (gpointer *) &app_uris)) {
895 g_hash_table_steal (app_table, old_app);
896
897 app_uris = g_list_prepend (app_uris, uri);
898
899 g_object_unref (app);
900 app = old_app;
901 } else {
902 app_uris = g_list_prepend (NULL, uri);
903 }
904
905 g_hash_table_insert (app_table, app, app_uris);
906 } else {
907 *unhandled_uris = g_list_prepend (*unhandled_uris, uri);
908 }
909 nautilus_file_unref (file);
910 }
911
912 g_hash_table_foreach (app_table,
913 (GHFunc) list_to_parameters_foreach,
914 &ret);
915
916 g_hash_table_destroy (app_table);
917
918 *unhandled_uris = g_list_reverse (*unhandled_uris);
919
920 return g_list_reverse (ret);
921 }
922
923 static gboolean
924 file_was_cancelled (NautilusFile *file)
925 {
926 GError *error;
927
928 error = nautilus_file_get_file_info_error (file);
929 return
930 error != NULL &&
931 error->domain == G_IO_ERROR &&
932 error->code == G_IO_ERROR_CANCELLED;
933 }
934
935 static gboolean
936 file_was_not_mounted (NautilusFile *file)
937 {
938 GError *error;
939
940 error = nautilus_file_get_file_info_error (file);
941 return
942 error != NULL &&
943 error->domain == G_IO_ERROR &&
944 error->code == G_IO_ERROR_NOT_MOUNTED;
945 }
946
947 static void
948 activation_parameters_free (ActivateParameters *parameters)
949 {
950 if (parameters->timed_wait_active) {
951 eel_timed_wait_stop (cancel_activate_callback, parameters);
952 }
953
954 if (parameters->slot) {
955 g_object_remove_weak_pointer (G_OBJECT (parameters->slot), (gpointer *)¶meters->slot);
956 }
957 if (parameters->parent_window) {
958 g_object_remove_weak_pointer (G_OBJECT (parameters->parent_window), (gpointer *)¶meters->parent_window);
959 }
960 g_object_unref (parameters->cancellable);
961 launch_location_list_free (parameters->locations);
962 nautilus_file_list_free (parameters->mountables);
963 nautilus_file_list_free (parameters->start_mountables);
964 nautilus_file_list_free (parameters->not_mounted);
965 g_free (parameters->activation_directory);
966 g_free (parameters->timed_wait_prompt);
967 g_assert (parameters->files_handle == NULL);
968 g_free (parameters);
969 }
970
971 static void
972 cancel_activate_callback (gpointer callback_data)
973 {
974 ActivateParameters *parameters = callback_data;
975
976 parameters->timed_wait_active = FALSE;
977
978 g_cancellable_cancel (parameters->cancellable);
979
980 if (parameters->files_handle) {
981 nautilus_file_list_cancel_call_when_ready (parameters->files_handle);
982 parameters->files_handle = NULL;
983 activation_parameters_free (parameters);
984 }
985 }
986
987 static void
988 activation_start_timed_cancel (ActivateParameters *parameters)
989 {
990 parameters->timed_wait_active = TRUE;
991 eel_timed_wait_start_with_duration
992 (DELAY_UNTIL_CANCEL_MSECS,
993 cancel_activate_callback,
994 parameters,
995 parameters->timed_wait_prompt,
996 parameters->parent_window);
997 }
998
999 static void
1000 pause_activation_timed_cancel (ActivateParameters *parameters)
1001 {
1002 if (parameters->timed_wait_active) {
1003 eel_timed_wait_stop (cancel_activate_callback, parameters);
1004 parameters->timed_wait_active = FALSE;
1005 }
1006 }
1007
1008 static void
1009 unpause_activation_timed_cancel (ActivateParameters *parameters)
1010 {
1011 if (!parameters->timed_wait_active) {
1012 activation_start_timed_cancel (parameters);
1013 }
1014 }
1015
1016
1017 static void
1018 activate_mount_op_active (GtkMountOperation *operation,
1019 GParamSpec *pspec,
1020 ActivateParameters *parameters)
1021 {
1022 gboolean is_active;
1023
1024 g_object_get (operation, "is-showing", &is_active, NULL);
1025
1026 if (is_active) {
1027 pause_activation_timed_cancel (parameters);
1028 } else {
1029 unpause_activation_timed_cancel (parameters);
1030 }
1031 }
1032
1033 static gboolean
1034 confirm_multiple_windows (GtkWindow *parent_window,
1035 int count,
1036 gboolean use_tabs)
1037 {
1038 GtkDialog *dialog;
1039 char *prompt;
1040 char *detail;
1041 int response;
1042
1043 if (count <= SILENT_WINDOW_OPEN_LIMIT) {
1044 return TRUE;
1045 }
1046
1047 prompt = _("Are you sure you want to open all files?");
1048 if (use_tabs) {
1049 detail = g_strdup_printf (ngettext("This will open %d separate tab.",
1050 "This will open %d separate tabs.", count), count);
1051 } else {
1052 detail = g_strdup_printf (ngettext("This will open %d separate window.",
1053 "This will open %d separate windows.", count), count);
1054 }
1055 dialog = eel_show_yes_no_dialog (prompt, detail,
1056 GTK_STOCK_OK, GTK_STOCK_CANCEL,
1057 parent_window);
1058 g_free (detail);
1059
1060 response = gtk_dialog_run (dialog);
1061 gtk_widget_destroy (GTK_WIDGET (dialog));
1062
1063 return response == GTK_RESPONSE_YES;
1064 }
1065
1066 typedef struct {
1067 NautilusWindowSlot *slot;
1068 GtkWindow *parent_window;
1069 NautilusFile *file;
1070 GList *files;
1071 NautilusWindowOpenFlags flags;
1072 char *activation_directory;
1073 gboolean user_confirmation;
1074 char *uri;
1075 GDBusProxy *proxy;
1076 GtkWidget *dialog;
1077 } ActivateParametersInstall;
1078
1079 static void
1080 activate_parameters_install_free (ActivateParametersInstall *parameters_install)
1081 {
1082 if (parameters_install->slot) {
1083 g_object_remove_weak_pointer (G_OBJECT (parameters_install->slot), (gpointer *)¶meters_install->slot);
1084 }
1085 if (parameters_install->parent_window) {
1086 g_object_remove_weak_pointer (G_OBJECT (parameters_install->parent_window), (gpointer *)¶meters_install->parent_window);
1087 }
1088
1089 if (parameters_install->proxy != NULL) {
1090 g_object_unref (parameters_install->proxy);
1091 }
1092
1093 nautilus_file_unref (parameters_install->file);
1094 nautilus_file_list_free (parameters_install->files);
1095 g_free (parameters_install->activation_directory);
1096 g_free (parameters_install->uri);
1097 g_free (parameters_install);
1098 }
1099
1100 static char *
1101 get_application_no_mime_type_handler_message (NautilusFile *file, char *uri)
1102 {
1103 char *uri_for_display;
1104 char *name;
1105 char *error_message;
1106
1107 name = nautilus_file_get_display_name (file);
1108
1109 /* Truncate the URI so it doesn't get insanely wide. Note that even
1110 * though the dialog uses wrapped text, if the URI doesn't contain
1111 * white space then the text-wrapping code is too stupid to wrap it.
1112 */
1113 uri_for_display = eel_str_middle_truncate (name, MAX_URI_IN_DIALOG_LENGTH);
1114 error_message = g_strdup_printf (_("Could not display “%s”."), uri_for_display);
1115 g_free (uri_for_display);
1116 g_free (name);
1117
1118 return error_message;
1119 }
1120
1121 static void
1122 open_with_response_cb (GtkDialog *dialog,
1123 gint response_id,
1124 gpointer user_data)
1125 {
1126 GtkWindow *parent_window;
1127 NautilusFile *file;
1128 GList files;
1129 GAppInfo *info;
1130 ActivateParametersInstall *parameters = user_data;
1131
1132 if (response_id != GTK_RESPONSE_OK) {
1133 gtk_widget_destroy (GTK_WIDGET (dialog));
1134 return;
1135 }
1136
1137 parent_window = parameters->parent_window;
1138 file = g_object_get_data (G_OBJECT (dialog), "mime-action:file");
1139 info = gtk_app_chooser_get_app_info (GTK_APP_CHOOSER (dialog));
1140
1141 gtk_widget_destroy (GTK_WIDGET (dialog));
1142
1143 g_signal_emit_by_name (nautilus_signaller_get_current (), "mime_data_changed");
1144
1145 files.next = NULL;
1146 files.prev = NULL;
1147 files.data = file;
1148 nautilus_launch_application (info, &files, parent_window);
1149
1150 g_object_unref (info);
1151
1152 activate_parameters_install_free (parameters);
1153 }
1154
1155 static void
1156 choose_program (GtkDialog *message_dialog, int response, gpointer callback_data)
1157 {
1158 GtkWidget *dialog;
1159 NautilusFile *file;
1160 GFile *location;
1161 ActivateParametersInstall *parameters = callback_data;
1162
1163 if (response != GTK_RESPONSE_ACCEPT){
1164 gtk_widget_destroy (GTK_WIDGET (message_dialog));
1165 activate_parameters_install_free (parameters);
1166 return;
1167 }
1168
1169 file = g_object_get_data (G_OBJECT (message_dialog), "mime-action:file");
1170
1171 g_assert (NAUTILUS_IS_FILE (file));
1172
1173 location = nautilus_file_get_location (file);
1174 nautilus_file_ref (file);
1175
1176 /* Destroy the message dialog after ref:ing the file */
1177 gtk_widget_destroy (GTK_WIDGET (message_dialog));
1178
1179 dialog = gtk_app_chooser_dialog_new (parameters->parent_window,
1180 0, location);
1181 g_object_set_data_full (G_OBJECT (dialog),
1182 "mime-action:file",
1183 nautilus_file_ref (file),
1184 (GDestroyNotify)nautilus_file_unref);
1185
1186 gtk_widget_show (dialog);
1187
1188 g_signal_connect (dialog,
1189 "response",
1190 G_CALLBACK (open_with_response_cb),
1191 parameters);
1192
1193 g_object_unref (location);
1194 nautilus_file_unref (file);
1195 }
1196
1197 static void
1198 show_unhandled_type_error (ActivateParametersInstall *parameters)
1199 {
1200 GtkWidget *dialog;
1201
1202 char *mime_type = nautilus_file_get_mime_type (parameters->file);
1203 char *error_message = get_application_no_mime_type_handler_message (parameters->file, parameters->uri);
1204 if (g_content_type_is_unknown (mime_type)) {
1205 dialog = gtk_message_dialog_new (parameters->parent_window,
1206 GTK_DIALOG_DESTROY_WITH_PARENT,
1207 GTK_MESSAGE_ERROR,
1208 0,
1209 NULL);
1210 g_object_set (dialog,
1211 "text", error_message,
1212 "secondary-text", _("The file is of an unknown type"),
1213 NULL);
1214 } else {
1215 char *text;
1216 text = g_strdup_printf (_("There is no application installed for “%s” files"), g_content_type_get_description (mime_type));
1217
1218 dialog = gtk_message_dialog_new (parameters->parent_window,
1219 GTK_DIALOG_DESTROY_WITH_PARENT,
1220 GTK_MESSAGE_ERROR,
1221 0,
1222 NULL);
1223 g_object_set (dialog,
1224 "text", error_message,
1225 "secondary-text", text,
1226 NULL);
1227
1228 g_free (text);
1229 }
1230
1231 gtk_dialog_add_button (GTK_DIALOG (dialog), _("_Select Application"), GTK_RESPONSE_ACCEPT);
1232
1233 gtk_dialog_add_button (GTK_DIALOG (dialog), GTK_STOCK_OK, GTK_RESPONSE_OK);
1234
1235 gtk_dialog_set_default_response (GTK_DIALOG (dialog), GTK_RESPONSE_OK);
1236
1237 g_object_set_data_full (G_OBJECT (dialog),
1238 "mime-action:file",
1239 nautilus_file_ref (parameters->file),
1240 (GDestroyNotify)nautilus_file_unref);
1241
1242 gtk_widget_show (GTK_WIDGET (dialog));
1243
1244 g_signal_connect (dialog, "response",
1245 G_CALLBACK (choose_program), parameters);
1246
1247 g_free (error_message);
1248 g_free (mime_type);
1249 }
1250
1251 static void
1252 search_for_application_dbus_call_notify_cb (GDBusProxy *proxy,
1253 GAsyncResult *result,
1254 gpointer user_data)
1255 {
1256 ActivateParametersInstall *parameters_install = user_data;
1257 GVariant *variant;
1258 GError *error = NULL;
1259
1260 variant = g_dbus_proxy_call_finish (proxy, result, &error);
1261 if (variant == NULL) {
1262 if (!g_dbus_error_is_remote_error (error) ||
1263 g_strcmp0 (g_dbus_error_get_remote_error (error), "org.freedesktop.PackageKit.Modify.Failed") == 0) {
1264 char *message;
1265
1266 message = g_strdup_printf ("%s\n%s",
1267 _("There was an internal error trying to search for applications:"),
1268 error->message);
1269 eel_show_error_dialog (_("Unable to search for application"), message,
1270 parameters_install->parent_window);
1271 g_free (message);
1272 }
1273
1274 g_error_free (error);
1275 activate_parameters_install_free (parameters_install);
1276 return;
1277 }
1278
1279 g_variant_unref (variant);
1280
1281 /* activate the file again */
1282 nautilus_mime_activate_files (parameters_install->parent_window,
1283 parameters_install->slot,
1284 parameters_install->files,
1285 parameters_install->activation_directory,
1286 parameters_install->flags,
1287 parameters_install->user_confirmation);
1288
1289 activate_parameters_install_free (parameters_install);
1290 }
1291
1292 static void
1293 search_for_application_mime_type (ActivateParametersInstall *parameters_install, const gchar *mime_type)
1294 {
1295 GdkWindow *window;
1296 guint xid = 0;
1297 const char *mime_types[2];
1298
1299 g_assert (parameters_install->proxy != NULL);
1300
1301 /* get XID from parent window */
1302 window = gtk_widget_get_window (GTK_WIDGET (parameters_install->parent_window));
1303 if (window != NULL) {
1304 xid = GDK_WINDOW_XID (window);
1305 }
1306
1307 mime_types[0] = mime_type;
1308 mime_types[1] = NULL;
1309
1310 g_dbus_proxy_call (parameters_install->proxy,
1311 "InstallMimeTypes",
1312 g_variant_new ("(u^ass)",
1313 xid,
1314 mime_types,
1315 "hide-confirm-search"),
1316 G_DBUS_CALL_FLAGS_NONE,
1317 G_MAXINT /* no timeout */,
1318 NULL /* cancellable */,
1319 (GAsyncReadyCallback) search_for_application_dbus_call_notify_cb,
1320 parameters_install);
1321
1322 DEBUG ("InstallMimeType method invoked for %s", mime_type);
1323 }
1324
1325 static void
1326 application_unhandled_file_install (GtkDialog *dialog,
1327 gint response_id,
1328 ActivateParametersInstall *parameters_install)
1329 {
1330 char *mime_type;
1331
1332 gtk_widget_destroy (GTK_WIDGET (dialog));
1333 parameters_install->dialog = NULL;
1334
1335 if (response_id == GTK_RESPONSE_YES) {
1336 mime_type = nautilus_file_get_mime_type (parameters_install->file);
1337 search_for_application_mime_type (parameters_install, mime_type);
1338 g_free (mime_type);
1339 } else {
1340 /* free as we're not going to get the async dbus callback */
1341 activate_parameters_install_free (parameters_install);
1342 }
1343 }
1344
1345 static gboolean
1346 delete_cb (GtkDialog *dialog)
1347 {
1348 gtk_dialog_response (dialog, GTK_RESPONSE_DELETE_EVENT);
1349 return TRUE;
1350 }
1351
1352 static void
1353 pk_proxy_appeared_cb (GObject *source,
1354 GAsyncResult *res,
1355 gpointer user_data)
1356 {
1357 ActivateParametersInstall *parameters_install = user_data;
1358 char *mime_type;
1359 char *error_message;
1360 GtkWidget *dialog;
1361 GDBusProxy *proxy;
1362 GError *error = NULL;
1363
1364 proxy = g_dbus_proxy_new_for_bus_finish (res, &error);
1365
1366 if (error != NULL) {
1367 g_warning ("Couldn't call Modify on the PackageKit interface: %s",
1368 error->message);
1369 g_error_free (error);
1370
1371 /* show an unhelpful dialog */
1372 show_unhandled_type_error (parameters_install);
1373 /* The callback wasn't started, so we have to free the parameters */
1374 activate_parameters_install_free (parameters_install);
1375
1376 return;
1377 }
1378
1379 mime_type = nautilus_file_get_mime_type (parameters_install->file);
1380 error_message = get_application_no_mime_type_handler_message (parameters_install->file,
1381 parameters_install->uri);
1382 /* use a custom dialog to prompt the user to install new software */
1383 dialog = gtk_message_dialog_new (parameters_install->parent_window, 0,
1384 GTK_MESSAGE_ERROR,
1385 GTK_BUTTONS_YES_NO,
1386 "%s", error_message);
1387 gtk_message_dialog_format_secondary_text (GTK_MESSAGE_DIALOG (dialog),
1388 _("There is no application installed for “%s” files.\n"
1389 "Do you want to search for an application to open this file?"),
1390 g_content_type_get_description (mime_type));
1391 gtk_window_set_resizable (GTK_WINDOW (dialog), FALSE);
1392
1393 parameters_install->dialog = dialog;
1394 parameters_install->proxy = proxy;
1395
1396 g_signal_connect (dialog, "response",
1397 G_CALLBACK (application_unhandled_file_install),
1398 parameters_install);
1399 g_signal_connect (dialog, "delete-event",
1400 G_CALLBACK (delete_cb), NULL);
1401 gtk_widget_show_all (dialog);
1402 g_free (mime_type);
1403 }
1404
1405 static void
1406 application_unhandled_uri (ActivateParameters *parameters, char *uri)
1407 {
1408 gboolean show_install_mime;
1409 char *mime_type;
1410 NautilusFile *file;
1411 ActivateParametersInstall *parameters_install;
1412
1413 file = nautilus_file_get_by_uri (uri);
1414
1415 mime_type = nautilus_file_get_mime_type (file);
1416
1417 /* copy the parts of parameters we are interested in as the orignal will be unref'd */
1418 parameters_install = g_new0 (ActivateParametersInstall, 1);
1419 parameters_install->slot = parameters->slot;
1420 g_object_add_weak_pointer (G_OBJECT (parameters_install->slot), (gpointer *)¶meters_install->slot);
1421 if (parameters->parent_window) {
1422 parameters_install->parent_window = parameters->parent_window;
1423 g_object_add_weak_pointer (G_OBJECT (parameters_install->parent_window), (gpointer *)¶meters_install->parent_window);
1424 }
1425 parameters_install->activation_directory = g_strdup (parameters->activation_directory);
1426 parameters_install->file = file;
1427 parameters_install->files = get_file_list_for_launch_locations (parameters->locations);
1428 parameters_install->flags = parameters->flags;
1429 parameters_install->user_confirmation = parameters->user_confirmation;
1430 parameters_install->uri = g_strdup(uri);
1431
1432 #ifdef ENABLE_PACKAGEKIT
1433 /* allow an admin to disable the PackageKit search functionality */
1434 show_install_mime = g_settings_get_boolean (nautilus_preferences, NAUTILUS_PREFERENCES_INSTALL_MIME_ACTIVATION);
1435 #else
1436 /* we have no install functionality */
1437 show_install_mime = FALSE;
1438 #endif
1439 /* There is no use trying to look for handlers of application/octet-stream */
1440 if (g_content_type_is_unknown (mime_type)) {
1441 show_install_mime = FALSE;
1442 }
1443
1444 g_free (mime_type);
1445
1446 if (!show_install_mime) {
1447 goto out;
1448 }
1449
1450 g_dbus_proxy_new_for_bus (G_BUS_TYPE_SESSION,
1451 G_DBUS_PROXY_FLAGS_NONE,
1452 NULL,
1453 "org.freedesktop.PackageKit",
1454 "/org/freedesktop/PackageKit",
1455 "org.freedesktop.PackageKit.Modify",
1456 NULL,
1457 pk_proxy_appeared_cb,
1458 parameters_install);
1459
1460 return;
1461
1462 out:
1463 /* show an unhelpful dialog */
1464 show_unhandled_type_error (parameters_install);
1465 }
1466
1467 typedef struct {
1468 GtkWindow *parent_window;
1469 NautilusFile *file;
1470 } ActivateParametersDesktop;
1471
1472 static void
1473 activate_parameters_desktop_free (ActivateParametersDesktop *parameters_desktop)
1474 {
1475 if (parameters_desktop->parent_window) {
1476 g_object_remove_weak_pointer (G_OBJECT (parameters_desktop->parent_window), (gpointer *)¶meters_desktop->parent_window);
1477 }
1478 nautilus_file_unref (parameters_desktop->file);
1479 g_free (parameters_desktop);
1480 }
1481
1482 static void
1483 untrusted_launcher_response_callback (GtkDialog *dialog,
1484 int response_id,
1485 ActivateParametersDesktop *parameters)
1486 {
1487 GdkScreen *screen;
1488 char *uri;
1489 GFile *file;
1490
1491 switch (response_id) {
1492 case RESPONSE_RUN:
1493 screen = gtk_widget_get_screen (GTK_WIDGET (parameters->parent_window));
1494 uri = nautilus_file_get_uri (parameters->file);
1495 DEBUG ("Launching untrusted launcher %s", uri);
1496 nautilus_launch_desktop_file (screen, uri, NULL,
1497 parameters->parent_window);
1498 g_free (uri);
1499 break;
1500 case RESPONSE_MARK_TRUSTED:
1501 file = nautilus_file_get_location (parameters->file);
1502 nautilus_file_mark_desktop_file_trusted (file,
1503 parameters->parent_window,
1504 TRUE,
1505 NULL, NULL);
1506 g_object_unref (file);
1507 break;
1508 default:
1509 /* Just destroy dialog */
1510 break;
1511 }
1512
1513 gtk_widget_destroy (GTK_WIDGET (dialog));
1514 activate_parameters_desktop_free (parameters);
1515 }
1516
1517 static void
1518 activate_desktop_file (ActivateParameters *parameters,
1519 NautilusFile *file)
1520 {
1521 ActivateParametersDesktop *parameters_desktop;
1522 char *primary, *secondary, *display_name;
1523 GtkWidget *dialog;
1524 GdkScreen *screen;
1525 char *uri;
1526
1527 screen = gtk_widget_get_screen (GTK_WIDGET (parameters->parent_window));
1528
1529 if (!nautilus_file_is_trusted_link (file)) {
1530 /* copy the parts of parameters we are interested in as the orignal will be freed */
1531 parameters_desktop = g_new0 (ActivateParametersDesktop, 1);
1532 if (parameters->parent_window) {
1533 parameters_desktop->parent_window = parameters->parent_window;
1534 g_object_add_weak_pointer (G_OBJECT (parameters_desktop->parent_window), (gpointer *)¶meters_desktop->parent_window);
1535 }
1536 parameters_desktop->file = nautilus_file_ref (file);
1537
1538 primary = _("Untrusted application launcher");
1539 display_name = nautilus_file_get_display_name (file);
1540 secondary =
1541 g_strdup_printf (_("The application launcher “%s” has not been marked as trusted. "
1542 "If you do not know the source of this file, launching it may be unsafe."
1543 ),
1544 display_name);
1545
1546 dialog = gtk_message_dialog_new (parameters->parent_window,
1547 0,
1548 GTK_MESSAGE_WARNING,
1549 GTK_BUTTONS_NONE,
1550 NULL);
1551 g_object_set (dialog,
1552 "text", primary,
1553 "secondary-text", secondary,
1554 NULL);
1555 gtk_dialog_add_button (GTK_DIALOG (dialog),
1556 _("_Launch Anyway"), RESPONSE_RUN);
1557 if (nautilus_file_can_set_permissions (file)) {
1558 gtk_dialog_add_button (GTK_DIALOG (dialog),
1559 _("Mark as _Trusted"), RESPONSE_MARK_TRUSTED);
1560 }
1561 gtk_dialog_add_button (GTK_DIALOG (dialog),
1562 GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL);
1563 gtk_dialog_set_default_response (GTK_DIALOG (dialog), GTK_RESPONSE_CANCEL);
1564
1565 g_signal_connect (dialog, "response",
1566 G_CALLBACK (untrusted_launcher_response_callback),
1567 parameters_desktop);
1568 gtk_widget_show (dialog);
1569
1570 g_free (display_name);
1571 g_free (secondary);
1572 return;
1573 }
1574
1575 uri = nautilus_file_get_uri (file);
1576 DEBUG ("Launching trusted launcher %s", uri);
1577 nautilus_launch_desktop_file (screen, uri, NULL,
1578 parameters->parent_window);
1579 g_free (uri);
1580 }
1581
1582 static void
1583 activate_files (ActivateParameters *parameters)
1584 {
1585 NautilusWindow *window;
1586 NautilusWindowOpenFlags flags;
1587 NautilusFile *file;
1588 GList *launch_desktop_files;
1589 GList *launch_files;
1590 GList *launch_in_terminal_files;
1591 GList *open_in_app_uris;
1592 GList *open_in_app_parameters;
1593 GList *unhandled_open_in_app_uris;
1594 ApplicationLaunchParameters *one_parameters;
1595 GList *open_in_view_files;
1596 GList *l;
1597 int count;
1598 char *uri;
1599 char *executable_path, *quoted_path;
1600 char *old_working_dir;
1601 ActivationAction action;
1602 GdkScreen *screen;
1603 LaunchLocation *location;
1604 gint num_apps;
1605 gint num_unhandled;
1606 gint num_files;
1607 gboolean open_files;
1608
1609 screen = gtk_widget_get_screen (GTK_WIDGET (parameters->parent_window));
1610
1611 launch_desktop_files = NULL;
1612 launch_files = NULL;
1613 launch_in_terminal_files = NULL;
1614 open_in_app_uris = NULL;
1615 open_in_view_files = NULL;
1616
1617 for (l = parameters->locations; l != NULL; l = l->next) {
1618 location = l->data;
1619 file = location->file;
1620
1621 if (file_was_cancelled (file)) {
1622 continue;
1623 }
1624
1625 action = get_activation_action (file);
1626 if (action == ACTIVATION_ACTION_ASK) {
1627 /* Special case for executable text files, since it might be
1628 * dangerous & unexpected to launch these.
1629 */
1630 pause_activation_timed_cancel (parameters);
1631 action = get_executable_text_file_action (parameters->parent_window, file);
1632 unpause_activation_timed_cancel (parameters);
1633 }
1634
1635 switch (action) {
1636 case ACTIVATION_ACTION_LAUNCH_DESKTOP_FILE :
1637 launch_desktop_files = g_list_prepend (launch_desktop_files, file);
1638 break;
1639 case ACTIVATION_ACTION_LAUNCH :
1640 launch_files = g_list_prepend (launch_files, file);
1641 break;
1642 case ACTIVATION_ACTION_LAUNCH_IN_TERMINAL :
1643 launch_in_terminal_files = g_list_prepend (launch_in_terminal_files, file);
1644 break;
1645 case ACTIVATION_ACTION_OPEN_IN_VIEW :
1646 open_in_view_files = g_list_prepend (open_in_view_files, file);
1647 break;
1648 case ACTIVATION_ACTION_OPEN_IN_APPLICATION :
1649 open_in_app_uris = g_list_prepend (open_in_app_uris, location->uri);
1650 break;
1651 case ACTIVATION_ACTION_DO_NOTHING :
1652 break;
1653 case ACTIVATION_ACTION_ASK :
1654 g_assert_not_reached ();
1655 break;
1656 }
1657 }
1658
1659 launch_desktop_files = g_list_reverse (launch_desktop_files);
1660 for (l = launch_desktop_files; l != NULL; l = l->next) {
1661 file = NAUTILUS_FILE (l->data);
1662
1663 activate_desktop_file (parameters, file);
1664 }
1665
1666 old_working_dir = NULL;
1667 if (parameters->activation_directory &&
1668 (launch_files != NULL || launch_in_terminal_files != NULL)) {
1669 old_working_dir = g_get_current_dir ();
1670 g_chdir (parameters->activation_directory);
1671
1672 }
1673
1674 launch_files = g_list_reverse (launch_files);
1675 for (l = launch_files; l != NULL; l = l->next) {
1676 file = NAUTILUS_FILE (l->data);
1677
1678 uri = nautilus_file_get_activation_uri (file);
1679 executable_path = g_filename_from_uri (uri, NULL, NULL);
1680 quoted_path = g_shell_quote (executable_path);
1681
1682 DEBUG ("Launching file path %s", quoted_path);
1683
1684 nautilus_launch_application_from_command (screen, quoted_path, FALSE, NULL);
1685 g_free (quoted_path);
1686 g_free (executable_path);
1687 g_free (uri);
1688
1689 }
1690
1691 launch_in_terminal_files = g_list_reverse (launch_in_terminal_files);
1692 for (l = launch_in_terminal_files; l != NULL; l = l->next) {
1693 file = NAUTILUS_FILE (l->data);
1694
1695 uri = nautilus_file_get_activation_uri (file);
1696 executable_path = g_filename_from_uri (uri, NULL, NULL);
1697 quoted_path = g_shell_quote (executable_path);
1698
1699 DEBUG ("Launching in terminal file quoted path %s", quoted_path);
1700
1701 nautilus_launch_application_from_command (screen, quoted_path, TRUE, NULL);
1702
1703 g_free (quoted_path);
1704 g_free (executable_path);
1705 g_free (uri);
1706 }
1707
1708 if (old_working_dir != NULL) {
1709 g_chdir (old_working_dir);
1710 g_free (old_working_dir);
1711 }
1712
1713 open_in_view_files = g_list_reverse (open_in_view_files);
1714 count = g_list_length (open_in_view_files);
1715
1716 flags = parameters->flags;
1717 if (count > 1) {
1718 if ((parameters->flags & NAUTILUS_WINDOW_OPEN_FLAG_NEW_WINDOW) == 0) {
1719 flags |= NAUTILUS_WINDOW_OPEN_FLAG_NEW_TAB;
1720 } else {
1721 flags |= NAUTILUS_WINDOW_OPEN_FLAG_NEW_WINDOW;
1722 }
1723 }
1724
1725 if (parameters->slot != NULL &&
1726 (!parameters->user_confirmation ||
1727 confirm_multiple_windows (parameters->parent_window, count,
1728 (flags & NAUTILUS_WINDOW_OPEN_FLAG_NEW_TAB) != 0))) {
1729
1730 if ((flags & NAUTILUS_WINDOW_OPEN_FLAG_NEW_TAB) != 0 &&
1731 g_settings_get_enum (nautilus_preferences, NAUTILUS_PREFERENCES_NEW_TAB_POSITION) ==
1732 NAUTILUS_NEW_TAB_POSITION_AFTER_CURRENT_TAB) {
1733 /* When inserting N tabs after the current one,
1734 * we first open tab N, then tab N-1, ..., then tab 0.
1735 * Each of them is appended to the current tab, i.e.
1736 * prepended to the list of tabs to open.
1737 */
1738 open_in_view_files = g_list_reverse (open_in_view_files);
1739 }
1740
1741
1742 for (l = open_in_view_files; l != NULL; l = l->next) {
1743 GFile *f;
1744 /* The ui should ask for navigation or object windows
1745 * depending on what the current one is */
1746 file = NAUTILUS_FILE (l->data);
1747
1748 uri = nautilus_file_get_activation_uri (file);
1749 f = g_file_new_for_uri (uri);
1750 nautilus_window_slot_open_location (parameters->slot, f, flags);
1751 g_object_unref (f);
1752 g_free (uri);
1753 }
1754 }
1755
1756 open_in_app_parameters = NULL;
1757 unhandled_open_in_app_uris = NULL;
1758
1759 if (open_in_app_uris != NULL) {
1760 open_in_app_uris = g_list_reverse (open_in_app_uris);
1761
1762 open_in_app_parameters = make_activation_parameters
1763 (open_in_app_uris, &unhandled_open_in_app_uris);
1764 }
1765
1766 num_apps = g_list_length (open_in_app_parameters);
1767 num_unhandled = g_list_length (unhandled_open_in_app_uris);
1768 num_files = g_list_length (open_in_app_uris);
1769 open_files = TRUE;
1770
1771 if (open_in_app_uris != NULL &&
1772 (!parameters->user_confirmation ||
1773 num_files + num_unhandled > SILENT_OPEN_LIMIT) &&
1774 num_apps > 1) {
1775 GtkDialog *dialog;
1776 char *prompt;
1777 char *detail;
1778 int response;
1779
1780 pause_activation_timed_cancel (parameters);
1781
1782 prompt = _("Are you sure you want to open all files?");
1783 detail = g_strdup_printf (ngettext ("This will open %d separate application.",
1784 "This will open %d separate applications.", num_apps), num_apps);
1785 dialog = eel_show_yes_no_dialog (prompt, detail,
1786 GTK_STOCK_OK, GTK_STOCK_CANCEL,
1787 parameters->parent_window);
1788 g_free (detail);
1789
1790 response = gtk_dialog_run (dialog);
1791 gtk_widget_destroy (GTK_WIDGET (dialog));
1792
1793 unpause_activation_timed_cancel (parameters);
1794
1795 if (response != GTK_RESPONSE_YES) {
1796 open_files = FALSE;
1797 }
1798 }
1799
1800 if (open_files) {
1801 for (l = open_in_app_parameters; l != NULL; l = l->next) {
1802 one_parameters = l->data;
1803
1804 nautilus_launch_application_by_uri (one_parameters->application,
1805 one_parameters->uris,
1806 parameters->parent_window);
1807 application_launch_parameters_free (one_parameters);
1808 }
1809
1810 for (l = unhandled_open_in_app_uris; l != NULL; l = l->next) {
1811 uri = l->data;
1812
1813 /* this does not block */
1814 application_unhandled_uri (parameters, uri);
1815 }
1816 }
1817
1818 window = NULL;
1819 if (parameters->slot != NULL) {
1820 window = nautilus_window_slot_get_window (parameters->slot);
1821 }
1822
1823 if (open_in_app_parameters != NULL ||
1824 unhandled_open_in_app_uris != NULL) {
1825 if ((parameters->flags & NAUTILUS_WINDOW_OPEN_FLAG_CLOSE_BEHIND) != 0 &&
1826 window != NULL) {
1827 nautilus_window_close (window);
1828 }
1829 }
1830
1831 g_list_free (launch_desktop_files);
1832 g_list_free (launch_files);
1833 g_list_free (launch_in_terminal_files);
1834 g_list_free (open_in_view_files);
1835 g_list_free (open_in_app_uris);
1836 g_list_free (open_in_app_parameters);
1837 g_list_free (unhandled_open_in_app_uris);
1838
1839 activation_parameters_free (parameters);
1840 }
1841
1842 static void
1843 activation_mount_not_mounted_callback (GObject *source_object,
1844 GAsyncResult *res,
1845 gpointer user_data)
1846 {
1847 ActivateParameters *parameters = user_data;
1848 GError *error;
1849 NautilusFile *file;
1850 LaunchLocation *loc;
1851
1852 file = parameters->not_mounted->data;
1853
1854 error = NULL;
1855 if (!g_file_mount_enclosing_volume_finish (G_FILE (source_object), res, &error)) {
1856 if (error->domain != G_IO_ERROR ||
1857 (error->code != G_IO_ERROR_CANCELLED &&
1858 error->code != G_IO_ERROR_FAILED_HANDLED &&
1859 error->code != G_IO_ERROR_ALREADY_MOUNTED)) {
1860 eel_show_error_dialog (_("Unable to access location"), error->message, parameters->parent_window);
1861 }
1862
1863 if (error->domain != G_IO_ERROR ||
1864 error->code != G_IO_ERROR_ALREADY_MOUNTED) {
1865 loc = find_launch_location_for_file (parameters->locations,
1866 file);
1867 if (loc) {
1868 parameters->locations =
1869 g_list_remove (parameters->locations, loc);
1870 launch_location_free (loc);
1871 }
1872 }
1873
1874 g_error_free (error);
1875 }
1876
1877 parameters->not_mounted = g_list_delete_link (parameters->not_mounted,
1878 parameters->not_mounted);
1879 nautilus_file_unref (file);
1880
1881 activation_mount_not_mounted (parameters);
1882 }
1883
1884 static void
1885 activation_mount_not_mounted (ActivateParameters *parameters)
1886 {
1887 NautilusFile *file;
1888 GFile *location;
1889 LaunchLocation *loc;
1890 GMountOperation *mount_op;
1891 GList *l, *next, *files;
1892
1893 if (parameters->not_mounted != NULL) {
1894 file = parameters->not_mounted->data;
1895 mount_op = gtk_mount_operation_new (parameters->parent_window);
1896 g_mount_operation_set_password_save (mount_op, G_PASSWORD_SAVE_FOR_SESSION);
1897 g_signal_connect (mount_op, "notify::is-showing",
1898 G_CALLBACK (activate_mount_op_active), parameters);
1899 location = nautilus_file_get_location (file);
1900 g_file_mount_enclosing_volume (location, 0, mount_op, parameters->cancellable,
1901 activation_mount_not_mounted_callback, parameters);
1902 g_object_unref (location);
1903 /* unref mount_op here - g_file_mount_enclosing_volume() does ref for itself */
1904 g_object_unref (mount_op);
1905 return;
1906 }
1907
1908 parameters->tried_mounting = TRUE;
1909
1910 if (parameters->locations == NULL) {
1911 activation_parameters_free (parameters);
1912 return;
1913 }
1914
1915 /* once the mount is finished, refresh all attributes */
1916 /* - fixes new windows not appearing after successful mount */
1917 for (l = parameters->locations; l != NULL; l = next) {
1918 loc = l->data;
1919 next = l->next;
1920 nautilus_file_invalidate_all_attributes (loc->file);
1921 }
1922
1923 files = get_file_list_for_launch_locations (parameters->locations);
1924 nautilus_file_list_call_when_ready
1925 (files,
1926 nautilus_mime_actions_get_required_file_attributes () | NAUTILUS_FILE_ATTRIBUTE_LINK_INFO,
1927 ¶meters->files_handle,
1928 activate_callback, parameters);
1929 nautilus_file_list_free (files);
1930 }
1931
1932
1933 static void
1934 activate_callback (GList *files, gpointer callback_data)
1935 {
1936 ActivateParameters *parameters = callback_data;
1937 GList *l, *next;
1938 NautilusFile *file;
1939 LaunchLocation *location;
1940
1941 parameters->files_handle = NULL;
1942
1943 for (l = parameters->locations; l != NULL; l = next) {
1944 location = l->data;
1945 file = location->file;
1946 next = l->next;
1947
1948 if (file_was_cancelled (file)) {
1949 launch_location_free (location);
1950 parameters->locations = g_list_delete_link (parameters->locations, l);
1951 continue;
1952 }
1953
1954 if (file_was_not_mounted (file)) {
1955 if (parameters->tried_mounting) {
1956 launch_location_free (location);
1957 parameters->locations = g_list_delete_link (parameters->locations, l);
1958 } else {
1959 parameters->not_mounted = g_list_prepend (parameters->not_mounted,
1960 nautilus_file_ref (file));
1961 }
1962 continue;
1963 }
1964 }
1965
1966
1967 if (parameters->not_mounted != NULL) {
1968 activation_mount_not_mounted (parameters);
1969 } else {
1970 activate_files (parameters);
1971 }
1972 }
1973
1974 static void
1975 activate_activation_uris_ready_callback (GList *files_ignore,
1976 gpointer callback_data)
1977 {
1978 ActivateParameters *parameters = callback_data;
1979 GList *l, *next, *files;
1980 NautilusFile *file;
1981 LaunchLocation *location;
1982
1983 parameters->files_handle = NULL;
1984
1985 for (l = parameters->locations; l != NULL; l = next) {
1986 location = l->data;
1987 file = location->file;
1988 next = l->next;
1989
1990 if (file_was_cancelled (file)) {
1991 launch_location_free (location);
1992 parameters->locations = g_list_delete_link (parameters->locations, l);
1993 continue;
1994 }
1995
1996 if (nautilus_file_is_broken_symbolic_link (file)) {
1997 launch_location_free (location);
1998 parameters->locations = g_list_delete_link (parameters->locations, l);
1999 pause_activation_timed_cancel (parameters);
2000 report_broken_symbolic_link (parameters->parent_window, file);
2001 unpause_activation_timed_cancel (parameters);
2002 continue;
2003 }
2004
2005 if (nautilus_file_get_file_type (file) == G_FILE_TYPE_MOUNTABLE &&
2006 !nautilus_file_has_activation_uri (file)) {
2007 /* Don't launch these... There is nothing we
2008 can do */
2009 launch_location_free (location);
2010 parameters->locations = g_list_delete_link (parameters->locations, l);
2011 continue;
2012 }
2013
2014 }
2015
2016 if (parameters->locations == NULL) {
2017 activation_parameters_free (parameters);
2018 return;
2019 }
2020
2021 /* Convert the files to the actual activation uri files */
2022 for (l = parameters->locations; l != NULL; l = l->next) {
2023 char *uri = NULL;
2024
2025 location = l->data;
2026
2027 /* We want the file for the activation URI since we care
2028 * about the attributes for that, not for the original file.
2029 */
2030 if (nautilus_file_is_symbolic_link (location->file)) {
2031 uri = nautilus_file_get_symbolic_link_target_uri (location->file);
2032 }
2033
2034 if (uri == NULL) {
2035 uri = nautilus_file_get_activation_uri (location->file);
2036 }
2037
2038 if (uri != NULL) {
2039 launch_location_update_from_uri (location, uri);
2040 }
2041 g_free (uri);
2042 }
2043
2044
2045 /* get the parameters for the actual files */
2046 files = get_file_list_for_launch_locations (parameters->locations);
2047 nautilus_file_list_call_when_ready
2048 (files,
2049 nautilus_mime_actions_get_required_file_attributes () | NAUTILUS_FILE_ATTRIBUTE_LINK_INFO,
2050 ¶meters->files_handle,
2051 activate_callback, parameters);
2052 nautilus_file_list_free (files);
2053 }
2054
2055 static void
2056 activation_get_activation_uris (ActivateParameters *parameters)
2057 {
2058 GList *l, *files;
2059 NautilusFile *file;
2060 LaunchLocation *location;
2061
2062 /* link target info might be stale, re-read it */
2063 for (l = parameters->locations; l != NULL; l = l->next) {
2064 location = l->data;
2065 file = location->file;
2066
2067 if (file_was_cancelled (file)) {
2068 launch_location_free (location);
2069 parameters->locations = g_list_delete_link (parameters->locations, l);
2070 continue;
2071 }
2072 }
2073
2074 if (parameters->locations == NULL) {
2075 activation_parameters_free (parameters);
2076 return;
2077 }
2078
2079 files = get_file_list_for_launch_locations (parameters->locations);
2080 nautilus_file_list_call_when_ready
2081 (files,
2082 NAUTILUS_FILE_ATTRIBUTE_INFO |
2083 NAUTILUS_FILE_ATTRIBUTE_LINK_INFO,
2084 ¶meters->files_handle,
2085 activate_activation_uris_ready_callback, parameters);
2086 nautilus_file_list_free (files);
2087 }
2088
2089 static void
2090 activation_mountable_mounted (NautilusFile *file,
2091 GFile *result_location,
2092 GError *error,
2093 gpointer callback_data)
2094 {
2095 ActivateParameters *parameters = callback_data;
2096 NautilusFile *target_file;
2097 LaunchLocation *location;
2098
2099 /* Remove from list of files that have to be mounted */
2100 parameters->mountables = g_list_remove (parameters->mountables, file);
2101 nautilus_file_unref (file);
2102
2103
2104 if (error == NULL) {
2105 /* Replace file with the result of the mount */
2106 target_file = nautilus_file_get (result_location);
2107
2108 location = find_launch_location_for_file (parameters->locations,
2109 file);
2110 if (location) {
2111 launch_location_update_from_file (location, target_file);
2112 }
2113 nautilus_file_unref (target_file);
2114 } else {
2115 /* Remove failed file */
2116
2117 if (error->domain != G_IO_ERROR ||
2118 (error->code != G_IO_ERROR_FAILED_HANDLED &&
2119 error->code != G_IO_ERROR_ALREADY_MOUNTED)) {
2120 location = find_launch_location_for_file (parameters->locations,
2121 file);
2122 if (location) {
2123 parameters->locations =
2124 g_list_remove (parameters->locations,
2125 location);
2126 launch_location_free (location);
2127 }
2128 }
2129
2130 if (error->domain != G_IO_ERROR ||
2131 (error->code != G_IO_ERROR_CANCELLED &&
2132 error->code != G_IO_ERROR_FAILED_HANDLED &&
2133 error->code != G_IO_ERROR_ALREADY_MOUNTED)) {
2134 eel_show_error_dialog (_("Unable to access location"),
2135 error->message, parameters->parent_window);
2136 }
2137
2138 if (error->code == G_IO_ERROR_CANCELLED) {
2139 activation_parameters_free (parameters);
2140 return;
2141 }
2142 }
2143
2144 /* Mount more mountables */
2145 activation_mount_mountables (parameters);
2146 }
2147
2148
2149 static void
2150 activation_mount_mountables (ActivateParameters *parameters)
2151 {
2152 NautilusFile *file;
2153 GMountOperation *mount_op;
2154
2155 if (parameters->mountables != NULL) {
2156 file = parameters->mountables->data;
2157 mount_op = gtk_mount_operation_new (parameters->parent_window);
2158 g_mount_operation_set_password_save (mount_op, G_PASSWORD_SAVE_FOR_SESSION);
2159 g_signal_connect (mount_op, "notify::is-showing",
2160 G_CALLBACK (activate_mount_op_active), parameters);
2161 nautilus_file_mount (file,
2162 mount_op,
2163 parameters->cancellable,
2164 activation_mountable_mounted,
2165 parameters);
2166 g_object_unref (mount_op);
2167 return;
2168 }
2169
2170 if (parameters->mountables == NULL && parameters->start_mountables == NULL)
2171 activation_get_activation_uris (parameters);
2172 }
2173
2174
2175 static void
2176 activation_mountable_started (NautilusFile *file,
2177 GFile *gfile_of_file,
2178 GError *error,
2179 gpointer callback_data)
2180 {
2181 ActivateParameters *parameters = callback_data;
2182 LaunchLocation *location;
2183
2184 /* Remove from list of files that have to be mounted */
2185 parameters->start_mountables = g_list_remove (parameters->start_mountables, file);
2186 nautilus_file_unref (file);
2187
2188 if (error == NULL) {
2189 /* Remove file */
2190 location = find_launch_location_for_file (parameters->locations, file);
2191 if (location != NULL) {
2192 parameters->locations = g_list_remove (parameters->locations, location);
2193 launch_location_free (location);
2194 }
2195
2196 } else {
2197 /* Remove failed file */
2198 if (error->domain != G_IO_ERROR ||
2199 (error->code != G_IO_ERROR_FAILED_HANDLED)) {
2200 location = find_launch_location_for_file (parameters->locations,
2201 file);
2202 if (location) {
2203 parameters->locations =
2204 g_list_remove (parameters->locations,
2205 location);
2206 launch_location_free (location);
2207 }
2208 }
2209
2210 if (error->domain != G_IO_ERROR ||
2211 (error->code != G_IO_ERROR_CANCELLED &&
2212 error->code != G_IO_ERROR_FAILED_HANDLED)) {
2213 eel_show_error_dialog (_("Unable to start location"),
2214 error->message, NULL);
2215 }
2216
2217 if (error->code == G_IO_ERROR_CANCELLED) {
2218 activation_parameters_free (parameters);
2219 return;
2220 }
2221 }
2222
2223 /* Start more mountables */
2224 activation_start_mountables (parameters);
2225 }
2226
2227 static void
2228 activation_start_mountables (ActivateParameters *parameters)
2229 {
2230 NautilusFile *file;
2231 GMountOperation *start_op;
2232
2233 if (parameters->start_mountables != NULL) {
2234 file = parameters->start_mountables->data;
2235 start_op = gtk_mount_operation_new (parameters->parent_window);
2236 g_signal_connect (start_op, "notify::is-showing",
2237 G_CALLBACK (activate_mount_op_active), parameters);
2238 nautilus_file_start (file,
2239 start_op,
2240 parameters->cancellable,
2241 activation_mountable_started,
2242 parameters);
2243 g_object_unref (start_op);
2244 return;
2245 }
2246
2247 if (parameters->mountables == NULL && parameters->start_mountables == NULL)
2248 activation_get_activation_uris (parameters);
2249 }
2250
2251 /**
2252 * nautilus_mime_activate_files:
2253 *
2254 * Activate a list of files. Each one might launch with an application or
2255 * with a component. This is normally called only by subclasses.
2256 * @view: FMDirectoryView in question.
2257 * @files: A GList of NautilusFiles to activate.
2258 *
2259 **/
2260 void
2261 nautilus_mime_activate_files (GtkWindow *parent_window,
2262 NautilusWindowSlot *slot,
2263 GList *files,
2264 const char *launch_directory,
2265 NautilusWindowOpenFlags flags,
2266 gboolean user_confirmation)
2267 {
2268 ActivateParameters *parameters;
2269 char *file_name;
2270 int file_count;
2271 GList *l, *next;
2272 NautilusFile *file;
2273 LaunchLocation *location;
2274
2275 if (files == NULL) {
2276 return;
2277 }
2278
2279 DEBUG_FILES (files, "Calling activate_files() with files:");
2280
2281 parameters = g_new0 (ActivateParameters, 1);
2282 parameters->slot = slot;
2283 g_object_add_weak_pointer (G_OBJECT (parameters->slot), (gpointer *)¶meters->slot);
2284 if (parent_window) {
2285 parameters->parent_window = parent_window;
2286 g_object_add_weak_pointer (G_OBJECT (parameters->parent_window), (gpointer *)¶meters->parent_window);
2287 }
2288 parameters->cancellable = g_cancellable_new ();
2289 parameters->activation_directory = g_strdup (launch_directory);
2290 parameters->locations = launch_locations_from_file_list (files);
2291 parameters->flags = flags;
2292 parameters->user_confirmation = user_confirmation;
2293
2294 file_count = g_list_length (files);
2295 if (file_count == 1) {
2296 file_name = nautilus_file_get_display_name (files->data);
2297 parameters->timed_wait_prompt = g_strdup_printf (_("Opening “%s”."), file_name);
2298 g_free (file_name);
2299 } else {
2300 parameters->timed_wait_prompt = g_strdup_printf (ngettext ("Opening %d item.",
2301 "Opening %d items.",
2302 file_count),
2303 file_count);
2304 }
2305
2306
2307 for (l = parameters->locations; l != NULL; l = next) {
2308 location = l->data;
2309 file = location->file;
2310 next = l->next;
2311
2312 if (nautilus_file_can_mount (file)) {
2313 parameters->mountables = g_list_prepend (parameters->mountables,
2314 nautilus_file_ref (file));
2315 }
2316
2317 if (nautilus_file_can_start (file)) {
2318 parameters->start_mountables = g_list_prepend (parameters->start_mountables,
2319 nautilus_file_ref (file));
2320 }
2321 }
2322
2323 activation_start_timed_cancel (parameters);
2324 if (parameters->mountables != NULL)
2325 activation_mount_mountables (parameters);
2326 if (parameters->start_mountables != NULL)
2327 activation_start_mountables (parameters);
2328 if (parameters->mountables == NULL && parameters->start_mountables == NULL)
2329 activation_get_activation_uris (parameters);
2330 }
2331
2332 /**
2333 * nautilus_mime_activate_file:
2334 *
2335 * Activate a file in this view. This might involve switching the displayed
2336 * location for the current window, or launching an application.
2337 * @view: FMDirectoryView in question.
2338 * @file: A NautilusFile representing the file in this view to activate.
2339 * @use_new_window: Should this item be opened in a new window?
2340 *
2341 **/
2342
2343 void
2344 nautilus_mime_activate_file (GtkWindow *parent_window,
2345 NautilusWindowSlot *slot,
2346 NautilusFile *file,
2347 const char *launch_directory,
2348 NautilusWindowOpenFlags flags)
2349 {
2350 GList *files;
2351
2352 g_return_if_fail (NAUTILUS_IS_FILE (file));
2353
2354 files = g_list_prepend (NULL, file);
2355 nautilus_mime_activate_files (parent_window, slot, files, launch_directory, flags, FALSE);
2356 g_list_free (files);
2357 }