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-2009 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., 51 Franklin St, Fifth Floor,
  19  * Boston, MA  02110-1301  USA
  20  *
  21  * Authors: Xavier Claessens <xclaesse@gmail.com>
  22  *          Martyn Russell <martyn@imendio.com>
  23  *          Cosimo Cecchi <cosimo.cecchi@collabora.co.uk>
  24  */
  25
  26 #include <config.h>
  27
  28 #include <string.h>
  29
  30 #include <gtk/gtk.h>
  31 #include <glib/gi18n-lib.h>
  32
  33 #include <libempathy/empathy-utils.h>
  34 #include <libempathy/empathy-account.h>
  35
  36 #include <telepathy-glib/connection-manager.h>
  37 #include <telepathy-glib/util.h>
  38 #include <dbus/dbus-protocol.h>
  39
  40 #include "empathy-account-widget.h"
  41 #include "empathy-account-widget-private.h"
  42 #include "empathy-account-widget-sip.h"
  43 #include "empathy-account-widget-irc.h"
  44 #include "empathy-ui-utils.h"
  45
  46 #define DEBUG_FLAG EMPATHY_DEBUG_ACCOUNT
  47 #include <libempathy/empathy-debug.h>
  48
  49 G_DEFINE_TYPE (EmpathyAccountWidget, empathy_account_widget, G_TYPE_OBJECT)
  50
  51 typedef struct {
  52   char *protocol;
  53   EmpathyAccountSettings *settings;
  54
  55   GtkWidget *apply_button;
  56   GtkWidget *entry_password;
  57   GtkWidget *button_forget;
  58   GtkWidget *spinbutton_port;
  59
  60   gboolean dispose_run;
  61 } EmpathyAccountWidgetPriv;
  62
  63 enum {
  64   PROP_PROTOCOL = 1,
  65   PROP_SETTINGS
  66 };
  67
  68 #define GET_PRIV(obj) EMPATHY_GET_PRIV (obj, EmpathyAccountWidget)
  69
  70 static void
  71 account_widget_handle_apply_sensitivity (EmpathyAccountWidget *self)
  72 {
  73   EmpathyAccountWidgetPriv *priv = GET_PRIV (self);
  74
  75   gtk_widget_set_sensitive (priv->apply_button,
  76       empathy_account_settings_is_valid (priv->settings));
  77 }
  78
  79 static gboolean
  80 account_widget_entry_focus_cb (GtkWidget *widget,
  81     GdkEventFocus *event,
  82     EmpathyAccountWidget *self)
  83 {
  84   const gchar *str;
  85   const gchar *param_name;
  86   EmpathyAccountWidgetPriv *priv = GET_PRIV (self);
  87
  88   str = gtk_entry_get_text (GTK_ENTRY (widget));
  89   param_name = g_object_get_data (G_OBJECT (widget), "param_name");
  90
  91   if (EMP_STR_EMPTY (str))
  92     {
  93       const gchar *value = NULL;
  94
  95       empathy_account_settings_unset (priv->settings, param_name);
  96       value = empathy_account_settings_get_string (priv->settings, param_name);
  97       DEBUG ("Unset %s and restore to %s", param_name, value);
  98       gtk_entry_set_text (GTK_ENTRY (widget), value ? value : "");
  99     }
 100   else
 101     {
 102       DEBUG ("Setting %s to %s", param_name,
 103           strstr (param_name, "password") ? "***" : str);
 104       empathy_account_settings_set_string (priv->settings, param_name, str);
 105     }
 106
 107   account_widget_handle_apply_sensitivity (self);
 108
 109   return FALSE;
 110 }
 111
 112 static void
 113 account_widget_int_changed_cb (GtkWidget *widget,
 114     EmpathyAccountWidget *self)
 115 {
 116   const gchar *param_name;
 117   gint value;
 118   const gchar *signature;
 119   EmpathyAccountWidgetPriv *priv = GET_PRIV (self);
 120
 121   value = gtk_spin_button_get_value_as_int (GTK_SPIN_BUTTON (widget));
 122   param_name = g_object_get_data (G_OBJECT (widget), "param_name");
 123
 124   signature = empathy_account_settings_get_dbus_signature (priv->settings,
 125     param_name);
 126   g_return_if_fail (signature != NULL);
 127
 128   DEBUG ("Setting %s to %d", param_name, value);
 129
 130   switch ((int)*signature)
 131     {
 132     case DBUS_TYPE_INT16:
 133     case DBUS_TYPE_INT32:
 134       empathy_account_settings_set_int32 (priv->settings, param_name, value);
 135       break;
 136     case DBUS_TYPE_INT64:
 137       empathy_account_settings_set_int64 (priv->settings, param_name, value);
 138       break;
 139     case DBUS_TYPE_UINT16:
 140     case DBUS_TYPE_UINT32:
 141       empathy_account_settings_set_uint32 (priv->settings, param_name, value);
 142       break;
 143     case DBUS_TYPE_UINT64:
 144       empathy_account_settings_set_uint64 (priv->settings, param_name, value);
 145       break;
 146     default:
 147       g_return_if_reached ();
 148     }
 149
 150   account_widget_handle_apply_sensitivity (self);
 151 }
 152
 153 static void
 154 account_widget_checkbutton_toggled_cb (GtkWidget *widget,
 155     EmpathyAccountWidget *self)
 156 {
 157   gboolean     value;
 158   gboolean     default_value;
 159   const gchar *param_name;
 160   EmpathyAccountWidgetPriv *priv = GET_PRIV (self);
 161
 162   value = gtk_toggle_button_get_active (GTK_TOGGLE_BUTTON (widget));
 163   param_name = g_object_get_data (G_OBJECT (widget), "param_name");
 164
 165   /* FIXME: This is ugly! checkbox don't have a "not-set" value so we
 166    * always unset the param and set the value if different from the
 167    * default value. */
 168   empathy_account_settings_unset (priv->settings, param_name);
 169   default_value = empathy_account_settings_get_boolean (priv->settings,
 170       param_name);
 171
 172   if (default_value == value)
 173     {
 174       DEBUG ("Unset %s and restore to %d", param_name, default_value);
 175     }
 176   else
 177     {
 178       DEBUG ("Setting %s to %d", param_name, value);
 179       empathy_account_settings_set_boolean (priv->settings, param_name, value);
 180     }
 181
 182   account_widget_handle_apply_sensitivity (self);
 183 }
 184
 185 static void
 186 account_widget_forget_clicked_cb (GtkWidget *button,
 187     EmpathyAccountWidget *self)
 188 {
 189   EmpathyAccountWidgetPriv *priv = GET_PRIV (self);
 190   const gchar *param_name;
 191
 192   param_name = g_object_get_data (G_OBJECT (priv->entry_password),
 193       "param_name");
 194
 195   DEBUG ("Unset %s", param_name);
 196   empathy_account_settings_unset (priv->settings, param_name);
 197   gtk_entry_set_text (GTK_ENTRY (priv->entry_password), "");
 198
 199   account_widget_handle_apply_sensitivity (self);
 200 }
 201
 202 static void
 203 account_widget_password_changed_cb (GtkWidget *entry,
 204     EmpathyAccountWidget *self)
 205 {
 206   EmpathyAccountWidgetPriv *priv = GET_PRIV (self);
 207   const gchar *str;
 208
 209   str = gtk_entry_get_text (GTK_ENTRY (entry));
 210   gtk_widget_set_sensitive (priv->button_forget, !EMP_STR_EMPTY (str));
 211 }
 212
 213 static void
 214 account_widget_jabber_ssl_toggled_cb (GtkWidget *checkbutton_ssl,
 215     EmpathyAccountWidget *self)
 216 {
 217   EmpathyAccountWidgetPriv *priv = GET_PRIV (self);
 218   gboolean   value;
 219   gint32       port = 0;
 220
 221   value = gtk_toggle_button_get_active (GTK_TOGGLE_BUTTON (checkbutton_ssl));
 222   port = empathy_account_settings_get_uint32 (priv->settings, "port");
 223
 224   if (value)
 225     {
 226       if (port == 5222 || port == 0)
 227         port = 5223;
 228     }
 229   else
 230     {
 231       if (port == 5223 || port == 0)
 232         port = 5222;
 233     }
 234
 235   gtk_spin_button_set_value (GTK_SPIN_BUTTON (priv->spinbutton_port), port);
 236 }
 237
 238 static void
 239 account_widget_setup_widget (EmpathyAccountWidget *self,
 240     GtkWidget *widget,
 241     const gchar *param_name)
 242 {
 243   EmpathyAccountWidgetPriv *priv = GET_PRIV (self);
 244
 245   g_object_set_data_full (G_OBJECT (widget), "param_name",
 246       g_strdup (param_name), g_free);
 247
 248   if (GTK_IS_SPIN_BUTTON (widget))
 249     {
 250       gint value = 0;
 251       const gchar *signature;
 252
 253       signature = empathy_account_settings_get_dbus_signature (priv->settings,
 254           param_name);
 255       g_return_if_fail (signature != NULL);
 256
 257       switch ((int)*signature)
 258         {
 259           case DBUS_TYPE_INT16:
 260           case DBUS_TYPE_INT32:
 261             value = empathy_account_settings_get_int32 (priv->settings,
 262               param_name);
 263             break;
 264           case DBUS_TYPE_INT64:
 265             value = empathy_account_settings_get_int64 (priv->settings,
 266               param_name);
 267             break;
 268           case DBUS_TYPE_UINT16:
 269           case DBUS_TYPE_UINT32:
 270             value = empathy_account_settings_get_uint32 (priv->settings,
 271               param_name);
 272             break;
 273           case DBUS_TYPE_UINT64:
 274             value = empathy_account_settings_get_uint64 (priv->settings,
 275                 param_name);
 276             break;
 277           default:
 278             g_return_if_reached ();
 279         }
 280
 281       gtk_spin_button_set_value (GTK_SPIN_BUTTON (widget), value);
 282
 283       g_signal_connect (widget, "value-changed",
 284           G_CALLBACK (account_widget_int_changed_cb),
 285           self);
 286     }
 287   else if (GTK_IS_ENTRY (widget))
 288     {
 289       const gchar *str = NULL;
 290
 291       str = empathy_account_settings_get_string (priv->settings, param_name);
 292       gtk_entry_set_text (GTK_ENTRY (widget), str ? str : "");
 293
 294       if (strstr (param_name, "password"))
 295         {
 296           gtk_entry_set_visibility (GTK_ENTRY (widget), FALSE);
 297         }
 298
 299       g_signal_connect (widget, "focus-out-event",
 300           G_CALLBACK (account_widget_entry_focus_cb),
 301           self);
 302     }
 303   else if (GTK_IS_TOGGLE_BUTTON (widget))
 304     {
 305       gboolean value = FALSE;
 306
 307       value = empathy_account_settings_get_boolean (priv->settings,
 308           param_name);
 309       gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (widget), value);
 310
 311       g_signal_connect (widget, "toggled",
 312           G_CALLBACK (account_widget_checkbutton_toggled_cb),
 313           self);
 314     }
 315   else
 316     {
 317       DEBUG ("Unknown type of widget for param %s", param_name);
 318     }
 319 }
 320
 321 static gchar *
 322 account_widget_generic_format_param_name (const gchar *param_name)
 323 {
 324   gchar *str;
 325   gchar *p;
 326
 327   str = g_strdup (param_name);
 328
 329   if (str && g_ascii_isalpha (str[0]))
 330     str[0] = g_ascii_toupper (str[0]);
 331
 332   while ((p = strchr (str, '-')) != NULL)
 333     {
 334       if (p[1] != '\0' && g_ascii_isalpha (p[1]))
 335         {
 336           p[0] = ' ';
 337           p[1] = g_ascii_toupper (p[1]);
 338         }
 339
 340       p++;
 341     }
 342
 343   return str;
 344 }
 345
 346 static void
 347 accounts_widget_generic_setup (EmpathyAccountWidget *self,
 348     GtkWidget *table_common_settings,
 349     GtkWidget *table_advanced_settings)
 350 {
 351   TpConnectionManagerParam *params, *param;
 352   EmpathyAccountWidgetPriv *priv = GET_PRIV (self);
 353
 354   params = empathy_account_settings_get_tp_params (priv->settings);
 355
 356   for (param = params; param != NULL && param->name != NULL; param++)
 357     {
 358       GtkWidget       *table_settings;
 359       guint            n_rows = 0;
 360       GtkWidget       *widget = NULL;
 361       gchar           *param_name_formatted;
 362
 363       if (param->flags & TP_CONN_MGR_PARAM_FLAG_REQUIRED)
 364         table_settings = table_common_settings;
 365       else
 366         table_settings = table_advanced_settings;
 367
 368       param_name_formatted = account_widget_generic_format_param_name
 369         (param->name);
 370       g_object_get (table_settings, "n-rows", &n_rows, NULL);
 371       gtk_table_resize (GTK_TABLE (table_settings), ++n_rows, 2);
 372
 373       if (param->dbus_signature[0] == 's')
 374         {
 375           gchar *str;
 376
 377           str = g_strdup_printf (_("%s:"), param_name_formatted);
 378           widget = gtk_label_new (str);
 379           gtk_misc_set_alignment (GTK_MISC (widget), 0, 0.5);
 380           g_free (str);
 381
 382           gtk_table_attach (GTK_TABLE (table_settings),
 383               widget,
 384               0, 1,
 385               n_rows - 1, n_rows,
 386               GTK_FILL, 0,
 387               0, 0);
 388           gtk_widget_show (widget);
 389
 390           widget = gtk_entry_new ();
 391           if (strcmp (param->name, "account") == 0)
 392             {
 393               g_signal_connect (widget, "realize",
 394                   G_CALLBACK (gtk_widget_grab_focus),
 395                   NULL);
 396             }
 397           gtk_table_attach (GTK_TABLE (table_settings),
 398               widget,
 399               1, 2,
 400               n_rows - 1, n_rows,
 401               GTK_FILL | GTK_EXPAND, 0,
 402               0, 0);
 403           gtk_widget_show (widget);
 404         }
 405       /* int types: ynqiuxt. double type is 'd' */
 406       else if (param->dbus_signature[0] == 'y' ||
 407           param->dbus_signature[0] == 'n' ||
 408           param->dbus_signature[0] == 'q' ||
 409           param->dbus_signature[0] == 'i' ||
 410           param->dbus_signature[0] == 'u' ||
 411           param->dbus_signature[0] == 'x' ||
 412           param->dbus_signature[0] == 't' ||
 413           param->dbus_signature[0] == 'd')
 414         {
 415           gchar   *str = NULL;
 416           gdouble  minint = 0;
 417           gdouble  maxint = 0;
 418           gdouble  step = 1;
 419
 420           switch (param->dbus_signature[0])
 421             {
 422             case 'y': minint = G_MININT8;  maxint = G_MAXINT8;   break;
 423             case 'n': minint = G_MININT16; maxint = G_MAXINT16;  break;
 424             case 'q': minint = 0;          maxint = G_MAXUINT16; break;
 425             case 'i': minint = G_MININT32; maxint = G_MAXINT32;  break;
 426             case 'u': minint = 0;          maxint = G_MAXUINT32; break;
 427             case 'x': minint = G_MININT64; maxint = G_MAXINT64;  break;
 428             case 't': minint = 0;          maxint = G_MAXUINT64; break;
 429             case 'd': minint = G_MININT32; maxint = G_MAXINT32;
 430               step = 0.1; break;
 431             }
 432
 433           str = g_strdup_printf (_("%s:"), param_name_formatted);
 434           widget = gtk_label_new (str);
 435           gtk_misc_set_alignment (GTK_MISC (widget), 0, 0.5);
 436           g_free (str);
 437
 438           gtk_table_attach (GTK_TABLE (table_settings),
 439               widget,
 440               0, 1,
 441               n_rows - 1, n_rows,
 442               GTK_FILL, 0,
 443               0, 0);
 444           gtk_widget_show (widget);
 445
 446           widget = gtk_spin_button_new_with_range (minint, maxint, step);
 447           gtk_table_attach (GTK_TABLE (table_settings),
 448               widget,
 449               1, 2,
 450               n_rows - 1, n_rows,
 451               GTK_FILL | GTK_EXPAND, 0,
 452               0, 0);
 453           gtk_widget_show (widget);
 454         }
 455       else if (param->dbus_signature[0] == 'b')
 456         {
 457           widget = gtk_check_button_new_with_label (param_name_formatted);
 458           gtk_table_attach (GTK_TABLE (table_settings),
 459               widget,
 460               0, 2,
 461               n_rows - 1, n_rows,
 462               GTK_FILL | GTK_EXPAND, 0,
 463               0, 0);
 464           gtk_widget_show (widget);
 465         }
 466       else
 467         {
 468           DEBUG ("Unknown signature for param %s: %s",
 469               param_name_formatted, param->dbus_signature);
 470         }
 471
 472       if (widget)
 473         account_widget_setup_widget (self, widget, param->name);
 474
 475       g_free (param_name_formatted);
 476     }
 477 }
 478
 479 static void
 480 account_widget_handle_params_valist (EmpathyAccountWidget *self,
 481     const gchar *first_widget,
 482     va_list args)
 483 {
 484   GObject *object;
 485   const gchar *name;
 486
 487   for (name = first_widget; name; name = va_arg (args, const gchar *))
 488     {
 489       const gchar *param_name;
 490
 491       param_name = va_arg (args, const gchar *);
 492       object = gtk_builder_get_object (self->ui_details->gui, name);
 493
 494       if (!object)
 495         {
 496           g_warning ("Builder is missing object '%s'.", name);
 497           continue;
 498         }
 499
 500       account_widget_setup_widget (self, GTK_WIDGET (object), param_name);
 501     }
 502 }
 503
 504 static void
 505 account_widget_apply_clicked_cb (GtkWidget *button,
 506     EmpathyAccountWidget *self)
 507 {
 508   EmpathyAccountWidgetPriv *priv = GET_PRIV (self);
 509
 510   empathy_account_settings_apply_async (priv->settings, NULL, NULL);
 511 }
 512
 513 static void
 514 account_widget_setup_generic (EmpathyAccountWidget *self)
 515 {
 516   GtkWidget *table_common_settings;
 517   GtkWidget *table_advanced_settings;
 518
 519   table_common_settings = GTK_WIDGET (gtk_builder_get_object
 520       (self->ui_details->gui, "table_common_settings"));
 521   table_advanced_settings = GTK_WIDGET (gtk_builder_get_object
 522       (self->ui_details->gui, "table_advanced_settings"));
 523
 524   accounts_widget_generic_setup (self, table_common_settings,
 525       table_advanced_settings);
 526
 527   g_object_unref (self->ui_details->gui);
 528 }
 529
 530 static void
 531 account_widget_settings_ready_cb (EmpathyAccountSettings *settings,
 532     GParamSpec *pspec,
 533     gpointer user_data)
 534 {
 535   EmpathyAccountWidget *self = user_data;
 536   EmpathyAccountWidgetPriv *priv = GET_PRIV (self);
 537
 538   if (empathy_account_settings_is_ready (priv->settings))
 539     account_widget_setup_generic (self);
 540 }
 541
 542 static void
 543 account_widget_build_generic (EmpathyAccountWidget *self,
 544     const char *filename)
 545 {
 546   EmpathyAccountWidgetPriv *priv = GET_PRIV (self);
 547   self->ui_details->gui = empathy_builder_get_file (filename,
 548       "vbox_generic_settings", &self->ui_details->widget,
 549       NULL);
 550
 551   g_object_ref (self->ui_details->gui);
 552
 553   if (empathy_account_settings_is_ready (priv->settings))
 554     account_widget_setup_generic (self);
 555   else
 556     g_signal_connect (priv->settings, "notify::ready",
 557         G_CALLBACK (account_widget_settings_ready_cb), self);
 558 }
 559
 560 static void
 561 account_widget_build_salut (EmpathyAccountWidget *self,
 562     const char *filename)
 563 {
 564   self->ui_details->gui = empathy_builder_get_file (filename,
 565       "vbox_salut_settings", &self->ui_details->widget,
 566       NULL);
 567
 568   empathy_account_widget_handle_params (self,
 569       "entry_published", "published-name",
 570       "entry_nickname", "nickname",
 571       "entry_first_name", "first-name",
 572       "entry_last_name", "last-name",
 573       "entry_email", "email",
 574       "entry_jid", "jid",
 575       NULL);
 576
 577   self->ui_details->default_focus = g_strdup ("entry_nickname");
 578 }
 579
 580 static void
 581 account_widget_build_msn (EmpathyAccountWidget *self,
 582     const char *filename)
 583 {
 584   self->ui_details->gui = empathy_builder_get_file (filename,
 585       "vbox_msn_settings", &self->ui_details->widget,
 586       NULL);
 587
 588   empathy_account_widget_handle_params (self,
 589       "entry_id", "account",
 590       "entry_password", "password",
 591       "entry_server", "server",
 592       "spinbutton_port", "port",
 593       NULL);
 594
 595   self->ui_details->default_focus = g_strdup ("entry_id");
 596   self->ui_details->add_forget = TRUE;
 597 }
 598
 599 static void
 600 account_widget_build_jabber (EmpathyAccountWidget *self,
 601     const char *filename)
 602 {
 603   EmpathyAccountWidgetPriv *priv = GET_PRIV (self);
 604   GtkWidget *spinbutton_port;
 605   GtkWidget *checkbutton_ssl;
 606
 607   self->ui_details->gui = empathy_builder_get_file (filename,
 608       "vbox_jabber_settings", &self->ui_details->widget,
 609       "spinbutton_port", &spinbutton_port,
 610       "checkbutton_ssl", &checkbutton_ssl,
 611       NULL);
 612
 613   empathy_account_widget_handle_params (self,
 614       "entry_id", "account",
 615       "entry_password", "password",
 616       "entry_resource", "resource",
 617       "entry_server", "server",
 618       "spinbutton_port", "port",
 619       "spinbutton_priority", "priority",
 620       "checkbutton_ssl", "old-ssl",
 621       "checkbutton_ignore_ssl_errors", "ignore-ssl-errors",
 622       "checkbutton_encryption", "require-encryption",
 623       NULL);
 624
 625   self->ui_details->default_focus = g_strdup ("entry_id");
 626   self->ui_details->add_forget = TRUE;
 627   priv->spinbutton_port = spinbutton_port;
 628
 629   g_signal_connect (checkbutton_ssl, "toggled",
 630       G_CALLBACK (account_widget_jabber_ssl_toggled_cb),
 631       self);
 632 }
 633
 634 static void
 635 account_widget_build_icq (EmpathyAccountWidget *self,
 636     const char *filename)
 637 {
 638   GtkWidget *spinbutton_port;
 639
 640   self->ui_details->gui = empathy_builder_get_file (filename,
 641       "vbox_icq_settings", &self->ui_details->widget,
 642       "spinbutton_port", &spinbutton_port,
 643       NULL);
 644
 645   empathy_account_widget_handle_params (self,
 646       "entry_uin", "account",
 647       "entry_password", "password",
 648       "entry_server", "server",
 649       "spinbutton_port", "port",
 650       "entry_charset", "charset",
 651       NULL);
 652
 653   self->ui_details->default_focus = g_strdup ("entry_uin");
 654   self->ui_details->add_forget = TRUE;
 655 }
 656
 657 static void
 658 account_widget_build_aim (EmpathyAccountWidget *self,
 659     const char *filename)
 660 {
 661   GtkWidget *spinbutton_port;
 662
 663   self->ui_details->gui = empathy_builder_get_file (filename,
 664       "vbox_aim_settings", &self->ui_details->widget,
 665       "spinbutton_port", &spinbutton_port,
 666       NULL);
 667
 668   empathy_account_widget_handle_params (self,
 669       "entry_screenname", "account",
 670       "entry_password", "password",
 671       "entry_server", "server",
 672       "spinbutton_port", "port",
 673       NULL);
 674
 675   self->ui_details->default_focus = g_strdup ("entry_screenname");
 676   self->ui_details->add_forget = TRUE;
 677 }
 678
 679 static void
 680 account_widget_build_yahoo (EmpathyAccountWidget *self,
 681     const char *filename)
 682 {
 683   self->ui_details->gui = empathy_builder_get_file (filename,
 684       "vbox_yahoo_settings", &self->ui_details->widget,
 685       NULL);
 686
 687   empathy_account_widget_handle_params (self,
 688       "entry_id", "account",
 689       "entry_password", "password",
 690       "entry_server", "server",
 691       "entry_locale", "room-list-locale",
 692       "entry_charset", "charset",
 693       "spinbutton_port", "port",
 694       "checkbutton_yahoojp", "yahoojp",
 695       "checkbutton_ignore_invites", "ignore-invites",
 696       NULL);
 697
 698   self->ui_details->default_focus = g_strdup ("entry_id");
 699   self->ui_details->add_forget = TRUE;
 700 }
 701
 702 static void
 703 account_widget_build_groupwise (EmpathyAccountWidget *self,
 704     const char *filename)
 705 {
 706   self->ui_details->gui = empathy_builder_get_file (filename,
 707       "vbox_groupwise_settings", &self->ui_details->widget,
 708       NULL);
 709
 710   empathy_account_widget_handle_params (self,
 711       "entry_id", "account",
 712       "entry_password", "password",
 713       "entry_server", "server",
 714       "spinbutton_port", "port",
 715       NULL);
 716
 717   self->ui_details->default_focus = g_strdup ("entry_id");
 718   self->ui_details->add_forget = TRUE;
 719 }
 720
 721 static void
 722 account_widget_destroy_cb (GtkWidget *widget,
 723     EmpathyAccountWidget *self)
 724 {
 725   g_object_unref (self);
 726 }
 727
 728 static void
 729 do_set_property (GObject *object,
 730     guint prop_id,
 731     const GValue *value,
 732     GParamSpec *pspec)
 733 {
 734   EmpathyAccountWidgetPriv *priv = GET_PRIV (object);
 735
 736   switch (prop_id)
 737     {
 738     case PROP_PROTOCOL:
 739       priv->protocol = g_value_dup_string (value);
 740       break;
 741     case PROP_SETTINGS:
 742       priv->settings = g_value_dup_object (value);
 743       break;
 744     default:
 745       G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
 746     }
 747 }
 748
 749 static void
 750 do_get_property (GObject *object,
 751     guint prop_id,
 752     GValue *value,
 753     GParamSpec *pspec)
 754 {
 755   EmpathyAccountWidgetPriv *priv = GET_PRIV (object);
 756
 757   switch (prop_id)
 758     {
 759     case PROP_PROTOCOL:
 760       g_value_set_string (value, priv->protocol);
 761       break;
 762     case PROP_SETTINGS:
 763       g_value_set_object (value, priv->settings);
 764       break;
 765     default:
 766       G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
 767     }
 768 }
 769
 770 static void
 771 do_constructed (GObject *obj)
 772 {
 773   EmpathyAccountWidget *self = EMPATHY_ACCOUNT_WIDGET (obj);
 774   EmpathyAccountWidgetPriv *priv = GET_PRIV (self);
 775   char *uiname, *filename;
 776
 777   uiname = g_strconcat ("empathy-account-widget-", priv->protocol,
 778       ".ui", NULL);
 779   filename = empathy_file_lookup (uiname, "libempathy-gtk");
 780
 781   if (!tp_strdiff (priv->protocol, "local-xmpp"))
 782     account_widget_build_salut (self, filename);
 783   else if (!tp_strdiff (priv->protocol, "msn"))
 784     account_widget_build_msn (self, filename);
 785   else if (!tp_strdiff (priv->protocol, "jabber"))
 786     account_widget_build_jabber (self, filename);
 787   else if (!tp_strdiff (priv->protocol, "icq"))
 788     account_widget_build_icq (self, filename);
 789   else if (!tp_strdiff (priv->protocol, "aim"))
 790     account_widget_build_aim (self, filename);
 791   else if (!tp_strdiff (priv->protocol, "yahoo"))
 792     account_widget_build_yahoo (self, filename);
 793   else if (!tp_strdiff (priv->protocol, "groupwise"))
 794     account_widget_build_groupwise (self, filename);
 795   else if (!tp_strdiff (priv->protocol, "irc"))
 796     empathy_account_widget_irc_build (self, filename);
 797   else if (!tp_strdiff (priv->protocol, "sip"))
 798     empathy_account_widget_sip_build (self, filename);
 799   else
 800     account_widget_build_generic (self, filename);
 801
 802   g_free (uiname);
 803   g_free (filename);
 804
 805   /* handle default focus */
 806   if (self->ui_details->default_focus != NULL)
 807     {
 808       GObject *default_focus_entry;
 809
 810       default_focus_entry = gtk_builder_get_object
 811         (self->ui_details->gui, self->ui_details->default_focus);
 812       g_signal_connect (default_focus_entry, "realize",
 813           G_CALLBACK (gtk_widget_grab_focus),
 814           NULL);
 815     }
 816
 817   /* handle forget button */
 818   if (self->ui_details->add_forget)
 819     {
 820       const gchar *password = NULL;
 821
 822       priv->button_forget = GTK_WIDGET (gtk_builder_get_object
 823           (self->ui_details->gui, "button_forget"));
 824       priv->entry_password = GTK_WIDGET (gtk_builder_get_object
 825           (self->ui_details->gui, "entry_password"));
 826
 827       password = empathy_account_settings_get_string (priv->settings,
 828           "password");
 829       gtk_widget_set_sensitive (priv->button_forget,
 830           !EMP_STR_EMPTY (password));
 831
 832       g_signal_connect (priv->button_forget, "clicked",
 833           G_CALLBACK (account_widget_forget_clicked_cb),
 834           self);
 835       g_signal_connect (priv->entry_password, "changed",
 836           G_CALLBACK (account_widget_password_changed_cb),
 837           self);
 838     }
 839
 840   /* handle apply button */
 841   priv->apply_button = gtk_button_new_from_stock (GTK_STOCK_APPLY);
 842   gtk_box_pack_end (GTK_BOX (self->ui_details->widget), priv->apply_button, FALSE, FALSE, 3);
 843
 844   g_signal_connect (priv->apply_button, "clicked",
 845       G_CALLBACK (account_widget_apply_clicked_cb),
 846       self);
 847   account_widget_handle_apply_sensitivity (self);
 848   gtk_widget_show (priv->apply_button);
 849
 850   /* hook up to widget destruction to unref ourselves */
 851   g_signal_connect (self->ui_details->widget, "destroy",
 852       G_CALLBACK (account_widget_destroy_cb), self);
 853
 854   empathy_builder_unref_and_keep_widget (self->ui_details->gui, self->ui_details->widget);
 855   self->ui_details->gui = NULL;
 856 }
 857
 858 static void
 859 do_dispose (GObject *obj)
 860 {
 861   EmpathyAccountWidget *self = EMPATHY_ACCOUNT_WIDGET (obj);
 862   EmpathyAccountWidgetPriv *priv = GET_PRIV (self);
 863
 864   if (priv->dispose_run)
 865     return;
 866
 867   priv->dispose_run = TRUE;
 868
 869   if (priv->settings != NULL)
 870     {
 871       g_object_unref (priv->settings);
 872       priv->settings = NULL;
 873     }
 874
 875   if (G_OBJECT_CLASS (empathy_account_widget_parent_class)->dispose != NULL)
 876     G_OBJECT_CLASS (empathy_account_widget_parent_class)->dispose (obj);
 877 }
 878
 879 static void
 880 do_finalize (GObject *obj)
 881 {
 882   EmpathyAccountWidget *self = EMPATHY_ACCOUNT_WIDGET (obj);
 883   EmpathyAccountWidgetPriv *priv = GET_PRIV (self);
 884
 885   g_free (self->ui_details->default_focus);
 886   g_slice_free (EmpathyAccountWidgetUIDetails, self->ui_details);
 887
 888   g_free (priv->protocol);
 889
 890   if (G_OBJECT_CLASS (empathy_account_widget_parent_class)->finalize != NULL)
 891     G_OBJECT_CLASS (empathy_account_widget_parent_class)->finalize (obj);
 892 }
 893
 894 static void
 895 empathy_account_widget_class_init (EmpathyAccountWidgetClass *klass)
 896 {
 897   GObjectClass *oclass = G_OBJECT_CLASS (klass);
 898   GParamSpec *param_spec;
 899
 900   oclass->get_property = do_get_property;
 901   oclass->set_property = do_set_property;
 902   oclass->constructed = do_constructed;
 903   oclass->dispose = do_dispose;
 904   oclass->finalize = do_finalize;
 905
 906   param_spec = g_param_spec_string ("protocol",
 907       "protocol", "The protocol of the account",
 908       NULL,
 909       G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS | G_PARAM_CONSTRUCT_ONLY);
 910   g_object_class_install_property (oclass, PROP_PROTOCOL, param_spec);
 911
 912   param_spec = g_param_spec_object ("settings",
 913       "settings", "The settings of the account",
 914       EMPATHY_TYPE_ACCOUNT_SETTINGS,
 915       G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS | G_PARAM_CONSTRUCT_ONLY);
 916   g_object_class_install_property (oclass, PROP_SETTINGS, param_spec);
 917
 918   g_type_class_add_private (klass, sizeof (EmpathyAccountWidgetPriv));
 919 }
 920
 921 static void
 922 empathy_account_widget_init (EmpathyAccountWidget *self)
 923 {
 924   EmpathyAccountWidgetPriv *priv =
 925     G_TYPE_INSTANCE_GET_PRIVATE ((self), EMPATHY_TYPE_ACCOUNT_WIDGET,
 926         EmpathyAccountWidgetPriv);
 927
 928   self->priv = priv;
 929   priv->dispose_run = FALSE;
 930
 931   self->ui_details = g_slice_new0 (EmpathyAccountWidgetUIDetails);
 932 }
 933
 934 /* public methods */
 935
 936 void
 937 empathy_account_widget_handle_params (EmpathyAccountWidget *self,
 938     const gchar *first_widget,
 939     ...)
 940 {
 941   va_list args;
 942
 943   va_start (args, first_widget);
 944   account_widget_handle_params_valist (self, first_widget, args);
 945   va_end (args);
 946 }
 947
 948 GtkWidget *
 949 empathy_account_widget_new_for_protocol (const char *protocol,
 950     EmpathyAccountSettings *settings)
 951 {
 952   EmpathyAccountWidget *self;
 953   EmpathyAccountWidgetPriv *priv;
 954
 955   g_return_val_if_fail (EMPATHY_IS_ACCOUNT_SETTINGS (settings), NULL);
 956   g_return_val_if_fail (settings != NULL, NULL);
 957
 958   self = g_object_new
 959     (EMPATHY_TYPE_ACCOUNT_WIDGET, "protocol", protocol,
 960         "settings", settings, NULL);
 961   priv = GET_PRIV (self);
 962
 963   return self->ui_details->widget;
 964 }