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