libempathy-gtk/empathy-account-widget.c

   1 /*
   2  * Copyright (C) 2006-2007 Imendio AB
   3  * Copyright (C) 2007-2009 Collabora Ltd.
   4  *
   5  * This program is free software; you can redistribute it and/or
   6  * modify it under the terms of the GNU General Public License as
   7  * published by the Free Software Foundation; either version 2 of the
   8  * License, or (at your option) any later version.
   9  *
  10  * This program is distributed in the hope that it will be useful,
  11  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  12  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  13  * General Public License for more details.
  14  *
  15  * You should have received a copy of the GNU General Public
  16  * License along with this program; if not, write to the
  17  * Free Software Foundation, Inc., 51 Franklin St, Fifth Floor,
  18  * Boston, MA  02110-1301  USA
  19  *
  20  * Authors: Xavier Claessens <xclaesse@gmail.com>
  21  *          Martyn Russell <martyn@imendio.com>
  22  *          Cosimo Cecchi <cosimo.cecchi@collabora.co.uk>
  23  *          Jonathan Tellier <jonathan.tellier@gmail.com>
  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 #ifdef HAVE_MOBLIN
  34 #include <nbtk/nbtk-gtk.h>
  35 #endif
  36
  37 #include <libempathy/empathy-utils.h>
  38
  39 #include <telepathy-glib/account.h>
  40 #include <telepathy-glib/account-manager.h>
  41 #include <telepathy-glib/connection-manager.h>
  42 #include <telepathy-glib/util.h>
  43 #include <dbus/dbus-protocol.h>
  44
  45 #include "empathy-account-widget.h"
  46 #include "empathy-account-widget-private.h"
  47 #include "empathy-account-widget-sip.h"
  48 #include "empathy-account-widget-irc.h"
  49 #include "empathy-ui-utils.h"
  50
  51 #define DEBUG_FLAG EMPATHY_DEBUG_ACCOUNT
  52 #include <libempathy/empathy-debug.h>
  53
  54 G_DEFINE_TYPE (EmpathyAccountWidget, empathy_account_widget, G_TYPE_OBJECT)
  55
  56 typedef struct {
  57   EmpathyAccountSettings *settings;
  58
  59   GtkWidget *table_common_settings;
  60   GtkWidget *apply_button;
  61   GtkWidget *cancel_button;
  62   GtkWidget *entry_password;
  63   GtkWidget *button_forget;
  64   GtkWidget *spinbutton_port;
  65   GtkWidget *enabled_checkbox;
  66   GtkWidget *radiobutton_reuse;
  67
  68   gboolean simple;
  69
  70   gboolean contains_pending_changes;
  71
  72   /* An EmpathyAccountWidget can be used to either create an account or
  73    * modify it. When we are creating an account, this member is set to TRUE */
  74   gboolean creating_account;
  75
  76   /* if TRUE, the GTK+ destroy signal has been fired and so the widgets
  77    * embedded in this account widget can't be used any more
  78    * workaround because some async callbacks can be called after the
  79    * widget has been destroyed */
  80   gboolean destroyed;
  81
  82   TpAccountManager *account_manager;
  83
  84   GtkWidget *param_account_widget;
  85   GtkWidget *param_password_widget;
  86
  87   gboolean dispose_run;
  88 } EmpathyAccountWidgetPriv;
  89
  90 enum {
  91   PROP_PROTOCOL = 1,
  92   PROP_SETTINGS,
  93   PROP_SIMPLE,
  94   PROP_CREATING_ACCOUNT
  95 };
  96
  97 enum {
  98   HANDLE_APPLY,
  99   ACCOUNT_CREATED,
 100   CANCELLED,
 101   LAST_SIGNAL
 102 };
 103
 104 static guint signals[LAST_SIGNAL] = { 0 };
 105
 106 #define GET_PRIV(obj) EMPATHY_GET_PRIV (obj, EmpathyAccountWidget)
 107 #define CHANGED_TIMEOUT 300
 108
 109 static void
 110 account_widget_set_control_buttons_sensitivity (EmpathyAccountWidget *self,
 111     gboolean sensitive)
 112 {
 113   EmpathyAccountWidgetPriv *priv = GET_PRIV (self);
 114
 115   if (!priv->simple)
 116     {
 117       gtk_widget_set_sensitive (priv->apply_button, sensitive);
 118       gtk_widget_set_sensitive (
 119           priv->cancel_button, sensitive || priv->creating_account);
 120     }
 121 }
 122
 123 static void
 124 account_widget_handle_control_buttons_sensitivity (EmpathyAccountWidget *self)
 125 {
 126   EmpathyAccountWidgetPriv *priv = GET_PRIV (self);
 127   gboolean is_valid;
 128
 129   is_valid = empathy_account_settings_is_valid (priv->settings);
 130
 131   if (!priv->simple)
 132       account_widget_set_control_buttons_sensitivity (self, is_valid);
 133
 134   g_signal_emit (self, signals[HANDLE_APPLY], 0, is_valid);
 135 }
 136
 137 static void
 138 account_widget_entry_changed_common (EmpathyAccountWidget *self,
 139     GtkEntry *entry, gboolean focus)
 140 {
 141   const gchar *str;
 142   const gchar *param_name;
 143   EmpathyAccountWidgetPriv *priv = GET_PRIV (self);
 144
 145   str = gtk_entry_get_text (entry);
 146   param_name = g_object_get_data (G_OBJECT (entry), "param_name");
 147
 148   if (EMP_STR_EMPTY (str))
 149     {
 150       const gchar *value = NULL;
 151
 152       empathy_account_settings_unset (priv->settings, param_name);
 153
 154       if (focus)
 155         {
 156           value = empathy_account_settings_get_string (priv->settings,
 157               param_name);
 158           DEBUG ("Unset %s and restore to %s", param_name, value);
 159           gtk_entry_set_text (entry, value ? value : "");
 160         }
 161     }
 162   else
 163     {
 164       DEBUG ("Setting %s to %s", param_name,
 165           tp_strdiff (param_name, "password") ? str : "***");
 166       empathy_account_settings_set_string (priv->settings, param_name, str);
 167     }
 168 }
 169
 170 static void
 171 account_widget_entry_changed_cb (GtkEditable *entry,
 172     EmpathyAccountWidget *self)
 173 {
 174   account_widget_entry_changed_common (self, GTK_ENTRY (entry), FALSE);
 175   empathy_account_widget_changed (self);
 176 }
 177
 178 static void
 179 account_widget_int_changed_cb (GtkWidget *widget,
 180     EmpathyAccountWidget *self)
 181 {
 182   const gchar *param_name;
 183   gint value;
 184   const gchar *signature;
 185   EmpathyAccountWidgetPriv *priv = GET_PRIV (self);
 186
 187   value = gtk_spin_button_get_value_as_int (GTK_SPIN_BUTTON (widget));
 188   param_name = g_object_get_data (G_OBJECT (widget), "param_name");
 189
 190   signature = empathy_account_settings_get_dbus_signature (priv->settings,
 191     param_name);
 192   g_return_if_fail (signature != NULL);
 193
 194   DEBUG ("Setting %s to %d", param_name, value);
 195
 196   switch ((int)*signature)
 197     {
 198     case DBUS_TYPE_INT16:
 199     case DBUS_TYPE_INT32:
 200       empathy_account_settings_set_int32 (priv->settings, param_name, value);
 201       break;
 202     case DBUS_TYPE_INT64:
 203       empathy_account_settings_set_int64 (priv->settings, param_name, value);
 204       break;
 205     case DBUS_TYPE_UINT16:
 206     case DBUS_TYPE_UINT32:
 207       empathy_account_settings_set_uint32 (priv->settings, param_name, value);
 208       break;
 209     case DBUS_TYPE_UINT64:
 210       empathy_account_settings_set_uint64 (priv->settings, param_name, value);
 211       break;
 212     default:
 213       g_return_if_reached ();
 214     }
 215
 216   empathy_account_widget_changed (self);
 217 }
 218
 219 static void
 220 account_widget_checkbutton_toggled_cb (GtkWidget *widget,
 221     EmpathyAccountWidget *self)
 222 {
 223   gboolean     value;
 224   gboolean     default_value;
 225   const gchar *param_name;
 226   EmpathyAccountWidgetPriv *priv = GET_PRIV (self);
 227
 228   value = gtk_toggle_button_get_active (GTK_TOGGLE_BUTTON (widget));
 229   param_name = g_object_get_data (G_OBJECT (widget), "param_name");
 230
 231   /* FIXME: This is ugly! checkbox don't have a "not-set" value so we
 232    * always unset the param and set the value if different from the
 233    * default value. */
 234   empathy_account_settings_unset (priv->settings, param_name);
 235   default_value = empathy_account_settings_get_boolean (priv->settings,
 236       param_name);
 237
 238   if (default_value == value)
 239     {
 240       DEBUG ("Unset %s and restore to %d", param_name, default_value);
 241     }
 242   else
 243     {
 244       DEBUG ("Setting %s to %d", param_name, value);
 245       empathy_account_settings_set_boolean (priv->settings, param_name, value);
 246     }
 247
 248   empathy_account_widget_changed (self);
 249 }
 250
 251 static void
 252 account_widget_forget_clicked_cb (GtkWidget *button,
 253     EmpathyAccountWidget *self)
 254 {
 255   EmpathyAccountWidgetPriv *priv = GET_PRIV (self);
 256   const gchar *param_name;
 257
 258   param_name = g_object_get_data (G_OBJECT (priv->entry_password),
 259       "param_name");
 260
 261   DEBUG ("Unset %s", param_name);
 262   empathy_account_settings_unset (priv->settings, param_name);
 263   gtk_entry_set_text (GTK_ENTRY (priv->entry_password), "");
 264
 265   empathy_account_widget_changed (self);
 266 }
 267
 268 static void
 269 account_widget_password_changed_cb (GtkWidget *entry,
 270     EmpathyAccountWidget *self)
 271 {
 272   EmpathyAccountWidgetPriv *priv = GET_PRIV (self);
 273   const gchar *str;
 274
 275   str = gtk_entry_get_text (GTK_ENTRY (entry));
 276   gtk_widget_set_sensitive (priv->button_forget, !EMP_STR_EMPTY (str));
 277
 278   priv->contains_pending_changes = TRUE;
 279 }
 280
 281 static void
 282 account_widget_jabber_ssl_toggled_cb (GtkWidget *checkbutton_ssl,
 283     EmpathyAccountWidget *self)
 284 {
 285   EmpathyAccountWidgetPriv *priv = GET_PRIV (self);
 286   gboolean   value;
 287   gint32       port = 0;
 288
 289   value = gtk_toggle_button_get_active (GTK_TOGGLE_BUTTON (checkbutton_ssl));
 290   port = empathy_account_settings_get_uint32 (priv->settings, "port");
 291
 292   if (value)
 293     {
 294       if (port == 5222 || port == 0)
 295         port = 5223;
 296     }
 297   else
 298     {
 299       if (port == 5223 || port == 0)
 300         port = 5222;
 301     }
 302
 303   gtk_spin_button_set_value (GTK_SPIN_BUTTON (priv->spinbutton_port), port);
 304
 305   priv->contains_pending_changes = TRUE;
 306 }
 307
 308 static void
 309 account_widget_combobox_changed_cb (GtkWidget *widget,
 310     EmpathyAccountWidget *self)
 311 {
 312   GtkTreeIter iter;
 313   GtkTreeModel *model;
 314   const gchar *value;
 315   const GValue *v;
 316   const gchar *default_value = NULL;
 317   const gchar *param_name;
 318   EmpathyAccountWidgetPriv *priv = GET_PRIV (self);
 319
 320   if (!gtk_combo_box_get_active_iter (GTK_COMBO_BOX (widget), &iter))
 321     return;
 322
 323   model = gtk_combo_box_get_model (GTK_COMBO_BOX (widget));
 324   /* the param value is stored in the first column */
 325   gtk_tree_model_get (model, &iter, 0, &value, -1);
 326
 327   param_name = g_object_get_data (G_OBJECT (widget), "param_name");
 328
 329   v = empathy_account_settings_get_default (priv->settings, param_name);
 330   if (v != NULL)
 331     default_value = g_value_get_string (v);
 332
 333   if (!tp_strdiff (value, default_value))
 334     {
 335       DEBUG ("Unset %s and restore to %s", param_name, default_value);
 336       empathy_account_settings_unset (priv->settings, param_name);
 337     }
 338   else
 339     {
 340       DEBUG ("Setting %s to %s", param_name, value);
 341       empathy_account_settings_set_string (priv->settings, param_name, value);
 342     }
 343
 344   empathy_account_widget_changed (self);
 345 }
 346
 347 void
 348 empathy_account_widget_setup_widget (EmpathyAccountWidget *self,
 349     GtkWidget *widget,
 350     const gchar *param_name)
 351 {
 352   EmpathyAccountWidgetPriv *priv = GET_PRIV (self);
 353
 354   g_object_set_data_full (G_OBJECT (widget), "param_name",
 355       g_strdup (param_name), g_free);
 356
 357   if (GTK_IS_SPIN_BUTTON (widget))
 358     {
 359       gint value = 0;
 360       const gchar *signature;
 361
 362       signature = empathy_account_settings_get_dbus_signature (priv->settings,
 363           param_name);
 364       g_return_if_fail (signature != NULL);
 365
 366       switch ((int)*signature)
 367         {
 368           case DBUS_TYPE_INT16:
 369           case DBUS_TYPE_INT32:
 370             value = empathy_account_settings_get_int32 (priv->settings,
 371               param_name);
 372             break;
 373           case DBUS_TYPE_INT64:
 374             value = empathy_account_settings_get_int64 (priv->settings,
 375               param_name);
 376             break;
 377           case DBUS_TYPE_UINT16:
 378           case DBUS_TYPE_UINT32:
 379             value = empathy_account_settings_get_uint32 (priv->settings,
 380               param_name);
 381             break;
 382           case DBUS_TYPE_UINT64:
 383             value = empathy_account_settings_get_uint64 (priv->settings,
 384                 param_name);
 385             break;
 386           default:
 387             g_return_if_reached ();
 388         }
 389
 390       gtk_spin_button_set_value (GTK_SPIN_BUTTON (widget), value);
 391
 392       g_signal_connect (widget, "value-changed",
 393           G_CALLBACK (account_widget_int_changed_cb),
 394           self);
 395     }
 396   else if (GTK_IS_ENTRY (widget))
 397     {
 398       const gchar *str = NULL;
 399
 400       str = empathy_account_settings_get_string (priv->settings, param_name);
 401       gtk_entry_set_text (GTK_ENTRY (widget), str ? str : "");
 402
 403       if (!tp_strdiff (param_name, "account"))
 404         priv->param_account_widget = widget;
 405       else if (!tp_strdiff (param_name, "password"))
 406         priv->param_password_widget = widget;
 407
 408       if (strstr (param_name, "password"))
 409         {
 410           gtk_entry_set_visibility (GTK_ENTRY (widget), FALSE);
 411         }
 412
 413       g_signal_connect (widget, "changed",
 414           G_CALLBACK (account_widget_entry_changed_cb), self);
 415     }
 416   else if (GTK_IS_TOGGLE_BUTTON (widget))
 417     {
 418       gboolean value = FALSE;
 419
 420       value = empathy_account_settings_get_boolean (priv->settings,
 421           param_name);
 422       gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (widget), value);
 423
 424       g_signal_connect (widget, "toggled",
 425           G_CALLBACK (account_widget_checkbutton_toggled_cb),
 426           self);
 427     }
 428   else if (GTK_IS_COMBO_BOX (widget))
 429     {
 430       /* The combo box's model has to contain the param value in its first
 431        * column (as a string) */
 432       const gchar *str;
 433       GtkTreeModel *model;
 434       GtkTreeIter iter;
 435       gboolean valid;
 436
 437       str = empathy_account_settings_get_string (priv->settings, param_name);
 438       model = gtk_combo_box_get_model (GTK_COMBO_BOX (widget));
 439
 440       valid = gtk_tree_model_get_iter_first (model, &iter);
 441       while (valid)
 442         {
 443           gchar *name;
 444
 445           gtk_tree_model_get (model, &iter, 0, &name, -1);
 446           if (!tp_strdiff (name, str))
 447             {
 448               gtk_combo_box_set_active_iter (GTK_COMBO_BOX (widget), &iter);
 449               valid = FALSE;
 450             }
 451           else
 452             {
 453               valid = gtk_tree_model_iter_next (model, &iter);
 454             }
 455
 456           g_free (name);
 457         }
 458
 459       g_signal_connect (widget, "changed",
 460           G_CALLBACK (account_widget_combobox_changed_cb),
 461           self);
 462     }
 463   else
 464     {
 465       DEBUG ("Unknown type of widget for param %s", param_name);
 466     }
 467 }
 468
 469 static gchar *
 470 account_widget_generic_format_param_name (const gchar *param_name)
 471 {
 472   gchar *str;
 473   gchar *p;
 474
 475   str = g_strdup (param_name);
 476
 477   if (str && g_ascii_isalpha (str[0]))
 478     str[0] = g_ascii_toupper (str[0]);
 479
 480   while ((p = strchr (str, '-')) != NULL)
 481     {
 482       if (p[1] != '\0' && g_ascii_isalpha (p[1]))
 483         {
 484           p[0] = ' ';
 485           p[1] = g_ascii_toupper (p[1]);
 486         }
 487
 488       p++;
 489     }
 490
 491   return str;
 492 }
 493
 494 static void
 495 accounts_widget_generic_setup (EmpathyAccountWidget *self,
 496     GtkWidget *table_common_settings,
 497     GtkWidget *table_advanced_settings)
 498 {
 499   TpConnectionManagerParam *params, *param;
 500   EmpathyAccountWidgetPriv *priv = GET_PRIV (self);
 501
 502   params = empathy_account_settings_get_tp_params (priv->settings);
 503
 504   for (param = params; param != NULL && param->name != NULL; param++)
 505     {
 506       GtkWidget       *table_settings;
 507       guint            n_rows = 0;
 508       GtkWidget       *widget = NULL;
 509       gchar           *param_name_formatted;
 510
 511       if (param->flags & TP_CONN_MGR_PARAM_FLAG_REQUIRED)
 512         table_settings = table_common_settings;
 513       else if (priv->simple)
 514         return;
 515       else
 516         table_settings = table_advanced_settings;
 517
 518       param_name_formatted = account_widget_generic_format_param_name
 519         (param->name);
 520       g_object_get (table_settings, "n-rows", &n_rows, NULL);
 521       gtk_table_resize (GTK_TABLE (table_settings), ++n_rows, 2);
 522
 523       if (param->dbus_signature[0] == 's')
 524         {
 525           gchar *str;
 526
 527           str = g_strdup_printf (_("%s:"), param_name_formatted);
 528           widget = gtk_label_new (str);
 529           gtk_misc_set_alignment (GTK_MISC (widget), 0, 0.5);
 530           g_free (str);
 531
 532           gtk_table_attach (GTK_TABLE (table_settings),
 533               widget,
 534               0, 1,
 535               n_rows - 1, n_rows,
 536               GTK_FILL, 0,
 537               0, 0);
 538           gtk_widget_show (widget);
 539
 540           widget = gtk_entry_new ();
 541           if (strcmp (param->name, "account") == 0)
 542             {
 543               g_signal_connect (widget, "realize",
 544                   G_CALLBACK (gtk_widget_grab_focus),
 545                   NULL);
 546             }
 547           gtk_table_attach (GTK_TABLE (table_settings),
 548               widget,
 549               1, 2,
 550               n_rows - 1, n_rows,
 551               GTK_FILL | GTK_EXPAND, 0,
 552               0, 0);
 553           gtk_widget_show (widget);
 554         }
 555       /* int types: ynqiuxt. double type is 'd' */
 556       else if (param->dbus_signature[0] == 'y' ||
 557           param->dbus_signature[0] == 'n' ||
 558           param->dbus_signature[0] == 'q' ||
 559           param->dbus_signature[0] == 'i' ||
 560           param->dbus_signature[0] == 'u' ||
 561           param->dbus_signature[0] == 'x' ||
 562           param->dbus_signature[0] == 't' ||
 563           param->dbus_signature[0] == 'd')
 564         {
 565           gchar   *str = NULL;
 566           gdouble  minint = 0;
 567           gdouble  maxint = 0;
 568           gdouble  step = 1;
 569
 570           switch (param->dbus_signature[0])
 571             {
 572             case 'y': minint = G_MININT8;  maxint = G_MAXINT8;   break;
 573             case 'n': minint = G_MININT16; maxint = G_MAXINT16;  break;
 574             case 'q': minint = 0;          maxint = G_MAXUINT16; break;
 575             case 'i': minint = G_MININT32; maxint = G_MAXINT32;  break;
 576             case 'u': minint = 0;          maxint = G_MAXUINT32; break;
 577             case 'x': minint = G_MININT64; maxint = G_MAXINT64;  break;
 578             case 't': minint = 0;          maxint = G_MAXUINT64; break;
 579             case 'd': minint = G_MININT32; maxint = G_MAXINT32;
 580               step = 0.1; break;
 581             }
 582
 583           str = g_strdup_printf (_("%s:"), param_name_formatted);
 584           widget = gtk_label_new (str);
 585           gtk_misc_set_alignment (GTK_MISC (widget), 0, 0.5);
 586           g_free (str);
 587
 588           gtk_table_attach (GTK_TABLE (table_settings),
 589               widget,
 590               0, 1,
 591               n_rows - 1, n_rows,
 592               GTK_FILL, 0,
 593               0, 0);
 594           gtk_widget_show (widget);
 595
 596           widget = gtk_spin_button_new_with_range (minint, maxint, step);
 597           gtk_table_attach (GTK_TABLE (table_settings),
 598               widget,
 599               1, 2,
 600               n_rows - 1, n_rows,
 601               GTK_FILL | GTK_EXPAND, 0,
 602               0, 0);
 603           gtk_widget_show (widget);
 604         }
 605       else if (param->dbus_signature[0] == 'b')
 606         {
 607           widget = gtk_check_button_new_with_label (param_name_formatted);
 608           gtk_table_attach (GTK_TABLE (table_settings),
 609               widget,
 610               0, 2,
 611               n_rows - 1, n_rows,
 612               GTK_FILL | GTK_EXPAND, 0,
 613               0, 0);
 614           gtk_widget_show (widget);
 615         }
 616       else
 617         {
 618           DEBUG ("Unknown signature for param %s: %s",
 619               param_name_formatted, param->dbus_signature);
 620         }
 621
 622       if (widget)
 623         empathy_account_widget_setup_widget (self, widget, param->name);
 624
 625       g_free (param_name_formatted);
 626     }
 627 }
 628
 629 static void
 630 account_widget_handle_params_valist (EmpathyAccountWidget *self,
 631     const gchar *first_widget,
 632     va_list args)
 633 {
 634   GObject *object;
 635   const gchar *name;
 636
 637   for (name = first_widget; name; name = va_arg (args, const gchar *))
 638     {
 639       const gchar *param_name;
 640
 641       param_name = va_arg (args, const gchar *);
 642       object = gtk_builder_get_object (self->ui_details->gui, name);
 643
 644       if (!object)
 645         {
 646           g_warning ("Builder is missing object '%s'.", name);
 647           continue;
 648         }
 649
 650       empathy_account_widget_setup_widget (self, GTK_WIDGET (object),
 651           param_name);
 652     }
 653 }
 654
 655 static void
 656 account_widget_cancel_clicked_cb (GtkWidget *button,
 657     EmpathyAccountWidget *self)
 658 {
 659   g_signal_emit (self, signals[CANCELLED], 0);
 660 }
 661
 662 static void
 663 account_widget_account_enabled_cb (GObject *source_object,
 664     GAsyncResult *res,
 665     gpointer user_data)
 666 {
 667   GError *error = NULL;
 668   TpAccount *account = TP_ACCOUNT (source_object);
 669   EmpathyAccountWidget *widget = EMPATHY_ACCOUNT_WIDGET (user_data);
 670   EmpathyAccountWidgetPriv *priv = GET_PRIV (widget);
 671   TpConnectionPresenceType presence;
 672   gchar *message = NULL;
 673   gchar *status = NULL;
 674
 675   tp_account_set_enabled_finish (account, res, &error);
 676
 677   if (error != NULL)
 678     {
 679       DEBUG ("Could not enable the account: %s", error->message);
 680       g_error_free (error);
 681     }
 682   else
 683     {
 684       /* only force presence if presence was offline, unknown or unset */
 685       presence = tp_account_get_requested_presence (account, NULL, NULL);
 686       switch (presence)
 687         {
 688         case TP_CONNECTION_PRESENCE_TYPE_OFFLINE:
 689         case TP_CONNECTION_PRESENCE_TYPE_UNKNOWN:
 690         case TP_CONNECTION_PRESENCE_TYPE_UNSET:
 691           presence = tp_account_manager_get_most_available_presence (
 692               priv->account_manager, &status, &message);
 693           tp_account_request_presence_async (account, presence,
 694               status, NULL, NULL, NULL);
 695           break;
 696         default:
 697           /* do nothing if the presence is not offline */
 698           break;
 699         }
 700     }
 701
 702   /* unref widget - part of the workaround */
 703   g_object_unref (widget);
 704   g_free (message);
 705   g_free (status);
 706 }
 707
 708 static void
 709 account_widget_applied_cb (GObject *source_object,
 710     GAsyncResult *res,
 711     gpointer user_data)
 712 {
 713   GError *error = NULL;
 714   TpAccount *account;
 715   EmpathyAccountSettings *settings = EMPATHY_ACCOUNT_SETTINGS (source_object);
 716   EmpathyAccountWidget *widget = EMPATHY_ACCOUNT_WIDGET (user_data);
 717   EmpathyAccountWidgetPriv *priv = GET_PRIV (widget);
 718
 719   empathy_account_settings_apply_finish (settings, res, &error);
 720
 721   if (error != NULL)
 722     {
 723       DEBUG ("Could not apply changes to account: %s", error->message);
 724       g_error_free (error);
 725       return;
 726     }
 727
 728   account = empathy_account_settings_get_account (priv->settings);
 729
 730   if (account != NULL)
 731     {
 732       if (priv->creating_account)
 733         {
 734           /* By default, when an account is created, we enable it. */
 735
 736           /* workaround to keep widget alive during async call */
 737           g_object_ref (widget);
 738
 739           tp_account_set_enabled_async (account, TRUE,
 740               account_widget_account_enabled_cb, widget);
 741           g_signal_emit (widget, signals[ACCOUNT_CREATED], 0, account);
 742         }
 743       else if (priv->enabled_checkbox != NULL)
 744         {
 745           gboolean enabled_checked;
 746
 747           enabled_checked =
 748 #ifdef HAVE_MOBLIN
 749             nbtk_gtk_light_switch_get_active (
 750                 NBTK_GTK_LIGHT_SWITCH (priv->enabled_checkbox));
 751 #else
 752             gtk_toggle_button_get_active (
 753                 GTK_TOGGLE_BUTTON (priv->enabled_checkbox));
 754 #endif
 755
 756           if (tp_account_is_enabled (account) && enabled_checked)
 757             {
 758               /* After having applied changes to a user account, we
 759                * automatically reconnect it. This is done so the new
 760                * information entered by the user is validated on the server. */
 761               tp_account_reconnect_async (account, NULL, NULL);
 762             }
 763         }
 764     }
 765
 766   if (!priv->destroyed)
 767     account_widget_set_control_buttons_sensitivity (widget, FALSE);
 768
 769   priv->contains_pending_changes = FALSE;
 770
 771   /* unref the widget - part of the workaround */
 772   g_object_unref (widget);
 773 }
 774
 775 static void
 776 account_widget_apply_clicked_cb (GtkWidget *button,
 777     EmpathyAccountWidget *self)
 778 {
 779   EmpathyAccountWidgetPriv *priv = GET_PRIV (self);
 780
 781   if (priv->radiobutton_reuse != NULL)
 782     {
 783       gboolean reuse = gtk_toggle_button_get_active (GTK_TOGGLE_BUTTON (
 784             priv->radiobutton_reuse));
 785
 786       DEBUG ("Set register param: %d", !reuse);
 787       empathy_account_settings_set_boolean (priv->settings, "register", !reuse);
 788     }
 789
 790   /* workaround to keep widget alive during async call */
 791   g_object_ref (self);
 792   empathy_account_settings_apply_async (priv->settings,
 793       account_widget_applied_cb, self);
 794 }
 795
 796 static void
 797 account_widget_setup_generic (EmpathyAccountWidget *self)
 798 {
 799   GtkWidget *table_common_settings;
 800   GtkWidget *table_advanced_settings;
 801
 802   table_common_settings = GTK_WIDGET (gtk_builder_get_object
 803       (self->ui_details->gui, "table_common_settings"));
 804   table_advanced_settings = GTK_WIDGET (gtk_builder_get_object
 805       (self->ui_details->gui, "table_advanced_settings"));
 806
 807   accounts_widget_generic_setup (self, table_common_settings,
 808       table_advanced_settings);
 809
 810   g_object_unref (self->ui_details->gui);
 811 }
 812
 813 static void
 814 account_widget_settings_ready_cb (EmpathyAccountSettings *settings,
 815     GParamSpec *pspec,
 816     gpointer user_data)
 817 {
 818   EmpathyAccountWidget *self = user_data;
 819   EmpathyAccountWidgetPriv *priv = GET_PRIV (self);
 820
 821   if (empathy_account_settings_is_ready (priv->settings))
 822     account_widget_setup_generic (self);
 823 }
 824
 825 static void
 826 account_widget_build_generic (EmpathyAccountWidget *self,
 827     const char *filename)
 828 {
 829   EmpathyAccountWidgetPriv *priv = GET_PRIV (self);
 830   GtkWidget *expander_advanced;
 831
 832   self->ui_details->gui = empathy_builder_get_file (filename,
 833       "table_common_settings", &priv->table_common_settings,
 834       "vbox_generic_settings", &self->ui_details->widget,
 835       "expander_advanced_settings", &expander_advanced,
 836       NULL);
 837
 838   if (priv->simple)
 839     gtk_widget_hide (expander_advanced);
 840
 841   g_object_ref (self->ui_details->gui);
 842
 843   if (empathy_account_settings_is_ready (priv->settings))
 844     account_widget_setup_generic (self);
 845   else
 846     g_signal_connect (priv->settings, "notify::ready",
 847         G_CALLBACK (account_widget_settings_ready_cb), self);
 848 }
 849
 850 static void
 851 account_widget_build_salut (EmpathyAccountWidget *self,
 852     const char *filename)
 853 {
 854   EmpathyAccountWidgetPriv *priv = GET_PRIV (self);
 855   GtkWidget *expander_advanced;
 856
 857   self->ui_details->gui = empathy_builder_get_file (filename,
 858       "table_common_settings", &priv->table_common_settings,
 859       "vbox_salut_settings", &self->ui_details->widget,
 860       "expander_advanced_settings", &expander_advanced,
 861       NULL);
 862
 863   empathy_account_widget_handle_params (self,
 864       "entry_published", "published-name",
 865       "entry_nickname", "nickname",
 866       "entry_first_name", "first-name",
 867       "entry_last_name", "last-name",
 868       "entry_email", "email",
 869       "entry_jid", "jid",
 870       NULL);
 871
 872   if (priv->simple)
 873     gtk_widget_hide (expander_advanced);
 874
 875   self->ui_details->default_focus = g_strdup ("entry_first_name");
 876 }
 877
 878 static void
 879 account_widget_build_irc (EmpathyAccountWidget *self,
 880   const char *filename)
 881 {
 882   EmpathyAccountWidgetPriv *priv = GET_PRIV (self);
 883   empathy_account_widget_irc_build (self, filename,
 884     &priv->table_common_settings);
 885 }
 886
 887 static void
 888 account_widget_build_sip (EmpathyAccountWidget *self,
 889   const char *filename)
 890 {
 891   EmpathyAccountWidgetPriv *priv = GET_PRIV (self);
 892   empathy_account_widget_sip_build (self, filename,
 893     &priv->table_common_settings);
 894 }
 895
 896 static void
 897 account_widget_build_msn (EmpathyAccountWidget *self,
 898     const char *filename)
 899 {
 900   EmpathyAccountWidgetPriv *priv = GET_PRIV (self);
 901
 902   if (priv->simple)
 903     {
 904       self->ui_details->gui = empathy_builder_get_file (filename,
 905           "vbox_msn_simple", &self->ui_details->widget,
 906           NULL);
 907
 908       empathy_account_widget_handle_params (self,
 909           "entry_id_simple", "account",
 910           "entry_password_simple", "password",
 911           NULL);
 912
 913       self->ui_details->default_focus = g_strdup ("entry_id_simple");
 914     }
 915   else
 916     {
 917       self->ui_details->gui = empathy_builder_get_file (filename,
 918           "table_common_msn_settings", &priv->table_common_settings,
 919           "vbox_msn_settings", &self->ui_details->widget,
 920           NULL);
 921
 922       empathy_account_widget_handle_params (self,
 923           "entry_id", "account",
 924           "entry_password", "password",
 925           "entry_server", "server",
 926           "spinbutton_port", "port",
 927           NULL);
 928
 929       self->ui_details->default_focus = g_strdup ("entry_id");
 930       self->ui_details->add_forget = TRUE;
 931     }
 932 }
 933
 934 static gboolean
 935 account_widget_is_gtalk (EmpathyAccountWidget *self)
 936 {
 937   EmpathyAccountWidgetPriv *priv = GET_PRIV (self);
 938
 939   return !tp_strdiff (empathy_account_settings_get_icon_name (priv->settings),
 940       "im-google-talk");
 941 }
 942
 943 static gboolean
 944 account_widget_is_facebook (EmpathyAccountWidget *self)
 945 {
 946   EmpathyAccountWidgetPriv *priv = GET_PRIV (self);
 947
 948   return !tp_strdiff (empathy_account_settings_get_icon_name (priv->settings),
 949       "im-facebook");
 950 }
 951
 952 static void
 953 account_widget_build_jabber (EmpathyAccountWidget *self,
 954     const char *filename)
 955 {
 956   EmpathyAccountWidgetPriv *priv = GET_PRIV (self);
 957   GtkWidget *spinbutton_port;
 958   GtkWidget *checkbutton_ssl;
 959   GtkWidget *label_id, *label_password;
 960   GtkWidget *label_id_create, *label_password_create;
 961   GtkWidget *label_example_gtalk, *label_example_jabber, *label_example_fb;
 962   gboolean is_gtalk, is_facebook;
 963
 964   is_gtalk = account_widget_is_gtalk (self);
 965   is_facebook = account_widget_is_facebook (self);
 966
 967   if (priv->simple && !is_gtalk && !is_facebook)
 968     {
 969       /* Simple widget for XMPP */
 970       self->ui_details->gui = empathy_builder_get_file (filename,
 971           "vbox_jabber_simple", &self->ui_details->widget,
 972           "label_id_simple", &label_id,
 973           "label_id_create", &label_id_create,
 974           "label_password_simple", &label_password,
 975           "label_password_create", &label_password_create,
 976           NULL);
 977
 978       if (empathy_account_settings_get_boolean (priv->settings, "register"))
 979         {
 980           gtk_widget_hide (label_id);
 981           gtk_widget_hide (label_password);
 982           gtk_widget_show (label_id_create);
 983           gtk_widget_show (label_password_create);
 984         }
 985
 986       empathy_account_widget_handle_params (self,
 987           "entry_id_simple", "account",
 988           "entry_password_simple", "password",
 989           NULL);
 990
 991       self->ui_details->default_focus = g_strdup ("entry_id_simple");
 992     }
 993   else if (priv->simple && is_gtalk)
 994     {
 995       /* Simple widget for Google Talk */
 996       self->ui_details->gui = empathy_builder_get_file (filename,
 997           "vbox_gtalk_simple", &self->ui_details->widget,
 998           NULL);
 999
1000       empathy_account_widget_handle_params (self,
1001           "entry_id_g_simple", "account",
1002           "entry_password_g_simple", "password",
1003           NULL);
1004
1005       self->ui_details->default_focus = g_strdup ("entry_id_g_simple");
1006     }
1007   /* TODO: Simple widget for Facebook */
1008   else
1009     {
1010       /* Full widget for XMPP, Google Talk and Facebook*/
1011       self->ui_details->gui = empathy_builder_get_file (filename,
1012           "table_common_settings", &priv->table_common_settings,
1013           "vbox_jabber_settings", &self->ui_details->widget,
1014           "spinbutton_port", &spinbutton_port,
1015           "checkbutton_ssl", &checkbutton_ssl,
1016           "label_username_example", &label_example_jabber,
1017           "label_username_g_example", &label_example_gtalk,
1018           "label_username_f_example", &label_example_fb,
1019           NULL);
1020
1021       empathy_account_widget_handle_params (self,
1022           "entry_id", "account",
1023           "entry_password", "password",
1024           "entry_resource", "resource",
1025           "entry_server", "server",
1026           "spinbutton_port", "port",
1027           "spinbutton_priority", "priority",
1028           "checkbutton_ssl", "old-ssl",
1029           "checkbutton_ignore_ssl_errors", "ignore-ssl-errors",
1030           "checkbutton_encryption", "require-encryption",
1031           NULL);
1032
1033       self->ui_details->default_focus = g_strdup ("entry_id");
1034       self->ui_details->add_forget = TRUE;
1035       priv->spinbutton_port = spinbutton_port;
1036
1037       g_signal_connect (checkbutton_ssl, "toggled",
1038           G_CALLBACK (account_widget_jabber_ssl_toggled_cb),
1039           self);
1040
1041       if (is_gtalk)
1042         {
1043           gtk_widget_hide (label_example_jabber);
1044           gtk_widget_show (label_example_gtalk);
1045         }
1046       else if (is_facebook)
1047         {
1048           gtk_widget_hide (label_example_jabber);
1049           gtk_widget_show (label_example_fb);
1050         }
1051     }
1052 }
1053
1054 static void
1055 account_widget_build_icq (EmpathyAccountWidget *self,
1056     const char *filename)
1057 {
1058   EmpathyAccountWidgetPriv *priv = GET_PRIV (self);
1059   GtkWidget *spinbutton_port;
1060
1061   if (priv->simple)
1062     {
1063       self->ui_details->gui = empathy_builder_get_file (filename,
1064           "vbox_icq_simple", &self->ui_details->widget,
1065           NULL);
1066
1067       empathy_account_widget_handle_params (self,
1068           "entry_uin_simple", "account",
1069           "entry_password_simple", "password",
1070           NULL);
1071
1072       self->ui_details->default_focus = g_strdup ("entry_uin_simple");
1073     }
1074   else
1075     {
1076       self->ui_details->gui = empathy_builder_get_file (filename,
1077           "table_common_settings", &priv->table_common_settings,
1078           "vbox_icq_settings", &self->ui_details->widget,
1079           "spinbutton_port", &spinbutton_port,
1080           NULL);
1081
1082       empathy_account_widget_handle_params (self,
1083           "entry_uin", "account",
1084           "entry_password", "password",
1085           "entry_server", "server",
1086           "spinbutton_port", "port",
1087           "entry_charset", "charset",
1088           NULL);
1089
1090       self->ui_details->default_focus = g_strdup ("entry_uin");
1091       self->ui_details->add_forget = TRUE;
1092     }
1093 }
1094
1095 static void
1096 account_widget_build_aim (EmpathyAccountWidget *self,
1097     const char *filename)
1098 {
1099   EmpathyAccountWidgetPriv *priv = GET_PRIV (self);
1100   GtkWidget *spinbutton_port;
1101
1102   if (priv->simple)
1103     {
1104       self->ui_details->gui = empathy_builder_get_file (filename,
1105           "vbox_aim_simple", &self->ui_details->widget,
1106           NULL);
1107
1108       empathy_account_widget_handle_params (self,
1109           "entry_screenname_simple", "account",
1110           "entry_password_simple", "password",
1111           NULL);
1112
1113       self->ui_details->default_focus = g_strdup ("entry_screenname_simple");
1114     }
1115   else
1116     {
1117       self->ui_details->gui = empathy_builder_get_file (filename,
1118           "table_common_settings", &priv->table_common_settings,
1119           "vbox_aim_settings", &self->ui_details->widget,
1120           "spinbutton_port", &spinbutton_port,
1121           NULL);
1122
1123       empathy_account_widget_handle_params (self,
1124           "entry_screenname", "account",
1125           "entry_password", "password",
1126           "entry_server", "server",
1127           "spinbutton_port", "port",
1128           NULL);
1129
1130       self->ui_details->default_focus = g_strdup ("entry_screenname");
1131       self->ui_details->add_forget = TRUE;
1132     }
1133 }
1134
1135 static void
1136 account_widget_build_yahoo (EmpathyAccountWidget *self,
1137     const char *filename)
1138 {
1139   EmpathyAccountWidgetPriv *priv = GET_PRIV (self);
1140
1141   if (priv->simple)
1142     {
1143       self->ui_details->gui = empathy_builder_get_file (filename,
1144           "vbox_yahoo_simple", &self->ui_details->widget,
1145           NULL);
1146
1147       empathy_account_widget_handle_params (self,
1148           "entry_id_simple", "account",
1149           "entry_password_simple", "password",
1150           NULL);
1151
1152       self->ui_details->default_focus = g_strdup ("entry_id_simple");
1153     }
1154   else
1155     {
1156       self->ui_details->gui = empathy_builder_get_file (filename,
1157           "table_common_settings", &priv->table_common_settings,
1158           "vbox_yahoo_settings", &self->ui_details->widget,
1159           NULL);
1160
1161       empathy_account_widget_handle_params (self,
1162           "entry_id", "account",
1163           "entry_password", "password",
1164           "entry_server", "server",
1165           "entry_locale", "room-list-locale",
1166           "entry_charset", "charset",
1167           "spinbutton_port", "port",
1168           "checkbutton_yahoojp", "yahoojp",
1169           "checkbutton_ignore_invites", "ignore-invites",
1170           NULL);
1171
1172       self->ui_details->default_focus = g_strdup ("entry_id");
1173       self->ui_details->add_forget = TRUE;
1174     }
1175 }
1176
1177 static void
1178 account_widget_build_groupwise (EmpathyAccountWidget *self,
1179     const char *filename)
1180 {
1181   EmpathyAccountWidgetPriv *priv = GET_PRIV (self);
1182
1183   if (priv->simple)
1184     {
1185       self->ui_details->gui = empathy_builder_get_file (filename,
1186           "vbox_groupwise_simple", &self->ui_details->widget,
1187           NULL);
1188
1189       empathy_account_widget_handle_params (self,
1190           "entry_id_simple", "account",
1191           "entry_password_simple", "password",
1192           NULL);
1193
1194       self->ui_details->default_focus = g_strdup ("entry_id_simple");
1195     }
1196   else
1197     {
1198       self->ui_details->gui = empathy_builder_get_file (filename,
1199           "table_common_groupwise_settings", &priv->table_common_settings,
1200           "vbox_groupwise_settings", &self->ui_details->widget,
1201           NULL);
1202
1203       empathy_account_widget_handle_params (self,
1204           "entry_id", "account",
1205           "entry_password", "password",
1206           "entry_server", "server",
1207           "spinbutton_port", "port",
1208           NULL);
1209
1210       self->ui_details->default_focus = g_strdup ("entry_id");
1211       self->ui_details->add_forget = TRUE;
1212     }
1213 }
1214
1215 static void
1216 account_widget_destroy_cb (GtkWidget *widget,
1217     EmpathyAccountWidget *self)
1218 {
1219   EmpathyAccountWidgetPriv *priv = GET_PRIV (self);
1220   /* set the destroyed flag - workaround */
1221   priv->destroyed = TRUE;
1222
1223   g_object_unref (self);
1224 }
1225
1226 static void
1227 empathy_account_widget_enabled_cb (TpAccount *account,
1228       GParamSpec *spec,
1229       gpointer user_data)
1230 {
1231   EmpathyAccountWidget *widget = EMPATHY_ACCOUNT_WIDGET (user_data);
1232   EmpathyAccountWidgetPriv *priv = GET_PRIV (widget);
1233   gboolean enabled = tp_account_is_enabled (account);
1234
1235   if (priv->enabled_checkbox != NULL)
1236     {
1237 #ifdef HAVE_MOBLIN
1238       nbtk_gtk_light_switch_set_active (
1239           NBTK_GTK_LIGHT_SWITCH (priv->enabled_checkbox),
1240           enabled);
1241 #else
1242       gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (priv->enabled_checkbox),
1243           enabled);
1244 #endif /* HAVE_MOBLIN */
1245     }
1246 }
1247
1248 static void
1249 #ifdef HAVE_MOBLIN
1250 account_widget_switch_flipped_cb (NbtkGtkLightSwitch *sw,
1251     gboolean state,
1252     gpointer user_data)
1253 #else
1254 account_widget_enabled_released_cb (GtkToggleButton *toggle_button,
1255     gpointer user_data)
1256 #endif /* HAVE_MOBLIN */
1257 {
1258   EmpathyAccountWidgetPriv *priv = GET_PRIV (user_data);
1259   TpAccount *account;
1260 #ifndef HAVE_MOBLIN
1261   gboolean state;
1262
1263   state = gtk_toggle_button_get_active (toggle_button);
1264 #endif
1265
1266   account = empathy_account_settings_get_account (priv->settings);
1267
1268   /* Enable the account according to the value of the "Enabled" checkbox */
1269   /* workaround to keep widget alive during async call */
1270   g_object_ref (user_data);
1271   tp_account_set_enabled_async (account, state,
1272       account_widget_account_enabled_cb, user_data);
1273 }
1274
1275 static void
1276 do_set_property (GObject *object,
1277     guint prop_id,
1278     const GValue *value,
1279     GParamSpec *pspec)
1280 {
1281   EmpathyAccountWidgetPriv *priv = GET_PRIV (object);
1282
1283   switch (prop_id)
1284     {
1285     case PROP_SETTINGS:
1286       priv->settings = g_value_dup_object (value);
1287       break;
1288     case PROP_SIMPLE:
1289       priv->simple = g_value_get_boolean (value);
1290       break;
1291     case PROP_CREATING_ACCOUNT:
1292       priv->creating_account = g_value_get_boolean (value);
1293       break;
1294     default:
1295       G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
1296     }
1297 }
1298
1299 static void
1300 do_get_property (GObject *object,
1301     guint prop_id,
1302     GValue *value,
1303     GParamSpec *pspec)
1304 {
1305   EmpathyAccountWidgetPriv *priv = GET_PRIV (object);
1306
1307   switch (prop_id)
1308     {
1309     case PROP_PROTOCOL:
1310       g_value_set_string (value,
1311         empathy_account_settings_get_protocol (priv->settings));
1312       break;
1313     case PROP_SETTINGS:
1314       g_value_set_object (value, priv->settings);
1315       break;
1316     case PROP_SIMPLE:
1317       g_value_set_boolean (value, priv->simple);
1318       break;
1319     case PROP_CREATING_ACCOUNT:
1320       g_value_set_boolean (value, priv->creating_account);
1321       break;
1322     default:
1323       G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
1324     }
1325 }
1326
1327 static void
1328 presence_changed_cb (TpAccountManager *manager,
1329     TpConnectionPresenceType state,
1330     const gchar *status,
1331     const gchar *message,
1332     EmpathyAccountWidget *self)
1333 {
1334   EmpathyAccountWidgetPriv *priv = GET_PRIV (self);
1335
1336   if (priv->destroyed)
1337     return;
1338
1339   if (priv->apply_button == NULL)
1340     /* This button doesn't exist in 'simple' mode */
1341     return;
1342
1343   if (state > TP_CONNECTION_PRESENCE_TYPE_OFFLINE)
1344     {
1345       /* We are online, display a Login button */
1346       GtkWidget *image;
1347
1348       gtk_button_set_use_stock (GTK_BUTTON (priv->apply_button), FALSE);
1349       gtk_button_set_label (GTK_BUTTON (priv->apply_button), _("L_og in"));
1350
1351       image = gtk_image_new_from_stock (GTK_STOCK_CONNECT,
1352           GTK_ICON_SIZE_BUTTON);
1353       gtk_button_set_image (GTK_BUTTON (priv->apply_button), image);
1354     }
1355   else
1356     {
1357       /* We are offline, display a Save button */
1358       gtk_button_set_image (GTK_BUTTON (priv->apply_button), NULL);
1359       gtk_button_set_use_stock (GTK_BUTTON (priv->apply_button), TRUE);
1360       gtk_button_set_label (GTK_BUTTON (priv->apply_button), GTK_STOCK_SAVE);
1361     }
1362 }
1363
1364 static void
1365 account_manager_ready_cb (GObject *source_object,
1366     GAsyncResult *result,
1367     gpointer user_data)
1368 {
1369   EmpathyAccountWidget *self = EMPATHY_ACCOUNT_WIDGET (user_data);
1370   TpAccountManager *account_manager = TP_ACCOUNT_MANAGER (source_object);
1371   GError *error = NULL;
1372   TpConnectionPresenceType state;
1373
1374   if (!tp_account_manager_prepare_finish (account_manager, result, &error))
1375     {
1376       DEBUG ("Failed to prepare account manager: %s", error->message);
1377       g_error_free (error);
1378       goto out;
1379     }
1380
1381   state = tp_account_manager_get_most_available_presence (account_manager, NULL,
1382       NULL);
1383
1384   /* simulate a presence change so the apply button will be changed
1385    * if needed */
1386   presence_changed_cb (account_manager, state, NULL, NULL, self);
1387
1388 out:
1389   g_object_unref (self);
1390 }
1391
1392 #define WIDGET(cm, proto) \
1393   { #cm, #proto, "empathy-account-widget-"#proto".ui", \
1394     account_widget_build_##proto }
1395
1396 static void
1397 add_enable_checkbox (EmpathyAccountWidget *self,
1398     TpAccount *account)
1399 {
1400   EmpathyAccountWidgetPriv *priv = GET_PRIV (self);
1401 #ifdef HAVE_MOBLIN
1402   GtkWidget *w;
1403 #else
1404   GtkWidget *vbox = self->ui_details->widget;
1405 #endif
1406   guint nb_rows, nb_columns;
1407   gboolean is_enabled;
1408
1409   /* handle the "Enabled" checkbox. We only add it when modifying an account */
1410   if (priv->creating_account || priv->table_common_settings == NULL)
1411     return;
1412
1413   is_enabled = tp_account_is_enabled (account);
1414
1415 #ifdef HAVE_MOBLIN
1416   w = gtk_label_new (_("Account:"));
1417   gtk_misc_set_alignment (GTK_MISC (w), 0, 0.5);
1418
1419   priv->enabled_checkbox = nbtk_gtk_light_switch_new ();
1420
1421   nbtk_gtk_light_switch_set_active (
1422       NBTK_GTK_LIGHT_SWITCH (priv->enabled_checkbox), is_enabled);
1423
1424   gtk_widget_show (w);
1425 #else
1426   priv->enabled_checkbox =
1427       gtk_check_button_new_with_label (_("Enabled"));
1428
1429   gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (priv->enabled_checkbox),
1430       is_enabled);
1431 #endif /* HAVE_MOBLIN */
1432
1433   g_object_get (priv->table_common_settings, "n-rows", &nb_rows,
1434       "n-columns", &nb_columns, NULL);
1435
1436   gtk_table_resize (GTK_TABLE (priv->table_common_settings), ++nb_rows,
1437       nb_columns);
1438
1439 #ifdef HAVE_MOBLIN
1440   gtk_table_attach (GTK_TABLE (priv->table_common_settings),
1441       w,
1442       0, 1, nb_rows - 1, nb_rows,
1443       GTK_FILL, 0, 0, 0);
1444   gtk_table_attach (GTK_TABLE (priv->table_common_settings),
1445       priv->enabled_checkbox,
1446       1, nb_columns, nb_rows - 1, nb_rows,
1447       GTK_EXPAND | GTK_FILL, 0, 0, 0);
1448 #else
1449   gtk_box_pack_start (GTK_BOX (vbox), priv->enabled_checkbox, FALSE, FALSE, 0);
1450   gtk_box_reorder_child (GTK_BOX (vbox), priv->enabled_checkbox, 0);
1451 #endif /* HAVE_MOBLIN */
1452
1453   gtk_widget_show (priv->enabled_checkbox);
1454
1455 #ifdef HAVE_MOBLIN
1456   g_signal_connect (G_OBJECT (priv->enabled_checkbox), "switch-flipped",
1457       G_CALLBACK (account_widget_switch_flipped_cb), self);
1458 #else
1459   g_signal_connect (G_OBJECT (priv->enabled_checkbox), "released",
1460       G_CALLBACK (account_widget_enabled_released_cb), self);
1461 #endif /* HAVE_MOBLIN */
1462 }
1463
1464 #ifndef HAVE_MOBLIN
1465 /* Moblin doesn't support registration */
1466 static void
1467 add_register_buttons (EmpathyAccountWidget *self,
1468     TpAccount *account)
1469 {
1470   EmpathyAccountWidgetPriv *priv = GET_PRIV (self);
1471   const TpConnectionManagerProtocol *protocol;
1472   GtkWidget *radiobutton_register;
1473   GtkWidget *vbox = self->ui_details->widget;
1474
1475   if (!priv->creating_account)
1476     return;
1477
1478   protocol = empathy_account_settings_get_tp_protocol (priv->settings);
1479   if (protocol == NULL)
1480     return;
1481
1482   if (!tp_connection_manager_protocol_can_register (protocol))
1483     return;
1484
1485   if (account_widget_is_gtalk (self))
1486     return;
1487
1488   if (priv->simple)
1489     return;
1490
1491   priv->radiobutton_reuse = gtk_radio_button_new_with_label (NULL,
1492       _("This account already exists on the server"));
1493   radiobutton_register = gtk_radio_button_new_with_label (
1494       gtk_radio_button_get_group (GTK_RADIO_BUTTON (priv->radiobutton_reuse)),
1495       _("Create a new account on the server"));
1496
1497   gtk_box_pack_start (GTK_BOX (vbox), priv->radiobutton_reuse, FALSE, FALSE, 0);
1498   gtk_box_pack_start (GTK_BOX (vbox), radiobutton_register, FALSE, FALSE, 0);
1499   gtk_box_reorder_child (GTK_BOX (vbox), priv->radiobutton_reuse, 0);
1500   gtk_box_reorder_child (GTK_BOX (vbox), radiobutton_register, 1);
1501   gtk_widget_show (priv->radiobutton_reuse);
1502   gtk_widget_show (radiobutton_register);
1503 }
1504 #endif
1505
1506 static void
1507 do_constructed (GObject *obj)
1508 {
1509   EmpathyAccountWidget *self = EMPATHY_ACCOUNT_WIDGET (obj);
1510   EmpathyAccountWidgetPriv *priv = GET_PRIV (self);
1511   TpAccount *account;
1512   const gchar *protocol, *cm_name;
1513   guint i = 0;
1514   struct {
1515     const gchar *cm_name;
1516     const gchar *protocol;
1517     const char *file;
1518     void (*func)(EmpathyAccountWidget *self, const gchar *filename);
1519   } widgets [] = {
1520     { "salut", "local-xmpp", "empathy-account-widget-local-xmpp.ui",
1521         account_widget_build_salut },
1522     WIDGET (gabble, jabber),
1523     WIDGET (butterfly, msn),
1524     WIDGET (haze, icq),
1525     WIDGET (haze, aim),
1526     WIDGET (haze, yahoo),
1527     WIDGET (haze, groupwise),
1528     WIDGET (idle, irc),
1529     WIDGET (sofiasip, sip),
1530   };
1531
1532   cm_name = empathy_account_settings_get_cm (priv->settings);
1533   protocol = empathy_account_settings_get_protocol (priv->settings);
1534
1535   for (i = 0 ; i < G_N_ELEMENTS (widgets); i++)
1536     {
1537       if (!tp_strdiff (widgets[i].cm_name, cm_name) &&
1538           !tp_strdiff (widgets[i].protocol, protocol))
1539         {
1540           gchar *filename;
1541
1542           filename = empathy_file_lookup (widgets[i].file,
1543               "libempathy-gtk");
1544           widgets[i].func (self, filename);
1545           g_free (filename);
1546
1547           break;
1548         }
1549     }
1550
1551   if (i == G_N_ELEMENTS (widgets))
1552     {
1553       gchar *filename = empathy_file_lookup (
1554           "empathy-account-widget-generic.ui", "libempathy-gtk");
1555       account_widget_build_generic (self, filename);
1556       g_free (filename);
1557     }
1558
1559   /* handle default focus */
1560   if (self->ui_details->default_focus != NULL)
1561     {
1562       GObject *default_focus_entry;
1563
1564       default_focus_entry = gtk_builder_get_object
1565         (self->ui_details->gui, self->ui_details->default_focus);
1566       g_signal_connect (default_focus_entry, "realize",
1567           G_CALLBACK (gtk_widget_grab_focus),
1568           NULL);
1569     }
1570
1571   /* handle forget button */
1572   if (self->ui_details->add_forget)
1573     {
1574       const gchar *password = NULL;
1575
1576       priv->button_forget = GTK_WIDGET (gtk_builder_get_object
1577           (self->ui_details->gui, "button_forget"));
1578       priv->entry_password = GTK_WIDGET (gtk_builder_get_object
1579           (self->ui_details->gui, "entry_password"));
1580
1581       password = empathy_account_settings_get_string (priv->settings,
1582           "password");
1583       gtk_widget_set_sensitive (priv->button_forget,
1584           !EMP_STR_EMPTY (password));
1585
1586       g_signal_connect (priv->button_forget, "clicked",
1587           G_CALLBACK (account_widget_forget_clicked_cb),
1588           self);
1589       g_signal_connect (priv->entry_password, "changed",
1590           G_CALLBACK (account_widget_password_changed_cb),
1591           self);
1592     }
1593
1594   /* dup and init the account-manager */
1595   priv->account_manager = tp_account_manager_dup ();
1596
1597   g_object_ref (self);
1598   tp_account_manager_prepare_async (priv->account_manager, NULL,
1599       account_manager_ready_cb, self);
1600
1601   /* handle apply and cancel button */
1602   if (!priv->simple)
1603     {
1604       GtkWidget *hbox = gtk_hbox_new (TRUE, 3);
1605
1606       priv->cancel_button = gtk_button_new_from_stock (GTK_STOCK_CANCEL);
1607
1608       if (priv->creating_account)
1609         {
1610           /* Assumre we are offline, display a Save button. We'll update
1611            * it once the account manager is ready if needed */
1612           priv->apply_button = gtk_button_new_from_stock (GTK_STOCK_SAVE);
1613
1614           empathy_signal_connect_weak (priv->account_manager,
1615               "most-available-presence-changed",
1616               G_CALLBACK (presence_changed_cb), obj);
1617         }
1618       else
1619         {
1620           /* We are editing an existing account, display an Apply button */
1621           priv->apply_button = gtk_button_new_from_stock (GTK_STOCK_APPLY);
1622         }
1623
1624       gtk_box_pack_end (GTK_BOX (hbox), priv->apply_button, TRUE,
1625           TRUE, 3);
1626       gtk_box_pack_end (GTK_BOX (hbox), priv->cancel_button, TRUE,
1627           TRUE, 3);
1628
1629       gtk_box_pack_end (GTK_BOX (self->ui_details->widget), hbox, FALSE,
1630           FALSE, 3);
1631
1632       g_signal_connect (priv->cancel_button, "clicked",
1633           G_CALLBACK (account_widget_cancel_clicked_cb),
1634           self);
1635       g_signal_connect (priv->apply_button, "clicked",
1636           G_CALLBACK (account_widget_apply_clicked_cb),
1637           self);
1638       gtk_widget_show_all (hbox);
1639
1640       if (priv->creating_account)
1641         /* When creating an account, the user might have nothing to enter.
1642          * That means that no control interaction might occur,
1643          * so we update the control button sensitivity manually.
1644          */
1645         account_widget_handle_control_buttons_sensitivity (self);
1646       else
1647         account_widget_set_control_buttons_sensitivity (self, FALSE);
1648     }
1649
1650   account = empathy_account_settings_get_account (priv->settings);
1651
1652   if (account != NULL)
1653     {
1654       g_signal_connect (account, "notify::enabled",
1655           G_CALLBACK (empathy_account_widget_enabled_cb), self);
1656     }
1657
1658 #ifndef HAVE_MOBLIN
1659   add_register_buttons (self, account);
1660 #endif
1661   add_enable_checkbox (self, account);
1662
1663   /* hook up to widget destruction to unref ourselves */
1664   g_signal_connect (self->ui_details->widget, "destroy",
1665       G_CALLBACK (account_widget_destroy_cb), self);
1666
1667   empathy_builder_unref_and_keep_widget (self->ui_details->gui,
1668       self->ui_details->widget);
1669   self->ui_details->gui = NULL;
1670 }
1671
1672 static void
1673 do_dispose (GObject *obj)
1674 {
1675   EmpathyAccountWidget *self = EMPATHY_ACCOUNT_WIDGET (obj);
1676   EmpathyAccountWidgetPriv *priv = GET_PRIV (self);
1677
1678   if (priv->dispose_run)
1679     return;
1680
1681   priv->dispose_run = TRUE;
1682
1683   empathy_account_settings_is_ready (priv->settings);
1684
1685   if (priv->settings != NULL)
1686     {
1687       TpAccount *account;
1688       account = empathy_account_settings_get_account (priv->settings);
1689
1690       if (account != NULL)
1691         {
1692           g_signal_handlers_disconnect_by_func (account,
1693               empathy_account_widget_enabled_cb, self);
1694         }
1695
1696       g_object_unref (priv->settings);
1697       priv->settings = NULL;
1698     }
1699
1700   if (priv->account_manager != NULL)
1701     {
1702       g_object_unref (priv->account_manager);
1703       priv->account_manager = NULL;
1704     }
1705
1706   if (G_OBJECT_CLASS (empathy_account_widget_parent_class)->dispose != NULL)
1707     G_OBJECT_CLASS (empathy_account_widget_parent_class)->dispose (obj);
1708 }
1709
1710 static void
1711 do_finalize (GObject *obj)
1712 {
1713   EmpathyAccountWidget *self = EMPATHY_ACCOUNT_WIDGET (obj);
1714
1715   g_free (self->ui_details->default_focus);
1716   g_slice_free (EmpathyAccountWidgetUIDetails, self->ui_details);
1717
1718   if (G_OBJECT_CLASS (empathy_account_widget_parent_class)->finalize != NULL)
1719     G_OBJECT_CLASS (empathy_account_widget_parent_class)->finalize (obj);
1720 }
1721
1722 static void
1723 empathy_account_widget_class_init (EmpathyAccountWidgetClass *klass)
1724 {
1725   GObjectClass *oclass = G_OBJECT_CLASS (klass);
1726   GParamSpec *param_spec;
1727
1728   oclass->get_property = do_get_property;
1729   oclass->set_property = do_set_property;
1730   oclass->constructed = do_constructed;
1731   oclass->dispose = do_dispose;
1732   oclass->finalize = do_finalize;
1733
1734   param_spec = g_param_spec_string ("protocol",
1735       "protocol", "The protocol of the account",
1736       NULL,
1737       G_PARAM_READABLE | G_PARAM_STATIC_STRINGS);
1738   g_object_class_install_property (oclass, PROP_PROTOCOL, param_spec);
1739
1740   param_spec = g_param_spec_object ("settings",
1741       "settings", "The settings of the account",
1742       EMPATHY_TYPE_ACCOUNT_SETTINGS,
1743       G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS | G_PARAM_CONSTRUCT_ONLY);
1744   g_object_class_install_property (oclass, PROP_SETTINGS, param_spec);
1745
1746   param_spec = g_param_spec_boolean ("simple",
1747       "simple", "Whether the account widget is a simple or an advanced one",
1748       FALSE,
1749       G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS | G_PARAM_CONSTRUCT_ONLY);
1750   g_object_class_install_property (oclass, PROP_SIMPLE, param_spec);
1751
1752   param_spec = g_param_spec_boolean ("creating-account",
1753       "creating-account",
1754       "TRUE if we're creating an account, FALSE if we're modifying it",
1755       FALSE,
1756       G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS | G_PARAM_CONSTRUCT_ONLY);
1757   g_object_class_install_property (oclass, PROP_CREATING_ACCOUNT, param_spec);
1758
1759   signals[HANDLE_APPLY] =
1760     g_signal_new ("handle-apply", G_TYPE_FROM_CLASS (klass),
1761         G_SIGNAL_RUN_LAST, 0, NULL, NULL,
1762         g_cclosure_marshal_VOID__BOOLEAN,
1763         G_TYPE_NONE,
1764         1, G_TYPE_BOOLEAN);
1765
1766   /* This signal is emitted when an account has been created and enabled. */
1767   signals[ACCOUNT_CREATED] =
1768       g_signal_new ("account-created", G_TYPE_FROM_CLASS (klass),
1769           G_SIGNAL_RUN_LAST, 0, NULL, NULL,
1770           g_cclosure_marshal_VOID__POINTER,
1771           G_TYPE_NONE,
1772           1, G_TYPE_OBJECT);
1773
1774   signals[CANCELLED] =
1775       g_signal_new ("cancelled", G_TYPE_FROM_CLASS (klass),
1776           G_SIGNAL_RUN_LAST, 0, NULL, NULL,
1777           g_cclosure_marshal_VOID__VOID,
1778           G_TYPE_NONE,
1779           0);
1780
1781   g_type_class_add_private (klass, sizeof (EmpathyAccountWidgetPriv));
1782 }
1783
1784 static void
1785 empathy_account_widget_init (EmpathyAccountWidget *self)
1786 {
1787   EmpathyAccountWidgetPriv *priv =
1788     G_TYPE_INSTANCE_GET_PRIVATE ((self), EMPATHY_TYPE_ACCOUNT_WIDGET,
1789         EmpathyAccountWidgetPriv);
1790
1791   self->priv = priv;
1792   priv->dispose_run = FALSE;
1793
1794   self->ui_details = g_slice_new0 (EmpathyAccountWidgetUIDetails);
1795 }
1796
1797 /* public methods */
1798
1799 void
1800 empathy_account_widget_discard_pending_changes
1801     (EmpathyAccountWidget *widget)
1802 {
1803   EmpathyAccountWidgetPriv *priv = GET_PRIV (widget);
1804
1805   empathy_account_settings_discard_changes (priv->settings);
1806   priv->contains_pending_changes = FALSE;
1807 }
1808
1809 gboolean
1810 empathy_account_widget_contains_pending_changes (EmpathyAccountWidget *widget)
1811 {
1812   EmpathyAccountWidgetPriv *priv = GET_PRIV (widget);
1813
1814   return priv->contains_pending_changes;
1815 }
1816
1817 void
1818 empathy_account_widget_handle_params (EmpathyAccountWidget *self,
1819     const gchar *first_widget,
1820     ...)
1821 {
1822   va_list args;
1823
1824   va_start (args, first_widget);
1825   account_widget_handle_params_valist (self, first_widget, args);
1826   va_end (args);
1827 }
1828
1829 GtkWidget *
1830 empathy_account_widget_get_widget (EmpathyAccountWidget *widget)
1831 {
1832   return widget->ui_details->widget;
1833 }
1834
1835 EmpathyAccountWidget *
1836 empathy_account_widget_new_for_protocol (EmpathyAccountSettings *settings,
1837     gboolean simple)
1838 {
1839   EmpathyAccountWidget *self;
1840
1841   g_return_val_if_fail (EMPATHY_IS_ACCOUNT_SETTINGS (settings), NULL);
1842
1843   self = g_object_new
1844     (EMPATHY_TYPE_ACCOUNT_WIDGET,
1845         "settings", settings, "simple", simple,
1846         "creating-account",
1847         empathy_account_settings_get_account (settings) == NULL,
1848         NULL);
1849
1850   return self;
1851 }
1852
1853 gchar *
1854 empathy_account_widget_get_default_display_name (EmpathyAccountWidget *self)
1855 {
1856   EmpathyAccountWidgetPriv *priv = GET_PRIV (self);
1857   const gchar *login_id;
1858   const gchar *protocol, *p;
1859   gchar *default_display_name;
1860
1861   login_id = empathy_account_settings_get_string (priv->settings, "account");
1862   protocol = empathy_account_settings_get_protocol (priv->settings);
1863
1864   if (login_id != NULL)
1865     {
1866       /* TODO: this should be done in empathy-account-widget-irc */
1867       if (!tp_strdiff (protocol, "irc"))
1868         {
1869           const gchar* server;
1870           server = empathy_account_settings_get_string (priv->settings,
1871               "server");
1872
1873           /* To translators: The first parameter is the login id and the
1874            * second one is the server. The resulting string will be something
1875            * like: "MyUserName on chat.freenode.net".
1876            * You should reverse the order of these arguments if the
1877            * server should come before the login id in your locale.*/
1878           default_display_name = g_strdup_printf (_("%1$s on %2$s"),
1879               login_id, server);
1880         }
1881       else
1882         {
1883           default_display_name = g_strdup (login_id);
1884         }
1885
1886       return default_display_name;
1887     }
1888
1889   if ((p = empathy_protocol_name_to_display_name (protocol)) != NULL)
1890     protocol = p;
1891
1892   if (protocol != NULL)
1893     {
1894       /* To translators: The parameter is the protocol name. The resulting
1895        * string will be something like: "Jabber Account" */
1896       default_display_name = g_strdup_printf (_("%s Account"), protocol);
1897     }
1898   else
1899     {
1900       default_display_name = g_strdup (_("New account"));
1901     }
1902
1903   return default_display_name;
1904 }
1905
1906 /* Used by subclass to indicate that widget contains pending changes */
1907 void
1908 empathy_account_widget_changed (EmpathyAccountWidget *self)
1909 {
1910   EmpathyAccountWidgetPriv *priv = GET_PRIV (self);
1911
1912   account_widget_handle_control_buttons_sensitivity (self);
1913   priv->contains_pending_changes = TRUE;
1914 }
1915
1916 void
1917 empathy_account_widget_set_account_param (EmpathyAccountWidget *self,
1918     const gchar *account)
1919 {
1920   EmpathyAccountWidgetPriv *priv = GET_PRIV (self);
1921
1922   if (priv->param_account_widget == NULL)
1923     return;
1924
1925   gtk_entry_set_text (GTK_ENTRY (priv->param_account_widget), account);
1926 }
1927
1928 void
1929 empathy_account_widget_set_password_param (EmpathyAccountWidget *self,
1930     const gchar *account)
1931 {
1932   EmpathyAccountWidgetPriv *priv = GET_PRIV (self);
1933
1934   if (priv->param_password_widget == NULL)
1935     return;
1936
1937   gtk_entry_set_text (GTK_ENTRY (priv->param_password_widget), account);
1938 }