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