/*

 * Copyright (C) 2006-2007 Imendio AB

 * Copyright (C) 2007-2009 Collabora Ltd.

 *

 * This library is free software; you can redistribute it and/or

 * modify it under the terms of the GNU Lesser General Public

 * License as published by the Free Software Foundation; either

 * version 2.1 of the License, or (at your option) any later version.

 *

 * This library is distributed in the hope that it will be useful,

 * but WITHOUT ANY WARRANTY; without even the implied warranty of

 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU

 * Lesser General Public License for more details.

 *

 * You should have received a copy of the GNU Lesser General Public

 * License along with this library; if not, write to the Free Software

 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA

 *

 * Authors: Xavier Claessens <xclaesse@gmail.com>

 *          Martyn Russell <martyn@imendio.com>

 *          Cosimo Cecchi <cosimo.cecchi@collabora.co.uk>

 *          Jonathan Tellier <jonathan.tellier@gmail.com>

 *          Danielle Madeley <danielle.madeley@collabora.co.uk>

 */

#include "config.h"

#include "tpaw-account-widget.h"

#include "tpaw-account-widget-private.h"

#include <glib/gi18n-lib.h>

#include <dbus/dbus-protocol.h>

#include "tpaw-account-widget-irc.h"

#include "tpaw-account-widget-private.h"

#include "tpaw-account-widget-sip.h"

#include "tpaw-builder.h"

#include "tpaw-utils.h"

#define DEBUG_FLAG TPAW_DEBUG_ACCOUNT

#include "tpaw-debug.h"

G_DEFINE_TYPE (TpawAccountWidget, tpaw_account_widget, GTK_TYPE_BOX)

typedef enum

{

  NO_SERVICE = 0,

  GTALK_SERVICE,

  N_SERVICES

} Service;

typedef struct

{

  const gchar *label_username_example;

  gboolean show_advanced;

} ServiceInfo;

static ServiceInfo services_infos[N_SERVICES] = {

    { "label_username_example", TRUE },

    { "label_username_g_example", FALSE },

};

struct _TpawAccountWidgetPriv {

  TpawAccountSettings *settings;

  GtkWidget *grid_common_settings;

  GtkWidget *apply_button;

  GtkWidget *cancel_button;

  GtkWidget *entry_password;

  GtkWidget *spinbutton_port;

  GtkWidget *dialog;

  gboolean simple;

  gboolean contains_pending_changes;

  /* Whether the action area is part of an external dialog or it's an

   * internal one we created ourselves */

  gboolean external_action_area;

  /* An TpawAccountWidget can be used to either create an account or

   * modify it. When we are creating an account, this member is set to TRUE */

  gboolean creating_account;

  /* whether there are any other real accounts. Necessary so we know whether

   * it's safe to dismiss this widget in some cases (eg, whether the Cancel

   * button should be sensitive) */

  gboolean other_accounts_exist;

  /* if TRUE, the GTK+ destroy signal has been fired and so the widgets

   * embedded in this account widget can't be used any more

   * workaround because some async callbacks can be called after the

   * widget has been destroyed */

  gboolean destroyed;

  TpAccountManager *account_manager;

  GtkWidget *param_account_widget;

  GtkWidget *param_password_widget;

  gboolean automatic_change;

  GtkWidget *remember_password_widget;

  /* Used only for IRC accounts */

  TpawIrcNetworkChooser *irc_network_chooser;

};

enum {

  PROP_PROTOCOL = 1,

  PROP_SETTINGS,

  PROP_SIMPLE,

  PROP_CREATING_ACCOUNT,

  PROP_OTHER_ACCOUNTS_EXIST,

  PROP_DIALOG,

};

enum {

  HANDLE_APPLY,

  ACCOUNT_CREATED,

  CANCELLED,

  CLOSE,

  LAST_SIGNAL

};

enum {

  RESPONSE_LAUNCH

};

static guint signals[LAST_SIGNAL] = { 0 };

#define CHANGED_TIMEOUT 300

#define DIGIT             "0-9"

#define DIGITS            "(["DIGIT"]+)"

#define ALPHA             "a-zA-Z"

#define ALPHAS            "(["ALPHA"]+)"

#define ALPHADIGIT        ALPHA DIGIT

#define ALPHADIGITS       "(["ALPHADIGIT"]+)"

#define ALPHADIGITDASH    ALPHA DIGIT "-"

#define ALPHADIGITDASHS   "(["ALPHADIGITDASH"]*)"

#define HOSTNUMBER        "("DIGITS"\\."DIGITS"\\."DIGITS"\\."DIGITS")"

#define TOPLABEL          "("ALPHAS \

                            "| (["ALPHA"]"ALPHADIGITDASHS "["ALPHADIGIT"]))"

#define DOMAINLABEL       "("ALPHADIGITS"|(["ALPHADIGIT"]" ALPHADIGITDASHS \

                                       "["ALPHADIGIT"]))"

#define HOSTNAME          "((" DOMAINLABEL "\\.)+" TOPLABEL ")"

/* Based on http://www.ietf.org/rfc/rfc1738.txt (section 5) */

#define HOST              "("HOSTNAME "|" HOSTNUMBER")"

/* Based on http://www.ietf.org/rfc/rfc0822.txt (appendix D) */

#define EMAIL_LOCALPART   "([^\\(\\)<>@,;:\\\\\"\\[\\]\\s]+)"

/* UIN is digital according to the unofficial specification:

 * http://iserverd.khstu.ru/docum_ext/icqv5.html#CTS

 * 5 digits minimum according to http://en.wikipedia.org/wiki/ICQ#UIN

 * According to an user, we can also provide an email address instead of the

 * ICQ UIN. */

#define ICQ_USER_NAME     "((["DIGIT"]{5,})|"EMAIL_LOCALPART"@"HOST")"

/* Based on http://www.ietf.org/rfc/rfc2812.txt (section 2.3.1) */

#define IRC_SPECIAL       "_\\[\\]{}\\\\|`^"

#define IRC_NICK_NAME     "(["ALPHA IRC_SPECIAL"]["ALPHADIGITDASH IRC_SPECIAL"]*)"

/* Based on http://www.ietf.org/rfc/rfc4622.txt (section 2.2)

 * We just exclude invalid characters to avoid ucschars and other redundant

 * complexity */

#define JABBER_USER_NAME  "([^@:'\"<>&\\s]+)"

/* ID is an email according to the unofficial specification:

 * http://www.hypothetic.org/docs/msn/general/names.php */

#define MSN_USER_NAME     EMAIL_LOCALPART

/* Based on the official help:

 * http://help.yahoo.com/l/us/yahoo/edit/registration/edit-01.html

 * Looks like an email address can be used as well (bgo #655959)

 * */

#define YAHOO_USER_NAME   "(["ALPHA"]["ALPHADIGIT"_\\.]{3,31})|("EMAIL_LOCALPART"@"HOST")"

#define ACCOUNT_REGEX_ICQ      "^"ICQ_USER_NAME"$"

#define ACCOUNT_REGEX_IRC      "^"IRC_NICK_NAME"$"

#define ACCOUNT_REGEX_JABBER   "^"JABBER_USER_NAME"@[^@/]+"

#define ACCOUNT_REGEX_MSN      "^"MSN_USER_NAME"@"HOST"$"

#define ACCOUNT_REGEX_YAHOO    "^"YAHOO_USER_NAME"$"

static void

account_widget_set_control_buttons_sensitivity (TpawAccountWidget *self,

    gboolean sensitive)

{

  /* we hit this case because of the 'other-accounts-exist' property handler

   * being called during init (before constructed()) */

  if (self->priv->apply_button == NULL || self->priv->cancel_button == NULL)

    return;

  gtk_widget_set_sensitive (self->priv->apply_button, sensitive);

  if (sensitive && self->priv->dialog == NULL)

    {

      /* We can't grab default if the widget hasn't be packed in a

       * window */

      GtkWidget *window;

      window = gtk_widget_get_toplevel (self->priv->apply_button);

      if (window != NULL &&

          gtk_widget_is_toplevel (window))

        {

          gtk_widget_set_can_default (self->priv->apply_button, TRUE);

          gtk_widget_grab_default (self->priv->apply_button);

        }

    }

}

static void

account_widget_set_entry_highlighting (GtkEntry *entry,

    gboolean highlight)

{

  GtkStyleContext *style;

  g_return_if_fail (GTK_IS_ENTRY (entry));

  style = gtk_widget_get_style_context (GTK_WIDGET (entry));

  if (highlight)

    {

      gtk_style_context_add_class (style, GTK_STYLE_CLASS_ERROR);

    }

  else

    {

      gtk_style_context_remove_class (style, GTK_STYLE_CLASS_ERROR);

    }

}

static void

account_widget_handle_control_buttons_sensitivity (TpawAccountWidget *self)

{

  gboolean is_valid;

  is_valid = tpaw_account_settings_is_valid (self->priv->settings);

  account_widget_set_control_buttons_sensitivity (self, is_valid);

  g_signal_emit (self, signals[HANDLE_APPLY], 0, is_valid);

}

static void

account_widget_entry_changed_common (TpawAccountWidget *self,

    GtkEntry *entry, gboolean focus)

{

  const gchar *str;

  const gchar *param_name;

  gboolean prev_status;

  gboolean curr_status;

  str = gtk_entry_get_text (entry);

  param_name = g_object_get_data (G_OBJECT (entry), "param_name");

  prev_status = tpaw_account_settings_parameter_is_valid (

      self->priv->settings, param_name);

  if (TPAW_STR_EMPTY (str))

    {

      tpaw_account_settings_unset (self->priv->settings, param_name);

      if (focus)

        {

          gchar *value;

          value = tpaw_account_settings_dup_string (self->priv->settings,

              param_name);

          DEBUG ("Unset %s and restore to %s", param_name, value);

          gtk_entry_set_text (entry, value ? value : "");

          g_free (value);

        }

    }

  else

    {

      DEBUG ("Setting %s to %s", param_name,

          tp_strdiff (param_name, "password") ? str : "***");

      tpaw_account_settings_set (self->priv->settings, param_name,

          g_variant_new_string (str));

    }

  curr_status = tpaw_account_settings_parameter_is_valid (

      self->priv->settings, param_name);

  if (curr_status != prev_status)

    account_widget_set_entry_highlighting (entry, !curr_status);

}

static void

account_widget_entry_changed_cb (GtkEditable *entry,

    TpawAccountWidget *self)

{

  if (self->priv->automatic_change)

    return;

  account_widget_entry_changed_common (self, GTK_ENTRY (entry), FALSE);

  tpaw_account_widget_changed (self);

}

static void

account_widget_entry_map_cb (GtkEntry *entry,

    TpawAccountWidget *self)

{

  const gchar *param_name;

  gboolean is_valid;

  /* need to initialize input highlighting */

  param_name = g_object_get_data (G_OBJECT (entry), "param_name");

  is_valid = tpaw_account_settings_parameter_is_valid (self->priv->settings,

      param_name);

  account_widget_set_entry_highlighting (entry, !is_valid);

}

static void

account_widget_int_changed_cb (GtkWidget *widget,

    TpawAccountWidget *self)

{

  const gchar *param_name;

  gint value;

  const gchar *signature;

  value = gtk_spin_button_get_value_as_int (GTK_SPIN_BUTTON (widget));

  param_name = g_object_get_data (G_OBJECT (widget), "param_name");

  signature = tpaw_account_settings_get_dbus_signature (self->priv->settings,

    param_name);

  g_return_if_fail (signature != NULL);

  DEBUG ("Setting %s to %d", param_name, value);

  switch ((int)*signature)

    {

    case DBUS_TYPE_INT16:

    case DBUS_TYPE_INT32:

      tpaw_account_settings_set (self->priv->settings, param_name,

          g_variant_new_int32 (value));

      break;

    case DBUS_TYPE_INT64:

      tpaw_account_settings_set (self->priv->settings, param_name,

          g_variant_new_int64 (value));

      break;

    case DBUS_TYPE_UINT16:

    case DBUS_TYPE_UINT32:

      tpaw_account_settings_set (self->priv->settings, param_name,

          g_variant_new_uint32 (value));

      break;

    case DBUS_TYPE_UINT64:

      tpaw_account_settings_set (self->priv->settings, param_name,

          g_variant_new_uint64 (value));

      break;

    default:

      g_return_if_reached ();

    }

  tpaw_account_widget_changed (self);

}

static void

account_widget_checkbutton_toggled_cb (GtkWidget *widget,

    TpawAccountWidget *self)

{

  gboolean     value;

  gboolean     default_value;

  const gchar *param_name;

  value = gtk_toggle_button_get_active (GTK_TOGGLE_BUTTON (widget));

  param_name = g_object_get_data (G_OBJECT (widget), "param_name");

  /* FIXME: This is ugly! checkbox don't have a "not-set" value so we

   * always unset the param and set the value if different from the

   * default value. */

  tpaw_account_settings_unset (self->priv->settings, param_name);

  default_value = tpaw_account_settings_get_boolean (self->priv->settings,

      param_name);

  if (default_value == value)

    {

      DEBUG ("Unset %s and restore to %d", param_name, default_value);

    }

  else

    {

      DEBUG ("Setting %s to %d", param_name, value);

      tpaw_account_settings_set (self->priv->settings, param_name,

          g_variant_new_boolean (value));

    }

  tpaw_account_widget_changed (self);

}

static void

account_widget_jabber_ssl_toggled_cb (GtkWidget *checkbutton_ssl,

    TpawAccountWidget *self)

{

  gboolean   value;

  gint32       port = 0;

  value = gtk_toggle_button_get_active (GTK_TOGGLE_BUTTON (checkbutton_ssl));

  port = tpaw_account_settings_get_uint32 (self->priv->settings, "port");

  if (value)

    {

      if (port == 5222 || port == 0)

        port = 5223;

    }

  else

    {

      if (port == 5223 || port == 0)

        port = 5222;

    }

  gtk_spin_button_set_value (GTK_SPIN_BUTTON (self->priv->spinbutton_port),

      port);

  self->priv->contains_pending_changes = TRUE;

}

static void

account_widget_combobox_changed_cb (GtkWidget *widget,

    TpawAccountWidget *self)

{

  GtkTreeIter iter;

  GtkTreeModel *model;

  const gchar *value;

  GVariant *v;

  const gchar *default_value = NULL;

  const gchar *param_name;

  if (!gtk_combo_box_get_active_iter (GTK_COMBO_BOX (widget), &iter))

    return;

  model = gtk_combo_box_get_model (GTK_COMBO_BOX (widget));

  /* the param value is stored in the first column */

  gtk_tree_model_get (model, &iter, 0, &value, -1);

  param_name = g_object_get_data (G_OBJECT (widget), "param_name");

  v = tpaw_account_settings_dup_default (self->priv->settings, param_name);

  if (v != NULL && g_variant_is_of_type (v, G_VARIANT_TYPE_STRING))

    default_value = g_variant_get_string (v, NULL);

  if (!tp_strdiff (value, default_value))

    {

      DEBUG ("Unset %s and restore to %s", param_name, default_value);

      tpaw_account_settings_unset (self->priv->settings, param_name);

    }

  else

    {

      DEBUG ("Setting %s to %s", param_name, value);

      tpaw_account_settings_set (self->priv->settings, param_name,

          g_variant_new_string (value));

    }

  tpaw_account_widget_changed (self);

  tp_clear_pointer (&v, g_variant_unref);

}

static void

clear_icon_released_cb (GtkEntry *entry,

    GtkEntryIconPosition icon_pos,

    GdkEvent *event,

    TpawAccountWidget *self)

{

  const gchar *param_name;

  param_name = g_object_get_data (G_OBJECT (entry), "param_name");

  DEBUG ("Unset %s", param_name);

  tpaw_account_settings_unset (self->priv->settings, param_name);

  gtk_entry_set_text (entry, "");

  tpaw_account_widget_changed (self);

}

static void

password_entry_changed_cb (GtkEditable *entry,

    TpawAccountWidget *self)

{

  const gchar *str;

  str = gtk_entry_get_text (GTK_ENTRY (entry));

  gtk_entry_set_icon_sensitive (GTK_ENTRY (entry),

      GTK_ENTRY_ICON_SECONDARY, !TPAW_STR_EMPTY (str));

}

static void

password_entry_activated_cb (GtkEntry *entry,

    TpawAccountWidget *self)

{

    if (gtk_widget_get_sensitive (self->priv->apply_button))

        tpaw_account_widget_apply_and_log_in (self);

}

static void

account_entry_activated_cb (GtkEntry *entry,

    TpawAccountWidget *self)

{

    if (gtk_widget_get_sensitive (self->priv->apply_button))

        tpaw_account_widget_apply_and_log_in (self);

}

void

tpaw_account_widget_setup_widget (TpawAccountWidget *self,

    GtkWidget *widget,

    const gchar *param_name)

{

  g_object_set_data_full (G_OBJECT (widget), "param_name",

      g_strdup (param_name), g_free);

  if (GTK_IS_SPIN_BUTTON (widget))

    {

      gint value = 0;

      const gchar *signature;

      signature = tpaw_account_settings_get_dbus_signature (

          self->priv->settings, param_name);

      g_return_if_fail (signature != NULL);

      switch ((int)*signature)

        {

          case DBUS_TYPE_INT16:

          case DBUS_TYPE_INT32:

            value = tpaw_account_settings_get_int32 (self->priv->settings,

              param_name);

            break;

          case DBUS_TYPE_INT64:

            value = tpaw_account_settings_get_int64 (self->priv->settings,

              param_name);

            break;

          case DBUS_TYPE_UINT16:

          case DBUS_TYPE_UINT32:

            value = tpaw_account_settings_get_uint32 (self->priv->settings,

              param_name);

            break;

          case DBUS_TYPE_UINT64:

            value = tpaw_account_settings_get_uint64 (self->priv->settings,

                param_name);

            break;

          default:

            g_return_if_reached ();

        }

      gtk_spin_button_set_value (GTK_SPIN_BUTTON (widget), value);

      g_signal_connect (widget, "value-changed",

          G_CALLBACK (account_widget_int_changed_cb),

          self);

    }

  else if (GTK_IS_ENTRY (widget))

    {

      gchar *str;

      str = tpaw_account_settings_dup_string (self->priv->settings,

          param_name);

      gtk_entry_set_text (GTK_ENTRY (widget), str ? str : "");

      if (!tp_strdiff (param_name, "account"))

        self->priv->param_account_widget = widget;

      else if (!tp_strdiff (param_name, "password"))

        self->priv->param_password_widget = widget;

      if (strstr (param_name, "password"))

        {

          if (self->priv->dialog != NULL)

            gtk_entry_set_activates_default (GTK_ENTRY (widget), TRUE);

          gtk_entry_set_visibility (GTK_ENTRY (widget), FALSE);

          /* Add 'clear' icon */

          gtk_entry_set_icon_from_icon_name (GTK_ENTRY (widget),

              GTK_ENTRY_ICON_SECONDARY, "edit-clear-symbolic");

          gtk_entry_set_icon_sensitive (GTK_ENTRY (widget),

              GTK_ENTRY_ICON_SECONDARY, !TPAW_STR_EMPTY (str));

          g_signal_connect (widget, "icon-release",

              G_CALLBACK (clear_icon_released_cb), self);

          g_signal_connect (widget, "changed",

              G_CALLBACK (password_entry_changed_cb), self);

          g_signal_connect (widget, "activate",

              G_CALLBACK (password_entry_activated_cb), self);

        }

      else if (strstr (param_name, "account"))

        {

          if (self->priv->dialog != NULL)

            gtk_entry_set_activates_default (GTK_ENTRY (widget), TRUE);

          g_signal_connect (widget, "activate",

              G_CALLBACK (account_entry_activated_cb), self);

        }

      g_signal_connect (widget, "changed",

          G_CALLBACK (account_widget_entry_changed_cb), self);

      g_signal_connect (widget, "map",

          G_CALLBACK (account_widget_entry_map_cb), self);

      g_free (str);

    }

  else if (GTK_IS_TOGGLE_BUTTON (widget))

    {

      gboolean value = FALSE;

      value = tpaw_account_settings_get_boolean (self->priv->settings,

          param_name);

      gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (widget), value);

      g_signal_connect (widget, "toggled",

          G_CALLBACK (account_widget_checkbutton_toggled_cb),

          self);

    }

  else if (GTK_IS_COMBO_BOX (widget))

    {

      /* The combo box's model has to contain the param value in its first

       * column (as a string) */

      gchar *str;

      GtkTreeModel *model;

      GtkTreeIter iter;

      gboolean valid;

      str = tpaw_account_settings_dup_string (self->priv->settings,

          param_name);

      model = gtk_combo_box_get_model (GTK_COMBO_BOX (widget));

      valid = gtk_tree_model_get_iter_first (model, &iter);

      while (valid)

        {

          gchar *name;

          gtk_tree_model_get (model, &iter, 0, &name, -1);

          if (!tp_strdiff (name, str))

            {

              gtk_combo_box_set_active_iter (GTK_COMBO_BOX (widget), &iter);

              valid = FALSE;

            }

          else

            {

              valid = gtk_tree_model_iter_next (model, &iter);

            }

          g_free (name);

        }

      g_free (str);

      g_signal_connect (widget, "changed",

          G_CALLBACK (account_widget_combobox_changed_cb),

          self);

    }

  else

    {

      DEBUG ("Unknown type of widget for param %s", param_name);

    }

  gtk_widget_set_sensitive (widget,

      tpaw_account_settings_param_is_supported (self->priv->settings,

        param_name));

}

static GHashTable *

build_translated_params (void)

{

  GHashTable *hash;

  hash = g_hash_table_new (g_str_hash, g_str_equal);

  g_hash_table_insert (hash, "account", _("Account"));

  g_hash_table_insert (hash, "password", _("Password"));

  g_hash_table_insert (hash, "server", _("Server"));

  g_hash_table_insert (hash, "port", _("Port"));

  return hash;

}

static gchar *

account_widget_generic_format_param_name (const gchar *param_name)

{

  gchar *str;

  gchar *p;

  static GHashTable *translated_params = NULL;

  g_return_val_if_fail (param_name != NULL, NULL);

  if (G_UNLIKELY (translated_params == NULL))

    translated_params = build_translated_params ();

  /* Translate most common parameters */

  str = g_hash_table_lookup (translated_params, param_name);

  if (str != NULL)

    return g_strdup (str);

  str = g_strdup (param_name);

  if (str && g_ascii_isalpha (str[0]))

    str[0] = g_ascii_toupper (str[0]);

  while ((p = strchr (str, '-')) != NULL)

    {

      if (p[1] != '\0' && g_ascii_isalpha (p[1]))

        {

          p[0] = ' ';

          p[1] = g_ascii_toupper (p[1]);

        }

      p++;

    }

  return str;

}

static void

accounts_widget_generic_setup (TpawAccountWidget *self,

    GtkWidget *grid_common_settings,

    GtkWidget *grid_advanced_settings)

{

  GList *params, *l;

  guint row_common = 0, row_advanced = 0;

  params = tpaw_account_settings_dup_tp_params (self->priv->settings);

  for (l = params; l != NULL; l = g_list_next (l))

    {

      TpConnectionManagerParam *param = l->data;

      GtkWidget       *grid_settings;

      guint           row;

      GtkWidget       *widget = NULL;

      gchar           *param_name_formatted;

      const gchar *dbus_signature;

      if (tp_connection_manager_param_is_required (param))

        {

          grid_settings = grid_common_settings;

          row = row_common++;

        }

      else if (self->priv->simple)

        {

          continue;

        }

      else

        {

          grid_settings = grid_advanced_settings;

          row = row_advanced++;

        }

      param_name_formatted = account_widget_generic_format_param_name (

          tp_connection_manager_param_get_name (param));

      dbus_signature = tp_connection_manager_param_get_dbus_signature (param);

      if (dbus_signature[0] == 's')

        {

          gchar *str;

          str = g_strdup_printf (_("%s"), param_name_formatted);

          widget = gtk_label_new (str);

          gtk_misc_set_alignment (GTK_MISC (widget), 1., 0.5);

          gtk_style_context_add_class (gtk_widget_get_style_context (widget),

              GTK_STYLE_CLASS_DIM_LABEL);

          g_free (str);

          gtk_grid_attach (GTK_GRID (grid_settings),

              widget, 0, row, 1, 1);

          gtk_widget_show (widget);

          widget = gtk_entry_new ();

          g_object_set (widget, "hexpand", TRUE, NULL);

          if (g_strcmp0 (tp_connection_manager_param_get_name (param),

                "account") == 0)

            {

              g_object_set (widget, "width-request", 280, NULL);

              g_signal_connect (widget, "realize",

                  G_CALLBACK (gtk_widget_grab_focus),

                  NULL);

            }

          gtk_grid_attach (GTK_GRID (grid_settings),

              widget, 1, row, 1, 1);

          gtk_widget_show (widget);

        }

      /* int types: ynqiuxt. double type is 'd' */

      else if (dbus_signature[0] == 'y' ||

          dbus_signature[0] == 'n' ||

          dbus_signature[0] == 'q' ||

          dbus_signature[0] == 'i' ||

          dbus_signature[0] == 'u' ||

          dbus_signature[0] == 'x' ||

          dbus_signature[0] == 't' ||

          dbus_signature[0] == 'd')

        {

          gchar   *str = NULL;

          gdouble  minint = 0;

          gdouble  maxint = 0;

          gdouble  step = 1;

          switch (dbus_signature[0])

            {

            case 'y': minint = G_MININT8;  maxint = G_MAXINT8;   break;

            case 'n': minint = G_MININT16; maxint = G_MAXINT16;  break;

            case 'q': minint = 0;          maxint = G_MAXUINT16; break;

            case 'i': minint = G_MININT32; maxint = G_MAXINT32;  break;

            case 'u': minint = 0;          maxint = G_MAXUINT32; break;

            case 'x': minint = G_MININT64; maxint = G_MAXINT64;  break;

            case 't': minint = 0;          maxint = G_MAXUINT64; break;

            case 'd': minint = G_MININT32; maxint = G_MAXINT32;

              step = 0.1; break;

            default: g_assert_not_reached ();

            }

          str = g_strdup_printf (_("%s:"), param_name_formatted);

          widget = gtk_label_new (str);

          gtk_misc_set_alignment (GTK_MISC (widget), 0, 0.5);

          g_free (str);

          gtk_grid_attach (GTK_GRID (grid_settings),

              widget, 0, row, 1, 1);

          gtk_widget_show (widget);

          widget = gtk_spin_button_new_with_range (minint, maxint, step);

          gtk_grid_attach (GTK_GRID (grid_settings),

              widget, 1, row, 1, 1);

          gtk_widget_show (widget);

        }

      else if (dbus_signature[0] == 'b')

        {

          widget = gtk_check_button_new_with_label (param_name_formatted);

          gtk_grid_attach (GTK_GRID (grid_settings),

              widget, 0, row, 2, 1);

          gtk_widget_show (widget);

        }

      else

        {

          DEBUG ("Unknown signature for param %s: %s",

              param_name_formatted, dbus_signature);

        }

      if (widget)

        tpaw_account_widget_setup_widget (self, widget,

            tp_connection_manager_param_get_name (param));

      g_free (param_name_formatted);

    }

  g_list_free_full (params, (GDestroyNotify) tp_connection_manager_param_free);

}

static void

account_widget_handle_params_valist (TpawAccountWidget *self,

    const gchar *first_widget,

    va_list args)

{

  GObject *object;

  const gchar *name;

  for (name = first_widget; name; name = va_arg (args, const gchar *))

    {

      const gchar *param_name;

      param_name = va_arg (args, const gchar *);

      object = gtk_builder_get_object (self->ui_details->gui, name);

      if (!object)

        {

          g_warning ("Builder is missing object '%s'.", name);

          continue;

        }

      tpaw_account_widget_setup_widget (self, GTK_WIDGET (object),

          param_name);

    }

}

static void

account_widget_cancel_clicked_cb (GtkWidget *button,

    TpawAccountWidget *self)

{

  g_signal_emit (self, signals[CANCELLED], 0);

  g_signal_emit (self, signals[CLOSE], 0, GTK_RESPONSE_CANCEL);

}

static void

account_widget_account_enabled_cb (GObject *source_object,

    GAsyncResult *res,