/* -*- Mode: C; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */

/* GTK - The GIMP Toolkit

 * Copyright (C) Christian Kellner <gicmo@gnome.org>

 *

 * This library is free software; you can redistribute it and/or

 * modify it under the terms of the GNU Lesser General Public

 * License as published by the Free Software Foundation; either

 * version 2 of the License, or (at your option) any later version.

 *

 * This library is distributed in the hope that it will be useful,

 * but WITHOUT ANY WARRANTY; without even the implied warranty of

 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU

 * Lesser General Public License for more details.

 *

 * You should have received a copy of the GNU Lesser General Public

 * License along with this library; if not, write to the

 * Free Software Foundation, Inc., 59 Temple Place - Suite 330,

 * Boston, MA 02111-1307, USA.

 */

/*

 * Modified by the GTK+ Team and others 1997-2000.  See the AUTHORS

 * file for a list of people on the GTK+ Team.  See the ChangeLog

 * files for a list of changes.  These files are distributed with

 * GTK+ at ftp://ftp.gtk.org/pub/gtk/.

 */

#include "config.h"

#include <string.h>

#include "gtkmountoperationprivate.h"

#include "gtkalignment.h"

#include "gtkbox.h"

#include "gtkentry.h"

#include "gtkhbox.h"

#include "gtkintl.h"

#include "gtklabel.h"

#include "gtkvbox.h"

#include "gtkmessagedialog.h"

#include "gtkmisc.h"

#include "gtkmountoperation.h"

#include "gtkprivate.h"

#include "gtkradiobutton.h"

#include "gtkstock.h"

#include "gtktable.h"

#include "gtkwindow.h"

#include "gtktreeview.h"

#include "gtktreeselection.h"

#include "gtkcellrenderertext.h"

#include "gtkcellrendererpixbuf.h"

#include "gtkscrolledwindow.h"

#include "gtkicontheme.h"

#include "gtkimagemenuitem.h"

#include "gtkmain.h"

#include "gtkalias.h"

/**

 * SECTION:filesystem

 * @short_description: Functions for working with GIO

 * @Title: Filesystem utilities

 *

 * The functions and objects described here make working with GTK+ and

 * GIO more convenient.

 *

 * #GtkMountOperation is needed when mounting volumes:

 * It is an implementation of #GMountOperation that can be used with

 * GIO functions for mounting volumes such as

 * g_file_mount_enclosing_volume(), g_file_mount_mountable(),

 * g_volume_mount(), g_mount_unmount_with_operation() and others.

 *

 * When necessary, #GtkMountOperation shows dialogs to ask for

 * passwords, questions or show processes blocking unmount.

 *

 * gtk_show_uri() is a convenient way to launch applications for URIs.

 *

 * Another object that is worth mentioning in this context is

 * #GdkAppLaunchContext, which provides visual feedback when lauching

 * applications.

 */

static void   gtk_mount_operation_finalize     (GObject          *object);

static void   gtk_mount_operation_set_property (GObject          *object,

                                                guint             prop_id,

                                                const GValue     *value,

                                                GParamSpec       *pspec);

static void   gtk_mount_operation_get_property (GObject          *object,

                                                guint             prop_id,

                                                GValue           *value,

                                                GParamSpec       *pspec);

static void   gtk_mount_operation_ask_password (GMountOperation *op,

                                                const char      *message,

                                                const char      *default_user,

                                                const char      *default_domain,

                                                GAskPasswordFlags flags);

static void   gtk_mount_operation_ask_question (GMountOperation *op,

                                                const char      *message,

                                                const char      *choices[]);

static void   gtk_mount_operation_show_processes (GMountOperation *op,

                                                  const char      *message,

                                                  GArray          *processes,

                                                  const char      *choices[]);

static void   gtk_mount_operation_aborted      (GMountOperation *op);

G_DEFINE_TYPE (GtkMountOperation, gtk_mount_operation, G_TYPE_MOUNT_OPERATION);

enum {

  PROP_0,

  PROP_PARENT,

  PROP_IS_SHOWING,

  PROP_SCREEN

};

struct _GtkMountOperationPrivate {

  GtkWindow *parent_window;

  GtkDialog *dialog;

  GdkScreen *screen;

  /* for the ask-password dialog */

  GtkWidget *entry_container;

  GtkWidget *username_entry;

  GtkWidget *domain_entry;

  GtkWidget *password_entry;

  GtkWidget *anonymous_toggle;

  GAskPasswordFlags ask_flags;

  GPasswordSave     password_save;

  gboolean          anonymous;

  /* for the show-processes dialog */

  GtkWidget *process_tree_view;

  GtkListStore *process_list_store;

};

static void

gtk_mount_operation_class_init (GtkMountOperationClass *klass)

{

  GObjectClass         *object_class = G_OBJECT_CLASS (klass);

  GMountOperationClass *mount_op_class = G_MOUNT_OPERATION_CLASS (klass);

  g_type_class_add_private (klass, sizeof (GtkMountOperationPrivate));

  object_class->finalize     = gtk_mount_operation_finalize;

  object_class->get_property = gtk_mount_operation_get_property;

  object_class->set_property = gtk_mount_operation_set_property;

  mount_op_class->ask_password = gtk_mount_operation_ask_password;

  mount_op_class->ask_question = gtk_mount_operation_ask_question;

  mount_op_class->show_processes = gtk_mount_operation_show_processes;

  mount_op_class->aborted = gtk_mount_operation_aborted;

  g_object_class_install_property (object_class,

                                   PROP_PARENT,

                                   g_param_spec_object ("parent",

                                                        P_("Parent"),

                                                        P_("The parent window"),

                                                        GTK_TYPE_WINDOW,

                                                        GTK_PARAM_READWRITE));

  g_object_class_install_property (object_class,

                                   PROP_IS_SHOWING,

                                   g_param_spec_boolean ("is-showing",

                                                         P_("Is Showing"),

                                                         P_("Are we showing a dialog"),

                                                         FALSE,

                                                         GTK_PARAM_READABLE));

  g_object_class_install_property (object_class,

                                   PROP_SCREEN,

                                   g_param_spec_object ("screen",

                                                        P_("Screen"),

                                                        P_("The screen where this window will be displayed."),

                                                        GDK_TYPE_SCREEN,

                                                        GTK_PARAM_READWRITE));

}

static void

gtk_mount_operation_init (GtkMountOperation *operation)

{

  operation->priv = G_TYPE_INSTANCE_GET_PRIVATE (operation,

                                                 GTK_TYPE_MOUNT_OPERATION,

                                                 GtkMountOperationPrivate);

}

static void

gtk_mount_operation_finalize (GObject *object)

{

  GtkMountOperation *operation = GTK_MOUNT_OPERATION (object);

  GtkMountOperationPrivate *priv = operation->priv;

  if (priv->parent_window)

    {

      g_signal_handlers_disconnect_by_func (priv->parent_window,

                                            gtk_widget_destroyed,

                                            &priv->parent_window);

      g_object_unref (priv->parent_window);

    }

  if (priv->screen)

    g_object_unref (priv->screen);

  G_OBJECT_CLASS (gtk_mount_operation_parent_class)->finalize (object);

}

static void

gtk_mount_operation_set_property (GObject      *object,

                                  guint         prop_id,

                                  const GValue *value,

                                  GParamSpec   *pspec)

{

  GtkMountOperation *operation = GTK_MOUNT_OPERATION (object);

  switch (prop_id)

    {

    case PROP_PARENT:

      gtk_mount_operation_set_parent (operation, g_value_get_object (value));

      break;

    case PROP_SCREEN:

      gtk_mount_operation_set_screen (operation, g_value_get_object (value));

      break;

    case PROP_IS_SHOWING:

    default:

      G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);

      break;

    }

}

static void

gtk_mount_operation_get_property (GObject    *object,

                                  guint       prop_id,

                                  GValue     *value,

                                  GParamSpec *pspec)

{

  GtkMountOperation *operation = GTK_MOUNT_OPERATION (object);

  GtkMountOperationPrivate *priv = operation->priv;

  switch (prop_id)

    {

    case PROP_PARENT:

      g_value_set_object (value, priv->parent_window);

      break;

    case PROP_IS_SHOWING:

      g_value_set_boolean (value, priv->dialog != NULL);

      break;

    case PROP_SCREEN:

      g_value_set_object (value, priv->screen);

      break;

    default:

      G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);

      break;

    }

}

static void

remember_button_toggled (GtkToggleButton   *button,

                         GtkMountOperation *operation)

{

  GtkMountOperationPrivate *priv = operation->priv;

  if (gtk_toggle_button_get_active (button))

    {

      gpointer data;

      data = g_object_get_data (G_OBJECT (button), "password-save");

      priv->password_save = GPOINTER_TO_INT (data);

    }

}

static void

pw_dialog_got_response (GtkDialog         *dialog,

                        gint               response_id,

                        GtkMountOperation *mount_op)

{

  GtkMountOperationPrivate *priv = mount_op->priv;

  GMountOperation *op = G_MOUNT_OPERATION (mount_op);

  if (response_id == GTK_RESPONSE_OK)

    {

      const char *text;

      if (priv->ask_flags & G_ASK_PASSWORD_ANONYMOUS_SUPPORTED)

        g_mount_operation_set_anonymous (op, priv->anonymous);

      if (priv->username_entry)

        {

          text = gtk_entry_get_text (GTK_ENTRY (priv->username_entry));

          g_mount_operation_set_username (op, text);

        }

      if (priv->domain_entry)

        {

          text = gtk_entry_get_text (GTK_ENTRY (priv->domain_entry));

          g_mount_operation_set_domain (op, text);

        }

      if (priv->password_entry)

        {

          text = gtk_entry_get_text (GTK_ENTRY (priv->password_entry));

          g_mount_operation_set_password (op, text);

        }

      if (priv->ask_flags & G_ASK_PASSWORD_SAVING_SUPPORTED)

        g_mount_operation_set_password_save (op, priv->password_save);

      g_mount_operation_reply (op, G_MOUNT_OPERATION_HANDLED);

    }

  else

    g_mount_operation_reply (op, G_MOUNT_OPERATION_ABORTED);

  priv->dialog = NULL;

  g_object_notify (G_OBJECT (op), "is-showing");

  gtk_widget_destroy (GTK_WIDGET (dialog));

  g_object_unref (op);

}

static gboolean

entry_has_input (GtkWidget *entry_widget)

{

  const char *text;

  if (entry_widget == NULL)

    return TRUE;

  text = gtk_entry_get_text (GTK_ENTRY (entry_widget));

  return text != NULL && text[0] != '\0';

}

static gboolean

pw_dialog_input_is_valid (GtkMountOperation *operation)

{

  GtkMountOperationPrivate *priv = operation->priv;

  gboolean is_valid = TRUE;

  /* We don't require password to be non-empty here

   * since there are situations where it is not needed,

   * see bug 578365.

   * We may add a way for the backend to specify that it

   * definitively needs a password.

   */

  is_valid = entry_has_input (priv->username_entry) &&

             entry_has_input (priv->domain_entry);

  return is_valid;

}

static void

pw_dialog_verify_input (GtkEditable       *editable,

                        GtkMountOperation *operation)

{

  GtkMountOperationPrivate *priv = operation->priv;

  gboolean is_valid;

  is_valid = pw_dialog_input_is_valid (operation);

  gtk_dialog_set_response_sensitive (GTK_DIALOG (priv->dialog),

                                     GTK_RESPONSE_OK,

                                     is_valid);

}

static void

pw_dialog_anonymous_toggled (GtkWidget         *widget,

                             GtkMountOperation *operation)

{

  GtkMountOperationPrivate *priv = operation->priv;

  gboolean is_valid;

  priv->anonymous = widget == priv->anonymous_toggle;

  if (priv->anonymous)

    is_valid = TRUE;

  else

    is_valid = pw_dialog_input_is_valid (operation);

  gtk_widget_set_sensitive (priv->entry_container, priv->anonymous == FALSE);

  gtk_dialog_set_response_sensitive (GTK_DIALOG (priv->dialog),

                                     GTK_RESPONSE_OK,

                                     is_valid);

}

static void

pw_dialog_cycle_focus (GtkWidget         *widget,

                       GtkMountOperation *operation)

{

  GtkMountOperationPrivate *priv;

  GtkWidget *next_widget = NULL;

  priv = operation->priv;

  if (widget == priv->username_entry)

    {

      if (priv->domain_entry != NULL)

        next_widget = priv->domain_entry;

      else if (priv->password_entry != NULL)

        next_widget = priv->password_entry;

    }

  else if (widget == priv->domain_entry && priv->password_entry)

    next_widget = priv->password_entry;

  if (next_widget)

    gtk_widget_grab_focus (next_widget);

  else if (pw_dialog_input_is_valid (operation))

    gtk_window_activate_default (GTK_WINDOW (priv->dialog));

}

static GtkWidget *

table_add_entry (GtkWidget  *table,

                 int         row,

                 const char *label_text,

                 const char *value,

                 gpointer    user_data)

{

  GtkWidget *entry;

  GtkWidget *label;

  label = gtk_label_new_with_mnemonic (label_text);

  gtk_misc_set_alignment (GTK_MISC (label), 0.0, 0.5);

  entry = gtk_entry_new ();

  if (value)

    gtk_entry_set_text (GTK_ENTRY (entry), value);

  gtk_table_attach (GTK_TABLE (table), label,

                    0, 1, row, row + 1,

                    GTK_FILL, GTK_EXPAND | GTK_FILL, 0, 0);

  gtk_table_attach_defaults (GTK_TABLE (table), entry,

                             1, 2, row, row + 1);

  gtk_label_set_mnemonic_widget (GTK_LABEL (label), entry);

  g_signal_connect (entry, "changed",

                    G_CALLBACK (pw_dialog_verify_input), user_data);

  g_signal_connect (entry, "activate",

                    G_CALLBACK (pw_dialog_cycle_focus), user_data);

  return entry;

}

static void

gtk_mount_operation_ask_password (GMountOperation   *mount_op,

                                  const char        *message,

                                  const char        *default_user,

                                  const char        *default_domain,

                                  GAskPasswordFlags  flags)

{

  GtkMountOperation *operation;

  GtkMountOperationPrivate *priv;

  GtkWidget *widget;

  GtkDialog *dialog;

  GtkWindow *window;

  GtkWidget *entry_container;

  GtkWidget *hbox, *main_vbox, *vbox, *icon;

  GtkWidget *table;

  GtkWidget *message_label;

  gboolean   can_anonymous;

  guint      rows;

  const gchar *secondary;

  operation = GTK_MOUNT_OPERATION (mount_op);

  priv = operation->priv;

  priv->ask_flags = flags;

  widget = gtk_dialog_new ();

  dialog = GTK_DIALOG (widget);

  window = GTK_WINDOW (widget);

  priv->dialog = dialog;

  /* Set the dialog up with HIG properties */

  gtk_dialog_set_has_separator (dialog, FALSE);

  gtk_container_set_border_width (GTK_CONTAINER (dialog), 5);

  gtk_box_set_spacing (GTK_BOX (dialog->vbox), 2); /* 2 * 5 + 2 = 12 */

  gtk_container_set_border_width (GTK_CONTAINER (dialog->action_area), 5);

  gtk_box_set_spacing (GTK_BOX (dialog->action_area), 6);

  gtk_window_set_resizable (window, FALSE);

  gtk_window_set_title (window, "");

  gtk_window_set_icon_name (window, GTK_STOCK_DIALOG_AUTHENTICATION);

  gtk_dialog_add_buttons (dialog,

                          GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL,

                          _("Co_nnect"), GTK_RESPONSE_OK,

                          NULL);

  gtk_dialog_set_default_response (dialog, GTK_RESPONSE_OK);

  gtk_dialog_set_alternative_button_order (dialog,

                                           GTK_RESPONSE_OK,

                                           GTK_RESPONSE_CANCEL,

                                           -1);

  /* Build contents */

  hbox = gtk_hbox_new (FALSE, 12);

  gtk_container_set_border_width (GTK_CONTAINER (hbox), 5);

  gtk_box_pack_start (GTK_BOX (dialog->vbox), hbox, TRUE, TRUE, 0);

  icon = gtk_image_new_from_stock (GTK_STOCK_DIALOG_AUTHENTICATION,

                                   GTK_ICON_SIZE_DIALOG);

  gtk_misc_set_alignment (GTK_MISC (icon), 0.5, 0.0);

  gtk_box_pack_start (GTK_BOX (hbox), icon, FALSE, FALSE, 0);

  main_vbox = gtk_vbox_new (FALSE, 18);

  gtk_box_pack_start (GTK_BOX (hbox), main_vbox, TRUE, TRUE, 0);

  secondary = strstr (message, "\n");

  if (secondary != NULL)

    {

      gchar *s;

      gchar *primary;

      primary = g_strndup (message, secondary - message + 1);

      s = g_strdup_printf ("<big>%s</big>%s", primary, secondary);

      message_label = gtk_label_new (NULL);

      gtk_label_set_markup (GTK_LABEL (message_label), s);

      gtk_misc_set_alignment (GTK_MISC (message_label), 0.0, 0.5);

      gtk_label_set_line_wrap (GTK_LABEL (message_label), TRUE);

      gtk_box_pack_start (GTK_BOX (main_vbox), GTK_WIDGET (message_label),

                          FALSE, TRUE, 0);

      g_free (s);

      g_free (primary);

    }

  else

    {

      message_label = gtk_label_new (message);

      gtk_misc_set_alignment (GTK_MISC (message_label), 0.0, 0.5);

      gtk_label_set_line_wrap (GTK_LABEL (message_label), TRUE);

      gtk_box_pack_start (GTK_BOX (main_vbox), GTK_WIDGET (message_label),

                          FALSE, FALSE, 0);

    }

  vbox = gtk_vbox_new (FALSE, 6);

  gtk_box_pack_start (GTK_BOX (main_vbox), vbox, FALSE, FALSE, 0);

  can_anonymous = flags & G_ASK_PASSWORD_ANONYMOUS_SUPPORTED;

  priv->anonymous_toggle = NULL;

  if (can_anonymous)

    {

      GtkWidget *anon_box;

      GtkWidget *choice;

      GSList    *group;

      anon_box = gtk_vbox_new (FALSE, 6);

      gtk_box_pack_start (GTK_BOX (vbox), anon_box,

                          FALSE, FALSE, 0);

      choice = gtk_radio_button_new_with_mnemonic (NULL, _("Connect _anonymously"));

      gtk_box_pack_start (GTK_BOX (anon_box),

                          choice,

                          FALSE, FALSE, 0);

      g_signal_connect (choice, "toggled",

                        G_CALLBACK (pw_dialog_anonymous_toggled), operation);

      priv->anonymous_toggle = choice;

      group = gtk_radio_button_get_group (GTK_RADIO_BUTTON (choice));

      choice = gtk_radio_button_new_with_mnemonic (group, _("Connect as u_ser:"));

      gtk_box_pack_start (GTK_BOX (anon_box),

                          choice,

                          FALSE, FALSE, 0);

      g_signal_connect (choice, "toggled",

                        G_CALLBACK (pw_dialog_anonymous_toggled), operation);

    }

  rows = 0;

  if (flags & G_ASK_PASSWORD_NEED_PASSWORD)

    rows++;

  if (flags & G_ASK_PASSWORD_NEED_USERNAME)

    rows++;

  if (flags &G_ASK_PASSWORD_NEED_DOMAIN)

    rows++;

  /* The table that holds the entries */

  entry_container = gtk_alignment_new (0.0, 0.0, 1.0, 1.0);

  gtk_alignment_set_padding (GTK_ALIGNMENT (entry_container),

                             0, 0, can_anonymous ? 12 : 0, 0);

  gtk_box_pack_start (GTK_BOX (vbox), entry_container,

                      FALSE, FALSE, 0);

  priv->entry_container = entry_container;

  table = gtk_table_new (rows, 2, FALSE);

  gtk_table_set_col_spacings (GTK_TABLE (table), 12);

  gtk_table_set_row_spacings (GTK_TABLE (table), 6);

  gtk_container_add (GTK_CONTAINER (entry_container), table);

  rows = 0;

  priv->username_entry = NULL;

  if (flags & G_ASK_PASSWORD_NEED_USERNAME)

    priv->username_entry = table_add_entry (table, rows++, _("_Username:"),

                                            default_user, operation);

  priv->domain_entry = NULL;

  if (flags & G_ASK_PASSWORD_NEED_DOMAIN)

    priv->domain_entry = table_add_entry (table, rows++, _("_Domain:"),

                                          default_domain, operation);

  priv->password_entry = NULL;

  if (flags & G_ASK_PASSWORD_NEED_PASSWORD)

    {

      priv->password_entry = table_add_entry (table, rows++, _("_Password:"),

                                              NULL, operation);

      gtk_entry_set_visibility (GTK_ENTRY (priv->password_entry), FALSE);

    }

   if (flags & G_ASK_PASSWORD_SAVING_SUPPORTED)

    {

      GtkWidget    *choice;

      GtkWidget    *remember_box;

      GSList       *group;

      GPasswordSave password_save;

      remember_box = gtk_vbox_new (FALSE, 6);

      gtk_box_pack_start (GTK_BOX (vbox), remember_box,

                          FALSE, FALSE, 0);

      password_save = g_mount_operation_get_password_save (mount_op);

      choice = gtk_radio_button_new_with_mnemonic (NULL, _("Forget password _immediately"));

      gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (choice),

                                    password_save == G_PASSWORD_SAVE_NEVER);

      g_object_set_data (G_OBJECT (choice), "password-save",

                         GINT_TO_POINTER (G_PASSWORD_SAVE_NEVER));

      g_signal_connect (choice, "toggled",

                        G_CALLBACK (remember_button_toggled), operation);

      gtk_box_pack_start (GTK_BOX (remember_box), choice, FALSE, FALSE, 0);

      group = gtk_radio_button_get_group (GTK_RADIO_BUTTON (choice));

      choice = gtk_radio_button_new_with_mnemonic (group, _("Remember password until you _logout"));

      gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (choice),

                                    password_save == G_PASSWORD_SAVE_FOR_SESSION);

      g_object_set_data (G_OBJECT (choice), "password-save",

                         GINT_TO_POINTER (G_PASSWORD_SAVE_FOR_SESSION));

      g_signal_connect (choice, "toggled",

                        G_CALLBACK (remember_button_toggled), operation);

      gtk_box_pack_start (GTK_BOX (remember_box), choice, FALSE, FALSE, 0);

      group = gtk_radio_button_get_group (GTK_RADIO_BUTTON (choice));

      choice = gtk_radio_button_new_with_mnemonic (group, _("Remember _forever"));

      gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (choice),

                                    password_save == G_PASSWORD_SAVE_PERMANENTLY);

      g_object_set_data (G_OBJECT (choice), "password-save",

                         GINT_TO_POINTER (G_PASSWORD_SAVE_PERMANENTLY));

      g_signal_connect (choice, "toggled",

                        G_CALLBACK (remember_button_toggled), operation);

      gtk_box_pack_start (GTK_BOX (remember_box), choice, FALSE, FALSE, 0);

    }

  g_signal_connect (G_OBJECT (dialog), "response",

                    G_CALLBACK (pw_dialog_got_response), operation);

  if (can_anonymous)

    {

      /* The anonymous option will be active by default,

       * ensure the toggled signal is emitted for it.

       */

      gtk_toggle_button_toggled (GTK_TOGGLE_BUTTON (priv->anonymous_toggle));

    }

  else if (! pw_dialog_input_is_valid (operation))

    gtk_dialog_set_response_sensitive (dialog, GTK_RESPONSE_OK, FALSE);

  g_object_notify (G_OBJECT (operation), "is-showing");

  if (priv->parent_window)

    {

      gtk_window_set_transient_for (window, priv->parent_window);

      gtk_window_set_modal (window, TRUE);

    }

  else if (priv->screen)

    gtk_window_set_screen (GTK_WINDOW (dialog), priv->screen);

  gtk_widget_show_all (GTK_WIDGET (dialog));

  g_object_ref (operation);

}

static void

question_dialog_button_clicked (GtkDialog       *dialog,

                                gint             button_number,

                                GMountOperation *op)

{

  GtkMountOperationPrivate *priv;

  GtkMountOperation *operation;

  operation = GTK_MOUNT_OPERATION (op);

  priv = operation->priv;

  if (button_number >= 0)

    {

      g_mount_operation_set_choice (op, button_number);

      g_mount_operation_reply (op, G_MOUNT_OPERATION_HANDLED);

    }

  else

    g_mount_operation_reply (op, G_MOUNT_OPERATION_ABORTED);

  priv->dialog = NULL;

  g_object_notify (G_OBJECT (operation), "is-showing");

  gtk_widget_destroy (GTK_WIDGET (dialog));

  g_object_unref (op);

}

static void

gtk_mount_operation_ask_question (GMountOperation *op,

                                  const char      *message,

                                  const char      *choices[])

{

  GtkMountOperationPrivate *priv;

  GtkWidget  *dialog;

  const char *secondary = NULL;

  char       *primary;

  int        count, len = 0;

  g_return_if_fail (GTK_IS_MOUNT_OPERATION (op));

  g_return_if_fail (message != NULL);

  g_return_if_fail (choices != NULL);

  priv = GTK_MOUNT_OPERATION (op)->priv;

  primary = strstr (message, "\n");

  if (primary)

    {

      secondary = primary + 1;

      primary = g_strndup (message, primary - message);

    }

  dialog = gtk_message_dialog_new (priv->parent_window, 0,

                                   GTK_MESSAGE_QUESTION,

                                   GTK_BUTTONS_NONE, "%s",

                                   primary != NULL ? primary : message);

  g_free (primary);

  if (secondary)

    gtk_message_dialog_format_secondary_text (GTK_MESSAGE_DIALOG (dialog),

                                              "%s", secondary);

  /* First count the items in the list then

   * add the buttons in reverse order */

  while (choices[len] != NULL)

    len++;

  for (count = len - 1; count >= 0; count--)

    gtk_dialog_add_button (GTK_DIALOG (dialog), choices[count], count);

  g_signal_connect (G_OBJECT (dialog), "response",

                    G_CALLBACK (question_dialog_button_clicked), op);

  priv->dialog = GTK_DIALOG (dialog);

  g_object_notify (G_OBJECT (op), "is-showing");

  if (priv->parent_window == NULL && priv->screen)

    gtk_window_set_screen (GTK_WINDOW (dialog), priv->screen);

  gtk_widget_show (dialog);

  g_object_ref (op);

}

static void

show_processes_button_clicked (GtkDialog       *dialog,

                               gint             button_number,

                               GMountOperation *op)

{

  GtkMountOperationPrivate *priv;

  GtkMountOperation *operation;

  operation = GTK_MOUNT_OPERATION (op);

  priv = operation->priv;

  if (button_number >= 0)

    {

      g_mount_operation_set_choice (op, button_number);

      g_mount_operation_reply (op, G_MOUNT_OPERATION_HANDLED);

    }

  else

    g_mount_operation_reply (op, G_MOUNT_OPERATION_ABORTED);

  priv->dialog = NULL;

  g_object_notify (G_OBJECT (operation), "is-showing");

  gtk_widget_destroy (GTK_WIDGET (dialog));

  g_object_unref (op);

}

static gint

pid_equal (gconstpointer a,

           gconstpointer b)

{

  GPid pa, pb;

  pa = *((GPid *) a);

  pb = *((GPid *) b);

  return GPOINTER_TO_INT(pb) - GPOINTER_TO_INT(pa);

}

static void

diff_sorted_arrays (GArray         *array1,

                    GArray         *array2,

                    GCompareFunc   compare,

                    GArray         *added_indices,

                    GArray         *removed_indices)

{

  gint order;

  guint n1, n2;

  guint elem_size;

  n1 = n2 = 0;

  elem_size = g_array_get_element_size (array1);

  g_assert (elem_size == g_array_get_element_size (array2));

  while (n1 < array1->len && n2 < array2->len)

    {

      order = (*compare) (((const char*) array1->data) + n1 * elem_size,

                          ((const char*) array2->data) + n2 * elem_size);

      if (order < 0)

        {

          g_array_append_val (removed_indices, n1);

          n1++;

        }

      else if (order > 0)

        {

          g_array_append_val (added_indices, n2);

          n2++;

        }

      else

        { /* same item */

          n1++;

          n2++;

        }

    }

  while (n1 < array1->len)

    {

      g_array_append_val (removed_indices, n1);

      n1++;

    }

  while (n2 < array2->len)

    {

      g_array_append_val (added_indices, n2);

      n2++;

    }

}

static void

add_pid_to_process_list_store (GtkMountOperation              *mount_operation,

                               GtkMountOperationLookupContext *lookup_context,

                               GtkListStore                   *list_store,

                               GPid                            pid)

{

  gchar *command_line;

  gchar *name;

  GdkPixbuf *pixbuf;

  gchar *markup;

  GtkTreeIter iter;

  name = NULL;

  pixbuf = NULL;

  command_line = NULL;

  _gtk_mount_operation_lookup_info (lookup_context,

                                    pid,

                                    24,