← Back to branch summary

~ubuntu-branches/ubuntu/natty/empathy/natty-updates

« back to all changes in this revision

Viewing changes to libempathy-gtk/empathy-account-widget.c

Tags: upstream-0.22.0
Import upstream version 0.22.0

Show diffs side-by-side

added added

removed removed

Lines of Context:
libempathy-gtk/empathy-account-widget.c
 
1
/* -*- Mode: C; tab-width: 8; indent-tabs-mode: t; c-basic-offset: 8 -*- */
 
2
/*
 
3
 * Copyright (C) 2006-2007 Imendio AB
 
4
 * Copyright (C) 2007-2008 Collabora Ltd.
 
5
 *
 
6
 * This program is free software; you can redistribute it and/or
 
7
 * modify it under the terms of the GNU General Public License as
 
8
 * published by the Free Software Foundation; either version 2 of the
 
9
 * License, or (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 GNU
 
14
 * General Public License for more details.
 
15
 *
 
16
 * You should have received a copy of the GNU General Public
 
17
 * License along with this program; if not, write to the
 
18
 * Free Software Foundation, Inc., 59 Temple Place - Suite 330,
 
19
 * Boston, MA 02111-1307, USA.
 
20
 * 
 
21
 * Authors: Xavier Claessens <xclaesse@gmail.com>
 
22
 *          Martyn Russell <martyn@imendio.com>
 
23
 */
 
24
 
 
25
#include <config.h>
 
26
 
 
27
#include <string.h>
 
28
 
 
29
#include <gtk/gtk.h>
 
30
#include <glib/gi18n.h>
 
31
 
 
32
#include <libmissioncontrol/mc-account.h>
 
33
#include <libmissioncontrol/mc-protocol.h>
 
34
 
 
35
#include <libempathy/empathy-debug.h>
 
36
 
 
37
#include "empathy-account-widget.h"
 
38
#include "empathy-ui-utils.h"
 
39
 
 
40
#define DEBUG_DOMAIN "AccountWidget"
 
41
 
 
42
static gboolean 
 
43
account_widget_entry_focus_cb (GtkWidget     *widget,
 
44
                               GdkEventFocus *event,
 
45
                               McAccount     *account)
 
46
{
 
47
        const gchar *str;
 
48
        const gchar *param_name;
 
49
 
 
50
        str = gtk_entry_get_text (GTK_ENTRY (widget));
 
51
        param_name = g_object_get_data (G_OBJECT (widget), "param_name");
 
52
 
 
53
        if (G_STR_EMPTY (str)) {
 
54
                gchar *value = NULL;
 
55
 
 
56
                mc_account_unset_param (account, param_name);
 
57
                mc_account_get_param_string (account, param_name, &value);
 
58
                empathy_debug (DEBUG_DOMAIN, "Unset %s and restore to %s", param_name, value);
 
59
                gtk_entry_set_text (GTK_ENTRY (widget), value ? value : "");
 
60
                g_free (value);
 
61
        } else {
 
62
                empathy_debug (DEBUG_DOMAIN, "Setting %s to %s", param_name, str);
 
63
                mc_account_set_param_string (account, param_name, str);
 
64
        }
 
65
 
 
66
        return FALSE;
 
67
}
 
68
 
 
69
static void
 
70
account_widget_int_changed_cb (GtkWidget *widget,
 
71
                               McAccount *account)
 
72
{
 
73
        const gchar *param_name;
 
74
        gint         value;
 
75
 
 
76
        value = gtk_spin_button_get_value_as_int (GTK_SPIN_BUTTON (widget));
 
77
        param_name = g_object_get_data (G_OBJECT (widget), "param_name");
 
78
 
 
79
        if (value == 0) {
 
80
                mc_account_unset_param (account, param_name);
 
81
                mc_account_get_param_int (account, param_name, &value);
 
82
                empathy_debug (DEBUG_DOMAIN, "Unset %s and restore to %d", param_name, value);
 
83
                gtk_spin_button_set_value (GTK_SPIN_BUTTON (widget), value);
 
84
        } else {
 
85
                empathy_debug (DEBUG_DOMAIN, "Setting %s to %d", param_name, value);
 
86
                mc_account_set_param_int (account, param_name, value);
 
87
        }
 
88
}
 
89
 
 
90
static void  
 
91
account_widget_checkbutton_toggled_cb (GtkWidget *widget,
 
92
                                       McAccount *account)
 
93
{
 
94
        gboolean     value;
 
95
        gboolean     default_value;
 
96
        const gchar *param_name;
 
97
 
 
98
        value = gtk_toggle_button_get_active (GTK_TOGGLE_BUTTON (widget));
 
99
        param_name = g_object_get_data (G_OBJECT (widget), "param_name");
 
100
 
 
101
        /* FIXME: This is ugly! checkbox don't have a "not-set" value so we
 
102
         * always unset the param and set the value if different from the
 
103
         * default value. */
 
104
        mc_account_unset_param (account, param_name);
 
105
        mc_account_get_param_boolean (account, param_name, &default_value);
 
106
 
 
107
        if (default_value == value) {
 
108
                empathy_debug (DEBUG_DOMAIN, "Unset %s and restore to %d", param_name, default_value);
 
109
        } else {
 
110
                empathy_debug (DEBUG_DOMAIN, "Setting %s to %d", param_name, value);
 
111
                mc_account_set_param_boolean (account, param_name, value);
 
112
        }
 
113
}
 
114
 
 
115
static void
 
116
account_widget_forget_clicked_cb (GtkWidget *button,
 
117
                                  GtkWidget *entry)
 
118
{
 
119
        McAccount   *account;
 
120
        const gchar *param_name;
 
121
 
 
122
        param_name = g_object_get_data (G_OBJECT (entry), "param_name");
 
123
        account = g_object_get_data (G_OBJECT (entry), "account");
 
124
 
 
125
        empathy_debug (DEBUG_DOMAIN, "Unset %s", param_name);
 
126
        mc_account_unset_param (account, param_name);
 
127
        gtk_entry_set_text (GTK_ENTRY (entry), "");
 
128
}
 
129
 
 
130
static void
 
131
account_widget_password_changed_cb (GtkWidget *entry,
 
132
                                    GtkWidget *button)
 
133
{
 
134
        const gchar *str;
 
135
 
 
136
        str = gtk_entry_get_text (GTK_ENTRY (entry));
 
137
        gtk_widget_set_sensitive (button, !G_STR_EMPTY (str));
 
138
}
 
139
 
 
140
static void  
 
141
account_widget_jabber_ssl_toggled_cb (GtkWidget *checkbutton_ssl,
 
142
                                      GtkWidget *spinbutton_port)
 
143
{
 
144
        McAccount *account;
 
145
        gboolean   value;
 
146
        gint       port = 0;
 
147
 
 
148
        value = gtk_toggle_button_get_active (GTK_TOGGLE_BUTTON (checkbutton_ssl));
 
149
        account = g_object_get_data (G_OBJECT (spinbutton_port), "account");
 
150
        mc_account_get_param_int (account, "port", &port);
 
151
 
 
152
        if (value) {
 
153
                if (port == 5222 || port == 0) {
 
154
                        port = 5223;
 
155
                }
 
156
        } else {
 
157
                if (port == 5223 || port == 0) {
 
158
                        port = 5222;
 
159
                }
 
160
        }
 
161
 
 
162
        gtk_spin_button_set_value (GTK_SPIN_BUTTON (spinbutton_port), port);
 
163
}
 
164
 
 
165
static void
 
166
account_widget_setup_widget (GtkWidget   *widget,
 
167
                             McAccount   *account,
 
168
                             const gchar *param_name)
 
169
{
 
170
        g_object_set_data_full (G_OBJECT (widget), "param_name", 
 
171
                                g_strdup (param_name), g_free);
 
172
        g_object_set_data_full (G_OBJECT (widget), "account", 
 
173
                                g_object_ref (account), g_object_unref);
 
174
 
 
175
        if (GTK_IS_SPIN_BUTTON (widget)) {
 
176
                gint value = 0;
 
177
 
 
178
                mc_account_get_param_int (account, param_name, &value);
 
179
                gtk_spin_button_set_value (GTK_SPIN_BUTTON (widget), value);
 
180
 
 
181
                g_signal_connect (widget, "value-changed",
 
182
                                  G_CALLBACK (account_widget_int_changed_cb),
 
183
                                  account);
 
184
        }
 
185
        else if (GTK_IS_ENTRY (widget)) {
 
186
                gchar *str = NULL;
 
187
 
 
188
                mc_account_get_param_string (account, param_name, &str);
 
189
                gtk_entry_set_text (GTK_ENTRY (widget), str ? str : "");
 
190
                g_free (str);
 
191
 
 
192
                if (strstr (param_name, "password")) {
 
193
                        gtk_entry_set_visibility (GTK_ENTRY (widget), FALSE);
 
194
                }
 
195
 
 
196
                g_signal_connect (widget, "focus-out-event",
 
197
                                  G_CALLBACK (account_widget_entry_focus_cb),
 
198
                                  account);
 
199
        }
 
200
        else if (GTK_IS_TOGGLE_BUTTON (widget)) {
 
201
                gboolean value = FALSE;
 
202
 
 
203
                mc_account_get_param_boolean (account, param_name, &value);
 
204
                gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (widget), value);
 
205
 
 
206
                g_signal_connect (widget, "toggled",
 
207
                                  G_CALLBACK (account_widget_checkbutton_toggled_cb),
 
208
                                  account);
 
209
        } else {
 
210
                empathy_debug (DEBUG_DOMAIN,
 
211
                               "Unknown type of widget for param %s",
 
212
                               param_name);
 
213
        }
 
214
}
 
215
 
 
216
static gchar *
 
217
account_widget_generic_format_param_name (const gchar *param_name)
 
218
{
 
219
        gchar *str;
 
220
        gchar *p;
 
221
 
 
222
        str = g_strdup (param_name);
 
223
        
 
224
        if (str && g_ascii_isalpha (str[0])) {
 
225
                str[0] = g_ascii_toupper (str[0]);
 
226
        }
 
227
        
 
228
        while ((p = strchr (str, '-')) != NULL) {
 
229
                if (p[1] != '\0' && g_ascii_isalpha (p[1])) {
 
230
                        p[0] = ' ';
 
231
                        p[1] = g_ascii_toupper (p[1]);
 
232
                }
 
233
 
 
234
                p++;
 
235
        }
 
236
        
 
237
        return str;
 
238
}
 
239
 
 
240
static void
 
241
accounts_widget_generic_setup (McAccount *account,
 
242
                               GtkWidget *table_common_settings,
 
243
                               GtkWidget *table_advanced_settings)
 
244
{
 
245
        McProtocol *protocol;
 
246
        McProfile  *profile;
 
247
        GSList     *params, *l;
 
248
 
 
249
        profile = mc_account_get_profile (account);
 
250
        protocol = mc_profile_get_protocol (profile);
 
251
 
 
252
        if (!protocol) {
 
253
                /* The CM is not installed, MC shouldn't list them
 
254
                 * see SF bug #1688779
 
255
                 * FIXME: We should display something asking the user to 
 
256
                 * install the CM
 
257
                 */
 
258
                g_object_unref (profile);
 
259
                return;
 
260
        }
 
261
 
 
262
        params = mc_protocol_get_params (protocol);
 
263
 
 
264
        for (l = params; l; l = l->next) {
 
265
                McProtocolParam *param;
 
266
                GtkWidget       *table_settings;
 
267
                guint            n_rows = 0;
 
268
                GtkWidget       *widget = NULL;
 
269
                gchar           *param_name_formatted;
 
270
 
 
271
                param = l->data;
 
272
                if (param->flags & MC_PROTOCOL_PARAM_REQUIRED) {
 
273
                        table_settings = table_common_settings;
 
274
                } else {
 
275
                        table_settings = table_advanced_settings;
 
276
                }
 
277
                param_name_formatted = account_widget_generic_format_param_name (param->name);
 
278
                g_object_get (table_settings, "n-rows", &n_rows, NULL);
 
279
                gtk_table_resize (GTK_TABLE (table_settings), ++n_rows, 2);
 
280
 
 
281
                if (param->signature[0] == 's') {
 
282
                        gchar *str;
 
283
 
 
284
                        str = g_strdup_printf (_("%s:"), param_name_formatted);
 
285
                        widget = gtk_label_new (str);
 
286
                        gtk_misc_set_alignment (GTK_MISC (widget), 0, 0.5);
 
287
                        g_free (str);
 
288
 
 
289
                        gtk_table_attach (GTK_TABLE (table_settings),
 
290
                                          widget,
 
291
                                          0, 1,
 
292
                                          n_rows - 1, n_rows,
 
293
                                          GTK_FILL, 0,
 
294
                                          0, 0);
 
295
 
 
296
                        widget = gtk_entry_new ();
 
297
                        gtk_table_attach (GTK_TABLE (table_settings),
 
298
                                          widget,
 
299
                                          1, 2,
 
300
                                          n_rows - 1, n_rows,
 
301
                                          GTK_FILL | GTK_EXPAND, 0,
 
302
                                          0, 0);
 
303
                }
 
304
                /* int types: ynqiuxt. double type is 'd' */
 
305
                else if (param->signature[0] == 'y' ||
 
306
                         param->signature[0] == 'n' ||
 
307
                         param->signature[0] == 'q' ||
 
308
                         param->signature[0] == 'i' ||
 
309
                         param->signature[0] == 'u' ||
 
310
                         param->signature[0] == 'x' ||
 
311
                         param->signature[0] == 't' ||
 
312
                         param->signature[0] == 'd') {
 
313
                        gchar   *str = NULL;
 
314
                        gdouble  minint = 0;
 
315
                        gdouble  maxint = 0;
 
316
                        gdouble  step = 1;
 
317
 
 
318
                        switch (param->signature[0]) {
 
319
                        case 'y': minint = G_MININT8;  maxint = G_MAXINT8;   break;
 
320
                        case 'n': minint = G_MININT16; maxint = G_MAXINT16;  break;
 
321
                        case 'q': minint = 0;          maxint = G_MAXUINT16; break;
 
322
                        case 'i': minint = G_MININT32; maxint = G_MAXINT32;  break;
 
323
                        case 'u': minint = 0;          maxint = G_MAXUINT32; break;
 
324
                        case 'x': minint = G_MININT64; maxint = G_MAXINT64;  break;
 
325
                        case 't': minint = 0;          maxint = G_MAXUINT64; break;
 
326
                        case 'd': minint = G_MININT32; maxint = G_MAXINT32; step = 0.1; break;
 
327
                        }
 
328
 
 
329
                        str = g_strdup_printf (_("%s:"), param_name_formatted);
 
330
                        widget = gtk_label_new (str);
 
331
                        gtk_misc_set_alignment (GTK_MISC (widget), 0, 0.5);
 
332
                        g_free (str);
 
333
 
 
334
                        gtk_table_attach (GTK_TABLE (table_settings),
 
335
                                          widget,
 
336
                                          0, 1,
 
337
                                          n_rows - 1, n_rows,
 
338
                                          GTK_FILL, 0,
 
339
                                          0, 0);
 
340
 
 
341
                        widget = gtk_spin_button_new_with_range (minint, maxint, step);
 
342
                        gtk_table_attach (GTK_TABLE (table_settings),
 
343
                                          widget,
 
344
                                          1, 2,
 
345
                                          n_rows - 1, n_rows,
 
346
                                          GTK_FILL | GTK_EXPAND, 0,
 
347
                                          0, 0);
 
348
                }
 
349
                else if (param->signature[0] == 'b') {
 
350
                        widget = gtk_check_button_new_with_label (param_name_formatted);
 
351
                        gtk_table_attach (GTK_TABLE (table_settings),
 
352
                                          widget,
 
353
                                          0, 2,
 
354
                                          n_rows - 1, n_rows,
 
355
                                          GTK_FILL | GTK_EXPAND, 0,
 
356
                                          0, 0);
 
357
                } else {
 
358
                        empathy_debug (DEBUG_DOMAIN,
 
359
                                       "Unknown signature for param %s: %s",
 
360
                                       param_name_formatted, param->signature);
 
361
                }
 
362
 
 
363
                if (widget) {
 
364
                        account_widget_setup_widget (widget, account, param->name);
 
365
                }
 
366
 
 
367
                g_free (param_name_formatted);
 
368
        }
 
369
 
 
370
        g_slist_free (params);
 
371
        g_object_unref (profile);
 
372
        g_object_unref (protocol);
 
373
}
 
374
 
 
375
static void
 
376
account_widget_handle_params_valist (McAccount   *account,
 
377
                                     GladeXML    *gui,
 
378
                                     const gchar *first_widget_name,
 
379
                                     va_list      args)
 
380
{
 
381
        GtkWidget   *widget;
 
382
        const gchar *widget_name;
 
383
 
 
384
        for (widget_name = first_widget_name; widget_name; widget_name = va_arg (args, gchar*)) {
 
385
                const gchar *param_name;
 
386
 
 
387
                param_name = va_arg (args, gchar*);
 
388
 
 
389
                widget = glade_xml_get_widget (gui, widget_name);
 
390
 
 
391
                if (!widget) {
 
392
                        g_warning ("Glade is missing widget '%s'.", widget_name);
 
393
                        continue;
 
394
                }
 
395
 
 
396
                account_widget_setup_widget (widget, account, param_name);
 
397
        }
 
398
}
 
399
 
 
400
void
 
401
empathy_account_widget_handle_params (McAccount   *account,
 
402
                                      GladeXML    *gui,
 
403
                                      const gchar *first_widget_name,
 
404
                                      ...)
 
405
{
 
406
        va_list args;
 
407
 
 
408
        g_return_if_fail (MC_IS_ACCOUNT (account));
 
409
 
 
410
        va_start (args, first_widget_name);
 
411
        account_widget_handle_params_valist (account, gui,
 
412
                                             first_widget_name,
 
413
                                             args);
 
414
        va_end (args);
 
415
}
 
416
 
 
417
void
 
418
empathy_account_widget_add_forget_button (McAccount   *account,
 
419
                                          GladeXML    *glade,
 
420
                                          const gchar *button,
 
421
                                          const gchar *entry)
 
422
{
 
423
        GtkWidget *button_forget;
 
424
        GtkWidget *entry_password;
 
425
        gchar     *password = NULL;
 
426
        
 
427
        button_forget = glade_xml_get_widget (glade, button);
 
428
        entry_password = glade_xml_get_widget (glade, entry);
 
429
 
 
430
        mc_account_get_param_string (account, "password", &password);
 
431
        gtk_widget_set_sensitive (button_forget, !G_STR_EMPTY (password));
 
432
        g_free (password);
 
433
 
 
434
        g_signal_connect (button_forget, "clicked",
 
435
                          G_CALLBACK (account_widget_forget_clicked_cb),
 
436
                          entry_password);
 
437
        g_signal_connect (entry_password, "changed",
 
438
                          G_CALLBACK (account_widget_password_changed_cb),
 
439
                          button_forget);
 
440
}
 
441
 
 
442
GtkWidget *
 
443
empathy_account_widget_generic_new (McAccount *account)
 
444
{
 
445
        GladeXML  *glade;
 
446
        GtkWidget *widget;
 
447
        GtkWidget *table_common_settings;
 
448
        GtkWidget *table_advanced_settings;
 
449
 
 
450
        g_return_val_if_fail (MC_IS_ACCOUNT (account), NULL);
 
451
 
 
452
        glade = empathy_glade_get_file ("empathy-account-widget-generic.glade",
 
453
                                        "vbox_generic_settings",
 
454
                                        NULL,
 
455
                                        "vbox_generic_settings", &widget,
 
456
                                        "table_common_settings", &table_common_settings,
 
457
                                        "table_advanced_settings", &table_advanced_settings,
 
458
                                        NULL);
 
459
 
 
460
        accounts_widget_generic_setup (account, table_common_settings, table_advanced_settings);
 
461
 
 
462
        g_object_unref (glade);
 
463
 
 
464
        gtk_widget_show_all (widget);
 
465
 
 
466
        return widget;
 
467
}
 
468
 
 
469
GtkWidget *
 
470
empathy_account_widget_salut_new (McAccount *account)
 
471
{
 
472
        GladeXML  *glade;
 
473
        GtkWidget *widget;
 
474
 
 
475
        glade = empathy_glade_get_file ("empathy-account-widget-salut.glade",
 
476
                                        "vbox_salut_settings",
 
477
                                        NULL,
 
478
                                        "vbox_salut_settings", &widget,
 
479
                                        NULL);
 
480
 
 
481
        empathy_account_widget_handle_params (account, glade,
 
482
                        "entry_published", "published-name",
 
483
                        "entry_nickname", "nickname",
 
484
                        "entry_first_name", "first-name",
 
485
                        "entry_last_name", "last-name",
 
486
                        "entry_email", "email",
 
487
                        "entry_jid", "jid",
 
488
                        NULL);
 
489
 
 
490
        g_object_unref (glade);
 
491
 
 
492
        gtk_widget_show (widget);
 
493
 
 
494
        return widget;
 
495
}
 
496
 
 
497
GtkWidget *
 
498
empathy_account_widget_msn_new (McAccount *account)
 
499
{
 
500
        GladeXML  *glade;
 
501
        GtkWidget *widget;
 
502
 
 
503
        glade = empathy_glade_get_file ("empathy-account-widget-msn.glade",
 
504
                                        "vbox_msn_settings",
 
505
                                        NULL,
 
506
                                        "vbox_msn_settings", &widget,
 
507
                                        NULL);
 
508
 
 
509
        empathy_account_widget_handle_params (account, glade,
 
510
                        "entry_id", "account",
 
511
                        "entry_password", "password",
 
512
                        "entry_server", "server",
 
513
                        "spinbutton_port", "port",
 
514
                        NULL);
 
515
 
 
516
        empathy_account_widget_add_forget_button (account, glade,
 
517
                                                  "button_forget",
 
518
                                                  "entry_password");
 
519
 
 
520
        g_object_unref (glade);
 
521
 
 
522
        gtk_widget_show (widget);
 
523
 
 
524
        return widget;
 
525
}
 
526
 
 
527
GtkWidget *
 
528
empathy_account_widget_jabber_new (McAccount *account)
 
529
{
 
530
        GladeXML  *glade;
 
531
        GtkWidget *widget;
 
532
        GtkWidget *spinbutton_port;
 
533
        GtkWidget *checkbutton_ssl;
 
534
 
 
535
        glade = empathy_glade_get_file ("empathy-account-widget-jabber.glade",
 
536
                                        "vbox_jabber_settings",
 
537
                                        NULL,
 
538
                                        "vbox_jabber_settings", &widget,
 
539
                                        "spinbutton_port", &spinbutton_port,
 
540
                                        "checkbutton_ssl", &checkbutton_ssl,
 
541
                                        NULL);
 
542
 
 
543
        empathy_account_widget_handle_params (account, glade,
 
544
                        "entry_id", "account",
 
545
                        "entry_password", "password",
 
546
                        "entry_resource", "resource",
 
547
                        "entry_server", "server",
 
548
                        "spinbutton_port", "port",
 
549
                        "spinbutton_priority", "priority",
 
550
                        "checkbutton_ssl", "old-ssl",
 
551
                        "checkbutton_ignore_ssl_errors", "ignore-ssl-errors",
 
552
                        "checkbutton_encryption", "require-encryption",
 
553
                        NULL);
 
554
 
 
555
        empathy_account_widget_add_forget_button (account, glade,
 
556
                                                  "button_forget",
 
557
                                                  "entry_password");
 
558
 
 
559
        g_signal_connect (checkbutton_ssl, "toggled",
 
560
                          G_CALLBACK (account_widget_jabber_ssl_toggled_cb),
 
561
                          spinbutton_port);
 
562
 
 
563
        g_object_unref (glade);
 
564
 
 
565
        gtk_widget_show (widget);
 
566
 
 
567
        return widget;
 
568
}
 
569
 
 
570
GtkWidget *
 
571
empathy_account_widget_icq_new (McAccount *account)
 
572
{
 
573
        GladeXML  *glade;
 
574
        GtkWidget *widget;
 
575
        GtkWidget *spinbutton_port;
 
576
 
 
577
        glade = empathy_glade_get_file ("empathy-account-widget-icq.glade",
 
578
                                        "vbox_icq_settings",
 
579
                                        NULL,
 
580
                                        "vbox_icq_settings", &widget,
 
581
                                        "spinbutton_port", &spinbutton_port,
 
582
                                        NULL);
 
583
 
 
584
        empathy_account_widget_handle_params (account, glade,
 
585
                        "entry_uin", "account",
 
586
                        "entry_password", "password",
 
587
                        "entry_server", "server",
 
588
                        "spinbutton_port", "port",
 
589
                        "entry_charset", "charset",
 
590
                        NULL);
 
591
 
 
592
        empathy_account_widget_add_forget_button (account, glade,
 
593
                                                  "button_forget",
 
594
                                                  "entry_password");
 
595
 
 
596
        g_object_unref (glade);
 
597
 
 
598
        gtk_widget_show (widget);
 
599
 
 
600
        return widget;
 
601
}
 
602
 
 
603
GtkWidget *
 
604
empathy_account_widget_yahoo_new (McAccount *account)
 
605
{
 
606
        GladeXML  *glade;
 
607
        GtkWidget *widget;
 
608
 
 
609
        glade = empathy_glade_get_file ("empathy-account-widget-yahoo.glade",
 
610
                                        "vbox_yahoo_settings",
 
611
                                        NULL,
 
612
                                        "vbox_yahoo_settings", &widget,
 
613
                                        NULL);
 
614
 
 
615
        empathy_account_widget_handle_params (account, glade,
 
616
                        "entry_id", "account",
 
617
                        "entry_password", "password",
 
618
                        "entry_server", "server",
 
619
                        "entry_serverjp", "serverjp",
 
620
                        "entry_locale", "room-list-locale",
 
621
                        "entry_charset", "charset",
 
622
                        "spinbutton_port", "port",
 
623
                        "checkbutton_yahoojp", "yahoojp",
 
624
                        "checkbutton_ignore_invites", "ignore-invites",
 
625
                        NULL);
 
626
 
 
627
        empathy_account_widget_add_forget_button (account, glade,
 
628
                                                  "button_forget",
 
629
                                                  "entry_password");
 
630
 
 
631
        g_object_unref (glade);
 
632
 
 
633
        gtk_widget_show (widget);
 
634
 
 
635
        return widget;
 
636
}
 
637