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