cut-n-paste/evmountoperation/ev-mount-operation.c

   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>
   4  *
   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.
   9  *
  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.
  14  *
  15  * You should have received a copy of the GNU Lesser General Public
  16  * License along with this library; if not, write to the
  17  * Free Software Foundation, Inc., 59 Temple Place - Suite 330,
  18  * Boston, MA 02111-1307, USA.
  19  */
  20
  21 /*
  22  * Modified by the GTK+ Team and others 1997-2000.  See the AUTHORS
  23  * file for a list of people on the GTK+ Team.  See the ChangeLog
  24  * files for a list of changes.  These files are distributed with
  25  * GTK+ at ftp://ftp.gtk.org/pub/gtk/.
  26  */
  27
  28 #include <config.h>
  29 #include <gtk/gtk.h>
  30 #include <glib/gi18n.h>
  31 #include <string.h>
  32
  33 #include "ev-mount-operation.h"
  34
  35 /* GObject, GtkObject methods
  36  */
  37 static void   ev_mount_operation_set_property (GObject          *object,
  38                                                guint             prop_id,
  39                                                const GValue     *value,
  40                                                GParamSpec       *pspec);
  41 static void   ev_mount_operation_get_property (GObject          *object,
  42                                                guint             prop_id,
  43                                                GValue           *value,
  44                                                GParamSpec       *pspec);
  45 static void   ev_mount_operation_finalize     (GObject          *object);
  46
  47 /* GMountOperation methods
  48  */
  49 static void   ev_mount_operation_ask_password (GMountOperation *op,
  50                                                const char      *message,
  51                                                const char      *default_user,
  52                                                const char      *default_domain,
  53                                                GAskPasswordFlags flags);
  54
  55 static void   ev_mount_operation_ask_question (GMountOperation *op,
  56                                                const char      *message,
  57                                                const char      *choices[]);
  58
  59 G_DEFINE_TYPE (EvMountOperation, ev_mount_operation, G_TYPE_MOUNT_OPERATION);
  60
  61 enum {
  62   PROP_0,
  63   PROP_PARENT,
  64   PROP_IS_SHOWING,
  65   PROP_SCREEN
  66
  67 };
  68
  69 struct EvMountOperationPrivate {
  70   GtkWindow *parent_window;
  71   GtkDialog *dialog;
  72   GdkScreen *screen;
  73
  74   /* for the ask-password dialog */
  75   GtkWidget *entry_container;
  76   GtkWidget *username_entry;
  77   GtkWidget *domain_entry;
  78   GtkWidget *password_entry;
  79   GtkWidget *anonymous_toggle;
  80
  81   GAskPasswordFlags ask_flags;
  82   GPasswordSave     password_save;
  83   gboolean          anonymous;
  84 };
  85
  86 static void
  87 ev_mount_operation_finalize (GObject *object)
  88 {
  89   EvMountOperation *operation;
  90   EvMountOperationPrivate *priv;
  91
  92   operation = EV_MOUNT_OPERATION (object);
  93
  94   priv = operation->priv;
  95
  96   if (priv->parent_window)
  97     g_object_unref (priv->parent_window);
  98
  99   if (priv->screen)
 100     g_object_unref (priv->screen);
 101
 102   G_OBJECT_CLASS (ev_mount_operation_parent_class)->finalize (object);
 103 }
 104
 105 static void
 106 ev_mount_operation_class_init (EvMountOperationClass *klass)
 107 {
 108   GObjectClass         *object_class = G_OBJECT_CLASS (klass);
 109   GMountOperationClass *mount_op_class;
 110
 111   g_type_class_add_private (klass, sizeof (EvMountOperationPrivate));
 112
 113   object_class->finalize     = ev_mount_operation_finalize;
 114   object_class->get_property = ev_mount_operation_get_property;
 115   object_class->set_property = ev_mount_operation_set_property;
 116
 117   mount_op_class = G_MOUNT_OPERATION_CLASS (klass);
 118   mount_op_class->ask_password = ev_mount_operation_ask_password;
 119   mount_op_class->ask_question = ev_mount_operation_ask_question;
 120
 121   g_object_class_install_property (object_class,
 122                                    PROP_PARENT,
 123                                    g_param_spec_object ("parent",
 124                                                         "Parent",
 125                                                         "The parent window",
 126                                                         GTK_TYPE_WINDOW,
 127                                                         G_PARAM_READWRITE));
 128
 129   g_object_class_install_property (object_class,
 130                                    PROP_IS_SHOWING,
 131                                    g_param_spec_boolean ("is-showing",
 132                                                          "Is Showing",
 133                                                          "Are we showing a dialog",
 134                                                          FALSE,
 135                                                          G_PARAM_READABLE));
 136
 137   g_object_class_install_property (object_class,
 138                                    PROP_SCREEN,
 139                                    g_param_spec_object ("screen",
 140                                                         "Screen",
 141                                                         "The screen where this window will be displayed.",
 142                                                         GTK_TYPE_WINDOW,
 143                                                         G_PARAM_READWRITE));
 144 }
 145
 146
 147 static void
 148 ev_mount_operation_set_property (GObject         *object,
 149                                  guint            prop_id,
 150                                  const GValue    *value,
 151                                  GParamSpec      *pspec)
 152 {
 153   EvMountOperation *operation;
 154   gpointer tmp;
 155
 156   operation = EV_MOUNT_OPERATION (object);
 157
 158   switch (prop_id)
 159     {
 160    case PROP_PARENT:
 161      tmp = g_value_get_object (value);
 162      ev_mount_operation_set_parent (operation, tmp);
 163      break;
 164
 165    case PROP_SCREEN:
 166       tmp = g_value_get_object (value);
 167       ev_mount_operation_set_screen (operation, tmp);
 168      break;
 169
 170    case PROP_IS_SHOWING:
 171    default:
 172       G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
 173       break;
 174     }
 175 }
 176
 177 static void
 178 ev_mount_operation_get_property (GObject         *object,
 179                                  guint            prop_id,
 180                                  GValue          *value,
 181                                  GParamSpec      *pspec)
 182 {
 183   EvMountOperationPrivate *priv;
 184   EvMountOperation *operation;
 185
 186   operation = EV_MOUNT_OPERATION (object);
 187   priv = operation->priv;
 188
 189   switch (prop_id)
 190     {
 191     case PROP_PARENT:
 192       g_value_set_object (value, priv->parent_window);
 193       break;
 194
 195     case PROP_IS_SHOWING:
 196       g_value_set_boolean (value, priv->dialog != NULL);
 197       break;
 198
 199     case PROP_SCREEN:
 200       g_value_set_object (value, priv->screen);
 201       break;
 202
 203     default:
 204       G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
 205       break;
 206     }
 207 }
 208
 209 static void
 210 ev_mount_operation_init (EvMountOperation *operation)
 211 {
 212   operation->priv = G_TYPE_INSTANCE_GET_PRIVATE (operation,
 213                                                  EV_TYPE_MOUNT_OPERATION,
 214                                                  EvMountOperationPrivate);
 215 }
 216
 217 static void
 218 remember_button_toggled (GtkWidget        *widget,
 219                          EvMountOperation *operation)
 220 {
 221   EvMountOperationPrivate *priv = operation->priv;
 222   gpointer data;
 223
 224   data = g_object_get_data (G_OBJECT (widget), "password-save");
 225   priv->password_save = GPOINTER_TO_INT (data);
 226 }
 227
 228 static void
 229 pw_dialog_got_response (GtkDialog        *dialog,
 230                         gint              response_id,
 231                         EvMountOperation *mount_op)
 232 {
 233   EvMountOperationPrivate *priv;
 234   GMountOperation *op;
 235
 236   priv = mount_op->priv;
 237   op = G_MOUNT_OPERATION (mount_op);
 238
 239   if (response_id == GTK_RESPONSE_OK)
 240     {
 241       const char *text;
 242
 243       if (priv->ask_flags & G_ASK_PASSWORD_ANONYMOUS_SUPPORTED)
 244         g_mount_operation_set_anonymous (op, priv->anonymous);
 245
 246       if (priv->username_entry)
 247         {
 248           text = gtk_entry_get_text (GTK_ENTRY (priv->username_entry));
 249           g_mount_operation_set_username (op, text);
 250         }
 251
 252       if (priv->domain_entry)
 253         {
 254           text = gtk_entry_get_text (GTK_ENTRY (priv->domain_entry));
 255           g_mount_operation_set_domain (op, text);
 256         }
 257
 258       if (priv->password_entry)
 259         {
 260           text = gtk_entry_get_text (GTK_ENTRY (priv->password_entry));
 261           g_mount_operation_set_password (op, text);
 262         }
 263
 264       if (priv->ask_flags & G_ASK_PASSWORD_SAVING_SUPPORTED)
 265         g_mount_operation_set_password_save (op, priv->password_save);
 266
 267       g_mount_operation_reply (op, G_MOUNT_OPERATION_HANDLED);
 268     }
 269   else
 270     g_mount_operation_reply (op, G_MOUNT_OPERATION_ABORTED);
 271
 272   priv->dialog = NULL;
 273   g_object_notify (G_OBJECT (op), "is-showing");
 274   gtk_widget_destroy (GTK_WIDGET (dialog));
 275   g_object_unref (op);
 276 }
 277
 278 static gboolean
 279 entry_has_input (GtkWidget *entry_widget)
 280 {
 281   const char *text;
 282
 283   if (entry_widget == NULL)
 284     return TRUE;
 285
 286   text = gtk_entry_get_text (GTK_ENTRY (entry_widget));
 287
 288   return text != NULL && text[0] != '\0';
 289 }
 290
 291 static gboolean
 292 pw_dialog_input_is_valid (EvMountOperation *operation)
 293 {
 294   EvMountOperationPrivate *priv = operation->priv;
 295   gboolean is_valid = TRUE;
 296
 297   is_valid = entry_has_input (priv->username_entry) &&
 298              entry_has_input (priv->domain_entry) &&
 299              entry_has_input (priv->password_entry);
 300
 301   return is_valid;
 302 }
 303
 304 static void
 305 pw_dialog_verify_input (GtkEditable      *editable,
 306                         EvMountOperation *operation)
 307 {
 308   EvMountOperationPrivate *priv = operation->priv;
 309   gboolean is_valid;
 310
 311   is_valid = pw_dialog_input_is_valid (operation);
 312   gtk_dialog_set_response_sensitive (GTK_DIALOG (priv->dialog),
 313                                      GTK_RESPONSE_OK,
 314                                      is_valid);
 315 }
 316
 317 static void
 318 pw_dialog_anonymous_toggled (GtkWidget        *widget,
 319                              EvMountOperation *operation)
 320 {
 321   EvMountOperationPrivate *priv = operation->priv;
 322   gboolean is_valid;
 323
 324   priv->anonymous = widget == priv->anonymous_toggle;
 325
 326   if (priv->anonymous)
 327     is_valid = TRUE;
 328   else
 329     is_valid = pw_dialog_input_is_valid (operation);
 330
 331   gtk_widget_set_sensitive (priv->entry_container, priv->anonymous == FALSE);
 332   gtk_dialog_set_response_sensitive (GTK_DIALOG (priv->dialog),
 333                                      GTK_RESPONSE_OK,
 334                                      is_valid);
 335 }
 336
 337
 338 static void
 339 pw_dialog_cycle_focus (GtkWidget        *widget,
 340                        EvMountOperation *operation)
 341 {
 342   EvMountOperationPrivate *priv;
 343   GtkWidget *next_widget = NULL;
 344
 345   priv = operation->priv;
 346
 347   if (widget == priv->username_entry)
 348     {
 349       if (priv->domain_entry != NULL)
 350         next_widget = priv->domain_entry;
 351       else if (priv->password_entry != NULL)
 352         next_widget = priv->password_entry;
 353     }
 354   else if (widget == priv->domain_entry && priv->password_entry)
 355     next_widget = priv->password_entry;
 356
 357   if (next_widget)
 358     gtk_widget_grab_focus (next_widget);
 359   else if (pw_dialog_input_is_valid (operation))
 360     gtk_window_activate_default (GTK_WINDOW (priv->dialog));
 361 }
 362
 363 static GtkWidget *
 364 table_add_entry (GtkWidget  *table,
 365                  int         row,
 366                  const char *label_text,
 367                  const char *value,
 368                  gpointer    user_data)
 369 {
 370   GtkWidget *entry;
 371   GtkWidget *label;
 372
 373   label = gtk_label_new_with_mnemonic (label_text);
 374   gtk_misc_set_alignment (GTK_MISC (label), 0.0, 0.5);
 375
 376   entry = gtk_entry_new ();
 377
 378   if (value)
 379     gtk_entry_set_text (GTK_ENTRY (entry), value);
 380
 381   gtk_table_attach (GTK_TABLE (table), label,
 382                     0, 1, row, row + 1,
 383                     GTK_FILL, GTK_EXPAND | GTK_FILL, 0, 0);
 384   gtk_table_attach_defaults (GTK_TABLE (table), entry,
 385                              1, 2, row, row + 1);
 386   gtk_label_set_mnemonic_widget (GTK_LABEL (label), entry);
 387
 388   g_signal_connect (entry, "changed",
 389                     G_CALLBACK (pw_dialog_verify_input), user_data);
 390
 391   g_signal_connect (entry, "activate",
 392                     G_CALLBACK (pw_dialog_cycle_focus), user_data);
 393
 394   return entry;
 395 }
 396
 397 static void
 398 ev_mount_operation_ask_password (GMountOperation   *mount_op,
 399                                  const char        *message,
 400                                  const char        *default_user,
 401                                  const char        *default_domain,
 402                                  GAskPasswordFlags  flags)
 403 {
 404   EvMountOperation *operation;
 405   EvMountOperationPrivate *priv;
 406   GtkWidget *widget;
 407   GtkDialog *dialog;
 408   GtkWindow *window;
 409   GtkWidget *entry_container;
 410   GtkWidget *hbox, *main_vbox, *vbox, *icon;
 411   GtkWidget *table;
 412   GtkWidget *message_label;
 413   gboolean   can_anonymous;
 414   guint      rows;
 415
 416   operation = EV_MOUNT_OPERATION (mount_op);
 417   priv = operation->priv;
 418
 419   priv->ask_flags = flags;
 420
 421   widget = gtk_dialog_new ();
 422   dialog = GTK_DIALOG (widget);
 423   window = GTK_WINDOW (widget);
 424
 425   priv->dialog = dialog;
 426
 427   /* Set the dialog up with HIG properties */
 428   gtk_dialog_set_has_separator (dialog, FALSE);
 429   gtk_container_set_border_width (GTK_CONTAINER (dialog), 5);
 430   gtk_box_set_spacing (GTK_BOX (dialog->vbox), 2); /* 2 * 5 + 2 = 12 */
 431   gtk_container_set_border_width (GTK_CONTAINER (dialog->action_area), 5);
 432   gtk_box_set_spacing (GTK_BOX (dialog->action_area), 6);
 433
 434   gtk_window_set_resizable (window, FALSE);
 435   gtk_window_set_icon_name (window, GTK_STOCK_DIALOG_AUTHENTICATION);
 436
 437   gtk_dialog_add_buttons (dialog,
 438                           GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL,
 439                           _("Co_nnect"), GTK_RESPONSE_OK,
 440                           NULL);
 441   gtk_dialog_set_default_response (dialog, GTK_RESPONSE_OK);
 442
 443   gtk_dialog_set_alternative_button_order (dialog,
 444                                            GTK_RESPONSE_OK,
 445                                            GTK_RESPONSE_CANCEL,
 446                                            -1);
 447
 448   /* Build contents */
 449   hbox = gtk_hbox_new (FALSE, 12);
 450   gtk_container_set_border_width (GTK_CONTAINER (hbox), 5);
 451   gtk_box_pack_start (GTK_BOX (dialog->vbox), hbox, TRUE, TRUE, 0);
 452
 453   icon = gtk_image_new_from_stock (GTK_STOCK_DIALOG_AUTHENTICATION,
 454                                    GTK_ICON_SIZE_DIALOG);
 455
 456   gtk_misc_set_alignment (GTK_MISC (icon), 0.5, 0.0);
 457   gtk_box_pack_start (GTK_BOX (hbox), icon, FALSE, FALSE, 0);
 458
 459   main_vbox = gtk_vbox_new (FALSE, 18);
 460   gtk_box_pack_start (GTK_BOX (hbox), main_vbox, TRUE, TRUE, 0);
 461
 462   message_label = gtk_label_new (message);
 463   gtk_misc_set_alignment (GTK_MISC (message_label), 0.0, 0.5);
 464   gtk_label_set_line_wrap (GTK_LABEL (message_label), TRUE);
 465   gtk_box_pack_start (GTK_BOX (main_vbox), GTK_WIDGET (message_label),
 466                       FALSE, FALSE, 0);
 467
 468   vbox = gtk_vbox_new (FALSE, 6);
 469   gtk_box_pack_start (GTK_BOX (main_vbox), vbox, FALSE, FALSE, 0);
 470
 471   can_anonymous = flags & G_ASK_PASSWORD_ANONYMOUS_SUPPORTED;
 472
 473   if (can_anonymous)
 474     {
 475       GtkWidget *anon_box;
 476       GtkWidget *choice;
 477       GSList    *group;
 478
 479       anon_box = gtk_vbox_new (FALSE, 6);
 480       gtk_box_pack_start (GTK_BOX (vbox), anon_box,
 481                           FALSE, FALSE, 0);
 482
 483       choice = gtk_radio_button_new_with_mnemonic (NULL, _("Connect _anonymously"));
 484       gtk_box_pack_start (GTK_BOX (anon_box),
 485                           choice,
 486                           FALSE, FALSE, 0);
 487       g_signal_connect (choice, "toggled",
 488                         G_CALLBACK (pw_dialog_anonymous_toggled), operation);
 489       priv->anonymous_toggle = choice;
 490
 491       group = gtk_radio_button_get_group (GTK_RADIO_BUTTON (choice));
 492       choice = gtk_radio_button_new_with_mnemonic (group, _("Connect as u_ser:"));
 493       gtk_box_pack_start (GTK_BOX (anon_box),
 494                           choice,
 495                           FALSE, FALSE, 0);
 496       g_signal_connect (choice, "toggled",
 497                         G_CALLBACK (pw_dialog_anonymous_toggled), operation);
 498     }
 499
 500   rows = 0;
 501
 502   if (flags & G_ASK_PASSWORD_NEED_PASSWORD)
 503     rows++;
 504
 505   if (flags & G_ASK_PASSWORD_NEED_USERNAME)
 506     rows++;
 507
 508   if (flags &G_ASK_PASSWORD_NEED_DOMAIN)
 509     rows++;
 510
 511   /* The table that holds the entries */
 512   entry_container = gtk_alignment_new (0.0, 0.0, 1.0, 1.0);
 513
 514   gtk_alignment_set_padding (GTK_ALIGNMENT (entry_container),
 515                              0, 0, can_anonymous ? 12 : 0, 0);
 516
 517   gtk_box_pack_start (GTK_BOX (vbox), entry_container,
 518                       FALSE, FALSE, 0);
 519   priv->entry_container = entry_container;
 520
 521   table = gtk_table_new (rows, 2, FALSE);
 522   gtk_table_set_col_spacings (GTK_TABLE (table), 12);
 523   gtk_table_set_row_spacings (GTK_TABLE (table), 6);
 524   gtk_container_add (GTK_CONTAINER (entry_container), table);
 525
 526   rows = 0;
 527
 528   if (flags & G_ASK_PASSWORD_NEED_USERNAME)
 529     priv->username_entry = table_add_entry (table, rows++, _("_Username:"),
 530                                             default_user, operation);
 531
 532   if (flags & G_ASK_PASSWORD_NEED_DOMAIN)
 533     priv->domain_entry = table_add_entry (table, rows++, _("_Domain:"),
 534                                           default_domain, operation);
 535
 536   if (flags & G_ASK_PASSWORD_NEED_PASSWORD)
 537     {
 538       priv->password_entry = table_add_entry (table, rows++, _("_Password:"),
 539                                               NULL, operation);
 540       gtk_entry_set_visibility (GTK_ENTRY (priv->password_entry), FALSE);
 541     }
 542
 543    if (flags & G_ASK_PASSWORD_SAVING_SUPPORTED)
 544     {
 545       GtkWidget  *choice;
 546       GtkWidget  *remember_box;
 547       GSList     *group;
 548
 549       remember_box = gtk_vbox_new (FALSE, 6);
 550       gtk_box_pack_start (GTK_BOX (vbox), remember_box,
 551                           FALSE, FALSE, 0);
 552
 553       choice = gtk_radio_button_new_with_mnemonic (NULL, _("_Forget password immediately"));
 554       g_object_set_data (G_OBJECT (choice), "password-save",
 555                          GINT_TO_POINTER (G_PASSWORD_SAVE_NEVER));
 556       g_signal_connect (choice, "toggled",
 557                         G_CALLBACK (remember_button_toggled), operation);
 558       gtk_box_pack_start (GTK_BOX (remember_box), choice, FALSE, FALSE, 0);
 559
 560       group = gtk_radio_button_get_group (GTK_RADIO_BUTTON (choice));
 561       choice = gtk_radio_button_new_with_mnemonic (group, _("_Remember password until you logout"));
 562       g_object_set_data (G_OBJECT (choice), "password-save",
 563                          GINT_TO_POINTER (G_PASSWORD_SAVE_FOR_SESSION));
 564       g_signal_connect (choice, "toggled",
 565                         G_CALLBACK (remember_button_toggled), operation);
 566       gtk_box_pack_start (GTK_BOX (remember_box), choice, FALSE, FALSE, 0);
 567
 568       group = gtk_radio_button_get_group (GTK_RADIO_BUTTON (choice));
 569       choice = gtk_radio_button_new_with_mnemonic (group, _("_Remember forever"));
 570       g_object_set_data (G_OBJECT (choice), "password-save",
 571                          GINT_TO_POINTER (G_PASSWORD_SAVE_PERMANENTLY));
 572       g_signal_connect (choice, "toggled",
 573                         G_CALLBACK (remember_button_toggled), operation);
 574       gtk_box_pack_start (GTK_BOX (remember_box), choice, FALSE, FALSE, 0);
 575     }
 576
 577   g_signal_connect (G_OBJECT (dialog), "response",
 578                     G_CALLBACK (pw_dialog_got_response), operation);
 579
 580   if (can_anonymous)
 581     {
 582       /* The anonymous option will be active by default,
 583        * ensure the toggled signal is emitted for it.
 584        */
 585       gtk_toggle_button_toggled (GTK_TOGGLE_BUTTON (priv->anonymous_toggle));
 586     }
 587   else if (! pw_dialog_input_is_valid (operation))
 588     gtk_dialog_set_response_sensitive (dialog, GTK_RESPONSE_OK, FALSE);
 589
 590   g_object_notify (G_OBJECT (operation), "is-showing");
 591
 592   if (priv->parent_window)
 593     {
 594       gtk_window_set_transient_for (window, priv->parent_window);
 595       gtk_window_set_modal (window, TRUE);
 596     }
 597   else if (priv->screen)
 598     gtk_window_set_screen (GTK_WINDOW (dialog), priv->screen);
 599
 600   gtk_widget_show_all (GTK_WIDGET (dialog));
 601
 602   g_object_ref (operation);
 603 }
 604
 605 static void
 606 question_dialog_button_clicked (GtkDialog       *dialog,
 607                                 gint             button_number,
 608                                 GMountOperation *op)
 609 {
 610   EvMountOperationPrivate *priv;
 611   EvMountOperation *operation;
 612
 613   operation = EV_MOUNT_OPERATION (op);
 614   priv = operation->priv;
 615
 616   if (button_number >= 0)
 617     {
 618       g_mount_operation_set_choice (op, button_number);
 619       g_mount_operation_reply (op, G_MOUNT_OPERATION_HANDLED);
 620     }
 621   else
 622     g_mount_operation_reply (op, G_MOUNT_OPERATION_ABORTED);
 623
 624   priv->dialog = NULL;
 625   g_object_notify (G_OBJECT (operation), "is-showing");
 626   gtk_widget_destroy (GTK_WIDGET (dialog));
 627   g_object_unref (op);
 628 }
 629
 630 static void
 631 ev_mount_operation_ask_question (GMountOperation *op,
 632                                  const char      *message,
 633                                  const char      *choices[])
 634 {
 635   EvMountOperationPrivate *priv;
 636   GtkWidget  *dialog;
 637   const char *secondary = NULL;
 638   char       *primary;
 639   int        count, len = 0;
 640
 641   g_return_if_fail (EV_IS_MOUNT_OPERATION (op));
 642   g_return_if_fail (message != NULL);
 643   g_return_if_fail (choices != NULL);
 644
 645   priv = EV_MOUNT_OPERATION (op)->priv;
 646
 647   primary = strstr (message, "\n");
 648   if (primary)
 649     {
 650       secondary = primary + 1;
 651       primary = g_strndup (message, primary - message);
 652     }
 653
 654   dialog = gtk_message_dialog_new (priv->parent_window, 0,
 655                                    GTK_MESSAGE_QUESTION,
 656                                    GTK_BUTTONS_NONE, "%s",
 657                                    primary != NULL ? primary : message);
 658   g_free (primary);
 659
 660   if (secondary)
 661     gtk_message_dialog_format_secondary_text (GTK_MESSAGE_DIALOG (dialog),
 662                                               "%s", secondary);
 663
 664   /* First count the items in the list then
 665    * add the buttons in reverse order */
 666
 667   while (choices[len] != NULL)
 668     len++;
 669
 670   for (count = len - 1; count >= 0; count--)
 671     gtk_dialog_add_button (GTK_DIALOG (dialog), choices[count], count);
 672
 673   g_signal_connect (G_OBJECT (dialog), "response",
 674                     G_CALLBACK (question_dialog_button_clicked), op);
 675
 676   priv->dialog = GTK_DIALOG (dialog);
 677   g_object_notify (G_OBJECT (op), "is-showing");
 678
 679   if (priv->parent_window == NULL && priv->screen)
 680     gtk_window_set_screen (GTK_WINDOW (dialog), priv->screen);
 681
 682   gtk_widget_show (dialog);
 683   g_object_ref (op);
 684 }
 685
 686 GMountOperation *
 687 ev_mount_operation_new (GtkWindow *parent)
 688 {
 689   GMountOperation *mount_operation;
 690
 691   mount_operation = g_object_new (EV_TYPE_MOUNT_OPERATION,
 692                                   "parent", parent, NULL);
 693
 694   return mount_operation;
 695 }
 696
 697 gboolean
 698 ev_mount_operation_is_showing (EvMountOperation *op)
 699 {
 700   g_return_val_if_fail (EV_IS_MOUNT_OPERATION (op), FALSE);
 701
 702   return op->priv->dialog != NULL;
 703 }
 704
 705 void
 706 ev_mount_operation_set_parent (EvMountOperation *op,
 707                                GtkWindow        *parent)
 708 {
 709   EvMountOperationPrivate *priv;
 710
 711   g_return_if_fail (EV_IS_MOUNT_OPERATION (op));
 712   g_return_if_fail (parent == NULL || GTK_IS_WINDOW (parent));
 713
 714   priv = op->priv;
 715
 716   if (priv->parent_window == parent)
 717     return;
 718
 719   if (priv->parent_window)
 720     {
 721       g_signal_handlers_disconnect_by_func (priv->parent_window,
 722                                             gtk_widget_destroyed,
 723                                             &priv->parent_window);
 724       priv->parent_window = NULL;
 725     }
 726
 727   if (parent)
 728     {
 729       priv->parent_window = g_object_ref (parent);
 730
 731       g_signal_connect (parent, "destroy",
 732                         G_CALLBACK (gtk_widget_destroyed),
 733                         &priv->parent_window);
 734
 735       if (priv->dialog)
 736         gtk_window_set_transient_for (GTK_WINDOW (priv->dialog), parent);
 737     }
 738
 739   g_object_notify (G_OBJECT (op), "parent");
 740 }
 741
 742 GtkWindow *
 743 ev_mount_operation_get_parent (EvMountOperation *op)
 744 {
 745   g_return_val_if_fail (EV_IS_MOUNT_OPERATION (op), NULL);
 746
 747   return op->priv->parent_window;
 748 }
 749
 750 void
 751 ev_mount_operation_set_screen (EvMountOperation *op,
 752                                GdkScreen        *screen)
 753 {
 754   EvMountOperationPrivate *priv;
 755
 756   g_return_if_fail (EV_IS_MOUNT_OPERATION (op));
 757   g_return_if_fail (GDK_IS_SCREEN (screen));
 758
 759   priv = op->priv;
 760
 761   if (priv->screen == screen)
 762     return;
 763
 764   if (priv->screen)
 765     g_object_unref (priv->screen);
 766
 767   priv->screen = g_object_ref (screen);
 768
 769   if (priv->dialog)
 770     gtk_window_set_screen (GTK_WINDOW (priv->dialog), screen);
 771
 772   g_object_notify (G_OBJECT (op), "screen");
 773 }
 774
 775 GdkScreen *
 776 ev_mount_operation_get_screen (EvMountOperation *op)
 777 {
 778   EvMountOperationPrivate *priv;
 779
 780   g_return_val_if_fail (EV_IS_MOUNT_OPERATION (op), NULL);
 781
 782   priv = op->priv;
 783
 784   if (priv->dialog)
 785     return gtk_window_get_screen (GTK_WINDOW (priv->dialog));
 786   else if (priv->parent_window)
 787     return gtk_window_get_screen (GTK_WINDOW (priv->parent_window));
 788   else if (priv->screen)
 789     return priv->screen;
 790   else
 791     return gdk_screen_get_default ();
 792 }
 793