1 /* -*- Mode: C; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
2 /* GTK - The GIMP Toolkit
3 * Copyright (C) Christian Kellner <gicmo@gnome.org>
5 * This library is free software; you can redistribute it and/or
6 * modify it under the terms of the GNU Lesser General Public
7 * License as published by the Free Software Foundation; either
8 * version 2 of the License, or (at your option) any later version.
10 * This library is distributed in the hope that it will be useful,
11 * but WITHOUT ANY WARRANTY; without even the implied warranty of
12 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
13 * Lesser General Public License for more details.
15 * You should have received a copy of the GNU Lesser General Public
16 * License along with this library. If not, see <http://www.gnu.org/licenses/>.
20 * Modified by the GTK+ Team and others 1997-2000. See the AUTHORS
21 * file for a list of people on the GTK+ Team. See the ChangeLog
22 * files for a list of changes. These files are distributed with
23 * GTK+ at ftp://ftp.gtk.org/pub/gtk/.
30 #include "gtkmountoperationprivate.h"
36 #include "gtkmessagedialog.h"
37 #include "gtkmountoperation.h"
38 #include "gtkprivate.h"
39 #include "gtkradiobutton.h"
42 #include "gtkwindow.h"
43 #include "gtktreeview.h"
44 #include "gtktreeselection.h"
45 #include "gtkcellrenderertext.h"
46 #include "gtkcellrendererpixbuf.h"
47 #include "gtkscrolledwindow.h"
48 #include "gtkicontheme.h"
49 #include "gtkimagemenuitem.h"
54 * @short_description: Functions for working with GIO
55 * @Title: Filesystem utilities
57 * The functions and objects described here make working with GTK+ and
58 * GIO more convenient.
60 * #GtkMountOperation is needed when mounting volumes:
61 * It is an implementation of #GMountOperation that can be used with
62 * GIO functions for mounting volumes such as
63 * g_file_mount_enclosing_volume(), g_file_mount_mountable(),
64 * g_volume_mount(), g_mount_unmount_with_operation() and others.
66 * When necessary, #GtkMountOperation shows dialogs to ask for
67 * passwords, questions or show processes blocking unmount.
69 * gtk_show_uri() is a convenient way to launch applications for URIs.
71 * Another object that is worth mentioning in this context is
72 * #GdkAppLaunchContext, which provides visual feedback when lauching
76 static void gtk_mount_operation_finalize (GObject *object);
77 static void gtk_mount_operation_set_property (GObject *object,
81 static void gtk_mount_operation_get_property (GObject *object,
86 static void gtk_mount_operation_ask_password (GMountOperation *op,
88 const char *default_user,
89 const char *default_domain,
90 GAskPasswordFlags flags);
92 static void gtk_mount_operation_ask_question (GMountOperation *op,
94 const char *choices[]);
96 static void gtk_mount_operation_show_processes (GMountOperation *op,
99 const char *choices[]);
101 static void gtk_mount_operation_aborted (GMountOperation *op);
103 G_DEFINE_TYPE (GtkMountOperation, gtk_mount_operation, G_TYPE_MOUNT_OPERATION);
113 struct _GtkMountOperationPrivate {
114 GtkWindow *parent_window;
118 /* for the ask-password dialog */
119 GtkWidget *entry_container;
120 GtkWidget *username_entry;
121 GtkWidget *domain_entry;
122 GtkWidget *password_entry;
123 GtkWidget *anonymous_toggle;
125 GAskPasswordFlags ask_flags;
126 GPasswordSave password_save;
129 /* for the show-processes dialog */
130 GtkWidget *process_tree_view;
131 GtkListStore *process_list_store;
135 gtk_mount_operation_class_init (GtkMountOperationClass *klass)
137 GObjectClass *object_class = G_OBJECT_CLASS (klass);
138 GMountOperationClass *mount_op_class = G_MOUNT_OPERATION_CLASS (klass);
140 g_type_class_add_private (klass, sizeof (GtkMountOperationPrivate));
142 object_class->finalize = gtk_mount_operation_finalize;
143 object_class->get_property = gtk_mount_operation_get_property;
144 object_class->set_property = gtk_mount_operation_set_property;
146 mount_op_class->ask_password = gtk_mount_operation_ask_password;
147 mount_op_class->ask_question = gtk_mount_operation_ask_question;
148 mount_op_class->show_processes = gtk_mount_operation_show_processes;
149 mount_op_class->aborted = gtk_mount_operation_aborted;
151 g_object_class_install_property (object_class,
153 g_param_spec_object ("parent",
155 P_("The parent window"),
157 GTK_PARAM_READWRITE));
159 g_object_class_install_property (object_class,
161 g_param_spec_boolean ("is-showing",
163 P_("Are we showing a dialog"),
165 GTK_PARAM_READABLE));
167 g_object_class_install_property (object_class,
169 g_param_spec_object ("screen",
171 P_("The screen where this window will be displayed."),
173 GTK_PARAM_READWRITE));
177 gtk_mount_operation_init (GtkMountOperation *operation)
179 operation->priv = G_TYPE_INSTANCE_GET_PRIVATE (operation,
180 GTK_TYPE_MOUNT_OPERATION,
181 GtkMountOperationPrivate);
185 gtk_mount_operation_finalize (GObject *object)
187 GtkMountOperation *operation = GTK_MOUNT_OPERATION (object);
188 GtkMountOperationPrivate *priv = operation->priv;
190 if (priv->parent_window)
191 g_object_unref (priv->parent_window);
194 g_object_unref (priv->screen);
196 G_OBJECT_CLASS (gtk_mount_operation_parent_class)->finalize (object);
200 gtk_mount_operation_set_property (GObject *object,
205 GtkMountOperation *operation = GTK_MOUNT_OPERATION (object);
210 gtk_mount_operation_set_parent (operation, g_value_get_object (value));
214 gtk_mount_operation_set_screen (operation, g_value_get_object (value));
217 case PROP_IS_SHOWING:
219 G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
225 gtk_mount_operation_get_property (GObject *object,
230 GtkMountOperation *operation = GTK_MOUNT_OPERATION (object);
231 GtkMountOperationPrivate *priv = operation->priv;
236 g_value_set_object (value, priv->parent_window);
239 case PROP_IS_SHOWING:
240 g_value_set_boolean (value, priv->dialog != NULL);
244 g_value_set_object (value, priv->screen);
248 G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
254 remember_button_toggled (GtkToggleButton *button,
255 GtkMountOperation *operation)
257 GtkMountOperationPrivate *priv = operation->priv;
259 if (gtk_toggle_button_get_active (button))
263 data = g_object_get_data (G_OBJECT (button), "password-save");
264 priv->password_save = GPOINTER_TO_INT (data);
269 pw_dialog_got_response (GtkDialog *dialog,
271 GtkMountOperation *mount_op)
273 GtkMountOperationPrivate *priv = mount_op->priv;
274 GMountOperation *op = G_MOUNT_OPERATION (mount_op);
276 if (response_id == GTK_RESPONSE_OK)
280 if (priv->ask_flags & G_ASK_PASSWORD_ANONYMOUS_SUPPORTED)
281 g_mount_operation_set_anonymous (op, priv->anonymous);
283 if (priv->username_entry)
285 text = gtk_entry_get_text (GTK_ENTRY (priv->username_entry));
286 g_mount_operation_set_username (op, text);
289 if (priv->domain_entry)
291 text = gtk_entry_get_text (GTK_ENTRY (priv->domain_entry));
292 g_mount_operation_set_domain (op, text);
295 if (priv->password_entry)
297 text = gtk_entry_get_text (GTK_ENTRY (priv->password_entry));
298 g_mount_operation_set_password (op, text);
301 if (priv->ask_flags & G_ASK_PASSWORD_SAVING_SUPPORTED)
302 g_mount_operation_set_password_save (op, priv->password_save);
304 g_mount_operation_reply (op, G_MOUNT_OPERATION_HANDLED);
307 g_mount_operation_reply (op, G_MOUNT_OPERATION_ABORTED);
310 g_object_notify (G_OBJECT (op), "is-showing");
311 gtk_widget_destroy (GTK_WIDGET (dialog));
316 entry_has_input (GtkWidget *entry_widget)
320 if (entry_widget == NULL)
323 text = gtk_entry_get_text (GTK_ENTRY (entry_widget));
325 return text != NULL && text[0] != '\0';
329 pw_dialog_input_is_valid (GtkMountOperation *operation)
331 GtkMountOperationPrivate *priv = operation->priv;
332 gboolean is_valid = TRUE;
334 /* We don't require password to be non-empty here
335 * since there are situations where it is not needed,
337 * We may add a way for the backend to specify that it
338 * definitively needs a password.
340 is_valid = entry_has_input (priv->username_entry) &&
341 entry_has_input (priv->domain_entry);
347 pw_dialog_verify_input (GtkEditable *editable,
348 GtkMountOperation *operation)
350 GtkMountOperationPrivate *priv = operation->priv;
353 is_valid = pw_dialog_input_is_valid (operation);
354 gtk_dialog_set_response_sensitive (GTK_DIALOG (priv->dialog),
360 pw_dialog_anonymous_toggled (GtkWidget *widget,
361 GtkMountOperation *operation)
363 GtkMountOperationPrivate *priv = operation->priv;
366 priv->anonymous = widget == priv->anonymous_toggle;
371 is_valid = pw_dialog_input_is_valid (operation);
373 gtk_widget_set_sensitive (priv->entry_container, priv->anonymous == FALSE);
374 gtk_dialog_set_response_sensitive (GTK_DIALOG (priv->dialog),
381 pw_dialog_cycle_focus (GtkWidget *widget,
382 GtkMountOperation *operation)
384 GtkMountOperationPrivate *priv;
385 GtkWidget *next_widget = NULL;
387 priv = operation->priv;
389 if (widget == priv->username_entry)
391 if (priv->domain_entry != NULL)
392 next_widget = priv->domain_entry;
393 else if (priv->password_entry != NULL)
394 next_widget = priv->password_entry;
396 else if (widget == priv->domain_entry && priv->password_entry)
397 next_widget = priv->password_entry;
400 gtk_widget_grab_focus (next_widget);
401 else if (pw_dialog_input_is_valid (operation))
402 gtk_window_activate_default (GTK_WINDOW (priv->dialog));
406 table_add_entry (GtkWidget *table,
408 const char *label_text,
415 label = gtk_label_new_with_mnemonic (label_text);
416 gtk_widget_set_halign (label, GTK_ALIGN_START);
417 gtk_widget_set_valign (label, GTK_ALIGN_CENTER);
418 gtk_widget_set_hexpand (label, TRUE);
420 entry = gtk_entry_new ();
423 gtk_entry_set_text (GTK_ENTRY (entry), value);
425 gtk_grid_attach (GTK_GRID (table), label, 0, row, 1, 1);
426 gtk_grid_attach (GTK_GRID (table), entry, 1, row, 1, 1);
427 gtk_label_set_mnemonic_widget (GTK_LABEL (label), entry);
429 g_signal_connect (entry, "changed",
430 G_CALLBACK (pw_dialog_verify_input), user_data);
432 g_signal_connect (entry, "activate",
433 G_CALLBACK (pw_dialog_cycle_focus), user_data);
439 gtk_mount_operation_ask_password (GMountOperation *mount_op,
441 const char *default_user,
442 const char *default_domain,
443 GAskPasswordFlags flags)
445 GtkMountOperation *operation;
446 GtkMountOperationPrivate *priv;
450 GtkWidget *hbox, *main_vbox, *vbox, *icon;
452 GtkWidget *message_label;
453 GtkWidget *content_area, *action_area;
454 gboolean can_anonymous;
456 const gchar *secondary;
458 operation = GTK_MOUNT_OPERATION (mount_op);
459 priv = operation->priv;
461 priv->ask_flags = flags;
463 widget = gtk_dialog_new ();
464 dialog = GTK_DIALOG (widget);
465 window = GTK_WINDOW (widget);
467 priv->dialog = dialog;
469 content_area = gtk_dialog_get_content_area (dialog);
470 action_area = gtk_dialog_get_action_area (dialog);
472 /* Set the dialog up with HIG properties */
473 gtk_container_set_border_width (GTK_CONTAINER (dialog), 5);
474 gtk_box_set_spacing (GTK_BOX (content_area), 2); /* 2 * 5 + 2 = 12 */
475 gtk_container_set_border_width (GTK_CONTAINER (action_area), 5);
476 gtk_box_set_spacing (GTK_BOX (action_area), 6);
478 gtk_window_set_resizable (window, FALSE);
479 gtk_window_set_title (window, "");
480 gtk_window_set_icon_name (window, GTK_STOCK_DIALOG_AUTHENTICATION);
482 gtk_dialog_add_buttons (dialog,
483 GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL,
484 _("Co_nnect"), GTK_RESPONSE_OK,
486 gtk_dialog_set_default_response (dialog, GTK_RESPONSE_OK);
488 gtk_dialog_set_alternative_button_order (dialog,
494 hbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 12);
495 gtk_container_set_border_width (GTK_CONTAINER (hbox), 5);
496 gtk_box_pack_start (GTK_BOX (content_area), hbox, TRUE, TRUE, 0);
498 icon = gtk_image_new_from_stock (GTK_STOCK_DIALOG_AUTHENTICATION,
499 GTK_ICON_SIZE_DIALOG);
501 gtk_widget_set_halign (icon, GTK_ALIGN_CENTER);
502 gtk_widget_set_valign (icon, GTK_ALIGN_START);
503 gtk_box_pack_start (GTK_BOX (hbox), icon, FALSE, FALSE, 0);
505 main_vbox = gtk_box_new (GTK_ORIENTATION_VERTICAL, 18);
506 gtk_box_pack_start (GTK_BOX (hbox), main_vbox, TRUE, TRUE, 0);
508 secondary = strstr (message, "\n");
509 if (secondary != NULL)
514 primary = g_strndup (message, secondary - message + 1);
515 s = g_strdup_printf ("<big><b>%s</b></big>%s", primary, secondary);
517 message_label = gtk_label_new (NULL);
518 gtk_label_set_markup (GTK_LABEL (message_label), s);
519 gtk_widget_set_halign (message_label, GTK_ALIGN_START);
520 gtk_widget_set_valign (message_label, GTK_ALIGN_CENTER);
521 gtk_label_set_line_wrap (GTK_LABEL (message_label), TRUE);
522 gtk_box_pack_start (GTK_BOX (main_vbox), GTK_WIDGET (message_label),
530 message_label = gtk_label_new (message);
531 gtk_widget_set_halign (message_label, GTK_ALIGN_START);
532 gtk_widget_set_valign (message_label, GTK_ALIGN_CENTER);
533 gtk_label_set_line_wrap (GTK_LABEL (message_label), TRUE);
534 gtk_box_pack_start (GTK_BOX (main_vbox), GTK_WIDGET (message_label),
538 vbox = gtk_box_new (GTK_ORIENTATION_VERTICAL, 6);
539 gtk_box_pack_start (GTK_BOX (main_vbox), vbox, FALSE, FALSE, 0);
541 can_anonymous = flags & G_ASK_PASSWORD_ANONYMOUS_SUPPORTED;
543 priv->anonymous_toggle = NULL;
550 anon_box = gtk_box_new (GTK_ORIENTATION_VERTICAL, 6);
551 gtk_box_pack_start (GTK_BOX (vbox), anon_box,
554 choice = gtk_radio_button_new_with_mnemonic (NULL, _("Connect _anonymously"));
555 gtk_box_pack_start (GTK_BOX (anon_box),
558 g_signal_connect (choice, "toggled",
559 G_CALLBACK (pw_dialog_anonymous_toggled), operation);
560 priv->anonymous_toggle = choice;
562 group = gtk_radio_button_get_group (GTK_RADIO_BUTTON (choice));
563 choice = gtk_radio_button_new_with_mnemonic (group, _("Connect as u_ser:"));
564 gtk_box_pack_start (GTK_BOX (anon_box),
567 g_signal_connect (choice, "toggled",
568 G_CALLBACK (pw_dialog_anonymous_toggled), operation);
573 if (flags & G_ASK_PASSWORD_NEED_PASSWORD)
576 if (flags & G_ASK_PASSWORD_NEED_USERNAME)
579 if (flags &G_ASK_PASSWORD_NEED_DOMAIN)
582 /* The table that holds the entries */
583 table = gtk_grid_new ();
584 gtk_grid_set_row_spacing (GTK_GRID (table), 6);
585 gtk_grid_set_column_spacing (GTK_GRID (table), 6);
588 gtk_widget_set_margin_left (table, 12);
590 gtk_box_pack_start (GTK_BOX (vbox), table, FALSE, FALSE, 0);
591 priv->entry_container = table;
595 priv->username_entry = NULL;
596 if (flags & G_ASK_PASSWORD_NEED_USERNAME)
597 priv->username_entry = table_add_entry (table, rows++, _("_Username:"),
598 default_user, operation);
600 priv->domain_entry = NULL;
601 if (flags & G_ASK_PASSWORD_NEED_DOMAIN)
602 priv->domain_entry = table_add_entry (table, rows++, _("_Domain:"),
603 default_domain, operation);
605 priv->password_entry = NULL;
606 if (flags & G_ASK_PASSWORD_NEED_PASSWORD)
608 priv->password_entry = table_add_entry (table, rows++, _("_Password:"),
610 gtk_entry_set_visibility (GTK_ENTRY (priv->password_entry), FALSE);
613 if (flags & G_ASK_PASSWORD_SAVING_SUPPORTED)
616 GtkWidget *remember_box;
618 GPasswordSave password_save;
620 remember_box = gtk_box_new (GTK_ORIENTATION_VERTICAL, 6);
621 gtk_box_pack_start (GTK_BOX (vbox), remember_box,
624 password_save = g_mount_operation_get_password_save (mount_op);
626 choice = gtk_radio_button_new_with_mnemonic (NULL, _("Forget password _immediately"));
627 gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (choice),
628 password_save == G_PASSWORD_SAVE_NEVER);
629 g_object_set_data (G_OBJECT (choice), "password-save",
630 GINT_TO_POINTER (G_PASSWORD_SAVE_NEVER));
631 g_signal_connect (choice, "toggled",
632 G_CALLBACK (remember_button_toggled), operation);
633 gtk_box_pack_start (GTK_BOX (remember_box), choice, FALSE, FALSE, 0);
635 group = gtk_radio_button_get_group (GTK_RADIO_BUTTON (choice));
636 choice = gtk_radio_button_new_with_mnemonic (group, _("Remember password until you _logout"));
637 gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (choice),
638 password_save == G_PASSWORD_SAVE_FOR_SESSION);
639 g_object_set_data (G_OBJECT (choice), "password-save",
640 GINT_TO_POINTER (G_PASSWORD_SAVE_FOR_SESSION));
641 g_signal_connect (choice, "toggled",
642 G_CALLBACK (remember_button_toggled), operation);
643 gtk_box_pack_start (GTK_BOX (remember_box), choice, FALSE, FALSE, 0);
645 group = gtk_radio_button_get_group (GTK_RADIO_BUTTON (choice));
646 choice = gtk_radio_button_new_with_mnemonic (group, _("Remember _forever"));
647 gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (choice),
648 password_save == G_PASSWORD_SAVE_PERMANENTLY);
649 g_object_set_data (G_OBJECT (choice), "password-save",
650 GINT_TO_POINTER (G_PASSWORD_SAVE_PERMANENTLY));
651 g_signal_connect (choice, "toggled",
652 G_CALLBACK (remember_button_toggled), operation);
653 gtk_box_pack_start (GTK_BOX (remember_box), choice, FALSE, FALSE, 0);
656 g_signal_connect (G_OBJECT (dialog), "response",
657 G_CALLBACK (pw_dialog_got_response), operation);
661 /* The anonymous option will be active by default,
662 * ensure the toggled signal is emitted for it.
664 gtk_toggle_button_toggled (GTK_TOGGLE_BUTTON (priv->anonymous_toggle));
666 else if (! pw_dialog_input_is_valid (operation))
667 gtk_dialog_set_response_sensitive (dialog, GTK_RESPONSE_OK, FALSE);
669 g_object_notify (G_OBJECT (operation), "is-showing");
671 if (priv->parent_window)
673 gtk_window_set_transient_for (window, priv->parent_window);
674 gtk_window_set_modal (window, TRUE);
676 else if (priv->screen)
677 gtk_window_set_screen (GTK_WINDOW (dialog), priv->screen);
679 gtk_widget_show_all (GTK_WIDGET (dialog));
681 g_object_ref (operation);
685 question_dialog_button_clicked (GtkDialog *dialog,
689 GtkMountOperationPrivate *priv;
690 GtkMountOperation *operation;
692 operation = GTK_MOUNT_OPERATION (op);
693 priv = operation->priv;
695 if (button_number >= 0)
697 g_mount_operation_set_choice (op, button_number);
698 g_mount_operation_reply (op, G_MOUNT_OPERATION_HANDLED);
701 g_mount_operation_reply (op, G_MOUNT_OPERATION_ABORTED);
704 g_object_notify (G_OBJECT (operation), "is-showing");
705 gtk_widget_destroy (GTK_WIDGET (dialog));
710 gtk_mount_operation_ask_question (GMountOperation *op,
712 const char *choices[])
714 GtkMountOperationPrivate *priv;
716 const char *secondary = NULL;
720 g_return_if_fail (GTK_IS_MOUNT_OPERATION (op));
721 g_return_if_fail (message != NULL);
722 g_return_if_fail (choices != NULL);
724 priv = GTK_MOUNT_OPERATION (op)->priv;
726 primary = strstr (message, "\n");
729 secondary = primary + 1;
730 primary = g_strndup (message, primary - message);
733 dialog = gtk_message_dialog_new (priv->parent_window, 0,
734 GTK_MESSAGE_QUESTION,
735 GTK_BUTTONS_NONE, "%s",
736 primary != NULL ? primary : message);
740 gtk_message_dialog_format_secondary_text (GTK_MESSAGE_DIALOG (dialog),
743 /* First count the items in the list then
744 * add the buttons in reverse order */
746 while (choices[len] != NULL)
749 for (count = len - 1; count >= 0; count--)
750 gtk_dialog_add_button (GTK_DIALOG (dialog), choices[count], count);
752 g_signal_connect (G_OBJECT (dialog), "response",
753 G_CALLBACK (question_dialog_button_clicked), op);
755 priv->dialog = GTK_DIALOG (dialog);
756 g_object_notify (G_OBJECT (op), "is-showing");
758 if (priv->parent_window == NULL && priv->screen)
759 gtk_window_set_screen (GTK_WINDOW (dialog), priv->screen);
761 gtk_widget_show (dialog);
766 show_processes_button_clicked (GtkDialog *dialog,
770 GtkMountOperationPrivate *priv;
771 GtkMountOperation *operation;
773 operation = GTK_MOUNT_OPERATION (op);
774 priv = operation->priv;
776 if (button_number >= 0)
778 g_mount_operation_set_choice (op, button_number);
779 g_mount_operation_reply (op, G_MOUNT_OPERATION_HANDLED);
782 g_mount_operation_reply (op, G_MOUNT_OPERATION_ABORTED);
785 g_object_notify (G_OBJECT (operation), "is-showing");
786 gtk_widget_destroy (GTK_WIDGET (dialog));
791 pid_equal (gconstpointer a,
799 return GPOINTER_TO_INT(pb) - GPOINTER_TO_INT(pa);
803 diff_sorted_arrays (GArray *array1,
805 GCompareFunc compare,
806 GArray *added_indices,
807 GArray *removed_indices)
815 elem_size = g_array_get_element_size (array1);
816 g_assert (elem_size == g_array_get_element_size (array2));
818 while (n1 < array1->len && n2 < array2->len)
820 order = (*compare) (((const char*) array1->data) + n1 * elem_size,
821 ((const char*) array2->data) + n2 * elem_size);
824 g_array_append_val (removed_indices, n1);
829 g_array_append_val (added_indices, n2);
839 while (n1 < array1->len)
841 g_array_append_val (removed_indices, n1);
844 while (n2 < array2->len)
846 g_array_append_val (added_indices, n2);
853 add_pid_to_process_list_store (GtkMountOperation *mount_operation,
854 GtkMountOperationLookupContext *lookup_context,
855 GtkListStore *list_store,
867 _gtk_mount_operation_lookup_info (lookup_context,
875 name = g_strdup_printf (_("Unknown Application (PID %d)"), pid);
877 if (command_line == NULL)
878 command_line = g_strdup ("");
883 theme = gtk_icon_theme_get_for_screen (gtk_widget_get_screen (GTK_WIDGET (mount_operation->priv->dialog)));
884 pixbuf = gtk_icon_theme_load_icon (theme,
885 "application-x-executable",
891 markup = g_strdup_printf ("<b>%s</b>\n"
896 gtk_list_store_append (list_store, &iter);
897 gtk_list_store_set (list_store, &iter,
904 g_object_unref (pixbuf);
907 g_free (command_line);
911 remove_pid_from_process_list_store (GtkMountOperation *mount_operation,
912 GtkListStore *list_store,
918 if (gtk_tree_model_get_iter_first (GTK_TREE_MODEL (list_store), &iter))
922 gtk_tree_model_get (GTK_TREE_MODEL (list_store),
927 if (pid_of_item == pid)
929 gtk_list_store_remove (list_store, &iter);
933 while (gtk_tree_model_iter_next (GTK_TREE_MODEL (list_store), &iter));
939 update_process_list_store (GtkMountOperation *mount_operation,
940 GtkListStore *list_store,
944 GtkMountOperationLookupContext *lookup_context;
945 GArray *current_pids;
946 GArray *pid_indices_to_add;
947 GArray *pid_indices_to_remove;
951 /* Just removing all items and adding new ones will screw up the
952 * focus handling in the treeview - so compute the delta, and add/remove
953 * items as appropriate
955 current_pids = g_array_new (FALSE, FALSE, sizeof (GPid));
956 pid_indices_to_add = g_array_new (FALSE, FALSE, sizeof (gint));
957 pid_indices_to_remove = g_array_new (FALSE, FALSE, sizeof (gint));
959 if (gtk_tree_model_get_iter_first (GTK_TREE_MODEL (list_store), &iter))
963 gtk_tree_model_get (GTK_TREE_MODEL (list_store),
968 g_array_append_val (current_pids, pid);
970 while (gtk_tree_model_iter_next (GTK_TREE_MODEL (list_store), &iter));
973 g_array_sort (current_pids, pid_equal);
974 g_array_sort (processes, pid_equal);
976 diff_sorted_arrays (current_pids, processes, pid_equal, pid_indices_to_add, pid_indices_to_remove);
978 for (n = 0; n < pid_indices_to_remove->len; n++)
980 pid = g_array_index (current_pids, GPid, n);
981 remove_pid_from_process_list_store (mount_operation, list_store, pid);
984 if (pid_indices_to_add->len > 0)
986 lookup_context = _gtk_mount_operation_lookup_context_get (gtk_widget_get_display (mount_operation->priv->process_tree_view));
987 for (n = 0; n < pid_indices_to_add->len; n++)
989 pid = g_array_index (processes, GPid, n);
990 add_pid_to_process_list_store (mount_operation, lookup_context, list_store, pid);
992 _gtk_mount_operation_lookup_context_free (lookup_context);
995 /* select the first item, if we went from a zero to a non-zero amount of processes */
996 if (current_pids->len == 0 && pid_indices_to_add->len > 0)
998 if (gtk_tree_model_get_iter_first (GTK_TREE_MODEL (list_store), &iter))
1000 GtkTreeSelection *tree_selection;
1001 tree_selection = gtk_tree_view_get_selection (GTK_TREE_VIEW (mount_operation->priv->process_tree_view));
1002 gtk_tree_selection_select_iter (tree_selection, &iter);
1006 g_array_unref (current_pids);
1007 g_array_unref (pid_indices_to_add);
1008 g_array_unref (pid_indices_to_remove);
1012 on_end_process_activated (GtkMenuItem *item,
1015 GtkMountOperation *op = GTK_MOUNT_OPERATION (user_data);
1016 GtkTreeSelection *selection;
1021 selection = gtk_tree_view_get_selection (GTK_TREE_VIEW (op->priv->process_tree_view));
1023 if (!gtk_tree_selection_get_selected (selection,
1028 gtk_tree_model_get (GTK_TREE_MODEL (op->priv->process_list_store),
1033 /* TODO: We might want to either
1035 * - Be smart about things and send SIGKILL rather than SIGTERM if
1036 * this is the second time the user requests killing a process
1038 * - Or, easier (but worse user experience), offer both "End Process"
1039 * and "Terminate Process" options
1041 * But that's not how things work right now....
1044 if (!_gtk_mount_operation_kill_process (pid_to_kill, &error))
1049 /* Use GTK_DIALOG_DESTROY_WITH_PARENT here since the parent dialog can be
1050 * indeed be destroyed via the GMountOperation::abort signal... for example,
1051 * this is triggered if the user yanks the device while we are showing
1054 dialog = gtk_message_dialog_new (GTK_WINDOW (op->priv->dialog),
1055 GTK_DIALOG_MODAL | GTK_DIALOG_DESTROY_WITH_PARENT,
1058 _("Unable to end process"));
1059 gtk_message_dialog_format_secondary_text (GTK_MESSAGE_DIALOG (dialog),
1063 gtk_widget_show_all (dialog);
1064 response = gtk_dialog_run (GTK_DIALOG (dialog));
1066 /* GTK_RESPONSE_NONE means the dialog were programmatically destroy, e.g. that
1067 * GTK_DIALOG_DESTROY_WITH_PARENT kicked in - so it would trigger a warning to
1068 * destroy the dialog in that case
1070 if (response != GTK_RESPONSE_NONE)
1071 gtk_widget_destroy (dialog);
1073 g_error_free (error);
1081 do_popup_menu_for_process_tree_view (GtkWidget *widget,
1082 GdkEventButton *event,
1083 GtkMountOperation *op)
1089 gboolean popped_up_menu;
1091 popped_up_menu = FALSE;
1093 menu = gtk_menu_new ();
1095 item = gtk_image_menu_item_new_with_mnemonic (_("_End Process"));
1096 gtk_image_menu_item_set_image (GTK_IMAGE_MENU_ITEM (item),
1097 gtk_image_new_from_stock (GTK_STOCK_CLOSE, GTK_ICON_SIZE_MENU));
1098 g_signal_connect (item, "activate",
1099 G_CALLBACK (on_end_process_activated),
1101 gtk_menu_shell_append (GTK_MENU_SHELL (menu), item);
1102 gtk_widget_show_all (menu);
1107 GtkTreeSelection *selection;
1109 if (gtk_tree_view_get_path_at_pos (GTK_TREE_VIEW (op->priv->process_tree_view),
1117 selection = gtk_tree_view_get_selection (GTK_TREE_VIEW (op->priv->process_tree_view));
1118 gtk_tree_selection_select_path (selection, path);
1119 gtk_tree_path_free (path);
1123 /* don't popup a menu if the user right-clicked in an area with no rows */
1127 button = event->button;
1128 event_time = event->time;
1133 event_time = gtk_get_current_event_time ();
1136 gtk_menu_popup (GTK_MENU (menu),
1144 popped_up_menu = TRUE;
1147 return popped_up_menu;
1151 on_popup_menu_for_process_tree_view (GtkWidget *widget,
1154 GtkMountOperation *op = GTK_MOUNT_OPERATION (user_data);
1155 return do_popup_menu_for_process_tree_view (widget, NULL, op);
1159 on_button_press_event_for_process_tree_view (GtkWidget *widget,
1160 GdkEventButton *event,
1163 GtkMountOperation *op = GTK_MOUNT_OPERATION (user_data);
1168 if (gdk_event_triggers_context_menu ((GdkEvent *) event))
1170 ret = do_popup_menu_for_process_tree_view (widget, event, op);
1177 create_show_processes_dialog (GMountOperation *op,
1178 const char *message,
1179 const char *choices[])
1181 GtkMountOperationPrivate *priv;
1183 const char *secondary = NULL;
1187 GtkWidget *tree_view;
1188 GtkWidget *scrolled_window;
1190 GtkWidget *content_area;
1191 GtkTreeViewColumn *column;
1192 GtkCellRenderer *renderer;
1193 GtkListStore *list_store;
1196 priv = GTK_MOUNT_OPERATION (op)->priv;
1198 primary = strstr (message, "\n");
1201 secondary = primary + 1;
1202 primary = g_strndup (message, primary - message);
1205 dialog = gtk_dialog_new ();
1207 if (priv->parent_window != NULL)
1208 gtk_window_set_transient_for (GTK_WINDOW (dialog), priv->parent_window);
1209 gtk_window_set_title (GTK_WINDOW (dialog), "");
1211 content_area = gtk_dialog_get_content_area (GTK_DIALOG (dialog));
1212 vbox = gtk_box_new (GTK_ORIENTATION_VERTICAL, 12);
1213 gtk_container_set_border_width (GTK_CONTAINER (vbox), 12);
1214 gtk_box_pack_start (GTK_BOX (content_area), vbox, TRUE, TRUE, 0);
1216 if (secondary != NULL)
1218 s = g_strdup_printf ("<big><b>%s</b></big>\n\n%s", primary, secondary);
1222 s = g_strdup_printf ("%s", primary);
1225 label = gtk_label_new (NULL);
1226 gtk_label_set_markup (GTK_LABEL (label), s);
1228 gtk_box_pack_start (GTK_BOX (vbox), label, TRUE, TRUE, 0);
1230 /* First count the items in the list then
1231 * add the buttons in reverse order */
1233 while (choices[len] != NULL)
1236 for (count = len - 1; count >= 0; count--)
1237 gtk_dialog_add_button (GTK_DIALOG (dialog), choices[count], count);
1239 g_signal_connect (G_OBJECT (dialog), "response",
1240 G_CALLBACK (show_processes_button_clicked), op);
1242 priv->dialog = GTK_DIALOG (dialog);
1243 g_object_notify (G_OBJECT (op), "is-showing");
1245 if (priv->parent_window == NULL && priv->screen)
1246 gtk_window_set_screen (GTK_WINDOW (dialog), priv->screen);
1248 tree_view = gtk_tree_view_new ();
1249 /* TODO: should use EM's when gtk+ RI patches land */
1250 gtk_widget_set_size_request (tree_view,
1254 column = gtk_tree_view_column_new ();
1255 renderer = gtk_cell_renderer_pixbuf_new ();
1256 gtk_tree_view_column_pack_start (column, renderer, FALSE);
1257 gtk_tree_view_column_set_attributes (column, renderer,
1260 renderer = gtk_cell_renderer_text_new ();
1261 g_object_set (renderer,
1262 "ellipsize", PANGO_ELLIPSIZE_MIDDLE,
1263 "ellipsize-set", TRUE,
1265 gtk_tree_view_column_pack_start (column, renderer, TRUE);
1266 gtk_tree_view_column_set_attributes (column, renderer,
1269 gtk_tree_view_append_column (GTK_TREE_VIEW (tree_view), column);
1270 gtk_tree_view_set_headers_visible (GTK_TREE_VIEW (tree_view), FALSE);
1273 scrolled_window = gtk_scrolled_window_new (NULL, NULL);
1274 gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (scrolled_window),
1276 GTK_POLICY_AUTOMATIC);
1277 gtk_scrolled_window_set_shadow_type (GTK_SCROLLED_WINDOW (scrolled_window), GTK_SHADOW_IN);
1279 gtk_container_add (GTK_CONTAINER (scrolled_window), tree_view);
1280 gtk_box_pack_start (GTK_BOX (vbox), scrolled_window, TRUE, TRUE, 0);
1282 g_signal_connect (tree_view, "popup-menu",
1283 G_CALLBACK (on_popup_menu_for_process_tree_view),
1285 g_signal_connect (tree_view, "button-press-event",
1286 G_CALLBACK (on_button_press_event_for_process_tree_view),
1289 list_store = gtk_list_store_new (3,
1294 gtk_tree_view_set_model (GTK_TREE_VIEW (tree_view), GTK_TREE_MODEL (list_store));
1296 priv->process_list_store = list_store;
1297 priv->process_tree_view = tree_view;
1298 /* set pointers to NULL when dialog goes away */
1299 g_object_add_weak_pointer (G_OBJECT (list_store), (gpointer *) &priv->process_list_store);
1300 g_object_add_weak_pointer (G_OBJECT (tree_view), (gpointer *) &priv->process_tree_view);
1302 g_object_unref (list_store);
1309 gtk_mount_operation_show_processes (GMountOperation *op,
1310 const char *message,
1312 const char *choices[])
1314 GtkMountOperationPrivate *priv;
1315 GtkWidget *dialog = NULL;
1317 g_return_if_fail (GTK_IS_MOUNT_OPERATION (op));
1318 g_return_if_fail (message != NULL);
1319 g_return_if_fail (processes != NULL);
1320 g_return_if_fail (choices != NULL);
1322 priv = GTK_MOUNT_OPERATION (op)->priv;
1324 if (priv->process_list_store == NULL)
1326 /* need to create the dialog */
1327 dialog = create_show_processes_dialog (op, message, choices);
1330 /* otherwise, we're showing the dialog, assume messages+choices hasn't changed */
1332 update_process_list_store (GTK_MOUNT_OPERATION (op),
1333 priv->process_list_store,
1338 gtk_widget_show_all (dialog);
1343 gtk_mount_operation_aborted (GMountOperation *op)
1345 GtkMountOperationPrivate *priv;
1347 priv = GTK_MOUNT_OPERATION (op)->priv;
1349 if (priv->dialog != NULL)
1351 gtk_widget_destroy (GTK_WIDGET (priv->dialog));
1352 priv->dialog = NULL;
1353 g_object_notify (G_OBJECT (op), "is-showing");
1354 g_object_unref (op);
1359 * gtk_mount_operation_new:
1360 * @parent: (allow-none): transient parent of the window, or %NULL
1362 * Creates a new #GtkMountOperation
1364 * Returns: a new #GtkMountOperation
1369 gtk_mount_operation_new (GtkWindow *parent)
1371 GMountOperation *mount_operation;
1373 mount_operation = g_object_new (GTK_TYPE_MOUNT_OPERATION,
1374 "parent", parent, NULL);
1376 return mount_operation;
1380 * gtk_mount_operation_is_showing:
1381 * @op: a #GtkMountOperation
1383 * Returns whether the #GtkMountOperation is currently displaying
1386 * Returns: %TRUE if @op is currently displaying a window
1391 gtk_mount_operation_is_showing (GtkMountOperation *op)
1393 g_return_val_if_fail (GTK_IS_MOUNT_OPERATION (op), FALSE);
1395 return op->priv->dialog != NULL;
1399 * gtk_mount_operation_set_parent:
1400 * @op: a #GtkMountOperation
1401 * @parent: (allow-none): transient parent of the window, or %NULL
1403 * Sets the transient parent for windows shown by the
1404 * #GtkMountOperation.
1409 gtk_mount_operation_set_parent (GtkMountOperation *op,
1412 GtkMountOperationPrivate *priv;
1414 g_return_if_fail (GTK_IS_MOUNT_OPERATION (op));
1415 g_return_if_fail (parent == NULL || GTK_IS_WINDOW (parent));
1419 if (priv->parent_window == parent)
1422 if (priv->parent_window)
1424 g_signal_handlers_disconnect_by_func (priv->parent_window,
1425 gtk_widget_destroyed,
1426 &priv->parent_window);
1427 priv->parent_window = NULL;
1432 priv->parent_window = g_object_ref (parent);
1434 g_signal_connect (parent, "destroy",
1435 G_CALLBACK (gtk_widget_destroyed),
1436 &priv->parent_window);
1439 gtk_window_set_transient_for (GTK_WINDOW (priv->dialog), parent);
1442 g_object_notify (G_OBJECT (op), "parent");
1446 * gtk_mount_operation_get_parent:
1447 * @op: a #GtkMountOperation
1449 * Gets the transient parent used by the #GtkMountOperation
1451 * Returns: (transfer none): the transient parent for windows shown by @op
1456 gtk_mount_operation_get_parent (GtkMountOperation *op)
1458 g_return_val_if_fail (GTK_IS_MOUNT_OPERATION (op), NULL);
1460 return op->priv->parent_window;
1464 * gtk_mount_operation_set_screen:
1465 * @op: a #GtkMountOperation
1466 * @screen: a #GdkScreen
1468 * Sets the screen to show windows of the #GtkMountOperation on.
1473 gtk_mount_operation_set_screen (GtkMountOperation *op,
1476 GtkMountOperationPrivate *priv;
1478 g_return_if_fail (GTK_IS_MOUNT_OPERATION (op));
1479 g_return_if_fail (GDK_IS_SCREEN (screen));
1483 if (priv->screen == screen)
1487 g_object_unref (priv->screen);
1489 priv->screen = g_object_ref (screen);
1492 gtk_window_set_screen (GTK_WINDOW (priv->dialog), screen);
1494 g_object_notify (G_OBJECT (op), "screen");
1498 * gtk_mount_operation_get_screen:
1499 * @op: a #GtkMountOperation
1501 * Gets the screen on which windows of the #GtkMountOperation
1504 * Returns: (transfer none): the screen on which windows of @op are shown
1509 gtk_mount_operation_get_screen (GtkMountOperation *op)
1511 GtkMountOperationPrivate *priv;
1513 g_return_val_if_fail (GTK_IS_MOUNT_OPERATION (op), NULL);
1518 return gtk_window_get_screen (GTK_WINDOW (priv->dialog));
1519 else if (priv->parent_window)
1520 return gtk_window_get_screen (GTK_WINDOW (priv->parent_window));
1521 else if (priv->screen)
1522 return priv->screen;
1524 return gdk_screen_get_default ();