/*
* Copyright (C) 2006-2007 Imendio AB
* Copyright (C) 2007-2009 Collabora Ltd.
*
* This program is free software; you can redistribute it and/or
* modify it under the terms of the GNU General Public License as
* published by the Free Software Foundation; either version 2 of the
* License, or (at your option) any later version.
*
* This program 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
* General Public License for more details.
*
* You should have received a copy of the GNU General Public
* License along with this program; 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 <string.h>
#include <gtk/gtk.h>
#include <glib/gi18n-lib.h>
#include <gio/gdesktopappinfo.h>
#include <libempathy/empathy-utils.h>
#include <telepathy-glib/account.h>
#include <telepathy-glib/account-manager.h>
#include <telepathy-glib/connection-manager.h>
#include <telepathy-glib/util.h>
#include <dbus/dbus-protocol.h>
#include "empathy-account-widget.h"
#include "empathy-account-widget-private.h"
#include "empathy-account-widget-sip.h"
#include "empathy-account-widget-irc.h"
#include "empathy-ui-utils.h"
#define DEBUG_FLAG EMPATHY_DEBUG_ACCOUNT
#include <libempathy/empathy-debug.h>
G_DEFINE_TYPE (EmpathyAccountWidget, empathy_account_widget, GTK_TYPE_BOX)
typedef enum
{
NO_SERVICE = 0,
GTALK_SERVICE,
FACEBOOK_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 },
{ "label_username_f_example", FALSE },
};
struct _EmpathyAccountWidgetPriv {
EmpathyAccountSettings *settings;
GtkWidget *grid_common_settings;
GtkWidget *apply_button;
GtkWidget *cancel_button;
GtkWidget *entry_password;
GtkWidget *spinbutton_port;
GtkWidget *radiobutton_reuse;
GtkWidget *hbox_buttons;
gboolean simple;
gboolean contains_pending_changes;
/* An EmpathyAccountWidget 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 */
EmpathyIrcNetworkChooser *irc_network_chooser;
/* Used for 'special' XMPP account having a service associated ensuring that
* JIDs have a specific suffix; such as Facebook for example */
gchar *jid_suffix;
};
enum {
PROP_PROTOCOL = 1,
PROP_SETTINGS,
PROP_SIMPLE,
PROP_CREATING_ACCOUNT,
PROP_OTHER_ACCOUNTS_EXIST,
};
enum {
HANDLE_APPLY,
ACCOUNT_CREATED,
CANCELLED,
CLOSE,
LAST_SIGNAL
};
static void account_widget_apply_and_log_in (EmpathyAccountWidget *);
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"]*)"
/* user = 1*( %x01-09 / %x0B-0C / %x0E-1F / %x21-3F / %x41-FF )
* ; any octet except NUL, CR, LF, " " and "@"
*
* so technically, like so many other places in IRC, we should be using arrays
* of bytes here rather than UTF-8 strings. Life: too short. In practice this
* will always be ASCII.
*/
#define IRC_USER_NAME "([^\r\n@ ])+"
/* 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 USERNAME_REGEX_IRC "^"IRC_USER_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 (EmpathyAccountWidget *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)
{
/* 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)
{
g_return_if_fail (GTK_IS_ENTRY (entry));
if (highlight)
{
GtkStyleContext *style;
GdkRGBA color;
style = gtk_widget_get_style_context (GTK_WIDGET (entry));
gtk_style_context_get_background_color (style, GTK_STATE_FLAG_SELECTED,
&color);
/* Here we take the current theme colour and add it to
* the colour for white and average the two. This
* gives a colour which is inline with the theme but
* slightly whiter.
*/
empathy_make_color_whiter (&color);
gtk_widget_override_background_color (GTK_WIDGET (entry), 0, &color);
}
else
{
gtk_widget_override_background_color (GTK_WIDGET (entry), 0, NULL);
}
}
static void
account_widget_handle_control_buttons_sensitivity (EmpathyAccountWidget *self)
{
gboolean is_valid;
is_valid = empathy_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 (EmpathyAccountWidget *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 = empathy_account_settings_parameter_is_valid (
self->priv->settings, param_name);
if (EMP_STR_EMPTY (str))
{
empathy_account_settings_unset (self->priv->settings, param_name);
if (focus)
{
gchar *value;
value = empathy_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 : "***");
empathy_account_settings_set (self->priv->settings, param_name,
g_variant_new_string (str));
}
curr_status = empathy_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,
EmpathyAccountWidget *self)
{
if (self->priv->automatic_change)
return;
account_widget_entry_changed_common (self, GTK_ENTRY (entry), FALSE);
empathy_account_widget_changed (self);
}
static void
account_widget_entry_map_cb (GtkEntry *entry,
EmpathyAccountWidget *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 = empathy_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,
EmpathyAccountWidget *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 = empathy_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:
empathy_account_settings_set (self->priv->settings, param_name,
g_variant_new_int32 (value));
break;
case DBUS_TYPE_INT64:
empathy_account_settings_set (self->priv->settings, param_name,
g_variant_new_int64 (value));
break;
case DBUS_TYPE_UINT16:
case DBUS_TYPE_UINT32:
empathy_account_settings_set (self->priv->settings, param_name,
g_variant_new_uint32 (value));
break;
case DBUS_TYPE_UINT64:
empathy_account_settings_set (self->priv->settings, param_name,
g_variant_new_uint64 (value));
break;
default:
g_return_if_reached ();
}
empathy_account_widget_changed (self);
}
static void
account_widget_checkbutton_toggled_cb (GtkWidget *widget,
EmpathyAccountWidget *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. */
empathy_account_settings_unset (self->priv->settings, param_name);
default_value = empathy_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);
empathy_account_settings_set (self->priv->settings, param_name,
g_variant_new_boolean (value));
}
empathy_account_widget_changed (self);
}
static void
account_widget_jabber_ssl_toggled_cb (GtkWidget *checkbutton_ssl,
EmpathyAccountWidget *self)
{
gboolean value;
gint32 port = 0;
value = gtk_toggle_button_get_active (GTK_TOGGLE_BUTTON (checkbutton_ssl));
port = empathy_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,
EmpathyAccountWidget *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 = empathy_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);
empathy_account_settings_unset (self->priv->settings, param_name);
}
else
{
DEBUG ("Setting %s to %s", param_name, value);
empathy_account_settings_set (self->priv->settings, param_name,
g_variant_new_string (value));
}
empathy_account_widget_changed (self);
tp_clear_pointer (&v, g_variant_unref);
}
static void
clear_icon_released_cb (GtkEntry *entry,
GtkEntryIconPosition icon_pos,
GdkEvent *event,
EmpathyAccountWidget *self)
{
const gchar *param_name;
param_name = g_object_get_data (G_OBJECT (entry), "param_name");
DEBUG ("Unset %s", param_name);
empathy_account_settings_unset (self->priv->settings, param_name);
gtk_entry_set_text (entry, "");
empathy_account_widget_changed (self);
}
static void
password_entry_changed_cb (GtkEditable *entry,
EmpathyAccountWidget *self)
{
const gchar *str;
str = gtk_entry_get_text (GTK_ENTRY (entry));
gtk_entry_set_icon_sensitive (GTK_ENTRY (entry),
GTK_ENTRY_ICON_SECONDARY, !EMP_STR_EMPTY (str));
}
static void
password_entry_activated_cb (GtkEntry *entry,
EmpathyAccountWidget *self)
{
if (gtk_widget_get_sensitive (self->priv->apply_button))
account_widget_apply_and_log_in (self);
}
static void
account_entry_activated_cb (GtkEntry *entry,
EmpathyAccountWidget *self)
{
if (gtk_widget_get_sensitive (self->priv->apply_button))
account_widget_apply_and_log_in (self);
}
void
empathy_account_widget_setup_widget (EmpathyAccountWidget *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 = empathy_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 = empathy_account_settings_get_int32 (self->priv->settings,
param_name);
break;
case DBUS_TYPE_INT64:
value = empathy_account_settings_get_int64 (self->priv->settings,
param_name);
break;
case DBUS_TYPE_UINT16:
case DBUS_TYPE_UINT32:
value = empathy_account_settings_get_uint32 (self->priv->settings,
param_name);
break;
case DBUS_TYPE_UINT64:
value = empathy_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 = empathy_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"))
{
gtk_entry_set_visibility (GTK_ENTRY (widget), FALSE);
/* Add 'clear' icon */
gtk_entry_set_icon_from_stock (GTK_ENTRY (widget),
GTK_ENTRY_ICON_SECONDARY, GTK_STOCK_CLEAR);
gtk_entry_set_icon_sensitive (GTK_ENTRY (widget),
GTK_ENTRY_ICON_SECONDARY, !EMP_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"))
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 = empathy_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 = empathy_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,
empathy_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 (EmpathyAccountWidget *self,
GtkWidget *grid_common_settings,
GtkWidget *grid_advanced_settings)
{
GList *params, *l;
guint row_common = 0, row_advanced = 0;
params = empathy_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 ();
if (strcmp (tp_connection_manager_param_get_name (param),
"account") == 0)
{
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)
empathy_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 (EmpathyAccountWidget *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;
}
empathy_account_widget_setup_widget (self, GTK_WIDGET (object),
param_name);
}
}
static void
account_widget_cancel_clicked_cb (GtkWidget *button,
EmpathyAccountWidget *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,
gpointer user_data)
{
GError *error = NULL;
TpAccount *account = TP_ACCOUNT (source_object);
EmpathyAccountWidget *self = EMPATHY_ACCOUNT_WIDGET (user_data);
tp_account_set_enabled_finish (account, res, &error);
if (error != NULL)
{
DEBUG ("Could not enable the account: %s", error->message);
g_error_free (error);
}
else
{
empathy_connect_new_account (account, self->priv->account_manager);
}
g_signal_emit (self, signals[CLOSE], 0, GTK_RESPONSE_APPLY);
/* unref self - part of the workaround */
g_object_unref (self);
}
static void
account_widget_applied_cb (GObject *source_object,
GAsyncResult *res,
gpointer user_data)
{
GError *error = NULL;
TpAccount *account;
EmpathyAccountSettings *settings = EMPATHY_ACCOUNT_SETTINGS (source_object);
EmpathyAccountWidget *self = EMPATHY_ACCOUNT_WIDGET (user_data);
gboolean reconnect_required;
gboolean fire_close = TRUE;
empathy_account_settings_apply_finish (settings, res, &reconnect_required,
&error);
if (error != NULL)
{
DEBUG ("Could not apply changes to account: %s", error->message);
g_error_free (error);
return;
}
account = empathy_account_settings_get_account (self->priv->settings);
if (account != NULL)
{
if (self->priv->creating_account)
{
/* By default, when an account is created, we enable it. */
/* workaround to keep self alive during async call */
g_object_ref (self);
tp_account_set_enabled_async (account, TRUE,
account_widget_account_enabled_cb, self);
g_signal_emit (self, signals[ACCOUNT_CREATED], 0, account);
/* Will be fired in account_widget_account_enabled_cb */
fire_close = FALSE;
}
else
{
/* If the account was offline, we always want to try reconnecting,
* to give it a chance to connect if the previous params were wrong.
* tp_account_reconnect_async() won't do anything if the requested
* presence is offline anyway. */
if (tp_account_get_connection_status (account, NULL) ==
TP_CONNECTION_STATUS_DISCONNECTED)
reconnect_required = TRUE;
if (reconnect_required && tp_account_is_enabled (account)
&& tp_account_is_enabled (account))
{
/* After having applied changes to a user account, we
* reconnect it if needed. This is done so the new
* information entered by the user is validated on the server. */
tp_account_reconnect_async (account, NULL, NULL);
}
}
}
if (!self->priv->destroyed)
account_widget_set_control_buttons_sensitivity (self, FALSE);
self->priv->contains_pending_changes = FALSE;
if (fire_close)
{
/* announce the widget can be closed */
g_signal_emit (self, signals[CLOSE], 0, GTK_RESPONSE_APPLY);
}
/* unref the widget - part of the workaround */
g_object_unref (self);
}
static void
account_widget_apply_and_log_in (EmpathyAccountWidget *self)
{
gboolean display_name_overridden;
if (self->priv->radiobutton_reuse != NULL)
{
gboolean reuse = gtk_toggle_button_get_active (GTK_TOGGLE_BUTTON (
self->priv->radiobutton_reuse));
DEBUG ("Set register param: %d", !reuse);
empathy_account_settings_set (self->priv->settings, "register",
g_variant_new_boolean (!reuse));
}
g_object_get (self->priv->settings,
"display-name-overridden", &display_name_overridden, NULL);
if (self->priv->creating_account || !display_name_overridden)
{
gchar *display_name;
/* set default display name for new accounts or update if user didn't
* manually override it. */
display_name = empathy_account_widget_get_default_display_name (self);
empathy_account_settings_set_display_name_async (self->priv->settings,
display_name, NULL, NULL);
g_free (display_name);
}
/* workaround to keep widget alive during async call */
g_object_ref (self);
empathy_account_settings_apply_async (self->priv->settings,
account_widget_applied_cb, self);
}
static void
account_widget_apply_clicked_cb (GtkWidget *button,
EmpathyAccountWidget *self)
{
account_widget_apply_and_log_in (self);
}
static void
account_widget_setup_generic (EmpathyAccountWidget *self)
{
GtkWidget *grid_common_settings;
GtkWidget *grid_advanced_settings;
grid_common_settings = GTK_WIDGET (gtk_builder_get_object
(self->ui_details->gui, "grid_common_settings"));
grid_advanced_settings = GTK_WIDGET (gtk_builder_get_object
(self->ui_details->gui, "grid_advanced_settings"));
accounts_widget_generic_setup (self, grid_common_settings,
grid_advanced_settings);
g_object_unref (self->ui_details->gui);
}
static void
account_widget_settings_ready_cb (EmpathyAccountSettings *settings,
GParamSpec *pspec,
gpointer user_data)
{
EmpathyAccountWidget *self = user_data;
if (empathy_account_settings_is_ready (self->priv->settings))
account_widget_setup_generic (self);
}
static GtkWidget *
account_widget_build_generic (EmpathyAccountWidget *self,
const char *filename)
{
GtkWidget *expander_advanced, *box;
self->ui_details->gui = empathy_builder_get_file (filename,
"grid_common_settings", &self->priv->grid_common_settings,
"vbox_generic_settings", &box,
"expander_advanced_settings", &expander_advanced,
NULL);
if (self->priv->simple)
gtk_widget_hide (expander_advanced);
g_object_ref (self->ui_details->gui);
if (empathy_account_settings_is_ready (self->priv->settings))
account_widget_setup_generic (self);
else
g_signal_connect (self->priv->settings, "notify::ready",
G_CALLBACK (account_widget_settings_ready_cb), self);
return box;
}
static GtkWidget *
account_widget_build_salut (EmpathyAccountWidget *self,
const char *filename)
{
GtkWidget *expander_advanced, *box;
self->ui_details->gui = empathy_builder_get_file (filename,
"grid_common_settings", &self->priv->grid_common_settings,
"vbox_salut_settings", &box,
"expander_advanced_settings", &expander_advanced,
NULL);
empathy_account_widget_handle_params (self,
"entry_published", "published-name",
"entry_nickname", "nickname",
"entry_first_name", "first-name",
"entry_last_name", "last-name",
"entry_email", "email",
"entry_jid", "jid",
NULL);
if (self->priv->simple)
gtk_widget_hide (expander_advanced);
self->ui_details->default_focus = g_strdup ("entry_first_name");
return box;
}
static GtkWidget *
account_widget_build_irc (EmpathyAccountWidget *self,
const char *filename)
{
GtkWidget *box;
empathy_account_settings_set_regex (self->priv->settings, "account",
ACCOUNT_REGEX_IRC);
empathy_account_settings_set_regex (self->priv->settings, "username",
USERNAME_REGEX_IRC);
if (self->priv->simple)
{
self->priv->irc_network_chooser = empathy_account_widget_irc_build_simple
(self, filename, &box);
}
else
{
self->priv->irc_network_chooser = empathy_account_widget_irc_build (self,
filename, &self->priv->grid_common_settings, &box);
}
return box;
}
static GtkWidget *
account_widget_build_sip (EmpathyAccountWidget *self,
const char *filename)
{
GtkWidget *box;
box = empathy_account_widget_sip_build (self, filename,
&self->priv->grid_common_settings);
if (self->priv->simple)
{
self->priv->remember_password_widget = GTK_WIDGET (
gtk_builder_get_object (self->ui_details->gui,
"remember_password_simple"));
}
else
{
self->priv->remember_password_widget = GTK_WIDGET (
gtk_builder_get_object (self->ui_details->gui, "remember_password"));
}
return box;
}
static GtkWidget *
account_widget_build_msn (EmpathyAccountWidget *self,
const char *filename)
{
GtkWidget *box;
empathy_account_settings_set_regex (self->priv->settings, "account",
ACCOUNT_REGEX_MSN);
if (self->priv->simple)
{
self->ui_details->gui = empathy_builder_get_file (filename,
"vbox_msn_simple", &box,
NULL);
empathy_account_widget_handle_params (self,
"entry_id_simple", "account",
"entry_password_simple", "password",
NULL);
self->ui_details->default_focus = g_strdup ("entry_id_simple");
self->priv->remember_password_widget = GTK_WIDGET (
gtk_builder_get_object (self->ui_details->gui,
"remember_password_simple"));
}
else
{
self->ui_details->gui = empathy_builder_get_file (filename,
"grid_common_msn_settings", &self->priv->grid_common_settings,
"vbox_msn_settings", &box,
NULL);
empathy_account_widget_handle_params (self,
"entry_id", "account",
"entry_password", "password",
"entry_server", "server",
"spinbutton_port", "port",
NULL);
self->ui_details->default_focus = g_strdup ("entry_id");
self->priv->remember_password_widget = GTK_WIDGET (
gtk_builder_get_object (self->ui_details->gui, "remember_password"));
}
return box;
}
static void
suffix_id_widget_changed_cb (GtkWidget *entry,
EmpathyAccountWidget *self)
{
gchar *account;
g_assert (self->priv->jid_suffix != NULL);
account_widget_entry_changed_common (self, GTK_ENTRY (entry), FALSE);
account = empathy_account_settings_dup_string (self->priv->settings,
"account");
if (!EMP_STR_EMPTY (account) &&
!g_str_has_suffix (account, self->priv->jid_suffix))
{
gchar *tmp;
tmp = g_strdup_printf ("%s%s", account, self->priv->jid_suffix);
DEBUG ("Change account from '%s' to '%s'", account, tmp);
empathy_account_settings_set (self->priv->settings, "account",
g_variant_new_string (tmp));
g_free (tmp);
}
empathy_account_widget_changed (self);
g_free (account);
}
static gchar *
remove_jid_suffix (EmpathyAccountWidget *self,
const gchar *str)
{
g_assert (self->priv->jid_suffix != NULL);
if (!g_str_has_suffix (str, self->priv->jid_suffix))
return g_strdup (str);
return g_strndup (str, strlen (str) - strlen (self->priv->jid_suffix));
}
static void
setup_id_widget_with_suffix (EmpathyAccountWidget *self,
GtkWidget *widget,
const gchar *suffix)
{
gchar *str = NULL;
g_object_set_data_full (G_OBJECT (widget), "param_name",
g_strdup ("account"), g_free);
g_assert (self->priv->jid_suffix == NULL);
self->priv->jid_suffix = g_strdup (suffix);
str = empathy_account_settings_dup_string (self->priv->settings, "account");
if (str != NULL)
{
gchar *tmp;
tmp = remove_jid_suffix (self, str);
gtk_entry_set_text (GTK_ENTRY (widget), tmp);
g_free (tmp);
g_free (str);
}
self->priv->param_account_widget = widget;
g_signal_connect (widget, "changed",
G_CALLBACK (suffix_id_widget_changed_cb), self);
}
static Service
account_widget_get_service (EmpathyAccountWidget *self)
{
const gchar *icon_name, *service;
icon_name = empathy_account_settings_get_icon_name (self->priv->settings);
service = empathy_account_settings_get_service (self->priv->settings);
/* Previous versions of Empathy didn't set the Service property on Facebook
* and gtalk accounts, so we check using the icon name as well. */
if (!tp_strdiff (icon_name, "im-google-talk") ||
!tp_strdiff (service, "google-talk"))
return GTALK_SERVICE;
if (!tp_strdiff (icon_name, "im-facebook") ||
!tp_strdiff (service, "facebook"))
return FACEBOOK_SERVICE;
return NO_SERVICE;
}
static GtkWidget *
account_widget_build_jabber (EmpathyAccountWidget *self,
const char *filename)
{
GtkWidget *spinbutton_port;
GtkWidget *checkbutton_ssl;
GtkWidget *label_id, *label_password;
GtkWidget *label_id_create, *label_password_create;
GtkWidget *label_example_fb;
GtkWidget *label_example;
GtkWidget *expander_advanced;
GtkWidget *entry_id;
GtkWidget *box;
Service service;
service = account_widget_get_service (self);
empathy_account_settings_set_regex (self->priv->settings, "account",
ACCOUNT_REGEX_JABBER);
if (self->priv->simple && service == NO_SERVICE)
{
/* Simple widget for XMPP */
self->ui_details->gui = empathy_builder_get_file (filename,
"vbox_jabber_simple", &box,
"label_id_simple", &label_id,
"label_id_create", &label_id_create,
"label_password_simple", &label_password,
"label_password_create", &label_password_create,
NULL);
if (empathy_account_settings_get_boolean (self->priv->settings,
"register"))
{
gtk_widget_hide (label_id);
gtk_widget_hide (label_password);
gtk_widget_show (label_id_create);
gtk_widget_show (label_password_create);
}
empathy_account_widget_handle_params (self,
"entry_id_simple", "account",
"entry_password_simple", "password",
NULL);
self->ui_details->default_focus = g_strdup ("entry_id_simple");
self->priv->remember_password_widget = GTK_WIDGET (
gtk_builder_get_object (self->ui_details->gui,
"remember_password_simple"));
}
else if (self->priv->simple && service == GTALK_SERVICE)
{
/* Simple widget for Google Talk */
self->ui_details->gui = empathy_builder_get_file (filename,
"vbox_gtalk_simple", &box,
NULL);
empathy_account_widget_handle_params (self,
"entry_id_g_simple", "account",
"entry_password_g_simple", "password",
NULL);
self->ui_details->default_focus = g_strdup ("entry_id_g_simple");
self->priv->remember_password_widget = GTK_WIDGET (
gtk_builder_get_object (self->ui_details->gui,
"remember_password_g_simple"));
}
else if (self->priv->simple && service == FACEBOOK_SERVICE)
{
/* Simple widget for Facebook */
self->ui_details->gui = empathy_builder_get_file (filename,
"vbox_fb_simple", &box,
"entry_id_fb_simple", &entry_id,
NULL);
empathy_account_widget_handle_params (self,
"entry_password_fb_simple", "password",
NULL);
setup_id_widget_with_suffix (self, entry_id, "@chat.facebook.com");
self->ui_details->default_focus = g_strdup ("entry_id_fb_simple");
self->priv->remember_password_widget = GTK_WIDGET (
gtk_builder_get_object (self->ui_details->gui,
"remember_password_fb_simple"));
}
else
{
ServiceInfo info = services_infos[service];
/* Full widget for XMPP, Google Talk and Facebook*/
self->ui_details->gui = empathy_builder_get_file (filename,
"grid_common_settings", &self->priv->grid_common_settings,
"vbox_jabber_settings", &box,
"spinbutton_port", &spinbutton_port,
"checkbutton_ssl", &checkbutton_ssl,
"label_username_f_example", &label_example_fb,
info.label_username_example, &label_example,
"expander_advanced", &expander_advanced,
"entry_id", &entry_id,
"label_id", &label_id,
NULL);
empathy_account_widget_handle_params (self,
"entry_password", "password",
"entry_resource", "resource",
"entry_server", "server",
"spinbutton_port", "port",
"spinbutton_priority", "priority",
"checkbutton_ssl", "old-ssl",
"checkbutton_ignore_ssl_errors", "ignore-ssl-errors",
"checkbutton_encryption", "require-encryption",
NULL);
if (service == FACEBOOK_SERVICE)
{
gtk_label_set_label (GTK_LABEL (label_id), _("Username:"));
/* Facebook special case the entry ID widget to hide the
* "@chat.facebook.com" part */
setup_id_widget_with_suffix (self, entry_id, "@chat.facebook.com");
}
else
{
empathy_account_widget_setup_widget (self, entry_id, "account");
}
self->ui_details->default_focus = g_strdup ("entry_id");
self->priv->spinbutton_port = spinbutton_port;
self->priv->remember_password_widget = GTK_WIDGET (
gtk_builder_get_object (self->ui_details->gui, "remember_password"));
g_signal_connect (checkbutton_ssl, "toggled",
G_CALLBACK (account_widget_jabber_ssl_toggled_cb),
self);
if (service == FACEBOOK_SERVICE)
{
GtkContainer *parent;
GList *children;
/* Removing the label from list of focusable widgets */
parent = GTK_CONTAINER (gtk_widget_get_parent (label_example_fb));
children = gtk_container_get_children (parent);
children = g_list_remove (children, label_example_fb);
gtk_container_set_focus_chain (parent, children);
g_list_free (children);
}
gtk_widget_show (label_example);
if (!info.show_advanced)
gtk_widget_hide (expander_advanced);
}
return box;
}
static GtkWidget *
account_widget_build_icq (EmpathyAccountWidget *self,
const char *filename)
{
GtkWidget *spinbutton_port;
GtkWidget *box;
empathy_account_settings_set_regex (self->priv->settings, "account",
ACCOUNT_REGEX_ICQ);
if (self->priv->simple)
{
self->ui_details->gui = empathy_builder_get_file (filename,
"vbox_icq_simple", &box,
NULL);
empathy_account_widget_handle_params (self,
"entry_uin_simple", "account",
"entry_password_simple", "password",
NULL);
self->ui_details->default_focus = g_strdup ("entry_uin_simple");
self->priv->remember_password_widget = GTK_WIDGET (
gtk_builder_get_object (self->ui_details->gui,
"remember_password_simple"));
}
else
{
self->ui_details->gui = empathy_builder_get_file (filename,
"grid_common_settings", &self->priv->grid_common_settings,
"vbox_icq_settings", &box,
"spinbutton_port", &spinbutton_port,
NULL);
empathy_account_widget_handle_params (self,
"entry_uin", "account",
"entry_password", "password",
"entry_server", "server",
"spinbutton_port", "port",
"entry_charset", "charset",
NULL);
self->ui_details->default_focus = g_strdup ("entry_uin");
self->priv->remember_password_widget = GTK_WIDGET (
gtk_builder_get_object (self->ui_details->gui, "remember_password"));
}
return box;
}
static GtkWidget *
account_widget_build_aim (EmpathyAccountWidget *self,
const char *filename)
{
GtkWidget *spinbutton_port, *box;
if (self->priv->simple)
{
self->ui_details->gui = empathy_builder_get_file (filename,
"vbox_aim_simple", &box,
NULL);
empathy_account_widget_handle_params (self,
"entry_screenname_simple", "account",
"entry_password_simple", "password",
NULL);
self->ui_details->default_focus = g_strdup ("entry_screenname_simple");
self->priv->remember_password_widget = GTK_WIDGET (
gtk_builder_get_object (self->ui_details->gui,
"remember_password_simple"));
}
else
{
self->ui_details->gui = empathy_builder_get_file (filename,
"grid_common_settings", &self->priv->grid_common_settings,
"vbox_aim_settings", &box,
"spinbutton_port", &spinbutton_port,
NULL);
empathy_account_widget_handle_params (self,
"entry_screenname", "account",
"entry_password", "password",
"entry_server", "server",
"spinbutton_port", "port",
NULL);
self->ui_details->default_focus = g_strdup ("entry_screenname");
self->priv->remember_password_widget = GTK_WIDGET (
gtk_builder_get_object (self->ui_details->gui, "remember_password"));
}
return box;
}
static GtkWidget *
account_widget_build_yahoo (EmpathyAccountWidget *self,
const char *filename)
{
GtkWidget *box;
empathy_account_settings_set_regex (self->priv->settings, "account",
ACCOUNT_REGEX_YAHOO);
if (self->priv->simple)
{
self->ui_details->gui = empathy_builder_get_file (filename,
"vbox_yahoo_simple", &box,
NULL);
empathy_account_widget_handle_params (self,
"entry_id_simple", "account",
"entry_password_simple", "password",
NULL);
self->ui_details->default_focus = g_strdup ("entry_id_simple");
self->priv->remember_password_widget = GTK_WIDGET (
gtk_builder_get_object (self->ui_details->gui,
"remember_password_simple"));
}
else
{
self->ui_details->gui = empathy_builder_get_file (filename,
"grid_common_settings", &self->priv->grid_common_settings,
"vbox_yahoo_settings", &box,
NULL);
empathy_account_widget_handle_params (self,
"entry_id", "account",
"entry_password", "password",
"entry_locale", "room-list-locale",
"entry_charset", "charset",
"spinbutton_port", "port",
"checkbutton_ignore_invites", "ignore-invites",
NULL);
self->ui_details->default_focus = g_strdup ("entry_id");
self->priv->remember_password_widget = GTK_WIDGET (
gtk_builder_get_object (self->ui_details->gui, "remember_password"));
}
return box;
}
static GtkWidget *
account_widget_build_groupwise (EmpathyAccountWidget *self,
const char *filename)
{
GtkWidget *box;
if (self->priv->simple)
{
self->ui_details->gui = empathy_builder_get_file (filename,
"vbox_groupwise_simple", &box,
NULL);
empathy_account_widget_handle_params (self,
"entry_id_simple", "account",
"entry_password_simple", "password",
NULL);
self->ui_details->default_focus = g_strdup ("entry_id_simple");
self->priv->remember_password_widget = GTK_WIDGET (
gtk_builder_get_object (self->ui_details->gui,
"remember_password_simple"));
}
else
{
self->ui_details->gui = empathy_builder_get_file (filename,
"grid_common_groupwise_settings", &self->priv->grid_common_settings,
"vbox_groupwise_settings", &box,
NULL);
empathy_account_widget_handle_params (self,
"entry_id", "account",
"entry_password", "password",
"entry_server", "server",
"spinbutton_port", "port",
NULL);
self->ui_details->default_focus = g_strdup ("entry_id");
self->priv->remember_password_widget = GTK_WIDGET (
gtk_builder_get_object (self->ui_details->gui, "remember_password"));
}
return box;
}
void
empathy_account_widget_set_other_accounts_exist (EmpathyAccountWidget *self,
gboolean others_exist)
{
self->priv->other_accounts_exist = others_exist;
if (self->priv->creating_account)
account_widget_handle_control_buttons_sensitivity (self);
}
static void
do_set_property (GObject *object,
guint prop_id,
const GValue *value,
GParamSpec *pspec)
{
EmpathyAccountWidget *self = EMPATHY_ACCOUNT_WIDGET (object);
switch (prop_id)
{
case PROP_SETTINGS:
self->priv->settings = g_value_dup_object (value);
break;
case PROP_SIMPLE:
self->priv->simple = g_value_get_boolean (value);
break;
case PROP_CREATING_ACCOUNT:
self->priv->creating_account = g_value_get_boolean (value);
break;
case PROP_OTHER_ACCOUNTS_EXIST:
empathy_account_widget_set_other_accounts_exist (
EMPATHY_ACCOUNT_WIDGET (object), g_value_get_boolean (value));
break;
default:
G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
}
}
static void
do_get_property (GObject *object,
guint prop_id,
GValue *value,
GParamSpec *pspec)
{
EmpathyAccountWidget *self = EMPATHY_ACCOUNT_WIDGET (object);
switch (prop_id)
{
case PROP_PROTOCOL:
g_value_set_string (value,
empathy_account_settings_get_protocol (self->priv->settings));
break;
case PROP_SETTINGS:
g_value_set_object (value, self->priv->settings);
break;
case PROP_SIMPLE:
g_value_set_boolean (value, self->priv->simple);
break;
case PROP_CREATING_ACCOUNT:
g_value_set_boolean (value, self->priv->creating_account);
break;
case PROP_OTHER_ACCOUNTS_EXIST:
g_value_set_boolean (value, self->priv->other_accounts_exist);
break;
default:
G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
}
}
static void
set_apply_button (EmpathyAccountWidget *self)
{
GtkWidget *image;
/* We can't use the stock button as its accelerator ('A') clashes with the
* Add button. */
gtk_button_set_use_stock (GTK_BUTTON (self->priv->apply_button), FALSE);
gtk_button_set_label (GTK_BUTTON (self->priv->apply_button), _("A_pply"));
gtk_button_set_use_underline (GTK_BUTTON (self->priv->apply_button), TRUE);
image = gtk_image_new_from_stock (GTK_STOCK_APPLY, GTK_ICON_SIZE_BUTTON);
gtk_button_set_image (GTK_BUTTON (self->priv->apply_button), image);
}
static void
presence_changed_cb (TpAccountManager *manager,
TpConnectionPresenceType state,
const gchar *status,
const gchar *message,
EmpathyAccountWidget *self)
{
if (self->priv->destroyed)
return;
if (self->priv->apply_button == NULL)
/* This button doesn't exist in 'simple' mode */
return;
if (state > TP_CONNECTION_PRESENCE_TYPE_OFFLINE &&
self->priv->creating_account)
{
/* We are online and creating a new account, display a Login button */
GtkWidget *image;
gtk_button_set_use_stock (GTK_BUTTON (self->priv->apply_button), FALSE);
gtk_button_set_label (GTK_BUTTON (self->priv->apply_button),
_("L_og in"));
image = gtk_image_new_from_stock (GTK_STOCK_CONNECT,
GTK_ICON_SIZE_BUTTON);
gtk_button_set_image (GTK_BUTTON (self->priv->apply_button), image);
}
else
{
/* We are offline or modifying an existing account, display
* a Save button */
set_apply_button (self);
}
}
static void
account_manager_ready_cb (GObject *source_object,
GAsyncResult *result,
gpointer user_data)
{
EmpathyAccountWidget *self = EMPATHY_ACCOUNT_WIDGET (user_data);
TpAccountManager *account_manager = TP_ACCOUNT_MANAGER (source_object);
GError *error = NULL;
TpConnectionPresenceType state;
if (!tp_proxy_prepare_finish (account_manager, result, &error))
{
DEBUG ("Failed to prepare account manager: %s", error->message);
g_error_free (error);
goto out;
}
state = tp_account_manager_get_most_available_presence (account_manager, NULL,
NULL);
/* simulate a presence change so the apply button will be changed
* if needed */
presence_changed_cb (account_manager, state, NULL, NULL, self);
out:
g_object_unref (self);
}
#define WIDGET(cm, proto) \
{ #cm, #proto, "empathy-account-widget-"#proto".ui", \
account_widget_build_##proto }
static void
add_register_buttons (EmpathyAccountWidget *self,
TpAccount *account)
{
TpProtocol *protocol;
GtkWidget *radiobutton_register;
if (!self->priv->creating_account)
return;
protocol = empathy_account_settings_get_tp_protocol (self->priv->settings);
if (protocol == NULL)
return;
if (!tp_protocol_can_register (protocol))
return;
if (account_widget_get_service (self) != NO_SERVICE)
return;
if (self->priv->simple)
return;
self->priv->radiobutton_reuse = gtk_radio_button_new_with_label (NULL,
_("This account already exists on the server"));
radiobutton_register = gtk_radio_button_new_with_label (
gtk_radio_button_get_group (
GTK_RADIO_BUTTON (self->priv->radiobutton_reuse)),
_("Create a new account on the server"));
gtk_box_pack_start (GTK_BOX (self), self->priv->radiobutton_reuse, FALSE,
FALSE, 0);
gtk_box_pack_start (GTK_BOX (self), radiobutton_register, FALSE, FALSE, 0);
gtk_box_reorder_child (GTK_BOX (self), self->priv->radiobutton_reuse, 0);
gtk_box_reorder_child (GTK_BOX (self), radiobutton_register, 1);
gtk_widget_show (self->priv->radiobutton_reuse);
gtk_widget_show (radiobutton_register);
}
static void
remember_password_toggled_cb (GtkToggleButton *button,
EmpathyAccountWidget *self)
{
if (gtk_toggle_button_get_active (button))
{
gtk_widget_set_sensitive (self->priv->param_password_widget, TRUE);
}
else
{
gtk_widget_set_sensitive (self->priv->param_password_widget, FALSE);
gtk_entry_set_text (GTK_ENTRY (self->priv->param_password_widget), "");
empathy_account_settings_unset (self->priv->settings, "password");
}
}
static void
account_settings_password_retrieved_cb (GObject *object,
gpointer user_data)
{
EmpathyAccountWidget *self = user_data;
gchar *password;
password = empathy_account_settings_dup_string (
self->priv->settings, "password");
if (password != NULL)
{
/* We have to do this so that when we call gtk_entry_set_text,
* the ::changed callback doesn't think the user made the
* change. */
self->priv->automatic_change = TRUE;
gtk_entry_set_text (GTK_ENTRY (self->priv->param_password_widget),
password);
self->priv->automatic_change = FALSE;
}
gtk_toggle_button_set_active (
GTK_TOGGLE_BUTTON (self->priv->remember_password_widget),
!EMP_STR_EMPTY (password));
g_free (password);
}
static void
do_constructed (GObject *obj)
{
EmpathyAccountWidget *self = EMPATHY_ACCOUNT_WIDGET (obj);
TpAccount *account;
const gchar *display_name, *default_display_name;
guint i = 0;
struct {
const gchar *cm_name;
const gchar *protocol;
const char *file;
GtkWidget * (*func)(EmpathyAccountWidget *self, const gchar *filename);
} widgets [] = {
{ "salut", "local-xmpp", "empathy-account-widget-local-xmpp.ui",
account_widget_build_salut },
WIDGET (gabble, jabber),
WIDGET (haze, msn),
WIDGET (haze, icq),
WIDGET (haze, aim),
WIDGET (haze, yahoo),
WIDGET (haze, groupwise),
WIDGET (idle, irc),
WIDGET (sofiasip, sip),
};
const gchar *protocol, *cm_name;
GtkWidget *box;
account = empathy_account_settings_get_account (self->priv->settings);
cm_name = empathy_account_settings_get_cm (self->priv->settings);
protocol = empathy_account_settings_get_protocol (self->priv->settings);
for (i = 0 ; i < G_N_ELEMENTS (widgets); i++)
{
if (!tp_strdiff (widgets[i].cm_name, cm_name) &&
!tp_strdiff (widgets[i].protocol, protocol))
{
gchar *filename;
filename = empathy_file_lookup (widgets[i].file,
"libempathy-gtk");
box = widgets[i].func (self, filename);
g_free (filename);
break;
}
}
if (i == G_N_ELEMENTS (widgets))
{
gchar *filename = empathy_file_lookup (
"empathy-account-widget-generic.ui", "libempathy-gtk");
box = account_widget_build_generic (self, filename);
g_free (filename);
}
gtk_container_add (GTK_CONTAINER (self), box);
/* handle default focus */
if (self->ui_details->default_focus != NULL)
{
GObject *default_focus_entry;
default_focus_entry = gtk_builder_get_object
(self->ui_details->gui, self->ui_details->default_focus);
g_signal_connect (default_focus_entry, "realize",
G_CALLBACK (gtk_widget_grab_focus),
NULL);
}
/* remember password */
if (self->priv->param_password_widget != NULL
&& self->priv->remember_password_widget != NULL
&& empathy_account_settings_supports_sasl (self->priv->settings))
{
if (self->priv->simple)
{
gtk_toggle_button_set_active (
GTK_TOGGLE_BUTTON (self->priv->remember_password_widget), TRUE);
}
else
{
gchar *password;
password = empathy_account_settings_dup_string (self->priv->settings,
"password");
gtk_toggle_button_set_active (
GTK_TOGGLE_BUTTON (self->priv->remember_password_widget),
!EMP_STR_EMPTY (password));
/* The password might not have been retrieved from the
* keyring yet. We should update the remember password
* toggle button and the password entry when/if it is. */
tp_g_signal_connect_object (self->priv->settings,
"password-retrieved",
G_CALLBACK (account_settings_password_retrieved_cb), self, 0);
g_free (password);
}
g_signal_connect (self->priv->remember_password_widget, "toggled",
G_CALLBACK (remember_password_toggled_cb), self);
remember_password_toggled_cb (
GTK_TOGGLE_BUTTON (self->priv->remember_password_widget), self);
}
else if (self->priv->remember_password_widget != NULL
&& !empathy_account_settings_supports_sasl (self->priv->settings))
{
gtk_widget_set_visible (self->priv->remember_password_widget, FALSE);
}
/* dup and init the account-manager */
self->priv->account_manager = tp_account_manager_dup ();
g_object_ref (self);
tp_proxy_prepare_async (self->priv->account_manager, NULL,
account_manager_ready_cb, self);
/* handle apply and cancel button */
self->priv->hbox_buttons = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 3);
gtk_box_set_homogeneous (GTK_BOX (self->priv->hbox_buttons), TRUE);
self->priv->cancel_button = gtk_button_new_from_stock (GTK_STOCK_CLOSE);
self->priv->apply_button = gtk_button_new ();
set_apply_button (self);
/* We'll change this button to a "Log in" one if we are creating a new
* account and are connected. */
tp_g_signal_connect_object (self->priv->account_manager,
"most-available-presence-changed",
G_CALLBACK (presence_changed_cb), obj, 0);
gtk_box_pack_end (GTK_BOX (self->priv->hbox_buttons),
self->priv->apply_button, TRUE, TRUE, 3);
gtk_box_pack_end (GTK_BOX (self->priv->hbox_buttons),
self->priv->cancel_button, TRUE, TRUE, 3);
gtk_box_pack_end (GTK_BOX (self), self->priv->hbox_buttons, FALSE,
FALSE, 3);
g_signal_connect (self->priv->cancel_button, "clicked",
G_CALLBACK (account_widget_cancel_clicked_cb),
self);
g_signal_connect (self->priv->apply_button, "clicked",
G_CALLBACK (account_widget_apply_clicked_cb),
self);
gtk_widget_show_all (self->priv->hbox_buttons);
if (self->priv->creating_account)
/* When creating an account, the user might have nothing to enter.
* That means that no control interaction might occur,
* so we update the control button sensitivity manually.
*/
account_widget_handle_control_buttons_sensitivity (self);
else
account_widget_set_control_buttons_sensitivity (self, FALSE);
add_register_buttons (self, account);
g_clear_object (&self->ui_details->gui);
display_name = empathy_account_settings_get_display_name (
self->priv->settings);
default_display_name = empathy_account_widget_get_default_display_name (self);
if (tp_strdiff (display_name, default_display_name) &&
!self->priv->creating_account)
{
/* The display name of the account is not the one that we'd assign by
* default; assume that the user changed it manually */
g_object_set (self->priv->settings, "display-name-overridden", TRUE,
NULL);
}
}
static void
do_dispose (GObject *obj)
{
EmpathyAccountWidget *self = EMPATHY_ACCOUNT_WIDGET (obj);
g_clear_object (&self->priv->settings);
g_clear_object (&self->priv->account_manager);
if (G_OBJECT_CLASS (empathy_account_widget_parent_class)->dispose != NULL)
G_OBJECT_CLASS (empathy_account_widget_parent_class)->dispose (obj);
}
static void
do_finalize (GObject *obj)
{
EmpathyAccountWidget *self = EMPATHY_ACCOUNT_WIDGET (obj);
g_free (self->ui_details->default_focus);
g_slice_free (EmpathyAccountWidgetUIDetails, self->ui_details);
g_free (self->priv->jid_suffix);
if (G_OBJECT_CLASS (empathy_account_widget_parent_class)->finalize != NULL)
G_OBJECT_CLASS (empathy_account_widget_parent_class)->finalize (obj);
}
static void
empathy_account_widget_class_init (EmpathyAccountWidgetClass *klass)
{
GObjectClass *oclass = G_OBJECT_CLASS (klass);
GParamSpec *param_spec;
oclass->get_property = do_get_property;
oclass->set_property = do_set_property;
oclass->constructed = do_constructed;
oclass->dispose = do_dispose;
oclass->finalize = do_finalize;
param_spec = g_param_spec_string ("protocol",
"protocol", "The protocol of the account",
NULL,
G_PARAM_READABLE | G_PARAM_STATIC_STRINGS);
g_object_class_install_property (oclass, PROP_PROTOCOL, param_spec);
param_spec = g_param_spec_object ("settings",
"settings", "The settings of the account",
EMPATHY_TYPE_ACCOUNT_SETTINGS,
G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS | G_PARAM_CONSTRUCT_ONLY);
g_object_class_install_property (oclass, PROP_SETTINGS, param_spec);
param_spec = g_param_spec_boolean ("simple",
"simple", "Whether the account widget is a simple or an advanced one",
FALSE,
G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS | G_PARAM_CONSTRUCT_ONLY);
g_object_class_install_property (oclass, PROP_SIMPLE, param_spec);
param_spec = g_param_spec_boolean ("creating-account",
"creating-account",
"TRUE if we're creating an account, FALSE if we're modifying it",
FALSE,
G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS | G_PARAM_CONSTRUCT_ONLY);
g_object_class_install_property (oclass, PROP_CREATING_ACCOUNT, param_spec);
param_spec = g_param_spec_boolean ("other-accounts-exist",
"other-accounts-exist",
"TRUE if there are any other accounts (even if this isn't yet saved)",
FALSE,
G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS | G_PARAM_CONSTRUCT_ONLY);
g_object_class_install_property (oclass, PROP_OTHER_ACCOUNTS_EXIST,
param_spec);
signals[HANDLE_APPLY] =
g_signal_new ("handle-apply", G_TYPE_FROM_CLASS (klass),
G_SIGNAL_RUN_LAST, 0, NULL, NULL,
g_cclosure_marshal_generic,
G_TYPE_NONE,
1, G_TYPE_BOOLEAN);
/* This signal is emitted when an account has been created and enabled. */
signals[ACCOUNT_CREATED] =
g_signal_new ("account-created", G_TYPE_FROM_CLASS (klass),
G_SIGNAL_RUN_LAST, 0, NULL, NULL,
g_cclosure_marshal_generic,
G_TYPE_NONE,
1, G_TYPE_OBJECT);
signals[CANCELLED] =
g_signal_new ("cancelled", G_TYPE_FROM_CLASS (klass),
G_SIGNAL_RUN_LAST, 0, NULL, NULL,
g_cclosure_marshal_generic,
G_TYPE_NONE,
0);
signals[CLOSE] =
g_signal_new ("close", G_TYPE_FROM_CLASS (klass),
G_SIGNAL_RUN_LAST, 0, NULL, NULL,
g_cclosure_marshal_VOID__INT,
G_TYPE_NONE,
1, G_TYPE_INT);
g_type_class_add_private (klass, sizeof (EmpathyAccountWidgetPriv));
}
static void
empathy_account_widget_init (EmpathyAccountWidget *self)
{
self->priv = G_TYPE_INSTANCE_GET_PRIVATE ((self), EMPATHY_TYPE_ACCOUNT_WIDGET,
EmpathyAccountWidgetPriv);
self->ui_details = g_slice_new0 (EmpathyAccountWidgetUIDetails);
}
/* public methods */
void
empathy_account_widget_discard_pending_changes (EmpathyAccountWidget *self)
{
empathy_account_settings_discard_changes (self->priv->settings);
self->priv->contains_pending_changes = FALSE;
}
gboolean
empathy_account_widget_contains_pending_changes (EmpathyAccountWidget *self)
{
return self->priv->contains_pending_changes;
}
void
empathy_account_widget_handle_params (EmpathyAccountWidget *self,
const gchar *first_widget,
...)
{
va_list args;
va_start (args, first_widget);
account_widget_handle_params_valist (self, first_widget, args);
va_end (args);
}
EmpathyAccountWidget *
empathy_account_widget_new_for_protocol (EmpathyAccountSettings *settings,
gboolean simple)
{
g_return_val_if_fail (EMPATHY_IS_ACCOUNT_SETTINGS (settings), NULL);
return g_object_new (EMPATHY_TYPE_ACCOUNT_WIDGET,
"orientation", GTK_ORIENTATION_VERTICAL,
"settings", settings,
"simple", simple,
"creating-account",
empathy_account_settings_get_account (settings) == NULL,
NULL);
}
gchar *
empathy_account_widget_get_default_display_name (EmpathyAccountWidget *self)
{
gchar *login_id;
const gchar *protocol, *p;
gchar *default_display_name;
Service service;
login_id = empathy_account_settings_dup_string (self->priv->settings,
"account");
protocol = empathy_account_settings_get_protocol (self->priv->settings);
service = account_widget_get_service (self);
if (login_id != NULL)
{
/* TODO: this should be done in empathy-account-widget-irc */
if (!tp_strdiff (protocol, "irc"))
{
EmpathyIrcNetwork *network;
network = empathy_irc_network_chooser_get_network (
self->priv->irc_network_chooser);
g_assert (network != NULL);
/* To translators: The first parameter is the login id and the
* second one is the network. The resulting string will be something
* like: "MyUserName on freenode".
* You should reverse the order of these arguments if the
* server should come before the login id in your locale.*/
default_display_name = g_strdup_printf (_("%1$s on %2$s"),
login_id, empathy_irc_network_get_name (network));
}
else if (service == FACEBOOK_SERVICE && self->priv->jid_suffix != NULL)
{
gchar *tmp;
tmp = remove_jid_suffix (self, login_id);
default_display_name = g_strdup_printf ("Facebook (%s)", tmp);
g_free (tmp);
}
else
{
default_display_name = g_strdup (login_id);
}
return default_display_name;
}
if ((p = empathy_protocol_name_to_display_name (protocol)) != NULL)
protocol = p;
if (protocol != NULL)
{
/* To translators: The parameter is the protocol name. The resulting
* string will be something like: "Jabber Account" */
default_display_name = g_strdup_printf (_("%s Account"), protocol);
}
else
{
default_display_name = g_strdup (_("New account"));
}
g_free (login_id);
return default_display_name;
}
/* Used by subclass to indicate that widget contains pending changes */
void
empathy_account_widget_changed (EmpathyAccountWidget *self)
{
account_widget_handle_control_buttons_sensitivity (self);
self->priv->contains_pending_changes = TRUE;
}
void
empathy_account_widget_set_account_param (EmpathyAccountWidget *self,
const gchar *account)
{
if (self->priv->param_account_widget == NULL)
return;
gtk_entry_set_text (GTK_ENTRY (self->priv->param_account_widget), account);
}
void
empathy_account_widget_set_password_param (EmpathyAccountWidget *self,
const gchar *account)
{
if (self->priv->param_password_widget == NULL)
return;
gtk_entry_set_text (GTK_ENTRY (self->priv->param_password_widget), account);
}
EmpathyAccountSettings *
empathy_account_widget_get_settings (EmpathyAccountWidget *self)
{
return self->priv->settings;
}
void
empathy_account_widget_hide_buttons (EmpathyAccountWidget *self)
{
gtk_widget_hide (self->priv->hbox_buttons);
}
