gio/gmountoperation.c

   1 /* GIO - GLib Input, Output and Streaming Library
   2  *
   3  * Copyright (C) 2006-2007 Red Hat, Inc.
   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.1 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
  16  * Public License along with this library; if not, see <http://www.gnu.org/licenses/>.
  17  *
  18  * Author: Alexander Larsson <alexl@redhat.com>
  19  */
  20
  21 #include "config.h"
  22
  23 #include <string.h>
  24
  25 #include "gmountoperation.h"
  26 #include "gioenumtypes.h"
  27 #include "glibintl.h"
  28
  29
  30 /**
  31  * SECTION:gmountoperation
  32  * @short_description: Object used for authentication and user interaction
  33  * @include: gio/gio.h
  34  *
  35  * #GMountOperation provides a mechanism for interacting with the user.
  36  * It can be used for authenticating mountable operations, such as loop
  37  * mounting files, hard drive partitions or server locations. It can
  38  * also be used to ask the user questions or show a list of applications
  39  * preventing unmount or eject operations from completing.
  40  *
  41  * Note that #GMountOperation is used for more than just #GMount
  42  * objects – for example it is also used in g_drive_start() and
  43  * g_drive_stop().
  44  *
  45  * Users should instantiate a subclass of this that implements all the
  46  * various callbacks to show the required dialogs, such as
  47  * #GtkMountOperation. If no user interaction is desired (for example
  48  * when automounting filesystems at login time), usually %NULL can be
  49  * passed, see each method taking a #GMountOperation for details.
  50  */
  51
  52 enum {
  53   ASK_PASSWORD,
  54   ASK_QUESTION,
  55   REPLY,
  56   ABORTED,
  57   SHOW_PROCESSES,
  58   SHOW_UNMOUNT_PROGRESS,
  59   LAST_SIGNAL
  60 };
  61
  62 static guint signals[LAST_SIGNAL] = { 0 };
  63
  64 struct _GMountOperationPrivate {
  65   char *password;
  66   char *user;
  67   char *domain;
  68   gboolean anonymous;
  69   GPasswordSave password_save;
  70   int choice;
  71 };
  72
  73 enum {
  74   PROP_0,
  75   PROP_USERNAME,
  76   PROP_PASSWORD,
  77   PROP_ANONYMOUS,
  78   PROP_DOMAIN,
  79   PROP_PASSWORD_SAVE,
  80   PROP_CHOICE
  81 };
  82
  83 G_DEFINE_TYPE_WITH_PRIVATE (GMountOperation, g_mount_operation, G_TYPE_OBJECT)
  84
  85 static void
  86 g_mount_operation_set_property (GObject      *object,
  87                                 guint         prop_id,
  88                                 const GValue *value,
  89                                 GParamSpec   *pspec)
  90 {
  91   GMountOperation *operation;
  92
  93   operation = G_MOUNT_OPERATION (object);
  94
  95   switch (prop_id)
  96     {
  97     case PROP_USERNAME:
  98       g_mount_operation_set_username (operation,
  99                                       g_value_get_string (value));
 100       break;
 101
 102     case PROP_PASSWORD:
 103       g_mount_operation_set_password (operation,
 104                                       g_value_get_string (value));
 105       break;
 106
 107     case PROP_ANONYMOUS:
 108       g_mount_operation_set_anonymous (operation,
 109                                        g_value_get_boolean (value));
 110       break;
 111
 112     case PROP_DOMAIN:
 113       g_mount_operation_set_domain (operation,
 114                                     g_value_get_string (value));
 115       break;
 116
 117     case PROP_PASSWORD_SAVE:
 118       g_mount_operation_set_password_save (operation,
 119                                            g_value_get_enum (value));
 120       break;
 121
 122     case PROP_CHOICE:
 123       g_mount_operation_set_choice (operation,
 124                                     g_value_get_int (value));
 125       break;
 126
 127     default:
 128       G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
 129       break;
 130     }
 131 }
 132
 133
 134 static void
 135 g_mount_operation_get_property (GObject    *object,
 136                                 guint       prop_id,
 137                                 GValue     *value,
 138                                 GParamSpec *pspec)
 139 {
 140   GMountOperation *operation;
 141   GMountOperationPrivate *priv;
 142
 143   operation = G_MOUNT_OPERATION (object);
 144   priv = operation->priv;
 145
 146   switch (prop_id)
 147     {
 148     case PROP_USERNAME:
 149       g_value_set_string (value, priv->user);
 150       break;
 151
 152     case PROP_PASSWORD:
 153       g_value_set_string (value, priv->password);
 154       break;
 155
 156     case PROP_ANONYMOUS:
 157       g_value_set_boolean (value, priv->anonymous);
 158       break;
 159
 160     case PROP_DOMAIN:
 161       g_value_set_string (value, priv->domain);
 162       break;
 163
 164     case PROP_PASSWORD_SAVE:
 165       g_value_set_enum (value, priv->password_save);
 166       break;
 167
 168     case PROP_CHOICE:
 169       g_value_set_int (value, priv->choice);
 170       break;
 171
 172     default:
 173       G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
 174       break;
 175     }
 176 }
 177
 178
 179 static void
 180 g_mount_operation_finalize (GObject *object)
 181 {
 182   GMountOperation *operation;
 183   GMountOperationPrivate *priv;
 184
 185   operation = G_MOUNT_OPERATION (object);
 186
 187   priv = operation->priv;
 188
 189   g_free (priv->password);
 190   g_free (priv->user);
 191   g_free (priv->domain);
 192
 193   G_OBJECT_CLASS (g_mount_operation_parent_class)->finalize (object);
 194 }
 195
 196 static gboolean
 197 reply_non_handled_in_idle (gpointer data)
 198 {
 199   GMountOperation *op = data;
 200
 201   g_mount_operation_reply (op, G_MOUNT_OPERATION_UNHANDLED);
 202   return G_SOURCE_REMOVE;
 203 }
 204
 205 static void
 206 ask_password (GMountOperation *op,
 207               const char      *message,
 208               const char      *default_user,
 209               const char      *default_domain,
 210               GAskPasswordFlags flags)
 211 {
 212   g_idle_add_full (G_PRIORITY_DEFAULT_IDLE,
 213                    reply_non_handled_in_idle,
 214                    g_object_ref (op),
 215                    g_object_unref);
 216 }
 217
 218 static void
 219 ask_question (GMountOperation *op,
 220               const char      *message,
 221               const char      *choices[])
 222 {
 223   g_idle_add_full (G_PRIORITY_DEFAULT_IDLE,
 224                    reply_non_handled_in_idle,
 225                    g_object_ref (op),
 226                    g_object_unref);
 227 }
 228
 229 static void
 230 show_processes (GMountOperation      *op,
 231                 const gchar          *message,
 232                 GArray               *processes,
 233                 const gchar          *choices[])
 234 {
 235   g_idle_add_full (G_PRIORITY_DEFAULT_IDLE,
 236                    reply_non_handled_in_idle,
 237                    g_object_ref (op),
 238                    g_object_unref);
 239 }
 240
 241 static void
 242 show_unmount_progress (GMountOperation *op,
 243                        const gchar     *message,
 244                        gint64           time_left,
 245                        gint64           bytes_left)
 246 {
 247   /* nothing to do */
 248 }
 249
 250 static void
 251 g_mount_operation_class_init (GMountOperationClass *klass)
 252 {
 253   GObjectClass *object_class;
 254
 255   object_class = G_OBJECT_CLASS (klass);
 256   object_class->finalize = g_mount_operation_finalize;
 257   object_class->get_property = g_mount_operation_get_property;
 258   object_class->set_property = g_mount_operation_set_property;
 259
 260   klass->ask_password = ask_password;
 261   klass->ask_question = ask_question;
 262   klass->show_processes = show_processes;
 263   klass->show_unmount_progress = show_unmount_progress;
 264
 265   /**
 266    * GMountOperation::ask-password:
 267    * @op: a #GMountOperation requesting a password.
 268    * @message: string containing a message to display to the user.
 269    * @default_user: string containing the default user name.
 270    * @default_domain: string containing the default domain.
 271    * @flags: a set of #GAskPasswordFlags.
 272    *
 273    * Emitted when a mount operation asks the user for a password.
 274    *
 275    * If the message contains a line break, the first line should be
 276    * presented as a heading. For example, it may be used as the
 277    * primary text in a #GtkMessageDialog.
 278    */
 279   signals[ASK_PASSWORD] =
 280     g_signal_new (I_("ask-password"),
 281                   G_TYPE_FROM_CLASS (object_class),
 282                   G_SIGNAL_RUN_LAST,
 283                   G_STRUCT_OFFSET (GMountOperationClass, ask_password),
 284                   NULL, NULL,
 285                   NULL,
 286                   G_TYPE_NONE, 4,
 287                   G_TYPE_STRING, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_ASK_PASSWORD_FLAGS);
 288
 289   /**
 290    * GMountOperation::ask-question:
 291    * @op: a #GMountOperation asking a question.
 292    * @message: string containing a message to display to the user.
 293    * @choices: an array of strings for each possible choice.
 294    *
 295    * Emitted when asking the user a question and gives a list of
 296    * choices for the user to choose from.
 297    *
 298    * If the message contains a line break, the first line should be
 299    * presented as a heading. For example, it may be used as the
 300    * primary text in a #GtkMessageDialog.
 301    */
 302   signals[ASK_QUESTION] =
 303     g_signal_new (I_("ask-question"),
 304                   G_TYPE_FROM_CLASS (object_class),
 305                   G_SIGNAL_RUN_LAST,
 306                   G_STRUCT_OFFSET (GMountOperationClass, ask_question),
 307                   NULL, NULL,
 308                   NULL,
 309                   G_TYPE_NONE, 2,
 310                   G_TYPE_STRING, G_TYPE_STRV);
 311
 312   /**
 313    * GMountOperation::reply:
 314    * @op: a #GMountOperation.
 315    * @result: a #GMountOperationResult indicating how the request was handled
 316    *
 317    * Emitted when the user has replied to the mount operation.
 318    */
 319   signals[REPLY] =
 320     g_signal_new (I_("reply"),
 321                   G_TYPE_FROM_CLASS (object_class),
 322                   G_SIGNAL_RUN_LAST,
 323                   G_STRUCT_OFFSET (GMountOperationClass, reply),
 324                   NULL, NULL,
 325                   g_cclosure_marshal_VOID__ENUM,
 326                   G_TYPE_NONE, 1,
 327                   G_TYPE_MOUNT_OPERATION_RESULT);
 328
 329   /**
 330    * GMountOperation::aborted:
 331    *
 332    * Emitted by the backend when e.g. a device becomes unavailable
 333    * while a mount operation is in progress.
 334    *
 335    * Implementations of GMountOperation should handle this signal
 336    * by dismissing open password dialogs.
 337    *
 338    * Since: 2.20
 339    */
 340   signals[ABORTED] =
 341     g_signal_new (I_("aborted"),
 342                   G_TYPE_FROM_CLASS (object_class),
 343                   G_SIGNAL_RUN_LAST,
 344                   G_STRUCT_OFFSET (GMountOperationClass, aborted),
 345                   NULL, NULL,
 346                   g_cclosure_marshal_VOID__VOID,
 347                   G_TYPE_NONE, 0);
 348
 349   /**
 350    * GMountOperation::show-processes:
 351    * @op: a #GMountOperation.
 352    * @message: string containing a message to display to the user.
 353    * @processes: (element-type GPid): an array of #GPid for processes
 354    *   blocking the operation.
 355    * @choices: an array of strings for each possible choice.
 356    *
 357    * Emitted when one or more processes are blocking an operation
 358    * e.g. unmounting/ejecting a #GMount or stopping a #GDrive.
 359    *
 360    * Note that this signal may be emitted several times to update the
 361    * list of blocking processes as processes close files. The
 362    * application should only respond with g_mount_operation_reply() to
 363    * the latest signal (setting #GMountOperation:choice to the choice
 364    * the user made).
 365    *
 366    * If the message contains a line break, the first line should be
 367    * presented as a heading. For example, it may be used as the
 368    * primary text in a #GtkMessageDialog.
 369    *
 370    * Since: 2.22
 371    */
 372   signals[SHOW_PROCESSES] =
 373     g_signal_new (I_("show-processes"),
 374                   G_TYPE_FROM_CLASS (object_class),
 375                   G_SIGNAL_RUN_LAST,
 376                   G_STRUCT_OFFSET (GMountOperationClass, show_processes),
 377                   NULL, NULL,
 378                   NULL,
 379                   G_TYPE_NONE, 3,
 380                   G_TYPE_STRING, G_TYPE_ARRAY, G_TYPE_STRV);
 381
 382   /**
 383    * GMountOperation::show-unmount-progress:
 384    * @op: a #GMountOperation:
 385    * @message: string containing a mesage to display to the user
 386    * @time_left: the estimated time left before the operation completes,
 387    *     in microseconds, or -1
 388    * @bytes_left: the amount of bytes to be written before the operation
 389    *     completes (or -1 if such amount is not known), or zero if the operation
 390    *     is completed
 391    *
 392    * Emitted when an unmount operation has been busy for more than some time
 393    * (typically 1.5 seconds).
 394    *
 395    * When unmounting or ejecting a volume, the kernel might need to flush
 396    * pending data in its buffers to the volume stable storage, and this operation
 397    * can take a considerable amount of time. This signal may be emitted several
 398    * times as long as the unmount operation is outstanding, and then one
 399    * last time when the operation is completed, with @bytes_left set to zero.
 400    *
 401    * Implementations of GMountOperation should handle this signal by
 402    * showing an UI notification, and then dismiss it, or show another notification
 403    * of completion, when @bytes_left reaches zero.
 404    *
 405    * If the message contains a line break, the first line should be
 406    * presented as a heading. For example, it may be used as the
 407    * primary text in a #GtkMessageDialog.
 408    *
 409    * Since: 2.34
 410    */
 411   signals[SHOW_UNMOUNT_PROGRESS] =
 412     g_signal_new (I_("show-unmount-progress"),
 413                   G_TYPE_FROM_CLASS (object_class),
 414                   G_SIGNAL_RUN_LAST,
 415                   G_STRUCT_OFFSET (GMountOperationClass, show_unmount_progress),
 416                   NULL, NULL, NULL,
 417                   G_TYPE_NONE, 3,
 418                   G_TYPE_STRING, G_TYPE_INT64, G_TYPE_INT64);
 419
 420   /**
 421    * GMountOperation:username:
 422    *
 423    * The user name that is used for authentication when carrying out
 424    * the mount operation.
 425    */
 426   g_object_class_install_property (object_class,
 427                                    PROP_USERNAME,
 428                                    g_param_spec_string ("username",
 429                                                         P_("Username"),
 430                                                         P_("The user name"),
 431                                                         NULL,
 432                                                         G_PARAM_READWRITE|
 433                                                         G_PARAM_STATIC_NAME|G_PARAM_STATIC_NICK|G_PARAM_STATIC_BLURB));
 434
 435   /**
 436    * GMountOperation:password:
 437    *
 438    * The password that is used for authentication when carrying out
 439    * the mount operation.
 440    */
 441   g_object_class_install_property (object_class,
 442                                    PROP_PASSWORD,
 443                                    g_param_spec_string ("password",
 444                                                         P_("Password"),
 445                                                         P_("The password"),
 446                                                         NULL,
 447                                                         G_PARAM_READWRITE|
 448                                                         G_PARAM_STATIC_NAME|G_PARAM_STATIC_NICK|G_PARAM_STATIC_BLURB));
 449
 450   /**
 451    * GMountOperation:anonymous:
 452    *
 453    * Whether to use an anonymous user when authenticating.
 454    */
 455   g_object_class_install_property (object_class,
 456                                    PROP_ANONYMOUS,
 457                                    g_param_spec_boolean ("anonymous",
 458                                                          P_("Anonymous"),
 459                                                          P_("Whether to use an anonymous user"),
 460                                                          FALSE,
 461                                                          G_PARAM_READWRITE|
 462                                                          G_PARAM_STATIC_NAME|G_PARAM_STATIC_NICK|G_PARAM_STATIC_BLURB));
 463
 464   /**
 465    * GMountOperation:domain:
 466    *
 467    * The domain to use for the mount operation.
 468    */
 469   g_object_class_install_property (object_class,
 470                                    PROP_DOMAIN,
 471                                    g_param_spec_string ("domain",
 472                                                         P_("Domain"),
 473                                                         P_("The domain of the mount operation"),
 474                                                         NULL,
 475                                                         G_PARAM_READWRITE|
 476                                                         G_PARAM_STATIC_NAME|G_PARAM_STATIC_NICK|G_PARAM_STATIC_BLURB));
 477
 478   /**
 479    * GMountOperation:password-save:
 480    *
 481    * Determines if and how the password information should be saved.
 482    */
 483   g_object_class_install_property (object_class,
 484                                    PROP_PASSWORD_SAVE,
 485                                    g_param_spec_enum ("password-save",
 486                                                       P_("Password save"),
 487                                                       P_("How passwords should be saved"),
 488                                                       G_TYPE_PASSWORD_SAVE,
 489                                                       G_PASSWORD_SAVE_NEVER,
 490                                                       G_PARAM_READWRITE|
 491                                                       G_PARAM_STATIC_NAME|G_PARAM_STATIC_NICK|G_PARAM_STATIC_BLURB));
 492
 493   /**
 494    * GMountOperation:choice:
 495    *
 496    * The index of the user's choice when a question is asked during the
 497    * mount operation. See the #GMountOperation::ask-question signal.
 498    */
 499   g_object_class_install_property (object_class,
 500                                    PROP_CHOICE,
 501                                    g_param_spec_int ("choice",
 502                                                      P_("Choice"),
 503                                                      P_("The users choice"),
 504                                                      0, G_MAXINT, 0,
 505                                                      G_PARAM_READWRITE|
 506                                                      G_PARAM_STATIC_NAME|G_PARAM_STATIC_NICK|G_PARAM_STATIC_BLURB));
 507 }
 508
 509 static void
 510 g_mount_operation_init (GMountOperation *operation)
 511 {
 512   operation->priv = g_mount_operation_get_instance_private (operation);
 513 }
 514
 515 /**
 516  * g_mount_operation_new:
 517  *
 518  * Creates a new mount operation.
 519  *
 520  * Returns: a #GMountOperation.
 521  **/
 522 GMountOperation *
 523 g_mount_operation_new (void)
 524 {
 525   return g_object_new (G_TYPE_MOUNT_OPERATION, NULL);
 526 }
 527
 528 /**
 529  * g_mount_operation_get_username:
 530  * @op: a #GMountOperation.
 531  *
 532  * Get the user name from the mount operation.
 533  *
 534  * Returns: a string containing the user name.
 535  **/
 536 const char *
 537 g_mount_operation_get_username (GMountOperation *op)
 538 {
 539   g_return_val_if_fail (G_IS_MOUNT_OPERATION (op), NULL);
 540   return op->priv->user;
 541 }
 542
 543 /**
 544  * g_mount_operation_set_username:
 545  * @op: a #GMountOperation.
 546  * @username: input username.
 547  *
 548  * Sets the user name within @op to @username.
 549  **/
 550 void
 551 g_mount_operation_set_username (GMountOperation *op,
 552                                 const char      *username)
 553 {
 554   g_return_if_fail (G_IS_MOUNT_OPERATION (op));
 555   g_free (op->priv->user);
 556   op->priv->user = g_strdup (username);
 557   g_object_notify (G_OBJECT (op), "username");
 558 }
 559
 560 /**
 561  * g_mount_operation_get_password:
 562  * @op: a #GMountOperation.
 563  *
 564  * Gets a password from the mount operation.
 565  *
 566  * Returns: a string containing the password within @op.
 567  **/
 568 const char *
 569 g_mount_operation_get_password (GMountOperation *op)
 570 {
 571   g_return_val_if_fail (G_IS_MOUNT_OPERATION (op), NULL);
 572   return op->priv->password;
 573 }
 574
 575 /**
 576  * g_mount_operation_set_password:
 577  * @op: a #GMountOperation.
 578  * @password: password to set.
 579  *
 580  * Sets the mount operation's password to @password.
 581  *
 582  **/
 583 void
 584 g_mount_operation_set_password (GMountOperation *op,
 585                                 const char      *password)
 586 {
 587   g_return_if_fail (G_IS_MOUNT_OPERATION (op));
 588   g_free (op->priv->password);
 589   op->priv->password = g_strdup (password);
 590   g_object_notify (G_OBJECT (op), "password");
 591 }
 592
 593 /**
 594  * g_mount_operation_get_anonymous:
 595  * @op: a #GMountOperation.
 596  *
 597  * Check to see whether the mount operation is being used
 598  * for an anonymous user.
 599  *
 600  * Returns: %TRUE if mount operation is anonymous.
 601  **/
 602 gboolean
 603 g_mount_operation_get_anonymous (GMountOperation *op)
 604 {
 605   g_return_val_if_fail (G_IS_MOUNT_OPERATION (op), FALSE);
 606   return op->priv->anonymous;
 607 }
 608
 609 /**
 610  * g_mount_operation_set_anonymous:
 611  * @op: a #GMountOperation.
 612  * @anonymous: boolean value.
 613  *
 614  * Sets the mount operation to use an anonymous user if @anonymous is %TRUE.
 615  **/
 616 void
 617 g_mount_operation_set_anonymous (GMountOperation *op,
 618                                  gboolean         anonymous)
 619 {
 620   GMountOperationPrivate *priv;
 621   g_return_if_fail (G_IS_MOUNT_OPERATION (op));
 622   priv = op->priv;
 623
 624   if (priv->anonymous != anonymous)
 625     {
 626       priv->anonymous = anonymous;
 627       g_object_notify (G_OBJECT (op), "anonymous");
 628     }
 629 }
 630
 631 /**
 632  * g_mount_operation_get_domain:
 633  * @op: a #GMountOperation.
 634  *
 635  * Gets the domain of the mount operation.
 636  *
 637  * Returns: a string set to the domain.
 638  **/
 639 const char *
 640 g_mount_operation_get_domain (GMountOperation *op)
 641 {
 642   g_return_val_if_fail (G_IS_MOUNT_OPERATION (op), NULL);
 643   return op->priv->domain;
 644 }
 645
 646 /**
 647  * g_mount_operation_set_domain:
 648  * @op: a #GMountOperation.
 649  * @domain: the domain to set.
 650  *
 651  * Sets the mount operation's domain.
 652  **/
 653 void
 654 g_mount_operation_set_domain (GMountOperation *op,
 655                               const char      *domain)
 656 {
 657   g_return_if_fail (G_IS_MOUNT_OPERATION (op));
 658   g_free (op->priv->domain);
 659   op->priv->domain = g_strdup (domain);
 660   g_object_notify (G_OBJECT (op), "domain");
 661 }
 662
 663 /**
 664  * g_mount_operation_get_password_save:
 665  * @op: a #GMountOperation.
 666  *
 667  * Gets the state of saving passwords for the mount operation.
 668  *
 669  * Returns: a #GPasswordSave flag.
 670  **/
 671
 672 GPasswordSave
 673 g_mount_operation_get_password_save (GMountOperation *op)
 674 {
 675   g_return_val_if_fail (G_IS_MOUNT_OPERATION (op), G_PASSWORD_SAVE_NEVER);
 676   return op->priv->password_save;
 677 }
 678
 679 /**
 680  * g_mount_operation_set_password_save:
 681  * @op: a #GMountOperation.
 682  * @save: a set of #GPasswordSave flags.
 683  *
 684  * Sets the state of saving passwords for the mount operation.
 685  *
 686  **/
 687 void
 688 g_mount_operation_set_password_save (GMountOperation *op,
 689                                      GPasswordSave    save)
 690 {
 691   GMountOperationPrivate *priv;
 692   g_return_if_fail (G_IS_MOUNT_OPERATION (op));
 693   priv = op->priv;
 694
 695   if (priv->password_save != save)
 696     {
 697       priv->password_save = save;
 698       g_object_notify (G_OBJECT (op), "password-save");
 699     }
 700 }
 701
 702 /**
 703  * g_mount_operation_get_choice:
 704  * @op: a #GMountOperation.
 705  *
 706  * Gets a choice from the mount operation.
 707  *
 708  * Returns: an integer containing an index of the user's choice from
 709  * the choice's list, or %0.
 710  **/
 711 int
 712 g_mount_operation_get_choice (GMountOperation *op)
 713 {
 714   g_return_val_if_fail (G_IS_MOUNT_OPERATION (op), 0);
 715   return op->priv->choice;
 716 }
 717
 718 /**
 719  * g_mount_operation_set_choice:
 720  * @op: a #GMountOperation.
 721  * @choice: an integer.
 722  *
 723  * Sets a default choice for the mount operation.
 724  **/
 725 void
 726 g_mount_operation_set_choice (GMountOperation *op,
 727                               int              choice)
 728 {
 729   GMountOperationPrivate *priv;
 730   g_return_if_fail (G_IS_MOUNT_OPERATION (op));
 731   priv = op->priv;
 732   if (priv->choice != choice)
 733     {
 734       priv->choice = choice;
 735       g_object_notify (G_OBJECT (op), "choice");
 736     }
 737 }
 738
 739 /**
 740  * g_mount_operation_reply:
 741  * @op: a #GMountOperation
 742  * @result: a #GMountOperationResult
 743  *
 744  * Emits the #GMountOperation::reply signal.
 745  **/
 746 void
 747 g_mount_operation_reply (GMountOperation *op,
 748                          GMountOperationResult result)
 749 {
 750   g_return_if_fail (G_IS_MOUNT_OPERATION (op));
 751   g_signal_emit (op, signals[REPLY], 0, result);
 752 }