← Back to branch summary

~ubuntu-branches/ubuntu/saucy/network-manager-applet/saucy-updates

« back to all changes in this revision

Viewing changes to .pc/applet_adhoc_use_wpa_rsn_part1.patch/src/applet-dialogs.c

  • Committer: Package Import Robot
  • Author(s): Mathieu Trudel-Lapierre
  • Date: 2012-09-07 16:06:37 UTC
  • Revision ID: package-import@ubuntu.com-20120907160637-tf6bw2ya7s6nxulm
Tags: 0.9.6.2-0ubuntu3
https://launchpad.net/bugs/1046918
debian/patches/applet_adhoc_use_wpa_rsn_part1.patch: enable the use of
WPA2/RSN for adhoc again, instead of WPA-None; to provide a way to get a
"good" encryption method available for adhoc networks. (LP: #1046918)

Show diffs side-by-side

added added

removed removed

Lines of Context:
.pc/applet_adhoc_use_wpa_rsn_part1.patch/src/applet-dialogs.c
 
1
/* -*- Mode: C; tab-width: 4; indent-tabs-mode: t; c-basic-offset: 4 -*- */
 
2
/* NetworkManager Wireless Applet -- Display wireless access points and allow user control
 
3
 *
 
4
 * Dan Williams <dcbw@redhat.com>
 
5
 *
 
6
 * This program is free software; you can redistribute it and/or modify
 
7
 * it under the terms of the GNU General Public License as published by
 
8
 * the Free Software Foundation; either version 2 of the License, or
 
9
 * (at your option) any later version.
 
10
 *
 
11
 * This program is distributed in the hope that it will be useful,
 
12
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 
13
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 
14
 * GNU General Public License for more details.
 
15
 *
 
16
 * You should have received a copy of the GNU General Public License along
 
17
 * with this program; if not, write to the Free Software Foundation, Inc.,
 
18
 * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
 
19
 *
 
20
 * (C) Copyright 2008 - 2011 Red Hat, Inc.
 
21
 */
 
22
 
 
23
#include "config.h"
 
24
 
 
25
#include <netinet/in.h>
 
26
#include <sys/socket.h>
 
27
#include <arpa/inet.h>
 
28
#include <ctype.h>
 
29
 
 
30
#include <nm-device-ethernet.h>
 
31
#include <nm-device-wifi.h>
 
32
#include <nm-device-modem.h>
 
33
#include <nm-device-wimax.h>
 
34
 
 
35
#include <nm-setting-connection.h>
 
36
#include <nm-setting-wireless.h>
 
37
#include <nm-setting-wireless-security.h>
 
38
#include <nm-setting-wired.h>
 
39
#include <nm-setting-8021x.h>
 
40
#include <nm-setting-ip4-config.h>
 
41
#include <nm-setting-ip6-config.h>
 
42
#include <nm-vpn-connection.h>
 
43
#include <nm-utils.h>
 
44
 
 
45
#include <gtk/gtk.h>
 
46
#include <glib/gi18n.h>
 
47
 
 
48
#include "applet-dialogs.h"
 
49
 
 
50
 
 
51
static void
 
52
info_dialog_show_error (const char *err)
 
53
{
 
54
        GtkWidget *dialog;
 
55
 
 
56
        dialog = gtk_message_dialog_new_with_markup (NULL, 0, GTK_MESSAGE_ERROR, GTK_BUTTONS_OK,
 
57
                        "<span weight=\"bold\" size=\"larger\">%s</span>\n\n%s", _("Error displaying connection information:"), err);
 
58
        gtk_window_set_position (GTK_WINDOW (dialog), GTK_WIN_POS_CENTER_ALWAYS);
 
59
        gtk_window_present (GTK_WINDOW (dialog));
 
60
        g_signal_connect_swapped (dialog, "response", G_CALLBACK (gtk_widget_destroy), dialog);
 
61
}
 
62
 
 
63
static char *
 
64
ip4_address_as_string (guint32 ip)
 
65
{
 
66
        char *ip_string;
 
67
        struct in_addr tmp_addr;
 
68
 
 
69
        tmp_addr.s_addr = ip;
 
70
        ip_string = g_malloc0 (INET_ADDRSTRLEN + 1);
 
71
        if (!inet_ntop (AF_INET, &tmp_addr, ip_string, INET_ADDRSTRLEN))
 
72
                strcpy (ip_string, "(none)");
 
73
        return ip_string;
 
74
}
 
75
 
 
76
static gchar *
 
77
ip6_address_as_string (const struct in6_addr *ip)
 
78
{
 
79
        char buf[INET6_ADDRSTRLEN];
 
80
 
 
81
        memset (&buf, '\0', sizeof (buf));
 
82
 
 
83
        if (inet_ntop (AF_INET6, ip, buf, INET6_ADDRSTRLEN)) {
 
84
                return g_strdup (buf);
 
85
        } else {
 
86
                int j;
 
87
                GString *ip6_str = g_string_new (NULL);
 
88
                g_string_append_printf (ip6_str, "%02X", ip->s6_addr[0]);
 
89
                for (j = 1; j < 16; j++)
 
90
                        g_string_append_printf (ip6_str, " %02X", ip->s6_addr[j]);
 
91
                g_warning ("%s: error converting IP6 address %s", __func__, ip6_str->str);
 
92
                g_string_free (ip6_str, TRUE);
 
93
                return NULL;
 
94
        }
 
95
}
 
96
 
 
97
static char *
 
98
get_eap_label (NMSettingWirelessSecurity *sec,
 
99
                           NMSetting8021x *s_8021x)
 
100
{
 
101
        GString *str = NULL;
 
102
        char *phase2_str = NULL;
 
103
 
 
104
        if (sec) {
 
105
                const char *key_mgmt = nm_setting_wireless_security_get_key_mgmt (sec);
 
106
                const char *auth_alg = nm_setting_wireless_security_get_auth_alg (sec);
 
107
 
 
108
                if (!strcmp (key_mgmt, "ieee8021x")) {
 
109
                        if (auth_alg && !strcmp (auth_alg, "leap"))
 
110
                                str = g_string_new (_("LEAP"));
 
111
                        else
 
112
                                str = g_string_new (_("Dynamic WEP"));
 
113
                } else if (!strcmp (key_mgmt, "wpa-eap"))
 
114
                        str = g_string_new (_("WPA/WPA2"));
 
115
                else
 
116
                        return NULL;
 
117
        } else if (s_8021x)
 
118
                str = g_string_new ("802.1x");
 
119
 
 
120
        if (!s_8021x)
 
121
                goto out;
 
122
 
 
123
        if (nm_setting_802_1x_get_num_eap_methods (s_8021x)) {
 
124
                char *eap_str = g_ascii_strup (nm_setting_802_1x_get_eap_method (s_8021x, 0), -1);
 
125
                g_string_append_printf (str, ", EAP-%s", eap_str);
 
126
                g_free (eap_str);
 
127
        }
 
128
 
 
129
        if (nm_setting_802_1x_get_phase2_auth (s_8021x))
 
130
                phase2_str = g_ascii_strup (nm_setting_802_1x_get_phase2_auth (s_8021x), -1);
 
131
        else if (nm_setting_802_1x_get_phase2_autheap (s_8021x))
 
132
                phase2_str = g_ascii_strup (nm_setting_802_1x_get_phase2_autheap (s_8021x), -1);
 
133
 
 
134
        if (phase2_str) {
 
135
                g_string_append (str, ", ");
 
136
                g_string_append (str, phase2_str);
 
137
                g_free (phase2_str);
 
138
        }
 
139
        
 
140
out:
 
141
        return g_string_free (str, FALSE);
 
142
}
 
143
 
 
144
static NMConnection *
 
145
get_connection_for_active (NMApplet *applet, NMActiveConnection *active)
 
146
{
 
147
        GSList *list, *iter;
 
148
        NMConnection *connection = NULL;
 
149
        const char *path;
 
150
 
 
151
        path = nm_active_connection_get_connection (active);
 
152
        g_return_val_if_fail (path != NULL, NULL);
 
153
 
 
154
        list = applet_get_all_connections (applet);
 
155
        for (iter = list; iter; iter = g_slist_next (iter)) {
 
156
                NMConnection *candidate = NM_CONNECTION (iter->data);
 
157
 
 
158
                if (!strcmp (nm_connection_get_path (candidate), path)) {
 
159
                        connection = candidate;
 
160
                        break;
 
161
                }
 
162
        }
 
163
        g_slist_free (list);
 
164
 
 
165
        return connection;
 
166
}
 
167
 
 
168
static NMConnection *
 
169
get_connection_for_active_path (NMApplet *applet, const char *active_path)
 
170
{
 
171
        NMActiveConnection *active = NULL;
 
172
        const GPtrArray *connections;
 
173
        int i;
 
174
 
 
175
        if (active_path == NULL)
 
176
                return NULL;
 
177
 
 
178
        connections = nm_client_get_active_connections (applet->nm_client);
 
179
        for (i = 0; connections && (i < connections->len); i++) {
 
180
                NMActiveConnection *candidate = g_ptr_array_index (connections, i);
 
181
                const char *ac_path = nm_object_get_path (NM_OBJECT (candidate));
 
182
 
 
183
                if (g_strcmp0 (ac_path, active_path) == 0) {
 
184
                        active = candidate;
 
185
                        break;
 
186
                }
 
187
        }
 
188
 
 
189
        return active ? get_connection_for_active (applet, active) : NULL;
 
190
}
 
191
 
 
192
static GtkWidget *
 
193
create_info_label (const char *text, gboolean selectable)
 
194
{
 
195
        GtkWidget *label;
 
196
 
 
197
        label = gtk_label_new (text ? text : "");
 
198
        gtk_misc_set_alignment (GTK_MISC (label), 0.0, 0.0);
 
199
        gtk_label_set_selectable (GTK_LABEL (label), selectable);
 
200
        return label;
 
201
}
 
202
 
 
203
static GtkWidget *
 
204
create_info_group_label (const char *text, gboolean selectable)
 
205
{
 
206
        GtkWidget *label;
 
207
        char *markup;
 
208
 
 
209
        label = create_info_label (NULL, selectable);
 
210
        markup = g_markup_printf_escaped ("<span weight=\"bold\">%s</span>", text);
 
211
        gtk_label_set_markup (GTK_LABEL (label), markup);
 
212
        g_free (markup);
 
213
 
 
214
        return label;
 
215
}
 
216
 
 
217
static GtkWidget *
 
218
create_info_label_security (NMConnection *connection)
 
219
{
 
220
        NMSettingConnection *s_con;
 
221
        char *label = NULL;
 
222
        GtkWidget *w = NULL;
 
223
        const char *connection_type;
 
224
 
 
225
        s_con = nm_connection_get_setting_connection (connection);
 
226
        g_assert (s_con);
 
227
 
 
228
        connection_type = nm_setting_connection_get_connection_type (s_con);
 
229
        if (!strcmp (connection_type, NM_SETTING_WIRELESS_SETTING_NAME)) {
 
230
                NMSettingWireless *s_wireless;
 
231
                NMSettingWirelessSecurity *s_wireless_sec;
 
232
                NMSetting8021x *s_8021x;
 
233
                const char *security;
 
234
 
 
235
                s_wireless = nm_connection_get_setting_wireless (connection);
 
236
                s_wireless_sec = nm_connection_get_setting_wireless_security (connection);
 
237
                s_8021x = nm_connection_get_setting_802_1x (connection);
 
238
                security = s_wireless ? nm_setting_wireless_get_security (s_wireless) : NULL;
 
239
 
 
240
                if (security && !strcmp (security, NM_SETTING_WIRELESS_SECURITY_SETTING_NAME) && s_wireless_sec) {
 
241
                        const char *key_mgmt = nm_setting_wireless_security_get_key_mgmt (s_wireless_sec);
 
242
 
 
243
                        if (!strcmp (key_mgmt, "none"))
 
244
                                label = g_strdup (_("WEP"));
 
245
                        else if (!strcmp (key_mgmt, "wpa-none"))
 
246
                                label = g_strdup (_("WPA/WPA2"));
 
247
                        else if (!strcmp (key_mgmt, "wpa-psk"))
 
248
                                label = g_strdup (_("WPA/WPA2"));
 
249
                        else
 
250
                                label = get_eap_label (s_wireless_sec, s_8021x);
 
251
                } else {
 
252
                        label = g_strdup (C_("Wifi/wired security", "None"));
 
253
                }
 
254
        } else if (!strcmp (connection_type, NM_SETTING_WIRED_SETTING_NAME)) {
 
255
                NMSetting8021x *s_8021x;
 
256
 
 
257
                s_8021x = nm_connection_get_setting_802_1x (connection);
 
258
                if (s_8021x)
 
259
                        label = get_eap_label (NULL, s_8021x);
 
260
                else
 
261
                        label = g_strdup (C_("Wifi/wired security", "None"));
 
262
        }
 
263
 
 
264
        if (label)
 
265
                w = create_info_label (label, TRUE);
 
266
        g_free (label);
 
267
 
 
268
        return w;
 
269
}
 
270
 
 
271
static GtkWidget *
 
272
create_info_notebook_label (NMConnection *connection, gboolean is_default)
 
273
{
 
274
        GtkWidget *label;
 
275
        char *str;
 
276
 
 
277
        if (is_default) {
 
278
                str = g_strdup_printf (_("%s (default)"), nm_connection_get_id (connection));
 
279
                label = gtk_label_new (str);
 
280
                g_free (str);
 
281
        } else
 
282
                label = gtk_label_new (nm_connection_get_id (connection));
 
283
 
 
284
        return label;
 
285
}
 
286
 
 
287
typedef struct {
 
288
        NMDevice *device;
 
289
        GtkWidget *label;
 
290
        guint32 id;
 
291
} LabelInfo;
 
292
 
 
293
static void
 
294
device_destroyed (gpointer data, GObject *device_ptr)
 
295
{
 
296
        LabelInfo *info = data;
 
297
 
 
298
        /* Device is destroyed, notify handler won't fire
 
299
         * anymore anyway.  Let the label destroy handler
 
300
         * know it doesn't have to disconnect the callback.
 
301
         */
 
302
        info->device = NULL;
 
303
        info->id = 0;
 
304
}
 
305
 
 
306
static void
 
307
label_destroyed (gpointer data, GObject *label_ptr)
 
308
{
 
309
        LabelInfo *info = data;
 
310
 
 
311
        /* Remove the notify handler from the device */
 
312
        if (info->device) {
 
313
                if (info->id)
 
314
                        g_signal_handler_disconnect (info->device, info->id);
 
315
                /* destroy our info data */
 
316
                g_object_weak_unref (G_OBJECT (info->device), device_destroyed, info);
 
317
                memset (info, 0, sizeof (LabelInfo));
 
318
                g_free (info);
 
319
        }
 
320
}
 
321
 
 
322
static void
 
323
label_info_new (NMDevice *device,
 
324
                GtkWidget *label,
 
325
                const char *notify_prop,
 
326
                GCallback callback)
 
327
{
 
328
        LabelInfo *info;
 
329
 
 
330
        info = g_malloc0 (sizeof (LabelInfo));
 
331
        info->device = device;
 
332
        info->label = label;
 
333
        info->id = g_signal_connect (device, notify_prop, callback, label);
 
334
        g_object_weak_ref (G_OBJECT (label), label_destroyed, info);
 
335
        g_object_weak_ref (G_OBJECT (device), device_destroyed, info);
 
336
}
 
337
 
 
338
static void
 
339
bitrate_changed_cb (GObject *device, GParamSpec *pspec, gpointer user_data)
 
340
{
 
341
        GtkWidget *speed_label = GTK_WIDGET (user_data);
 
342
        guint32 bitrate = 0;
 
343
        char *str = NULL;
 
344
 
 
345
        bitrate = nm_device_wifi_get_bitrate (NM_DEVICE_WIFI (device)) / 1000;
 
346
        if (bitrate)
 
347
                str = g_strdup_printf (_("%u Mb/s"), bitrate);
 
348
 
 
349
        gtk_label_set_text (GTK_LABEL (speed_label), str ? str : C_("Speed", "Unknown"));
 
350
        g_free (str);
 
351
}
 
352
 
 
353
static void
 
354
wimax_cinr_changed_cb (NMDevice *device, GParamSpec *pspec, gpointer user_data)
 
355
{
 
356
        GtkWidget *label = GTK_WIDGET (user_data);
 
357
        gint cinr;
 
358
        char *str = NULL;
 
359
 
 
360
        cinr = nm_device_wimax_get_cinr (NM_DEVICE_WIMAX (device));
 
361
        if (cinr)
 
362
                str = g_strdup_printf (_("%d dB"), cinr);
 
363
 
 
364
        gtk_label_set_text (GTK_LABEL (label), str ? str : C_("WiMAX CINR", "unknown"));
 
365
        g_free (str);
 
366
}
 
367
 
 
368
static void
 
369
wimax_bsid_changed_cb (NMDevice *device, GParamSpec *pspec, gpointer user_data)
 
370
{
 
371
        GtkWidget *label = GTK_WIDGET (user_data);
 
372
        const char *str = NULL;
 
373
 
 
374
        str = nm_device_wimax_get_bsid (NM_DEVICE_WIMAX (device));
 
375
        if (!str)
 
376
                str = C_("WiMAX Base Station ID", "unknown");
 
377
        gtk_label_set_text (GTK_LABEL (label), str);
 
378
}
 
379
 
 
380
static void
 
381
info_dialog_add_page (GtkNotebook *notebook,
 
382
                      NMConnection *connection,
 
383
                      gboolean is_default,
 
384
                      NMDevice *device)
 
385
{
 
386
        GtkTable *table;
 
387
        guint32 speed = 0;
 
388
        char *str;
 
389
        const char *iface, *method = NULL;
 
390
        NMIP4Config *ip4_config;
 
391
        NMIP6Config *ip6_config;
 
392
        const GArray *dns;
 
393
        const GSList *dns6;
 
394
        NMIP4Address *def_addr = NULL;
 
395
        NMIP6Address *def6_addr = NULL;
 
396
        NMSettingIP6Config *s_ip6;
 
397
        guint32 hostmask, network, bcast, netmask;
 
398
        int i, row = 0;
 
399
        GtkWidget* speed_label, *sec_label = NULL;
 
400
        const GSList *addresses;
 
401
        gboolean show_security = FALSE;
 
402
 
 
403
        table = GTK_TABLE (gtk_table_new (12, 2, FALSE));
 
404
        gtk_table_set_col_spacings (table, 12);
 
405
        gtk_table_set_row_spacings (table, 6);
 
406
        gtk_container_set_border_width (GTK_CONTAINER (table), 12);
 
407
 
 
408
        /* Interface */
 
409
        iface = nm_device_get_iface (device);
 
410
        if (NM_IS_DEVICE_ETHERNET (device)) {
 
411
                str = g_strdup_printf (_("Ethernet (%s)"), iface);
 
412
                show_security = TRUE;
 
413
        } else if (NM_IS_DEVICE_WIFI (device)) {
 
414
                str = g_strdup_printf (_("802.11 WiFi (%s)"), iface);
 
415
                show_security = TRUE;
 
416
        } else if (NM_IS_DEVICE_MODEM (device)) {
 
417
                NMDeviceModemCapabilities caps;
 
418
 
 
419
                caps = nm_device_modem_get_current_capabilities (NM_DEVICE_MODEM (device));
 
420
                if (caps & NM_DEVICE_MODEM_CAPABILITY_GSM_UMTS)
 
421
                        str = g_strdup_printf (_("GSM (%s)"), iface);
 
422
                else if (caps & NM_DEVICE_MODEM_CAPABILITY_CDMA_EVDO)
 
423
                        str = g_strdup_printf (_("CDMA (%s)"), iface);
 
424
                else
 
425
                        str = g_strdup_printf (_("Mobile Broadband (%s)"), iface);
 
426
        } else if (NM_IS_DEVICE_WIMAX (device))
 
427
                str = g_strdup_printf (_("WiMAX (%s)"), iface);
 
428
        else
 
429
                str = g_strdup (iface);
 
430
 
 
431
 
 
432
        /*--- General ---*/
 
433
        gtk_table_attach (table, create_info_group_label (_("General"), FALSE),
 
434
                          0, 1, row, row + 1, GTK_FILL, GTK_FILL, 0, 0);
 
435
        row++;
 
436
 
 
437
        gtk_table_attach (table, create_info_label (_("Interface:"), FALSE),
 
438
                          0, 1, row, row + 1, GTK_FILL, GTK_FILL, 0, 0);
 
439
        gtk_table_attach (table, create_info_label (str, TRUE),
 
440
                          1, 2, row, row + 1, GTK_FILL, GTK_FILL, 0, 0);
 
441
        g_free (str);
 
442
        row++;
 
443
 
 
444
        /* Hardware address */
 
445
        str = NULL;
 
446
        if (NM_IS_DEVICE_ETHERNET (device))
 
447
                str = g_strdup (nm_device_ethernet_get_hw_address (NM_DEVICE_ETHERNET (device)));
 
448
        else if (NM_IS_DEVICE_WIFI (device))
 
449
                str = g_strdup (nm_device_wifi_get_hw_address (NM_DEVICE_WIFI (device)));
 
450
        else if (NM_IS_DEVICE_WIMAX (device))
 
451
                str = g_strdup (nm_device_wimax_get_hw_address (NM_DEVICE_WIMAX (device)));
 
452
 
 
453
        gtk_table_attach (table, create_info_label (_("Hardware Address:"), FALSE),
 
454
                          0, 1, row, row + 1, GTK_FILL, GTK_FILL, 0, 0);
 
455
        gtk_table_attach (table, create_info_label (str, TRUE),
 
456
                          1, 2, row, row + 1, GTK_FILL, GTK_FILL, 0, 0);
 
457
        g_free (str);
 
458
        row++;
 
459
 
 
460
        /* Driver */
 
461
        gtk_table_attach (table, create_info_label (_("Driver:"), FALSE),
 
462
                          0, 1, row, row + 1, GTK_FILL, GTK_FILL, 0, 0);
 
463
        gtk_table_attach (table, create_info_label (nm_device_get_driver (device), TRUE),
 
464
                          1, 2, row, row + 1, GTK_FILL, GTK_FILL, 0, 0);
 
465
        row++;
 
466
 
 
467
        speed_label = create_info_label ("", TRUE);
 
468
 
 
469
        /* Speed */
 
470
        str = NULL;
 
471
        if (NM_IS_DEVICE_ETHERNET (device)) {
 
472
                /* Wired speed in Mb/s */
 
473
                speed = nm_device_ethernet_get_speed (NM_DEVICE_ETHERNET (device));
 
474
        } else if (NM_IS_DEVICE_WIFI (device)) {
 
475
                /* Wireless speed in Kb/s */
 
476
                speed = nm_device_wifi_get_bitrate (NM_DEVICE_WIFI (device)) / 1000;
 
477
 
 
478
                label_info_new (device,
 
479
                                speed_label,
 
480
                                "notify::" NM_DEVICE_WIFI_BITRATE,
 
481
                                G_CALLBACK (bitrate_changed_cb));
 
482
        }
 
483
 
 
484
        if (speed)
 
485
                str = g_strdup_printf (_("%u Mb/s"), speed);
 
486
 
 
487
        gtk_label_set_text (GTK_LABEL(speed_label), str ? str : C_("Speed", "Unknown"));
 
488
        g_free (str);
 
489
 
 
490
        gtk_table_attach (table, create_info_label (_("Speed:"), FALSE),
 
491
                          0, 1, row, row + 1, GTK_FILL, GTK_FILL, 0, 0);
 
492
        gtk_table_attach (table, speed_label,
 
493
                          1, 2, row, row + 1, GTK_FILL, GTK_FILL, 0, 0);
 
494
        row++;
 
495
 
 
496
        /* Security */
 
497
        if (show_security) {
 
498
                sec_label = create_info_label_security (connection);
 
499
                if (sec_label) {
 
500
                        gtk_table_attach (table, create_info_label (_("Security:"), FALSE),
 
501
                                              0, 1, row, row + 1, GTK_FILL, GTK_FILL, 0, 0);
 
502
                        gtk_table_attach (table, sec_label,
 
503
                                              1, 2, row, row + 1, GTK_FILL, GTK_FILL, 0, 0);
 
504
                        row++;
 
505
                }
 
506
        }
 
507
 
 
508
        if (NM_IS_DEVICE_WIMAX (device)) {
 
509
                GtkWidget *bsid_label, *cinr_label;
 
510
 
 
511
                /* CINR */
 
512
                cinr_label = create_info_label ("", TRUE);
 
513
                gtk_table_attach (table, create_info_label (_("CINR:"), FALSE),
 
514
                                      0, 1, row, row + 1, GTK_FILL, GTK_FILL, 0, 0);
 
515
                gtk_table_attach (table, cinr_label,
 
516
                                      1, 2, row, row + 1, GTK_FILL, GTK_FILL, 0, 0);
 
517
                label_info_new (device,
 
518
                                cinr_label,
 
519
                                "notify::" NM_DEVICE_WIMAX_CINR,
 
520
                                G_CALLBACK (wimax_cinr_changed_cb));
 
521
                wimax_cinr_changed_cb (device, NULL, cinr_label);
 
522
                row++;
 
523
 
 
524
                /* Base Station ID */
 
525
                bsid_label = create_info_label ("", TRUE);
 
526
                gtk_table_attach (table, create_info_label (_("BSID:"), FALSE),
 
527
                                      0, 1, row, row + 1, GTK_FILL, GTK_FILL, 0, 0);
 
528
                gtk_table_attach (table, bsid_label,
 
529
                                      1, 2, row, row + 1, GTK_FILL, GTK_FILL, 0, 0);
 
530
                label_info_new (device,
 
531
                                bsid_label,
 
532
                                "notify::" NM_DEVICE_WIMAX_BSID,
 
533
                                G_CALLBACK (wimax_bsid_changed_cb));
 
534
                wimax_bsid_changed_cb (device, NULL, bsid_label);
 
535
                row++;
 
536
        }
 
537
 
 
538
        /* Empty line */
 
539
        gtk_table_attach (table, gtk_label_new (""), 0, 2, row, row + 1, GTK_FILL, GTK_FILL, 0, 0);
 
540
        row++;
 
541
 
 
542
        /*--- IPv4 ---*/
 
543
        gtk_table_attach (table, create_info_group_label (_("IPv4"), FALSE),
 
544
                          0, 1, row, row + 1, GTK_FILL, GTK_FILL, 0, 0);
 
545
 
 
546
        row++;
 
547
 
 
548
        ip4_config = nm_device_get_ip4_config (device);
 
549
        addresses = nm_ip4_config_get_addresses (ip4_config);
 
550
        if (g_slist_length ((GSList *) addresses))
 
551
                def_addr = addresses->data;
 
552
 
 
553
        /* Address */
 
554
        gtk_table_attach (table, create_info_label (_("IP Address:"), FALSE),
 
555
                          0, 1, row, row + 1, GTK_FILL, GTK_FILL, 0, 0);
 
556
        str = def_addr ? ip4_address_as_string (nm_ip4_address_get_address (def_addr)) : g_strdup (C_("Address", "Unknown"));
 
557
        gtk_table_attach (table, create_info_label (str, TRUE),
 
558
                          1, 2, row, row + 1, GTK_FILL, GTK_FILL, 0, 0);
 
559
        g_free (str);
 
560
        row++;
 
561
 
 
562
        /* Broadcast */
 
563
        if (def_addr) {
 
564
                netmask = nm_utils_ip4_prefix_to_netmask (nm_ip4_address_get_prefix (def_addr));
 
565
                network = ntohl (nm_ip4_address_get_address (def_addr)) & ntohl (netmask);
 
566
                hostmask = ~ntohl (netmask);
 
567
                bcast = htonl (network | hostmask);
 
568
        }
 
569
 
 
570
        gtk_table_attach (table, create_info_label (_("Broadcast Address:"), FALSE),
 
571
                          0, 1, row, row + 1, GTK_FILL, GTK_FILL, 0, 0);
 
572
        str = def_addr ? ip4_address_as_string (bcast) : g_strdup (C_("Address", "Unknown"));
 
573
        gtk_table_attach (table, create_info_label (str, TRUE),
 
574
                          1, 2, row, row + 1, GTK_FILL, GTK_FILL, 0, 0);
 
575
        g_free (str);
 
576
        row++;
 
577
 
 
578
        /* Prefix */
 
579
        gtk_table_attach (table, create_info_label (_("Subnet Mask:"), FALSE),
 
580
                          0, 1, row, row + 1, GTK_FILL, GTK_FILL, 0, 0);
 
581
        str = def_addr ? ip4_address_as_string (netmask) : g_strdup (C_("Subnet Mask", "Unknown"));
 
582
        gtk_table_attach (table, create_info_label (str, TRUE),
 
583
                          1, 2, row, row + 1, GTK_FILL, GTK_FILL, 0, 0);
 
584
        g_free (str);
 
585
        row++;
 
586
 
 
587
        /* Gateway */
 
588
        if (def_addr && nm_ip4_address_get_gateway (def_addr)) {
 
589
                gtk_table_attach (table, create_info_label (_("Default Route:"), FALSE),
 
590
                                  0, 1, row, row + 1, GTK_FILL, GTK_FILL, 0, 0);
 
591
                str = ip4_address_as_string (nm_ip4_address_get_gateway (def_addr));
 
592
                gtk_table_attach (table, create_info_label (str, TRUE),
 
593
                                  1, 2, row, row + 1, GTK_FILL, GTK_FILL, 0, 0);
 
594
                g_free (str);
 
595
                row++;
 
596
        }
 
597
 
 
598
        /* DNS */
 
599
        dns = def_addr ? nm_ip4_config_get_nameservers (ip4_config) : NULL;
 
600
        if (dns && dns->len) {
 
601
                gtk_table_attach (table, create_info_label (_("Primary DNS:"), FALSE),
 
602
                                  0, 1, row, row + 1, GTK_FILL, GTK_FILL, 0, 0);
 
603
                str = ip4_address_as_string (g_array_index (dns, guint32, 0));
 
604
                gtk_table_attach (table, create_info_label (str, TRUE),
 
605
                                  1, 2, row, row + 1, GTK_FILL, GTK_FILL, 0, 0);
 
606
                g_free (str);
 
607
                row++;
 
608
 
 
609
                if (dns->len > 1) {
 
610
                        gtk_table_attach (table, create_info_label (_("Secondary DNS:"), FALSE),
 
611
                                          0, 1, row, row + 1, GTK_FILL, GTK_FILL, 0, 0);
 
612
                        str = ip4_address_as_string (g_array_index (dns, guint32, 1));
 
613
                        gtk_table_attach (table, create_info_label (str, TRUE),
 
614
                                          1, 2, row, row + 1, GTK_FILL, GTK_FILL, 0, 0);
 
615
                        g_free (str);
 
616
                        row++;
 
617
                }
 
618
 
 
619
                if (dns->len > 2) {
 
620
                        gtk_table_attach (table, create_info_label (_("Ternary DNS:"), FALSE),
 
621
                                          0, 1, row, row + 1, GTK_FILL, GTK_FILL, 0, 0);
 
622
                        str = ip4_address_as_string (g_array_index (dns, guint32, 2));
 
623
                        gtk_table_attach (table, create_info_label (str, TRUE),
 
624
                                          1, 2, row, row + 1, GTK_FILL, GTK_FILL, 0, 0);
 
625
                        g_free (str);
 
626
                        row++;
 
627
                }
 
628
        }
 
629
 
 
630
        /* Empty line */
 
631
        gtk_table_attach (table, gtk_label_new (""), 0, 2, row, row + 1, GTK_FILL, GTK_FILL, 0, 0);
 
632
        row++;
 
633
 
 
634
        /*--- IPv6 ---*/
 
635
        gtk_table_attach (table, create_info_group_label (_("IPv6"), FALSE),
 
636
                          0, 1, row, row + 1, GTK_FILL, GTK_FILL, 0, 0);
 
637
        row++;
 
638
 
 
639
        s_ip6 = nm_connection_get_setting_ip6_config (connection);
 
640
        if (s_ip6)
 
641
                 method = nm_setting_ip6_config_get_method (s_ip6);
 
642
 
 
643
        if (method && !strcmp (method, NM_SETTING_IP6_CONFIG_METHOD_IGNORE)) {
 
644
                gtk_table_attach (table, create_info_label (_("Ignored"), FALSE),
 
645
                                  0, 1, row, row + 1, GTK_FILL, GTK_FILL, 0, 0);
 
646
                row++;
 
647
        }
 
648
 
 
649
        ip6_config = nm_device_get_ip6_config (device);
 
650
        if (ip6_config) {
 
651
                addresses = nm_ip6_config_get_addresses (ip6_config);
 
652
                if (g_slist_length ((GSList *) addresses))
 
653
                        def6_addr = addresses->data;
 
654
        }
 
655
 
 
656
        /* Address */
 
657
        if (def6_addr) {
 
658
                char *tmp_addr;
 
659
                guint32 prefix;
 
660
 
 
661
                gtk_table_attach (table, create_info_label (_("IP Address:"), FALSE),
 
662
                                  0, 1, row, row + 1, GTK_FILL, GTK_FILL, 0, 0);
 
663
                tmp_addr = ip6_address_as_string (nm_ip6_address_get_address (def6_addr));
 
664
                prefix = nm_ip6_address_get_prefix (def6_addr);
 
665
                str = g_strdup_printf ("%s/%d", tmp_addr, prefix);
 
666
                g_free (tmp_addr);
 
667
 
 
668
                gtk_table_attach (table, create_info_label (str, TRUE),
 
669
                                  1, 2, row, row + 1, GTK_FILL, GTK_FILL, 0, 0);
 
670
                g_free (str);
 
671
                row++;
 
672
        }
 
673
 
 
674
        /* Gateway */
 
675
        if (def6_addr && nm_ip6_address_get_gateway (def6_addr)) {
 
676
                gtk_table_attach (table, create_info_label (_("Default Route:"), FALSE),
 
677
                                  0, 1, row, row + 1, GTK_FILL, GTK_FILL, 0, 0);
 
678
                str = ip6_address_as_string (nm_ip6_address_get_gateway (def6_addr));
 
679
                gtk_table_attach (table, create_info_label (str, TRUE),
 
680
                                  1, 2, row, row + 1, GTK_FILL, GTK_FILL, 0, 0);
 
681
                g_free (str);
 
682
                row++;
 
683
        }
 
684
 
 
685
        /* DNS */
 
686
        dns6 = def6_addr ? nm_ip6_config_get_nameservers (ip6_config) : NULL;
 
687
 
 
688
        for (i = 0; dns6 && i < 3 ; dns6 = g_slist_next (dns6), i++) {
 
689
                char *label[] = { "Primary DNS:", "Secondary DNS:", "Ternary DNS:" };
 
690
 
 
691
                gtk_table_attach (table, create_info_label (_(label[i]), FALSE),
 
692
                                  0, 1, row, row + 1, GTK_FILL, GTK_FILL, 0, 0);
 
693
                str = ip6_address_as_string (dns6->data);
 
694
                gtk_table_attach (table, create_info_label (str, TRUE),
 
695
                                  1, 2, row, row + 1, GTK_FILL, GTK_FILL, 0, 0);
 
696
                g_free (str);
 
697
                row++;
 
698
        }
 
699
 
 
700
        gtk_notebook_append_page (notebook, GTK_WIDGET (table),
 
701
                                  create_info_notebook_label (connection, is_default));
 
702
 
 
703
        gtk_widget_show_all (GTK_WIDGET (table));
 
704
}
 
705
 
 
706
static char *
 
707
get_vpn_connection_type (NMConnection *connection)
 
708
{
 
709
        const char *type, *p;
 
710
 
 
711
        /* The service type is in format of "org.freedesktop.NetworkManager.vpnc".
 
712
         * Extract end part after last dot, e.g. "vpnc" */
 
713
        type = nm_setting_vpn_get_service_type (nm_connection_get_setting_vpn (connection));
 
714
        p = strrchr (type, '.');
 
715
        return g_strdup (p ? p + 1 : type);
 
716
}
 
717
 
 
718
/* VPN parameters can be found at:
 
719
 * http://git.gnome.org/browse/network-manager-openvpn/tree/src/nm-openvpn-service.h
 
720
 * http://git.gnome.org/browse/network-manager-vpnc/tree/src/nm-vpnc-service.h
 
721
 * http://git.gnome.org/browse/network-manager-pptp/tree/src/nm-pptp-service.h
 
722
 * http://git.gnome.org/browse/network-manager-openconnect/tree/src/nm-openconnect-service.h
 
723
 * http://git.gnome.org/browse/network-manager-openswan/tree/src/nm-openswan-service.h
 
724
 * See also 'properties' directory in these plugins.
 
725
 */
 
726
static const gchar *
 
727
find_vpn_gateway_key (const char *vpn_type)
 
728
{
 
729
        if (g_strcmp0 (vpn_type, "openvpn") == 0)     return "remote";
 
730
        if (g_strcmp0 (vpn_type, "vpnc") == 0)        return "IPSec gateway";
 
731
        if (g_strcmp0 (vpn_type, "pptp") == 0)        return "gateway";
 
732
        if (g_strcmp0 (vpn_type, "openconnect") == 0) return "gateway";
 
733
        if (g_strcmp0 (vpn_type, "openswan") == 0)    return "right";
 
734
        return "";
 
735
}
 
736
 
 
737
static const gchar *
 
738
find_vpn_username_key (const char *vpn_type)
 
739
{
 
740
        if (g_strcmp0 (vpn_type, "openvpn") == 0)     return "username";
 
741
        if (g_strcmp0 (vpn_type, "vpnc") == 0)        return "Xauth username";
 
742
        if (g_strcmp0 (vpn_type, "pptp") == 0)        return "user";
 
743
        if (g_strcmp0 (vpn_type, "openconnect") == 0) return "username";
 
744
        if (g_strcmp0 (vpn_type, "openswan") == 0)    return "leftxauthusername";
 
745
        return "";
 
746
}
 
747
 
 
748
enum VpnDataItem {
 
749
        VPN_DATA_ITEM_GATEWAY,
 
750
        VPN_DATA_ITEM_USERNAME
 
751
};
 
752
 
 
753
static const gchar *
 
754
get_vpn_data_item (NMConnection *connection, enum VpnDataItem vpn_data_item)
 
755
{
 
756
        const char *key;
 
757
        char *type = get_vpn_connection_type (connection);
 
758
 
 
759
        switch (vpn_data_item) {
 
760
        case VPN_DATA_ITEM_GATEWAY:
 
761
                key = find_vpn_gateway_key (type);
 
762
                break;
 
763
        case VPN_DATA_ITEM_USERNAME:
 
764
                key = find_vpn_username_key (type);
 
765
                break;
 
766
        default:
 
767
                key = "";
 
768
                break;
 
769
        }
 
770
        g_free (type);
 
771
 
 
772
        return nm_setting_vpn_get_data_item (nm_connection_get_setting_vpn (connection), key);
 
773
}
 
774
 
 
775
static void
 
776
info_dialog_add_page_for_vpn (GtkNotebook *notebook,
 
777
                              NMConnection *connection,
 
778
                              NMActiveConnection *active,
 
779
                              NMConnection *parent_con)
 
780
{
 
781
        GtkTable *table;
 
782
        char *str;
 
783
        int row = 0;
 
784
        gboolean is_default = nm_active_connection_get_default (active);
 
785
 
 
786
        table = GTK_TABLE (gtk_table_new (12, 2, FALSE));
 
787
        gtk_table_set_col_spacings (table, 12);
 
788
        gtk_table_set_row_spacings (table, 6);
 
789
        gtk_container_set_border_width (GTK_CONTAINER (table), 12);
 
790
 
 
791
        /*--- General ---*/
 
792
        gtk_table_attach (table, create_info_group_label (_("General"), FALSE),
 
793
                          0, 1, row, row + 1, GTK_FILL, GTK_FILL, 0, 0);
 
794
        row++;
 
795
 
 
796
        str = get_vpn_connection_type (connection);
 
797
        gtk_table_attach (table, create_info_label (_("VPN Type:"), FALSE),
 
798
                          0, 1, row, row + 1, GTK_FILL, GTK_FILL, 0, 0);
 
799
        gtk_table_attach (table, create_info_label (str, TRUE),
 
800
                          1, 2, row, row + 1, GTK_FILL, GTK_FILL, 0, 0);
 
801
        g_free (str);
 
802
        row++;
 
803
 
 
804
        gtk_table_attach (table, create_info_label (_("VPN Gateway:"), FALSE),
 
805
                          0, 1, row, row + 1, GTK_FILL, GTK_FILL, 0, 0);
 
806
        gtk_table_attach (table, create_info_label (get_vpn_data_item (connection, VPN_DATA_ITEM_GATEWAY), TRUE),
 
807
                          1, 2, row, row + 1, GTK_FILL, GTK_FILL, 0, 0);
 
808
        row++;
 
809
 
 
810
        gtk_table_attach (table, create_info_label (_("VPN Username:"), FALSE),
 
811
                          0, 1, row, row + 1, GTK_FILL, GTK_FILL, 0, 0);
 
812
        gtk_table_attach (table, create_info_label (get_vpn_data_item (connection, VPN_DATA_ITEM_USERNAME), TRUE),
 
813
                          1, 2, row, row + 1, GTK_FILL, GTK_FILL, 0, 0);
 
814
        row++;
 
815
 
 
816
        gtk_table_attach (table, create_info_label (_("VPN Banner:"), FALSE),
 
817
                          0, 1, row, row + 1, GTK_FILL, GTK_FILL, 0, 0);
 
818
        gtk_table_attach (table, create_info_label (nm_vpn_connection_get_banner (NM_VPN_CONNECTION (active)), TRUE),
 
819
                          1, 2, row, row + 1, GTK_FILL, GTK_FILL, 0, 0);
 
820
        row++;
 
821
 
 
822
        gtk_table_attach (table, create_info_label (_("Base Connection:"), FALSE),
 
823
                          0, 1, row, row + 1, GTK_FILL, GTK_FILL, 0, 0);
 
824
        gtk_table_attach (table, create_info_label (parent_con ? nm_connection_get_id (parent_con) : _("Unknown"), TRUE),
 
825
                          1, 2, row, row + 1, GTK_FILL, GTK_FILL, 0, 0);
 
826
 
 
827
        gtk_notebook_append_page (notebook, GTK_WIDGET (table),
 
828
                                  create_info_notebook_label (connection, is_default));
 
829
 
 
830
        gtk_widget_show_all (GTK_WIDGET (table));
 
831
}
 
832
 
 
833
static GtkWidget *
 
834
info_dialog_update (NMApplet *applet)
 
835
{
 
836
        GtkNotebook *notebook;
 
837
        const GPtrArray *connections;
 
838
        int i;
 
839
        int pages = 0;
 
840
 
 
841
        notebook = GTK_NOTEBOOK (GTK_WIDGET (gtk_builder_get_object (applet->info_dialog_ui, "info_notebook")));
 
842
 
 
843
        /* Remove old pages */
 
844
        for (i = gtk_notebook_get_n_pages (notebook); i > 0; i--)
 
845
                gtk_notebook_remove_page (notebook, -1);
 
846
 
 
847
        /* Add new pages */
 
848
        connections = nm_client_get_active_connections (applet->nm_client);
 
849
        for (i = 0; connections && (i < connections->len); i++) {
 
850
                NMActiveConnection *active_connection = g_ptr_array_index (connections, i);
 
851
                NMConnection *connection;
 
852
                const GPtrArray *devices;
 
853
 
 
854
                if (nm_active_connection_get_state (active_connection) != NM_ACTIVE_CONNECTION_STATE_ACTIVATED)
 
855
                        continue;
 
856
 
 
857
                connection = get_connection_for_active (applet, active_connection);
 
858
                if (!connection) {
 
859
                        g_warning ("%s: couldn't find the default active connection's NMConnection!", __func__);
 
860
                        continue;
 
861
                }
 
862
 
 
863
                devices = nm_active_connection_get_devices (active_connection);
 
864
                if (devices && devices->len > 0)
 
865
                        info_dialog_add_page (notebook,
 
866
                                              connection,
 
867
                                              nm_active_connection_get_default (active_connection),
 
868
                                              g_ptr_array_index (devices, 0));
 
869
                else {
 
870
                        if (NM_IS_VPN_CONNECTION (active_connection)) {
 
871
                                const char *spec_object = nm_active_connection_get_specific_object (active_connection);
 
872
                                NMConnection *parent_con = get_connection_for_active_path (applet, spec_object);
 
873
 
 
874
                                info_dialog_add_page_for_vpn (notebook, connection, active_connection, parent_con);
 
875
                        } else {
 
876
                                g_warning ("Active connection %s had no devices and was not a VPN!",
 
877
                                           nm_object_get_path (NM_OBJECT (active_connection)));
 
878
                                continue;
 
879
                        }
 
880
                }
 
881
 
 
882
                pages++;
 
883
        }
 
884
 
 
885
        if (pages == 0) {
 
886
                /* Shouldn't really happen but ... */
 
887
                info_dialog_show_error (_("No valid active connections found!"));
 
888
                return NULL;
 
889
        }
 
890
 
 
891
        return GTK_WIDGET (gtk_builder_get_object (applet->info_dialog_ui, "info_dialog"));
 
892
}
 
893
 
 
894
void
 
895
applet_info_dialog_show (NMApplet *applet)
 
896
{
 
897
        GtkWidget *dialog;
 
898
 
 
899
        dialog = info_dialog_update (applet);
 
900
        if (!dialog)
 
901
                return;
 
902
 
 
903
        g_signal_connect (dialog, "delete-event", G_CALLBACK (gtk_widget_hide_on_delete), dialog);
 
904
        g_signal_connect_swapped (dialog, "response", G_CALLBACK (gtk_widget_hide), dialog);
 
905
        gtk_widget_realize (dialog);
 
906
        gtk_window_set_position (GTK_WINDOW(dialog), GTK_WIN_POS_CENTER_ALWAYS);
 
907
        gtk_window_present_with_time (GTK_WINDOW (dialog),
 
908
                gdk_x11_get_server_time (gtk_widget_get_window (dialog)));
 
909
}
 
910
 
 
911
#if !GTK_CHECK_VERSION(2,23,0)
 
912
static void 
 
913
about_dialog_handle_url_cb (GtkAboutDialog *about, const gchar *url, gpointer data)
 
914
{
 
915
        gboolean ret;
 
916
        char *cmdline;
 
917
        GdkScreen *screen;
 
918
 
 
919
        screen = gtk_window_get_screen (GTK_WINDOW (about));
 
920
 
 
921
        cmdline = g_strconcat ("gnome-open ", url, NULL);
 
922
        ret = gdk_spawn_command_line_on_screen (screen, cmdline, NULL);
 
923
        g_free (cmdline);
 
924
 
 
925
        if (ret == FALSE) {
 
926
                cmdline = g_strconcat ("xdg-open ", url, NULL);
 
927
                ret = gdk_spawn_command_line_on_screen (screen, cmdline, NULL);
 
928
                g_free (cmdline);
 
929
        }
 
930
}
 
931
#endif
 
932
 
 
933
void
 
934
applet_about_dialog_show (NMApplet *applet)
 
935
{
 
936
#if !GTK_CHECK_VERSION(2,23,0)
 
937
        gtk_about_dialog_set_url_hook (about_dialog_handle_url_cb, NULL, NULL);
 
938
#endif
 
939
        gtk_show_about_dialog (NULL,
 
940
                               "version", VERSION,
 
941
                               "copyright", _("Copyright \xc2\xa9 2004-2011 Red Hat, Inc.\n"
 
942
                                              "Copyright \xc2\xa9 2005-2008 Novell, Inc.\n"
 
943
                                              "and many other community contributors and translators"),
 
944
                               "comments", _("Notification area applet for managing your network devices and connections."),
 
945
                               "website", "http://www.gnome.org/projects/NetworkManager/",
 
946
                               "website-label", _("NetworkManager Website"),
 
947
                               "logo-icon-name", GTK_STOCK_NETWORK,
 
948
                               NULL);
 
949
}
 
950
 
 
951
GtkWidget *
 
952
applet_warning_dialog_show (const char *message)
 
953
{
 
954
        GtkWidget *dialog;
 
955
 
 
956
        dialog = gtk_message_dialog_new (NULL, GTK_DIALOG_MODAL, GTK_MESSAGE_ERROR, GTK_BUTTONS_OK, message, NULL);
 
957
 
 
958
        /* Bash focus-stealing prevention in the face */
 
959
        gtk_window_set_position (GTK_WINDOW (dialog), GTK_WIN_POS_CENTER_ALWAYS);
 
960
        gtk_window_set_default_icon_name (GTK_STOCK_DIALOG_ERROR);
 
961
        gtk_window_set_title (GTK_WINDOW (dialog), _("Missing resources"));
 
962
        gtk_widget_realize (dialog);
 
963
        gtk_widget_show (dialog);
 
964
        gtk_window_present_with_time (GTK_WINDOW (dialog),
 
965
                gdk_x11_get_server_time (gtk_widget_get_window (dialog)));
 
966
 
 
967
        g_signal_connect_swapped (dialog, "response",
 
968
                                  G_CALLBACK (gtk_widget_destroy),
 
969
                                  dialog);
 
970
        return dialog;
 
971
}
 
972
 
 
973
GtkWidget *
 
974
applet_mobile_password_dialog_new (NMConnection *connection,
 
975
                                   GtkEntry **out_secret_entry)
 
976
{
 
977
        GtkDialog *dialog;
 
978
        GtkWidget *w;
 
979
        GtkBox *box = NULL, *vbox = NULL;
 
980
        NMSettingConnection *s_con;
 
981
        char *tmp;
 
982
        const char *id;
 
983
 
 
984
        dialog = GTK_DIALOG (gtk_dialog_new ());
 
985
        gtk_window_set_modal (GTK_WINDOW (dialog), TRUE);
 
986
        gtk_window_set_position (GTK_WINDOW (dialog), GTK_WIN_POS_CENTER_ALWAYS);
 
987
        gtk_window_set_title (GTK_WINDOW (dialog), _("Mobile broadband network password"));
 
988
 
 
989
        w = gtk_dialog_add_button (dialog, GTK_STOCK_CANCEL, GTK_RESPONSE_REJECT);
 
990
        w = gtk_dialog_add_button (dialog, GTK_STOCK_OK, GTK_RESPONSE_OK);
 
991
        gtk_window_set_default (GTK_WINDOW (dialog), w);
 
992
 
 
993
        s_con = nm_connection_get_setting_connection (connection);
 
994
        id = nm_setting_connection_get_id (s_con);
 
995
        g_assert (id);
 
996
        tmp = g_strdup_printf (_("A password is required to connect to '%s'."), id);
 
997
        w = gtk_label_new (tmp);
 
998
        g_free (tmp);
 
999
 
 
1000
        vbox = GTK_BOX (gtk_dialog_get_content_area (dialog));
 
1001
 
 
1002
        gtk_box_pack_start (vbox, w, TRUE, TRUE, 0);
 
1003
 
 
1004
        w = gtk_alignment_new (0.5, 0.5, 0, 1.0);
 
1005
        gtk_box_pack_start (vbox, w, TRUE, TRUE, 0);
 
1006
 
 
1007
#if GTK_CHECK_VERSION(3,1,6)
 
1008
        box = GTK_BOX (gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 6));
 
1009
#else
 
1010
        box = GTK_BOX (gtk_hbox_new (FALSE, 6));
 
1011
#endif
 
1012
        gtk_container_set_border_width (GTK_CONTAINER (box), 6);
 
1013
        gtk_container_add (GTK_CONTAINER (w), GTK_WIDGET (box));
 
1014
 
 
1015
        gtk_box_pack_start (box, gtk_label_new (_("Password:")), FALSE, FALSE, 0);
 
1016
 
 
1017
        w = gtk_entry_new ();
 
1018
        *out_secret_entry = GTK_ENTRY (w);
 
1019
        gtk_entry_set_activates_default (GTK_ENTRY (w), TRUE);
 
1020
        gtk_box_pack_start (box, w, FALSE, FALSE, 0);
 
1021
 
 
1022
        gtk_widget_show_all (GTK_WIDGET (vbox));
 
1023
        return GTK_WIDGET (dialog);
 
1024
}
 
1025
 
 
1026
/**********************************************************************/
 
1027
 
 
1028
static void
 
1029
mpd_entry_changed (GtkWidget *widget, gpointer user_data)
 
1030
{
 
1031
        GtkWidget *dialog = GTK_WIDGET (user_data);
 
1032
        GtkBuilder *builder = g_object_get_data (G_OBJECT (dialog), "builder");
 
1033
        GtkWidget *entry;
 
1034
        guint32 minlen;
 
1035
        gboolean valid = FALSE;
 
1036
        const char *text, *text2 = NULL, *text3 = NULL;
 
1037
        gboolean match23;
 
1038
 
 
1039
        g_return_if_fail (builder != NULL);
 
1040
 
 
1041
        entry = GTK_WIDGET (gtk_builder_get_object (builder, "code1_entry"));
 
1042
        if (g_object_get_data (G_OBJECT (entry), "active")) {
 
1043
                minlen = GPOINTER_TO_UINT (g_object_get_data (G_OBJECT (entry), "minlen"));
 
1044
                text = gtk_entry_get_text (GTK_ENTRY (entry));
 
1045
                if (text && (strlen (text) < minlen))
 
1046
                        goto done;
 
1047
        }
 
1048
 
 
1049
        entry = GTK_WIDGET (gtk_builder_get_object (builder, "code2_entry"));
 
1050
        if (g_object_get_data (G_OBJECT (entry), "active")) {
 
1051
                minlen = GPOINTER_TO_UINT (g_object_get_data (G_OBJECT (entry), "minlen"));
 
1052
                text2 = gtk_entry_get_text (GTK_ENTRY (entry));
 
1053
                if (text2 && (strlen (text2) < minlen))
 
1054
                        goto done;
 
1055
        }
 
1056
 
 
1057
        entry = GTK_WIDGET (gtk_builder_get_object (builder, "code3_entry"));
 
1058
        if (g_object_get_data (G_OBJECT (entry), "active")) {
 
1059
                minlen = GPOINTER_TO_UINT (g_object_get_data (G_OBJECT (entry), "minlen"));
 
1060
                text3 = gtk_entry_get_text (GTK_ENTRY (entry));
 
1061
                if (text3 && (strlen (text3) < minlen))
 
1062
                        goto done;
 
1063
        }
 
1064
 
 
1065
        /* Validate 2 & 3 if they are supposed to be the same */
 
1066
        match23 = GPOINTER_TO_UINT (g_object_get_data (G_OBJECT (dialog), "match23"));
 
1067
        if (match23) {
 
1068
                if (!text2 || !text3 || strcmp (text2, text3))
 
1069
                        goto done;
 
1070
        }
 
1071
 
 
1072
        valid = TRUE;
 
1073
 
 
1074
done:
 
1075
        /* Clear any error text in the progress label now that the user has changed something */
 
1076
        widget = GTK_WIDGET (gtk_builder_get_object (builder, "progress_label"));
 
1077
        gtk_label_set_text (GTK_LABEL (widget), "");
 
1078
 
 
1079
        widget = GTK_WIDGET (gtk_builder_get_object (builder, "unlock_button"));
 
1080
        g_warn_if_fail (widget != NULL);
 
1081
        gtk_widget_set_sensitive (widget, valid);
 
1082
        if (valid)
 
1083
                gtk_widget_grab_default (widget);
 
1084
}
 
1085
 
 
1086
void
 
1087
applet_mobile_pin_dialog_destroy (GtkWidget *widget)
 
1088
{
 
1089
        gtk_widget_hide (widget);
 
1090
        gtk_widget_destroy (widget);
 
1091
}
 
1092
 
 
1093
static void
 
1094
mpd_cancel_dialog (GtkDialog *dialog)
 
1095
{
 
1096
        gtk_dialog_response (dialog, GTK_RESPONSE_CANCEL);
 
1097
}
 
1098
 
 
1099
static void
 
1100
show_toggled_cb (GtkWidget *button, gpointer user_data)
 
1101
{
 
1102
        GtkWidget *dialog = GTK_WIDGET (user_data);
 
1103
        gboolean show;
 
1104
        GtkWidget *widget;
 
1105
        GtkBuilder *builder;
 
1106
 
 
1107
        builder = g_object_get_data (G_OBJECT (dialog), "builder");
 
1108
        g_return_if_fail (builder != NULL);
 
1109
 
 
1110
        show = gtk_toggle_button_get_active (GTK_TOGGLE_BUTTON (button));
 
1111
 
 
1112
        widget = GTK_WIDGET (gtk_builder_get_object (builder, "code1_entry"));
 
1113
        gtk_entry_set_visibility (GTK_ENTRY (widget), show);
 
1114
        widget = GTK_WIDGET (gtk_builder_get_object (builder, "code2_entry"));
 
1115
        gtk_entry_set_visibility (GTK_ENTRY (widget), show);
 
1116
        widget = GTK_WIDGET (gtk_builder_get_object (builder, "code3_entry"));
 
1117
        gtk_entry_set_visibility (GTK_ENTRY (widget), show);
 
1118
}
 
1119
 
 
1120
GtkWidget *
 
1121
applet_mobile_pin_dialog_new (const char *title,
 
1122
                              const char *header,
 
1123
                              const char *desc,
 
1124
                              const char *show_password_label,
 
1125
                              gboolean show_auto_unlock_checkbox)
 
1126
{
 
1127
        char *str;
 
1128
        GtkWidget *dialog;
 
1129
        GtkWidget *widget;
 
1130
        GError *error = NULL;
 
1131
        GtkBuilder *builder;
 
1132
 
 
1133
        g_return_val_if_fail (title != NULL, NULL);
 
1134
        g_return_val_if_fail (header != NULL, NULL);
 
1135
        g_return_val_if_fail (desc != NULL, NULL);
 
1136
        g_return_val_if_fail (show_password_label != NULL, NULL);
 
1137
 
 
1138
        builder = gtk_builder_new ();
 
1139
 
 
1140
        if (!gtk_builder_add_from_file (builder, UIDIR "/gsm-unlock.ui", &error)) {
 
1141
                g_warning ("Couldn't load builder file: %s", error->message);
 
1142
                g_error_free (error);
 
1143
                g_object_unref (builder);
 
1144
                return NULL;
 
1145
        }
 
1146
 
 
1147
        dialog = GTK_WIDGET (gtk_builder_get_object (builder, "unlock_dialog"));
 
1148
        if (!dialog) {
 
1149
                g_object_unref (builder);
 
1150
                g_return_val_if_fail (dialog != NULL, NULL);
 
1151
        }
 
1152
 
 
1153
        g_object_set_data_full (G_OBJECT (dialog), "builder", builder, (GDestroyNotify) g_object_unref);
 
1154
 
 
1155
        gtk_window_set_position (GTK_WINDOW(dialog), GTK_WIN_POS_CENTER_ALWAYS);
 
1156
        gtk_window_set_title (GTK_WINDOW (dialog), title);
 
1157
 
 
1158
        widget = GTK_WIDGET (gtk_builder_get_object (builder, "header_label"));
 
1159
        str = g_strdup_printf ("<span size=\"larger\" weight=\"bold\">%s</span>", header);
 
1160
        gtk_label_set_use_markup (GTK_LABEL (widget), TRUE);
 
1161
        gtk_label_set_markup (GTK_LABEL (widget), str);
 
1162
        g_free (str);
 
1163
 
 
1164
        widget = GTK_WIDGET (gtk_builder_get_object (builder, "desc_label"));
 
1165
        gtk_label_set_text (GTK_LABEL (widget), desc);
 
1166
 
 
1167
        widget = GTK_WIDGET (gtk_builder_get_object (builder, "show_password_checkbutton"));
 
1168
        gtk_button_set_label (GTK_BUTTON (widget), show_password_label);
 
1169
        gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (widget), FALSE);
 
1170
        g_signal_connect (widget, "toggled", G_CALLBACK (show_toggled_cb), dialog);
 
1171
        show_toggled_cb (widget, dialog);
 
1172
 
 
1173
        g_signal_connect (dialog, "delete-event", G_CALLBACK (mpd_cancel_dialog), NULL);
 
1174
 
 
1175
        widget = GTK_WIDGET (gtk_builder_get_object (builder, "save_checkbutton"));
 
1176
        if (show_auto_unlock_checkbox)
 
1177
                g_object_set_data (G_OBJECT (widget), "active", GUINT_TO_POINTER (TRUE));
 
1178
 
 
1179
        mpd_entry_changed (NULL, dialog);
 
1180
 
 
1181
        return dialog;
 
1182
}
 
1183
 
 
1184
void
 
1185
applet_mobile_pin_dialog_present (GtkWidget *dialog, gboolean now)
 
1186
{
 
1187
        GtkBuilder *builder;
 
1188
        GtkWidget *widget;
 
1189
 
 
1190
        g_return_if_fail (dialog != NULL);
 
1191
        builder = g_object_get_data (G_OBJECT (dialog), "builder");
 
1192
        g_return_if_fail (builder != NULL);
 
1193
 
 
1194
        gtk_widget_show_all (dialog);
 
1195
 
 
1196
        widget = GTK_WIDGET (gtk_builder_get_object (builder, "progress_hbox"));
 
1197
        gtk_widget_hide (widget);
 
1198
 
 
1199
        /* Hide inactive entries */
 
1200
 
 
1201
        widget = GTK_WIDGET (gtk_builder_get_object (builder, "code2_entry"));
 
1202
        if (!g_object_get_data (G_OBJECT (widget), "active")) {
 
1203
                gtk_widget_hide (widget);
 
1204
                widget = GTK_WIDGET (gtk_builder_get_object (builder, "code2_label"));
 
1205
                gtk_widget_hide (widget);
 
1206
        }
 
1207
 
 
1208
        widget = GTK_WIDGET (gtk_builder_get_object (builder, "code3_entry"));
 
1209
        if (!g_object_get_data (G_OBJECT (widget), "active")) {
 
1210
                gtk_widget_hide (widget);
 
1211
                widget = GTK_WIDGET (gtk_builder_get_object (builder, "code3_label"));
 
1212
                gtk_widget_hide (widget);
 
1213
        }
 
1214
 
 
1215
        widget = GTK_WIDGET (gtk_builder_get_object (builder, "save_checkbutton"));
 
1216
        if (!g_object_get_data (G_OBJECT (widget), "active"))
 
1217
                gtk_widget_hide (widget);
 
1218
 
 
1219
        /* Need to resize the dialog after hiding widgets */
 
1220
        gtk_window_resize (GTK_WINDOW (dialog), 400, 100);
 
1221
 
 
1222
        /* Show the dialog */
 
1223
        gtk_widget_realize (dialog);
 
1224
        if (now)
 
1225
                gtk_window_present_with_time (GTK_WINDOW (dialog),
 
1226
                        gdk_x11_get_server_time (gtk_widget_get_window (dialog)));
 
1227
        else
 
1228
                gtk_window_present (GTK_WINDOW (dialog));
 
1229
}
 
1230
 
 
1231
static void
 
1232
mpd_entry_filter (GtkEntry *entry,
 
1233
                  const char *text,
 
1234
                  gint length,
 
1235
                  gint *position,
 
1236
                  gpointer user_data)
 
1237
{
 
1238
        GtkEditable *editable = GTK_EDITABLE (entry);
 
1239
        int i, count = 0;
 
1240
        gchar *result = g_malloc0 (length);
 
1241
 
 
1242
        /* Digits only */
 
1243
        for (i = 0; i < length; i++) {
 
1244
                if (isdigit (text[i]))
 
1245
                        result[count++] = text[i];
 
1246
        }
 
1247
 
 
1248
        if (count > 0) {
 
1249
                g_signal_handlers_block_by_func (G_OBJECT (editable),
 
1250
                                                 G_CALLBACK (mpd_entry_filter),
 
1251
                                                 user_data);
 
1252
                gtk_editable_insert_text (editable, result, count, position);
 
1253
                g_signal_handlers_unblock_by_func (G_OBJECT (editable),
 
1254
                                                   G_CALLBACK (mpd_entry_filter),
 
1255
                                                   user_data);
 
1256
        }
 
1257
        g_signal_stop_emission_by_name (G_OBJECT (editable), "insert-text");
 
1258
        g_free (result);
 
1259
}
 
1260
 
 
1261
static void
 
1262
mpd_set_entry (GtkWidget *dialog,
 
1263
               const char *entry_name,
 
1264
               const char *label_name,
 
1265
               const char *label,
 
1266
               guint32 minlen,
 
1267
               guint32 maxlen)
 
1268
{
 
1269
        GtkBuilder *builder;
 
1270
        GtkWidget *widget;
 
1271
        gboolean entry2_active = FALSE;
 
1272
        gboolean entry3_active = FALSE;
 
1273
 
 
1274
        g_return_if_fail (dialog != NULL);
 
1275
        builder = g_object_get_data (G_OBJECT (dialog), "builder");
 
1276
        g_return_if_fail (builder != NULL);
 
1277
 
 
1278
        widget = GTK_WIDGET (gtk_builder_get_object (builder, label_name));
 
1279
        gtk_label_set_text (GTK_LABEL (widget), label);
 
1280
 
 
1281
        widget = GTK_WIDGET (gtk_builder_get_object (builder, entry_name));
 
1282
        g_signal_connect (widget, "changed", G_CALLBACK (mpd_entry_changed), dialog);
 
1283
        g_signal_connect (widget, "insert-text", G_CALLBACK (mpd_entry_filter), NULL);
 
1284
 
 
1285
        if (maxlen)
 
1286
                gtk_entry_set_max_length (GTK_ENTRY (widget), maxlen);
 
1287
        g_object_set_data (G_OBJECT (widget), "minlen", GUINT_TO_POINTER (minlen));
 
1288
 
 
1289
        /* Tag it so we know it's active */
 
1290
        g_object_set_data (G_OBJECT (widget), "active", GUINT_TO_POINTER (1));
 
1291
 
 
1292
        /* Make a single-entry dialog look better */
 
1293
        widget = GTK_WIDGET (gtk_builder_get_object (builder, "code2_entry"));
 
1294
        entry2_active = GPOINTER_TO_UINT (g_object_get_data (G_OBJECT (widget), "active"));
 
1295
        widget = GTK_WIDGET (gtk_builder_get_object (builder, "code3_entry"));
 
1296
        entry3_active = GPOINTER_TO_UINT (g_object_get_data (G_OBJECT (widget), "active"));
 
1297
 
 
1298
        widget = GTK_WIDGET (gtk_builder_get_object (builder, "table14"));
 
1299
        if (entry2_active || entry3_active)
 
1300
                gtk_table_set_row_spacings (GTK_TABLE (widget), 6);
 
1301
        else
 
1302
                gtk_table_set_row_spacings (GTK_TABLE (widget), 0);
 
1303
 
 
1304
        mpd_entry_changed (NULL, dialog);
 
1305
}
 
1306
 
 
1307
void
 
1308
applet_mobile_pin_dialog_set_entry1 (GtkWidget *dialog,
 
1309
                                     const char *label,
 
1310
                                     guint32 minlen,
 
1311
                                     guint32 maxlen)
 
1312
{
 
1313
        mpd_set_entry (dialog, "code1_entry", "code1_label", label, minlen, maxlen);
 
1314
}
 
1315
 
 
1316
void
 
1317
applet_mobile_pin_dialog_set_entry2 (GtkWidget *dialog,
 
1318
                                     const char *label,
 
1319
                                     guint32 minlen,
 
1320
                                     guint32 maxlen)
 
1321
{
 
1322
        mpd_set_entry (dialog, "code2_entry", "code2_label", label, minlen, maxlen);
 
1323
}
 
1324
 
 
1325
void
 
1326
applet_mobile_pin_dialog_set_entry3 (GtkWidget *dialog,
 
1327
                                     const char *label,
 
1328
                                     guint32 minlen,
 
1329
                                     guint32 maxlen)
 
1330
{
 
1331
        mpd_set_entry (dialog, "code3_entry", "code3_label", label, minlen, maxlen);
 
1332
}
 
1333
 
 
1334
void applet_mobile_pin_dialog_match_23 (GtkWidget *dialog, gboolean match)
 
1335
{
 
1336
        g_return_if_fail (dialog != NULL);
 
1337
 
 
1338
        g_object_set_data (G_OBJECT (dialog), "match23", GUINT_TO_POINTER (match));
 
1339
}
 
1340
 
 
1341
static const char *
 
1342
mpd_get_entry (GtkWidget *dialog, const char *entry_name)
 
1343
{
 
1344
        GtkBuilder *builder;
 
1345
        GtkWidget *widget;
 
1346
 
 
1347
        g_return_val_if_fail (dialog != NULL, NULL);
 
1348
        builder = g_object_get_data (G_OBJECT (dialog), "builder");
 
1349
        g_return_val_if_fail (builder != NULL, NULL);
 
1350
 
 
1351
        widget = GTK_WIDGET (gtk_builder_get_object (builder, entry_name));
 
1352
        return gtk_entry_get_text (GTK_ENTRY (widget));
 
1353
}
 
1354
 
 
1355
const char *
 
1356
applet_mobile_pin_dialog_get_entry1 (GtkWidget *dialog)
 
1357
{
 
1358
        return mpd_get_entry (dialog, "code1_entry");
 
1359
}
 
1360
 
 
1361
const char *
 
1362
applet_mobile_pin_dialog_get_entry2 (GtkWidget *dialog)
 
1363
{
 
1364
        return mpd_get_entry (dialog, "code2_entry");
 
1365
}
 
1366
 
 
1367
const char *
 
1368
applet_mobile_pin_dialog_get_entry3 (GtkWidget *dialog)
 
1369
{
 
1370
        return mpd_get_entry (dialog, "code3_entry");
 
1371
}
 
1372
 
 
1373
gboolean
 
1374
applet_mobile_pin_dialog_get_auto_unlock (GtkWidget *dialog)
 
1375
{
 
1376
        GtkBuilder *builder;
 
1377
        GtkWidget *widget;
 
1378
 
 
1379
        g_return_val_if_fail (dialog != NULL, FALSE);
 
1380
        builder = g_object_get_data (G_OBJECT (dialog), "builder");
 
1381
        g_return_val_if_fail (builder != NULL, FALSE);
 
1382
 
 
1383
        widget = GTK_WIDGET (gtk_builder_get_object (builder, "save_checkbutton"));
 
1384
        return gtk_toggle_button_get_active (GTK_TOGGLE_BUTTON (widget));
 
1385
}
 
1386
 
 
1387
void
 
1388
applet_mobile_pin_dialog_start_spinner (GtkWidget *dialog, const char *text)
 
1389
{
 
1390
        GtkBuilder *builder;
 
1391
        GtkWidget *spinner, *widget, *hbox, *align;
 
1392
 
 
1393
        g_return_if_fail (dialog != NULL);
 
1394
        g_return_if_fail (text != NULL);
 
1395
 
 
1396
        builder = g_object_get_data (G_OBJECT (dialog), "builder");
 
1397
        g_return_if_fail (builder != NULL);
 
1398
 
 
1399
        spinner = gtk_spinner_new ();
 
1400
        g_return_if_fail (spinner != NULL);
 
1401
        g_object_set_data (G_OBJECT (dialog), "spinner", spinner);
 
1402
 
 
1403
        align = GTK_WIDGET (gtk_builder_get_object (builder, "spinner_alignment"));
 
1404
        gtk_container_add (GTK_CONTAINER (align), spinner);
 
1405
        gtk_spinner_start (GTK_SPINNER (spinner));
 
1406
 
 
1407
        widget = GTK_WIDGET (gtk_builder_get_object (builder, "progress_label"));
 
1408
        gtk_label_set_text (GTK_LABEL (widget), text);
 
1409
        gtk_widget_show (widget);
 
1410
 
 
1411
        hbox = GTK_WIDGET (gtk_builder_get_object (builder, "progress_hbox"));
 
1412
        gtk_widget_show_all (hbox);
 
1413
 
 
1414
        /* Desensitize everything while spinning */
 
1415
        widget = GTK_WIDGET (gtk_builder_get_object (builder, "code1_entry"));
 
1416
        gtk_widget_set_sensitive (widget, FALSE);
 
1417
        widget = GTK_WIDGET (gtk_builder_get_object (builder, "code2_entry"));
 
1418
        gtk_widget_set_sensitive (widget, FALSE);
 
1419
        widget = GTK_WIDGET (gtk_builder_get_object (builder, "code3_entry"));
 
1420
        gtk_widget_set_sensitive (widget, FALSE);
 
1421
        widget = GTK_WIDGET (gtk_builder_get_object (builder, "unlock_button"));
 
1422
        gtk_widget_set_sensitive (widget, FALSE);
 
1423
        widget = GTK_WIDGET (gtk_builder_get_object (builder, "unlock_cancel_button"));
 
1424
        gtk_widget_set_sensitive (widget, FALSE);
 
1425
 
 
1426
        widget = GTK_WIDGET (gtk_builder_get_object (builder, "show_password_checkbutton"));
 
1427
        gtk_widget_set_sensitive (widget, FALSE);
 
1428
}
 
1429
 
 
1430
void
 
1431
applet_mobile_pin_dialog_stop_spinner (GtkWidget *dialog, const char *text)
 
1432
{
 
1433
        GtkBuilder *builder;
 
1434
        GtkWidget *spinner, *widget, *align;
 
1435
 
 
1436
        g_return_if_fail (dialog != NULL);
 
1437
 
 
1438
        builder = g_object_get_data (G_OBJECT (dialog), "builder");
 
1439
        g_return_if_fail (builder != NULL);
 
1440
 
 
1441
        spinner = g_object_get_data (G_OBJECT (dialog), "spinner");
 
1442
        g_return_if_fail (spinner != NULL);
 
1443
        gtk_spinner_stop (GTK_SPINNER (spinner));
 
1444
        g_object_set_data (G_OBJECT (dialog), "spinner", NULL);
 
1445
 
 
1446
        /* Remove it from the alignment */
 
1447
        align = GTK_WIDGET (gtk_builder_get_object (builder, "spinner_alignment"));
 
1448
        gtk_container_remove (GTK_CONTAINER (align), spinner);
 
1449
 
 
1450
        widget = GTK_WIDGET (gtk_builder_get_object (builder, "progress_label"));
 
1451
        if (text) {
 
1452
                gtk_label_set_text (GTK_LABEL (widget), text);
 
1453
                gtk_widget_show (widget);
 
1454
        } else
 
1455
                gtk_widget_hide (widget);
 
1456
 
 
1457
        /* Resensitize stuff */
 
1458
        widget = GTK_WIDGET (gtk_builder_get_object (builder, "code1_entry"));
 
1459
        gtk_widget_set_sensitive (widget, TRUE);
 
1460
        widget = GTK_WIDGET (gtk_builder_get_object (builder, "code2_entry"));
 
1461
        gtk_widget_set_sensitive (widget, TRUE);
 
1462
        widget = GTK_WIDGET (gtk_builder_get_object (builder, "code3_entry"));
 
1463
        gtk_widget_set_sensitive (widget, TRUE);
 
1464
        widget = GTK_WIDGET (gtk_builder_get_object (builder, "unlock_button"));
 
1465
        gtk_widget_set_sensitive (widget, TRUE);
 
1466
        widget = GTK_WIDGET (gtk_builder_get_object (builder, "unlock_cancel_button"));
 
1467
        gtk_widget_set_sensitive (widget, TRUE);
 
1468
 
 
1469
        widget = GTK_WIDGET (gtk_builder_get_object (builder, "show_password_checkbutton"));
 
1470
        gtk_widget_set_sensitive (widget, TRUE);
 
1471
}
 
1472