← Back to branch summary

~ubuntu-branches/ubuntu/oneiric/evince/oneiric-updates

« back to all changes in this revision

Viewing changes to cut-n-paste/evmountoperation/ev-mount-operation.c

  • Committer: Bazaar Package Importer
  • Author(s): Josselin Mouette, Josselin Mouette, Marc 'HE' Brockschmidt
  • Date: 2008-12-31 16:41:58 UTC
  • mfrom: (1.1.36 upstream)
  • mto: (1.5.1 sid)
  • mto: This revision was merged to the branch mainline in revision 109.
  • Revision ID: james.westby@ubuntu.com-20081231164158-xnobl1sokvvc6ho8
Tags: 2.24.2-1
http://bugs.debian.org/506836
[ Josselin Mouette ]
* README.Debian: document that you need to install poppler-data.
  Closes: #506836.

[ Marc 'HE' Brockschmidt ]
* debian/control: Make the Gnome team maintainer. I'm not doing the job
   anyway.

[ Josselin Mouette ]
* New upstream release.
* Require nautilus 2.22 to build the extension for the correct 
  version.

Show diffs side-by-side

added added

removed removed

Lines of Context:
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