← Back to branch summary

~ubuntu-branches/ubuntu/natty/gnome-keyring/natty

« back to all changes in this revision

Viewing changes to gcr/gcr-unlock-options-widget.c

  • Committer: Bazaar Package Importer
  • Author(s): Sebastien Bacher
  • Date: 2010-12-06 17:58:28 UTC
  • mfrom: (1.1.65 upstream)
  • Revision ID: james.westby@ubuntu.com-20101206175828-8xjojyxw89qacpq7
Tags: 2.92.92.is.2.32.1-0ubuntu1
* New upstream version
* debian/control.in:
  - updated the libglib requirement
* debian/libgcr0.symbols:
  - new version update
* debian/patches/02_uidir_relocate.patch:
  - updated for the new version
* debian/patches/10_git_fix_cka_trusted_collections.patch:
  - dropped, the patch is the new version
* debian/patches/90_git_pam_headers.patch:
  - dropped, the patch is the new version

Show diffs side-by-side

added added

removed removed

Lines of Context:
gcr/gcr-unlock-options-widget.c
25
25
 
26
26
enum {
27
27
        PROP_0,
28
 
        PROP_UNLOCK_TIMEOUT,
29
 
        PROP_UNLOCK_IDLE
 
28
        PROP_CHOICE,
 
29
        PROP_TTL
30
30
};
31
31
 
32
32
struct _GcrUnlockOptionsWidgetPrivate {
33
33
        GtkBuilder *builder;
34
 
        GtkToggleButton *lock_logout;
35
 
        GtkToggleButton *lock_after;
36
 
        GtkToggleButton *lock_idle;
37
 
        GtkSpinButton *spin_minutes;
 
34
        gchar *choice;
38
35
};
39
36
 
40
37
G_DEFINE_TYPE (GcrUnlockOptionsWidget, gcr_unlock_options_widget, GTK_TYPE_ALIGNMENT);
59
56
        return GTK_SPIN_BUTTON (object);
60
57
}
61
58
 
 
59
static const gchar*
 
60
widget_name_for_option (const gchar *option)
 
61
{
 
62
        g_return_val_if_fail (option, NULL);
 
63
        if (g_str_equal (option, GCR_UNLOCK_OPTION_ALWAYS))
 
64
                return "lock_always_choice";
 
65
        else if (g_str_equal (option, GCR_UNLOCK_OPTION_SESSION))
 
66
                return "lock_session_choice";
 
67
        else if (g_str_equal (option, GCR_UNLOCK_OPTION_TIMEOUT))
 
68
                return "lock_timeout_choice";
 
69
        else if (g_str_equal (option, GCR_UNLOCK_OPTION_IDLE))
 
70
                return "lock_idle_choice";
 
71
        else
 
72
                return NULL;
 
73
}
 
74
 
 
75
static GtkToggleButton*
 
76
widget_button_for_option (GcrUnlockOptionsWidget *self, const gchar *option)
 
77
{
 
78
        const gchar *name = widget_name_for_option (option);
 
79
        g_return_val_if_fail (name, NULL);
 
80
        return builder_get_toggle_button (self->pv->builder, name);
 
81
}
 
82
 
 
83
static const gchar*
 
84
widget_button_to_option (GcrUnlockOptionsWidget *self, GtkToggleButton *button)
 
85
{
 
86
        const gchar *option;
 
87
        g_return_val_if_fail (button, NULL);
 
88
        option = g_object_get_data (G_OBJECT (button), "unlock-choice");
 
89
        g_return_val_if_fail (option, NULL);
 
90
        return option;
 
91
}
 
92
 
62
93
static void
63
 
on_timeout_choices_toggled (GtkToggleButton *unused, GtkBuilder *builder)
 
94
on_choice_toggled (GtkToggleButton *button, GcrUnlockOptionsWidget *self)
64
95
{
65
96
        GtkWidget *spin;
66
97
        GtkToggleButton *after, *idle;
67
98
 
68
 
        spin = GTK_WIDGET (gtk_builder_get_object (builder, "lock_minutes_spin"));
69
 
        after = builder_get_toggle_button (builder, "lock_after_choice");
70
 
        idle = builder_get_toggle_button (builder, "lock_idle_choice");
 
99
        spin = GTK_WIDGET (gtk_builder_get_object (self->pv->builder, "lock_minutes_spin"));
 
100
        after = builder_get_toggle_button (self->pv->builder, "lock_timeout_choice");
 
101
        idle = builder_get_toggle_button (self->pv->builder, "lock_idle_choice");
71
102
        gtk_widget_set_sensitive (spin, gtk_toggle_button_get_active (after) ||
72
103
                                        gtk_toggle_button_get_active (idle));
73
104
 
74
 
}
75
 
 
76
 
static const gchar*
77
 
widget_name_for_option (guint option)
78
 
{
79
 
        switch (option) {
80
 
        case GCR_UNLOCK_OPTION_SESSION:
81
 
                return "lock_logout_choice";
82
 
        case GCR_UNLOCK_OPTION_TIMEOUT:
83
 
                return "lock_after_choice";
84
 
        case GCR_UNLOCK_OPTION_IDLE:
85
 
                return "lock_idle_choice";
86
 
        default:
87
 
                return NULL;
 
105
        if (gtk_toggle_button_get_active (button)) {
 
106
                g_free (self->pv->choice);
 
107
                self->pv->choice = g_strdup (widget_button_to_option (self, button));
88
108
        }
89
109
}
90
110
 
112
132
                gtk_container_add (GTK_CONTAINER (self), widget);
113
133
                gtk_widget_show (widget);
114
134
 
115
 
                button = builder_get_toggle_button (self->pv->builder, "lock_logout_choice");
116
 
                g_signal_connect (button, "toggled", G_CALLBACK (on_timeout_choices_toggled), self->pv->builder);
117
 
                button = builder_get_toggle_button (self->pv->builder, "lock_after_choice");
118
 
                g_signal_connect (button, "toggled", G_CALLBACK (on_timeout_choices_toggled), self->pv->builder);
 
135
                button = builder_get_toggle_button (self->pv->builder, "lock_always_choice");
 
136
                g_signal_connect (button, "toggled", G_CALLBACK (on_choice_toggled), self);
 
137
                g_object_set_data (G_OBJECT (button), "unlock-choice", GCR_UNLOCK_OPTION_ALWAYS);
 
138
 
 
139
                button = builder_get_toggle_button (self->pv->builder, "lock_session_choice");
 
140
                g_signal_connect (button, "toggled", G_CALLBACK (on_choice_toggled), self);
 
141
                g_object_set_data (G_OBJECT (button), "unlock-choice", GCR_UNLOCK_OPTION_SESSION);
 
142
                on_choice_toggled (button, self);
 
143
 
 
144
                button = builder_get_toggle_button (self->pv->builder, "lock_timeout_choice");
 
145
                g_signal_connect (button, "toggled", G_CALLBACK (on_choice_toggled), self);
 
146
                g_object_set_data (G_OBJECT (button), "unlock-choice", GCR_UNLOCK_OPTION_TIMEOUT);
 
147
 
119
148
                button = builder_get_toggle_button (self->pv->builder, "lock_idle_choice");
120
 
                g_signal_connect (button, "toggled", G_CALLBACK (on_timeout_choices_toggled), self->pv->builder);
121
 
                on_timeout_choices_toggled (button, self->pv->builder);
 
149
                g_signal_connect (button, "toggled", G_CALLBACK (on_choice_toggled), self);
 
150
                g_object_set_data (G_OBJECT (button), "unlock-choice", GCR_UNLOCK_OPTION_IDLE);
122
151
        }
123
152
 
124
153
        return obj;
149
178
        GcrUnlockOptionsWidget *self = GCR_UNLOCK_OPTIONS_WIDGET (obj);
150
179
 
151
180
        g_assert (!self->pv->builder);
 
181
        g_free (self->pv->choice);
 
182
        self->pv->choice = NULL;
152
183
 
153
184
        G_OBJECT_CLASS (gcr_unlock_options_widget_parent_class)->finalize (obj);
154
185
}
158
189
                                        GParamSpec *pspec)
159
190
{
160
191
        GcrUnlockOptionsWidget *self = GCR_UNLOCK_OPTIONS_WIDGET (obj);
161
 
        GtkToggleButton *button;
162
 
        GtkSpinButton *spin;
163
 
        gint seconds;
164
 
 
165
 
        spin = builder_get_spin_button (self->pv->builder, "lock_minutes_spin");
166
192
 
167
193
        switch (prop_id) {
168
 
        case PROP_UNLOCK_TIMEOUT:
169
 
                button = builder_get_toggle_button (self->pv->builder, "lock_after_choice");
170
 
                seconds = g_value_get_int (value);
171
 
                if (seconds <= 0) {
172
 
                        gtk_toggle_button_set_active (button, FALSE);
173
 
                } else {
174
 
                        gtk_toggle_button_set_active (button, TRUE);
175
 
                        spin = builder_get_spin_button (self->pv->builder, "lock_minutes_spin");
176
 
                        gtk_spin_button_set_value (spin, seconds / 60);
177
 
                }
 
194
        case PROP_CHOICE:
 
195
                gcr_unlock_options_widget_set_choice (self, g_value_get_string (value));
178
196
                break;
179
 
        case PROP_UNLOCK_IDLE:
180
 
                button = builder_get_toggle_button (self->pv->builder, "lock_idle_choice");
181
 
                seconds = g_value_get_int (value);
182
 
                if (seconds <= 0) {
183
 
                        gtk_toggle_button_set_active (button, FALSE);
184
 
                } else {
185
 
                        gtk_toggle_button_set_active (button, TRUE);
186
 
                        spin = builder_get_spin_button (self->pv->builder, "lock_minutes_spin");
187
 
                        gtk_spin_button_set_value (spin, seconds / 60);
188
 
                }
 
197
        case PROP_TTL:
 
198
                gcr_unlock_options_widget_set_ttl (self, g_value_get_uint (value));
189
199
                break;
190
200
        default:
191
201
                G_OBJECT_WARN_INVALID_PROPERTY_ID (obj, prop_id, pspec);
198
208
                                        GParamSpec *pspec)
199
209
{
200
210
        GcrUnlockOptionsWidget *self = GCR_UNLOCK_OPTIONS_WIDGET (obj);
201
 
        GtkToggleButton *button;
202
 
        GtkSpinButton *spin;
203
 
        gint minutes;
204
 
 
205
 
        spin = builder_get_spin_button (self->pv->builder, "lock_minutes_spin");
206
 
        minutes = gtk_spin_button_get_value_as_int (spin);
207
211
 
208
212
        switch (prop_id) {
209
 
        case PROP_UNLOCK_TIMEOUT:
210
 
                button = builder_get_toggle_button (self->pv->builder, "lock_after_choice");
211
 
                if (!gtk_toggle_button_get_active (button))
212
 
                        g_value_set_int (value, 0);
213
 
                else
214
 
                        g_value_set_int (value, minutes * 60);
 
213
        case PROP_CHOICE:
 
214
                g_value_set_string (value, gcr_unlock_options_widget_get_choice (self));
215
215
                break;
216
 
        case PROP_UNLOCK_IDLE:
217
 
                button = builder_get_toggle_button (self->pv->builder, "lock_idle_choice");
218
 
                if (!gtk_toggle_button_get_active (button))
219
 
                        g_value_set_int (value, 0);
220
 
                else
221
 
                        g_value_set_int (value, minutes * 60);
 
216
        case PROP_TTL:
 
217
                g_value_set_uint (value, gcr_unlock_options_widget_get_ttl (self));
222
218
                break;
223
219
        default:
224
220
                G_OBJECT_WARN_INVALID_PROPERTY_ID (obj, prop_id, pspec);
240
236
        gobject_class->set_property = gcr_unlock_options_widget_set_property;
241
237
        gobject_class->get_property = gcr_unlock_options_widget_get_property;
242
238
 
243
 
        g_object_class_install_property (gobject_class, PROP_UNLOCK_TIMEOUT,
244
 
                       g_param_spec_int ("unlock-timeout", "Unlock Timeout", "Unlock Timeout",
245
 
                                         0, G_MAXINT, 0, G_PARAM_READWRITE));
 
239
        g_object_class_install_property (gobject_class, PROP_CHOICE,
 
240
                       g_param_spec_string ("choice", "Choice", "Unlock Option Choice",
 
241
                                            NULL, G_PARAM_READWRITE));
246
242
 
247
 
        g_object_class_install_property (gobject_class, PROP_UNLOCK_IDLE,
248
 
                       g_param_spec_int ("unlock-idle", "Unlock Idle", "Unlock Idle Timeout",
249
 
                                         0, G_MAXINT, 0, G_PARAM_READWRITE));
 
243
        g_object_class_install_property (gobject_class, PROP_TTL,
 
244
                       g_param_spec_uint ("ttl", "TTL", "Unlock Option Timeout in Seconds",
 
245
                                          0, G_MAXUINT, 0, G_PARAM_READWRITE));
250
246
}
251
247
 
252
248
/* -----------------------------------------------------------------------------
260
256
}
261
257
 
262
258
const gchar*
263
 
gcr_unlock_options_widget_get_label (GcrUnlockOptionsWidget *self, guint option)
 
259
gcr_unlock_options_widget_get_choice (GcrUnlockOptionsWidget *self)
 
260
{
 
261
        g_return_val_if_fail (GCR_IS_UNLOCK_OPTIONS_WIDGET (self), NULL);
 
262
        return self->pv->choice;
 
263
}
 
264
 
 
265
void
 
266
gcr_unlock_options_widget_set_choice (GcrUnlockOptionsWidget *self, const gchar *option)
 
267
{
 
268
        GtkToggleButton *button;
 
269
 
 
270
        g_return_if_fail (GCR_IS_UNLOCK_OPTIONS_WIDGET (self));
 
271
        g_return_if_fail (option);
 
272
 
 
273
        button = widget_button_for_option (self, option);
 
274
        gtk_toggle_button_set_active (button, TRUE);
 
275
}
 
276
 
 
277
guint
 
278
gcr_unlock_options_widget_get_ttl (GcrUnlockOptionsWidget *self)
 
279
{
 
280
        GtkSpinButton *spin;
 
281
        gint amount;
 
282
 
 
283
        g_return_val_if_fail (GCR_IS_UNLOCK_OPTIONS_WIDGET (self), 0);
 
284
 
 
285
        spin = builder_get_spin_button (self->pv->builder, "lock_minutes_spin");
 
286
        amount = gtk_spin_button_get_value_as_int (spin);
 
287
        return amount * 60;
 
288
}
 
289
 
 
290
void
 
291
gcr_unlock_options_widget_set_ttl (GcrUnlockOptionsWidget *self, guint ttl)
 
292
{
 
293
        GtkSpinButton *spin;
 
294
        guint amount;
 
295
 
 
296
        g_return_if_fail (GCR_IS_UNLOCK_OPTIONS_WIDGET (self));
 
297
 
 
298
        amount = ttl / 60;
 
299
        if (!amount || ttl % 60)
 
300
                amount += 1;
 
301
 
 
302
        spin = builder_get_spin_button (self->pv->builder, "lock_minutes_spin");
 
303
        gtk_spin_button_set_value (spin, amount);
 
304
}
 
305
 
 
306
const gchar*
 
307
gcr_unlock_options_widget_get_label (GcrUnlockOptionsWidget *self, const gchar *option)
264
308
{
265
309
        GtkToggleButton *button;
266
310
        const gchar *name;
267
311
 
268
312
        g_return_val_if_fail (GCR_IS_UNLOCK_OPTIONS_WIDGET (self), NULL);
 
313
        g_return_val_if_fail (option, NULL);
269
314
 
270
315
        name = widget_name_for_option (option);
271
316
        g_return_val_if_fail (name, NULL);
277
322
}
278
323
 
279
324
void
280
 
gcr_unlock_options_widget_set_label (GcrUnlockOptionsWidget *self, guint option,
 
325
gcr_unlock_options_widget_set_label (GcrUnlockOptionsWidget *self, const gchar *option,
281
326
                                     const gchar *text)
282
327
{
283
328
        GtkToggleButton *button;
284
329
        const gchar *name;
285
330
 
286
331
        g_return_if_fail (GCR_IS_UNLOCK_OPTIONS_WIDGET (self));
 
332
        g_return_if_fail (option);
287
333
        g_return_if_fail (text);
288
334
 
289
335
        name = widget_name_for_option (option);
294
340
 
295
341
        gtk_button_set_label (GTK_BUTTON (button), text);
296
342
}
 
343
 
 
344
gboolean
 
345
gcr_unlock_options_widget_get_sensitive (GcrUnlockOptionsWidget *self, const gchar *option)
 
346
{
 
347
        GtkToggleButton *button;
 
348
        GtkStateType state;
 
349
 
 
350
        g_return_val_if_fail (GCR_IS_UNLOCK_OPTIONS_WIDGET (self), FALSE);
 
351
        g_return_val_if_fail (option, FALSE);
 
352
 
 
353
        button = widget_button_for_option (self, option);
 
354
        state = gtk_widget_get_state (GTK_WIDGET (button));
 
355
        return (state & GTK_STATE_INSENSITIVE) != GTK_STATE_INSENSITIVE;
 
356
}
 
357
 
 
358
void
 
359
gcr_unlock_options_widget_set_sensitive (GcrUnlockOptionsWidget *self, const gchar *option,
 
360
                                         gboolean sensitive, const gchar *reason)
 
361
{
 
362
        GtkToggleButton *button;
 
363
 
 
364
        g_return_if_fail (GCR_IS_UNLOCK_OPTIONS_WIDGET (self));
 
365
        g_return_if_fail (option);
 
366
 
 
367
        button = widget_button_for_option (self, option);
 
368
        gtk_widget_set_sensitive (GTK_WIDGET (button), sensitive);
 
369
 
 
370
        if (!sensitive && reason)
 
371
                gtk_widget_set_tooltip_text (GTK_WIDGET (button), reason);
 
372
        else if (sensitive)
 
373
                gtk_widget_set_has_tooltip (GTK_WIDGET (button), FALSE);
 
374
}