-/* -*- Mode: C; tab-width: 8; indent-tabs-mode: t; c-basic-offset: 8 -*- */
/*
* Copyright (C) 2006-2007 Imendio AB
* Copyright (C) 2007-2009 Collabora Ltd.
* Authors: Xavier Claessens <xclaesse@gmail.com>
* Martyn Russell <martyn@imendio.com>
* Cosimo Cecchi <cosimo.cecchi@collabora.co.uk>
+ * Jonathan Tellier <jonathan.tellier@gmail.com>
*/
#include <config.h>
#include <gtk/gtk.h>
#include <glib/gi18n-lib.h>
+#ifdef HAVE_MEEGO
+#include <mx/mx-gtk.h>
+#endif /* HAVE_MEEGO */
+
#include <libempathy/empathy-utils.h>
-#include <libempathy/empathy-account.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>
G_DEFINE_TYPE (EmpathyAccountWidget, empathy_account_widget, G_TYPE_OBJECT)
typedef struct {
- char *protocol;
EmpathyAccountSettings *settings;
+ GtkWidget *table_common_settings;
GtkWidget *apply_button;
+ GtkWidget *cancel_button;
GtkWidget *entry_password;
GtkWidget *button_forget;
GtkWidget *spinbutton_port;
+ GtkWidget *enabled_checkbox;
+ GtkWidget *radiobutton_reuse;
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 dispose_run;
} EmpathyAccountWidgetPriv;
enum {
PROP_PROTOCOL = 1,
PROP_SETTINGS,
- PROP_SIMPLE
+ PROP_SIMPLE,
+ PROP_CREATING_ACCOUNT,
+ PROP_OTHER_ACCOUNTS_EXIST,
};
enum {
HANDLE_APPLY,
+ ACCOUNT_CREATED,
+ CANCELLED,
LAST_SIGNAL
};
static guint signals[LAST_SIGNAL] = { 0 };
#define GET_PRIV(obj) EMPATHY_GET_PRIV (obj, EmpathyAccountWidget)
+#define CHANGED_TIMEOUT 300
+
+static void
+account_widget_set_control_buttons_sensitivity (EmpathyAccountWidget *self,
+ gboolean sensitive)
+{
+ EmpathyAccountWidgetPriv *priv = GET_PRIV (self);
+
+ if (!priv->simple)
+ {
+ /* we hit this case because of the 'other-accounts-exist' property handler
+ * being called during init (before constructed()) */
+ if (priv->apply_button == NULL || priv->cancel_button == NULL)
+ return;
+
+ gtk_widget_set_sensitive (priv->apply_button, sensitive);
+ gtk_widget_set_sensitive (priv->cancel_button,
+ (sensitive || priv->creating_account) && priv->other_accounts_exist);
+ }
+}
static void
-account_widget_handle_apply_sensitivity (EmpathyAccountWidget *self)
+account_widget_handle_control_buttons_sensitivity (EmpathyAccountWidget *self)
{
EmpathyAccountWidgetPriv *priv = GET_PRIV (self);
gboolean is_valid;
is_valid = empathy_account_settings_is_valid (priv->settings);
if (!priv->simple)
- gtk_widget_set_sensitive (priv->apply_button, is_valid);
+ account_widget_set_control_buttons_sensitivity (self, is_valid);
g_signal_emit (self, signals[HANDLE_APPLY], 0, is_valid);
}
-static gboolean
-account_widget_entry_focus_cb (GtkWidget *widget,
- GdkEventFocus *event,
- EmpathyAccountWidget *self)
+static void
+account_widget_entry_changed_common (EmpathyAccountWidget *self,
+ GtkEntry *entry, gboolean focus)
{
const gchar *str;
const gchar *param_name;
EmpathyAccountWidgetPriv *priv = GET_PRIV (self);
- str = gtk_entry_get_text (GTK_ENTRY (widget));
- param_name = g_object_get_data (G_OBJECT (widget), "param_name");
+ str = gtk_entry_get_text (entry);
+ param_name = g_object_get_data (G_OBJECT (entry), "param_name");
if (EMP_STR_EMPTY (str))
{
const gchar *value = NULL;
empathy_account_settings_unset (priv->settings, param_name);
- value = empathy_account_settings_get_string (priv->settings, param_name);
- DEBUG ("Unset %s and restore to %s", param_name, value);
- gtk_entry_set_text (GTK_ENTRY (widget), value ? value : "");
+
+ if (focus)
+ {
+ value = empathy_account_settings_get_string (priv->settings,
+ param_name);
+ DEBUG ("Unset %s and restore to %s", param_name, value);
+ gtk_entry_set_text (entry, value ? value : "");
+ }
}
else
{
DEBUG ("Setting %s to %s", param_name,
- strstr (param_name, "password") ? "***" : str);
+ tp_strdiff (param_name, "password") ? str : "***");
empathy_account_settings_set_string (priv->settings, param_name, str);
}
+}
- account_widget_handle_apply_sensitivity (self);
-
- return FALSE;
+static void
+account_widget_entry_changed_cb (GtkEditable *entry,
+ EmpathyAccountWidget *self)
+{
+ account_widget_entry_changed_common (self, GTK_ENTRY (entry), FALSE);
+ empathy_account_widget_changed (self);
}
static void
g_return_if_reached ();
}
- account_widget_handle_apply_sensitivity (self);
+ empathy_account_widget_changed (self);
}
static void
empathy_account_settings_set_boolean (priv->settings, param_name, value);
}
- account_widget_handle_apply_sensitivity (self);
+ empathy_account_widget_changed (self);
}
static void
empathy_account_settings_unset (priv->settings, param_name);
gtk_entry_set_text (GTK_ENTRY (priv->entry_password), "");
- account_widget_handle_apply_sensitivity (self);
+ empathy_account_widget_changed (self);
}
static void
str = gtk_entry_get_text (GTK_ENTRY (entry));
gtk_widget_set_sensitive (priv->button_forget, !EMP_STR_EMPTY (str));
+
+ priv->contains_pending_changes = TRUE;
}
static void
}
gtk_spin_button_set_value (GTK_SPIN_BUTTON (priv->spinbutton_port), port);
+
+ priv->contains_pending_changes = TRUE;
}
static void
-account_widget_setup_widget (EmpathyAccountWidget *self,
+account_widget_combobox_changed_cb (GtkWidget *widget,
+ EmpathyAccountWidget *self)
+{
+ GtkTreeIter iter;
+ GtkTreeModel *model;
+ const gchar *value;
+ const GValue *v;
+ const gchar *default_value = NULL;
+ const gchar *param_name;
+ EmpathyAccountWidgetPriv *priv = GET_PRIV (self);
+
+ 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_get_default (priv->settings, param_name);
+ if (v != NULL)
+ default_value = g_value_get_string (v);
+
+ if (!tp_strdiff (value, default_value))
+ {
+ DEBUG ("Unset %s and restore to %s", param_name, default_value);
+ empathy_account_settings_unset (priv->settings, param_name);
+ }
+ else
+ {
+ DEBUG ("Setting %s to %s", param_name, value);
+ empathy_account_settings_set_string (priv->settings, param_name, value);
+ }
+
+ empathy_account_widget_changed (self);
+}
+
+void
+empathy_account_widget_setup_widget (EmpathyAccountWidget *self,
GtkWidget *widget,
const gchar *param_name)
{
str = empathy_account_settings_get_string (priv->settings, param_name);
gtk_entry_set_text (GTK_ENTRY (widget), str ? str : "");
+ if (!tp_strdiff (param_name, "account"))
+ priv->param_account_widget = widget;
+ else if (!tp_strdiff (param_name, "password"))
+ priv->param_password_widget = widget;
+
if (strstr (param_name, "password"))
{
gtk_entry_set_visibility (GTK_ENTRY (widget), FALSE);
}
- g_signal_connect (widget, "focus-out-event",
- G_CALLBACK (account_widget_entry_focus_cb),
- self);
+ g_signal_connect (widget, "changed",
+ G_CALLBACK (account_widget_entry_changed_cb), self);
}
else if (GTK_IS_TOGGLE_BUTTON (widget))
{
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) */
+ const gchar *str;
+ GtkTreeModel *model;
+ GtkTreeIter iter;
+ gboolean valid;
+
+ str = empathy_account_settings_get_string (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_signal_connect (widget, "changed",
+ G_CALLBACK (account_widget_combobox_changed_cb),
+ self);
+ }
else
{
DEBUG ("Unknown type of widget for param %s", param_name);
if (param->flags & TP_CONN_MGR_PARAM_FLAG_REQUIRED)
table_settings = table_common_settings;
+ else if (priv->simple)
+ return;
else
table_settings = table_advanced_settings;
}
if (widget)
- account_widget_setup_widget (self, widget, param->name);
+ empathy_account_widget_setup_widget (self, widget, param->name);
g_free (param_name_formatted);
}
continue;
}
- account_widget_setup_widget (self, GTK_WIDGET (object), param_name);
+ 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);
+}
+
+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 *widget = EMPATHY_ACCOUNT_WIDGET (user_data);
+ EmpathyAccountWidgetPriv *priv = GET_PRIV (widget);
+
+ 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, priv->account_manager);
+ }
+
+ /* unref widget - part of the workaround */
+ g_object_unref (widget);
+}
+
+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 *widget = EMPATHY_ACCOUNT_WIDGET (user_data);
+ EmpathyAccountWidgetPriv *priv = GET_PRIV (widget);
+
+ empathy_account_settings_apply_finish (settings, res, &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 (priv->settings);
+
+ if (account != NULL)
+ {
+ if (priv->creating_account)
+ {
+ /* By default, when an account is created, we enable it. */
+
+ /* workaround to keep widget alive during async call */
+ g_object_ref (widget);
+
+ tp_account_set_enabled_async (account, TRUE,
+ account_widget_account_enabled_cb, widget);
+ g_signal_emit (widget, signals[ACCOUNT_CREATED], 0, account);
+ }
+ else if (priv->enabled_checkbox != NULL)
+ {
+ gboolean enabled_checked;
+
+ enabled_checked =
+#ifdef HAVE_MEEGO
+ mx_gtk_light_switch_get_active (
+ MX_GTK_LIGHT_SWITCH (priv->enabled_checkbox));
+#else
+ gtk_toggle_button_get_active (
+ GTK_TOGGLE_BUTTON (priv->enabled_checkbox));
+#endif /* HAVE_MEEGO */
+
+ if (tp_account_is_enabled (account) && enabled_checked)
+ {
+ /* After having applied changes to a user account, we
+ * automatically reconnect it. This is done so the new
+ * information entered by the user is validated on the server. */
+ tp_account_reconnect_async (account, NULL, NULL);
+ }
+ }
}
+
+ if (!priv->destroyed)
+ account_widget_set_control_buttons_sensitivity (widget, FALSE);
+
+ priv->contains_pending_changes = FALSE;
+
+ /* unref the widget - part of the workaround */
+ g_object_unref (widget);
}
static void
EmpathyAccountWidget *self)
{
EmpathyAccountWidgetPriv *priv = GET_PRIV (self);
+ gboolean display_name_overridden;
+
+ if (priv->radiobutton_reuse != NULL)
+ {
+ gboolean reuse = gtk_toggle_button_get_active (GTK_TOGGLE_BUTTON (
+ priv->radiobutton_reuse));
+
+ DEBUG ("Set register param: %d", !reuse);
+ empathy_account_settings_set_boolean (priv->settings, "register", !reuse);
+ }
+
+ g_object_get (priv->settings,
+ "display-name-overridden", &display_name_overridden, NULL);
+
+ if (priv->creating_account || !display_name_overridden)
+ {
+ gchar *display_name;
- empathy_account_settings_apply_async (priv->settings, NULL, NULL);
+ /* 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 (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 (priv->settings,
+ account_widget_applied_cb, self);
}
static void
const char *filename)
{
EmpathyAccountWidgetPriv *priv = GET_PRIV (self);
+ GtkWidget *expander_advanced;
+
self->ui_details->gui = empathy_builder_get_file (filename,
+ "table_common_settings", &priv->table_common_settings,
"vbox_generic_settings", &self->ui_details->widget,
+ "expander_advanced_settings", &expander_advanced,
NULL);
+ if (priv->simple)
+ gtk_widget_hide (expander_advanced);
+
g_object_ref (self->ui_details->gui);
if (empathy_account_settings_is_ready (priv->settings))
account_widget_build_salut (EmpathyAccountWidget *self,
const char *filename)
{
+ EmpathyAccountWidgetPriv *priv = GET_PRIV (self);
+ GtkWidget *expander_advanced;
+
self->ui_details->gui = empathy_builder_get_file (filename,
+ "table_common_settings", &priv->table_common_settings,
"vbox_salut_settings", &self->ui_details->widget,
+ "expander_advanced_settings", &expander_advanced,
NULL);
empathy_account_widget_handle_params (self,
"entry_jid", "jid",
NULL);
- self->ui_details->default_focus = g_strdup ("entry_nickname");
+ if (priv->simple)
+ gtk_widget_hide (expander_advanced);
+
+ self->ui_details->default_focus = g_strdup ("entry_first_name");
}
static void
-account_widget_build_msn (EmpathyAccountWidget *self,
- const char *filename)
+account_widget_build_irc (EmpathyAccountWidget *self,
+ const char *filename)
{
- self->ui_details->gui = empathy_builder_get_file (filename,
- "vbox_msn_settings", &self->ui_details->widget,
- NULL);
-
- empathy_account_widget_handle_params (self,
- "entry_id", "account",
- "entry_password", "password",
- "entry_server", "server",
- "spinbutton_port", "port",
- NULL);
+ EmpathyAccountWidgetPriv *priv = GET_PRIV (self);
+ empathy_account_widget_irc_build (self, filename,
+ &priv->table_common_settings);
+}
- self->ui_details->default_focus = g_strdup ("entry_id");
- self->ui_details->add_forget = TRUE;
+static void
+account_widget_build_sip (EmpathyAccountWidget *self,
+ const char *filename)
+{
+ EmpathyAccountWidgetPriv *priv = GET_PRIV (self);
+ empathy_account_widget_sip_build (self, filename,
+ &priv->table_common_settings);
}
static void
-account_widget_build_jabber (EmpathyAccountWidget *self,
+account_widget_build_msn (EmpathyAccountWidget *self,
const char *filename)
{
EmpathyAccountWidgetPriv *priv = GET_PRIV (self);
- GtkWidget *spinbutton_port;
- GtkWidget *checkbutton_ssl;
if (priv->simple)
{
self->ui_details->gui = empathy_builder_get_file (filename,
- "vbox_jabber_simple", &self->ui_details->widget,
+ "vbox_msn_simple", &self->ui_details->widget,
NULL);
-
+
empathy_account_widget_handle_params (self,
- "entry_simple_id", "account",
- "entry_simple_password", "password",
+ "entry_id_simple", "account",
+ "entry_password_simple", "password",
NULL);
- self->ui_details->default_focus = g_strdup ("entry_simple_id");
+ self->ui_details->default_focus = g_strdup ("entry_id_simple");
}
else
{
self->ui_details->gui = empathy_builder_get_file (filename,
- "vbox_jabber_settings", &self->ui_details->widget,
- "spinbutton_port", &spinbutton_port,
- "checkbutton_ssl", &checkbutton_ssl,
+ "table_common_msn_settings", &priv->table_common_settings,
+ "vbox_msn_settings", &self->ui_details->widget,
NULL);
empathy_account_widget_handle_params (self,
"entry_id", "account",
"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);
self->ui_details->default_focus = g_strdup ("entry_id");
self->ui_details->add_forget = TRUE;
- priv->spinbutton_port = spinbutton_port;
-
- g_signal_connect (checkbutton_ssl, "toggled",
- G_CALLBACK (account_widget_jabber_ssl_toggled_cb),
- self);
}
}
-static void
-account_widget_build_icq (EmpathyAccountWidget *self,
- const char *filename)
+static gboolean
+account_widget_is_gtalk (EmpathyAccountWidget *self)
{
- GtkWidget *spinbutton_port;
+ EmpathyAccountWidgetPriv *priv = GET_PRIV (self);
- self->ui_details->gui = empathy_builder_get_file (filename,
- "vbox_icq_settings", &self->ui_details->widget,
- "spinbutton_port", &spinbutton_port,
- NULL);
+ return !tp_strdiff (empathy_account_settings_get_icon_name (priv->settings),
+ "im-google-talk");
+}
- empathy_account_widget_handle_params (self,
- "entry_uin", "account",
- "entry_password", "password",
- "entry_server", "server",
- "spinbutton_port", "port",
- "entry_charset", "charset",
- NULL);
+static gboolean
+account_widget_is_facebook (EmpathyAccountWidget *self)
+{
+ EmpathyAccountWidgetPriv *priv = GET_PRIV (self);
- self->ui_details->default_focus = g_strdup ("entry_uin");
- self->ui_details->add_forget = TRUE;
+ return !tp_strdiff (empathy_account_settings_get_icon_name (priv->settings),
+ "im-facebook");
}
+#define FACEBOOK_SUFFIX "@chat.facebook.com"
+
static void
-account_widget_build_aim (EmpathyAccountWidget *self,
- const char *filename)
+facebook_id_widget_changed_cb (GtkWidget *entry,
+ EmpathyAccountWidget *self)
{
- GtkWidget *spinbutton_port;
+ EmpathyAccountWidgetPriv *priv = GET_PRIV (self);
+ const gchar *account;
- self->ui_details->gui = empathy_builder_get_file (filename,
- "vbox_aim_settings", &self->ui_details->widget,
- "spinbutton_port", &spinbutton_port,
- NULL);
+ account_widget_entry_changed_common (self, GTK_ENTRY (entry), FALSE);
- empathy_account_widget_handle_params (self,
- "entry_screenname", "account",
- "entry_password", "password",
- "entry_server", "server",
- "spinbutton_port", "port",
- NULL);
+ account = empathy_account_settings_get_string (priv->settings, "account");
+ if (!EMP_STR_EMPTY (account) &&
+ !g_str_has_suffix (account, FACEBOOK_SUFFIX))
+ {
+ gchar *tmp;
- self->ui_details->default_focus = g_strdup ("entry_screenname");
- self->ui_details->add_forget = TRUE;
-}
+ tmp = g_strdup_printf ("%s%s", account, FACEBOOK_SUFFIX);
-static void
-account_widget_build_yahoo (EmpathyAccountWidget *self,
- const char *filename)
-{
- self->ui_details->gui = empathy_builder_get_file (filename,
- "vbox_yahoo_settings", &self->ui_details->widget,
- NULL);
+ DEBUG ("Change account from '%s' to '%s'", account, tmp);
- empathy_account_widget_handle_params (self,
- "entry_id", "account",
- "entry_password", "password",
- "entry_server", "server",
- "entry_locale", "room-list-locale",
- "entry_charset", "charset",
- "spinbutton_port", "port",
- "checkbutton_yahoojp", "yahoojp",
- "checkbutton_ignore_invites", "ignore-invites",
- NULL);
+ empathy_account_settings_set_string (priv->settings, "account", tmp);
+ g_free (tmp);
+ }
- self->ui_details->default_focus = g_strdup ("entry_id");
- self->ui_details->add_forget = TRUE;
+ empathy_account_widget_changed (self);
}
-static void
-account_widget_build_groupwise (EmpathyAccountWidget *self,
- const char *filename)
+static gchar *
+remove_facebook_suffix (const gchar *str)
{
- self->ui_details->gui = empathy_builder_get_file (filename,
- "vbox_groupwise_settings", &self->ui_details->widget,
- NULL);
-
- empathy_account_widget_handle_params (self,
- "entry_id", "account",
- "entry_password", "password",
- "entry_server", "server",
- "spinbutton_port", "port",
- NULL);
+ if (!g_str_has_suffix (str, FACEBOOK_SUFFIX))
+ return g_strdup (str);
- self->ui_details->default_focus = g_strdup ("entry_id");
- self->ui_details->add_forget = TRUE;
+ return g_strndup (str, strlen (str) - strlen (FACEBOOK_SUFFIX));
}
static void
-account_widget_destroy_cb (GtkWidget *widget,
- EmpathyAccountWidget *self)
+setup_facebook_id_widget (EmpathyAccountWidget *self,
+ GtkWidget *widget)
{
- g_object_unref (self);
-}
+ EmpathyAccountWidgetPriv *priv = GET_PRIV (self);
+ const gchar *str = NULL;
-static void
-do_set_property (GObject *object,
- guint prop_id,
- const GValue *value,
- GParamSpec *pspec)
-{
- EmpathyAccountWidgetPriv *priv = GET_PRIV (object);
+ g_object_set_data_full (G_OBJECT (widget), "param_name",
+ g_strdup ("account"), g_free);
- switch (prop_id)
+ str = empathy_account_settings_get_string (priv->settings, "account");
+ if (str != NULL)
{
- case PROP_PROTOCOL:
- priv->protocol = g_value_dup_string (value);
- break;
- case PROP_SETTINGS:
- priv->settings = g_value_dup_object (value);
- break;
- case PROP_SIMPLE:
- priv->simple = g_value_get_boolean (value);
- break;
- default:
- G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
+ gchar *tmp;
+
+ tmp = remove_facebook_suffix (str);
+ gtk_entry_set_text (GTK_ENTRY (widget), tmp);
+ g_free (tmp);
}
-}
-static void
-do_get_property (GObject *object,
- guint prop_id,
- GValue *value,
- GParamSpec *pspec)
-{
- EmpathyAccountWidgetPriv *priv = GET_PRIV (object);
+ priv->param_account_widget = widget;
- switch (prop_id)
- {
- case PROP_PROTOCOL:
- g_value_set_string (value, priv->protocol);
- break;
- case PROP_SETTINGS:
- g_value_set_object (value, priv->settings);
- break;
- case PROP_SIMPLE:
- g_value_set_boolean (value, priv->simple);
- default:
- G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
- }
+ g_signal_connect (widget, "changed",
+ G_CALLBACK (facebook_id_widget_changed_cb), self);
}
static void
-do_constructed (GObject *obj)
+account_widget_build_jabber (EmpathyAccountWidget *self,
+ const char *filename)
{
- EmpathyAccountWidget *self = EMPATHY_ACCOUNT_WIDGET (obj);
EmpathyAccountWidgetPriv *priv = GET_PRIV (self);
- char *uiname, *filename;
-
- uiname = g_strconcat ("empathy-account-widget-", priv->protocol,
- ".ui", NULL);
- filename = empathy_file_lookup (uiname, "libempathy-gtk");
-
- if (!tp_strdiff (priv->protocol, "local-xmpp"))
- account_widget_build_salut (self, filename);
- else if (!tp_strdiff (priv->protocol, "msn"))
- account_widget_build_msn (self, filename);
- else if (!tp_strdiff (priv->protocol, "jabber"))
- account_widget_build_jabber (self, filename);
- else if (!tp_strdiff (priv->protocol, "icq"))
- account_widget_build_icq (self, filename);
- else if (!tp_strdiff (priv->protocol, "aim"))
- account_widget_build_aim (self, filename);
- else if (!tp_strdiff (priv->protocol, "yahoo"))
- account_widget_build_yahoo (self, filename);
- else if (!tp_strdiff (priv->protocol, "groupwise"))
- account_widget_build_groupwise (self, filename);
- else if (!tp_strdiff (priv->protocol, "irc"))
- empathy_account_widget_irc_build (self, filename);
- else if (!tp_strdiff (priv->protocol, "sip"))
- empathy_account_widget_sip_build (self, filename);
- else
- account_widget_build_generic (self, filename);
+ GtkWidget *spinbutton_port;
+ GtkWidget *checkbutton_ssl;
+ GtkWidget *label_id, *label_password;
+ GtkWidget *label_id_create, *label_password_create;
+ GtkWidget *label_example_gtalk, *label_example_jabber, *label_example_fb;
+ gboolean is_gtalk, is_facebook;
+ GtkWidget *expander_advanced;
+ GtkWidget *entry_id;
+
+ is_gtalk = account_widget_is_gtalk (self);
+ is_facebook = account_widget_is_facebook (self);
+
+ if (priv->simple && !is_gtalk && !is_facebook)
+ {
+ /* Simple widget for XMPP */
+ self->ui_details->gui = empathy_builder_get_file (filename,
+ "vbox_jabber_simple", &self->ui_details->widget,
+ "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 (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");
+ }
+ else if (priv->simple && is_gtalk)
+ {
+ /* Simple widget for Google Talk */
+ self->ui_details->gui = empathy_builder_get_file (filename,
+ "vbox_gtalk_simple", &self->ui_details->widget,
+ 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");
+ }
+ else if (priv->simple && is_facebook)
+ {
+ /* Simple widget for Facebook */
+ self->ui_details->gui = empathy_builder_get_file (filename,
+ "vbox_fb_simple", &self->ui_details->widget,
+ "entry_id_fb_simple", &entry_id,
+ NULL);
+
+ empathy_account_widget_handle_params (self,
+ "entry_password_fb_simple", "password",
+ NULL);
+
+ setup_facebook_id_widget (self, entry_id);
+
+ self->ui_details->default_focus = g_strdup ("entry_id_fb_simple");
+ }
+ else
+ {
+ /* Full widget for XMPP, Google Talk and Facebook*/
+ self->ui_details->gui = empathy_builder_get_file (filename,
+ "table_common_settings", &priv->table_common_settings,
+ "vbox_jabber_settings", &self->ui_details->widget,
+ "spinbutton_port", &spinbutton_port,
+ "checkbutton_ssl", &checkbutton_ssl,
+ "label_username_example", &label_example_jabber,
+ "label_username_g_example", &label_example_gtalk,
+ "label_username_f_example", &label_example_fb,
+ "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 (is_facebook)
+ {
+ gtk_label_set_label (GTK_LABEL (label_id), _("Username:"));
+
+ /* Facebook special case the entry ID widget to hide the
+ * "@chat.facebook.com" part */
+ setup_facebook_id_widget (self, entry_id);
+ }
+ else
+ {
+ empathy_account_widget_setup_widget (self, entry_id, "account");
+ }
+
+ self->ui_details->default_focus = g_strdup ("entry_id");
+ self->ui_details->add_forget = TRUE;
+ priv->spinbutton_port = spinbutton_port;
+
+ g_signal_connect (checkbutton_ssl, "toggled",
+ G_CALLBACK (account_widget_jabber_ssl_toggled_cb),
+ self);
+
+ if (is_gtalk)
+ {
+ gtk_widget_hide (label_example_jabber);
+ gtk_widget_show (label_example_gtalk);
+ }
+ else if (is_facebook)
+ {
+ gtk_widget_hide (label_example_jabber);
+ gtk_widget_show (label_example_fb);
+ gtk_widget_hide (expander_advanced);
+ }
+ }
+}
+
+static void
+account_widget_build_icq (EmpathyAccountWidget *self,
+ const char *filename)
+{
+ EmpathyAccountWidgetPriv *priv = GET_PRIV (self);
+ GtkWidget *spinbutton_port;
+
+ if (priv->simple)
+ {
+ self->ui_details->gui = empathy_builder_get_file (filename,
+ "vbox_icq_simple", &self->ui_details->widget,
+ 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");
+ }
+ else
+ {
+ self->ui_details->gui = empathy_builder_get_file (filename,
+ "table_common_settings", &priv->table_common_settings,
+ "vbox_icq_settings", &self->ui_details->widget,
+ "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->ui_details->add_forget = TRUE;
+ }
+}
+
+static void
+account_widget_build_aim (EmpathyAccountWidget *self,
+ const char *filename)
+{
+ EmpathyAccountWidgetPriv *priv = GET_PRIV (self);
+ GtkWidget *spinbutton_port;
+
+ if (priv->simple)
+ {
+ self->ui_details->gui = empathy_builder_get_file (filename,
+ "vbox_aim_simple", &self->ui_details->widget,
+ 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");
+ }
+ else
+ {
+ self->ui_details->gui = empathy_builder_get_file (filename,
+ "table_common_settings", &priv->table_common_settings,
+ "vbox_aim_settings", &self->ui_details->widget,
+ "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->ui_details->add_forget = TRUE;
+ }
+}
+
+static void
+account_widget_build_yahoo (EmpathyAccountWidget *self,
+ const char *filename)
+{
+ EmpathyAccountWidgetPriv *priv = GET_PRIV (self);
+
+ if (priv->simple)
+ {
+ self->ui_details->gui = empathy_builder_get_file (filename,
+ "vbox_yahoo_simple", &self->ui_details->widget,
+ 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");
+ }
+ else
+ {
+ self->ui_details->gui = empathy_builder_get_file (filename,
+ "table_common_settings", &priv->table_common_settings,
+ "vbox_yahoo_settings", &self->ui_details->widget,
+ NULL);
+
+ empathy_account_widget_handle_params (self,
+ "entry_id", "account",
+ "entry_password", "password",
+ "entry_server", "server",
+ "entry_locale", "room-list-locale",
+ "entry_charset", "charset",
+ "spinbutton_port", "port",
+ "checkbutton_yahoojp", "yahoojp",
+ "checkbutton_ignore_invites", "ignore-invites",
+ NULL);
+
+ self->ui_details->default_focus = g_strdup ("entry_id");
+ self->ui_details->add_forget = TRUE;
+ }
+}
+
+static void
+account_widget_build_groupwise (EmpathyAccountWidget *self,
+ const char *filename)
+{
+ EmpathyAccountWidgetPriv *priv = GET_PRIV (self);
+
+ if (priv->simple)
+ {
+ self->ui_details->gui = empathy_builder_get_file (filename,
+ "vbox_groupwise_simple", &self->ui_details->widget,
+ 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");
+ }
+ else
+ {
+ self->ui_details->gui = empathy_builder_get_file (filename,
+ "table_common_groupwise_settings", &priv->table_common_settings,
+ "vbox_groupwise_settings", &self->ui_details->widget,
+ 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->ui_details->add_forget = TRUE;
+ }
+}
+
+static void
+account_widget_destroy_cb (GtkWidget *widget,
+ EmpathyAccountWidget *self)
+{
+ EmpathyAccountWidgetPriv *priv = GET_PRIV (self);
+ /* set the destroyed flag - workaround */
+ priv->destroyed = TRUE;
+
+ g_object_unref (self);
+}
+
+static void
+empathy_account_widget_enabled_cb (TpAccount *account,
+ GParamSpec *spec,
+ gpointer user_data)
+{
+ EmpathyAccountWidget *widget = EMPATHY_ACCOUNT_WIDGET (user_data);
+ EmpathyAccountWidgetPriv *priv = GET_PRIV (widget);
+ gboolean enabled = tp_account_is_enabled (account);
+
+ if (priv->enabled_checkbox != NULL)
+ {
+#ifdef HAVE_MEEGO
+ mx_gtk_light_switch_set_active (
+ MX_GTK_LIGHT_SWITCH (priv->enabled_checkbox),
+ enabled);
+#else
+ gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (priv->enabled_checkbox),
+ enabled);
+#endif /* HAVE_MEEGO */
+ }
+}
+
+static void
+#ifdef HAVE_MEEGO
+account_widget_switch_flipped_cb (MxGtkLightSwitch *sw,
+ gboolean state,
+ gpointer user_data)
+#else
+account_widget_enabled_released_cb (GtkToggleButton *toggle_button,
+ gpointer user_data)
+#endif /* HAVE_MEEGO */
+{
+ EmpathyAccountWidgetPriv *priv = GET_PRIV (user_data);
+ TpAccount *account;
+#ifndef HAVE_MEEGO
+ gboolean state;
+
+ state = gtk_toggle_button_get_active (toggle_button);
+#endif /* HAVE_MEEGO */
+
+ account = empathy_account_settings_get_account (priv->settings);
+
+ /* Enable the account according to the value of the "Enabled" checkbox */
+ /* workaround to keep widget alive during async call */
+ g_object_ref (user_data);
+ tp_account_set_enabled_async (account, state,
+ account_widget_account_enabled_cb, user_data);
+}
+
+void
+empathy_account_widget_set_other_accounts_exist (EmpathyAccountWidget *self,
+ gboolean others_exist)
+{
+ EmpathyAccountWidgetPriv *priv = GET_PRIV (self);
+
+ priv->other_accounts_exist = others_exist;
+
+ if (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)
+{
+ EmpathyAccountWidgetPriv *priv = GET_PRIV (object);
+
+ switch (prop_id)
+ {
+ case PROP_SETTINGS:
+ priv->settings = g_value_dup_object (value);
+ break;
+ case PROP_SIMPLE:
+ priv->simple = g_value_get_boolean (value);
+ break;
+ case PROP_CREATING_ACCOUNT:
+ 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);
+ }
+}
- g_free (uiname);
- g_free (filename);
+static void
+do_get_property (GObject *object,
+ guint prop_id,
+ GValue *value,
+ GParamSpec *pspec)
+{
+ EmpathyAccountWidgetPriv *priv = GET_PRIV (object);
+
+ switch (prop_id)
+ {
+ case PROP_PROTOCOL:
+ g_value_set_string (value,
+ empathy_account_settings_get_protocol (priv->settings));
+ break;
+ case PROP_SETTINGS:
+ g_value_set_object (value, priv->settings);
+ break;
+ case PROP_SIMPLE:
+ g_value_set_boolean (value, priv->simple);
+ break;
+ case PROP_CREATING_ACCOUNT:
+ g_value_set_boolean (value, priv->creating_account);
+ break;
+ case PROP_OTHER_ACCOUNTS_EXIST:
+ g_value_set_boolean (value, priv->other_accounts_exist);
+ break;
+ default:
+ G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
+ }
+}
+
+static void
+presence_changed_cb (TpAccountManager *manager,
+ TpConnectionPresenceType state,
+ const gchar *status,
+ const gchar *message,
+ EmpathyAccountWidget *self)
+{
+ EmpathyAccountWidgetPriv *priv = GET_PRIV (self);
+
+ if (priv->destroyed)
+ return;
+
+ if (priv->apply_button == NULL)
+ /* This button doesn't exist in 'simple' mode */
+ return;
+
+ if (state > TP_CONNECTION_PRESENCE_TYPE_OFFLINE &&
+ priv->creating_account)
+ {
+ /* We are online and creating a new account, display a Login button */
+ GtkWidget *image;
+
+ gtk_button_set_use_stock (GTK_BUTTON (priv->apply_button), FALSE);
+ gtk_button_set_label (GTK_BUTTON (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 (priv->apply_button), image);
+ }
+ else
+ {
+ /* We are offline or modifying an existing account, display
+ * a Save button */
+ gtk_button_set_image (GTK_BUTTON (priv->apply_button), NULL);
+ gtk_button_set_use_stock (GTK_BUTTON (priv->apply_button), TRUE);
+ gtk_button_set_label (GTK_BUTTON (priv->apply_button), GTK_STOCK_APPLY);
+ }
+}
+
+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_account_manager_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_enable_checkbox (EmpathyAccountWidget *self,
+ TpAccount *account)
+{
+ EmpathyAccountWidgetPriv *priv = GET_PRIV (self);
+#ifdef HAVE_MEEGO
+ GtkWidget *w;
+#else
+ GtkWidget *vbox = self->ui_details->widget;
+#endif /* HAVE_MEEGO */
+ guint nb_rows, nb_columns;
+ gboolean is_enabled;
+
+ /* handle the "Enabled" checkbox. We only add it when modifying an account */
+ if (priv->creating_account || priv->table_common_settings == NULL)
+ return;
+
+ is_enabled = tp_account_is_enabled (account);
+
+#ifdef HAVE_MEEGO
+ w = gtk_label_new (_("Account:"));
+ gtk_misc_set_alignment (GTK_MISC (w), 0, 0.5);
+
+ priv->enabled_checkbox = mx_gtk_light_switch_new ();
+
+ mx_gtk_light_switch_set_active (
+ MX_GTK_LIGHT_SWITCH (priv->enabled_checkbox), is_enabled);
+
+ gtk_widget_show (w);
+#else
+ priv->enabled_checkbox =
+ gtk_check_button_new_with_label (_("Enabled"));
+
+ gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (priv->enabled_checkbox),
+ is_enabled);
+#endif /* HAVE_MEEGO */
+
+ g_object_get (priv->table_common_settings, "n-rows", &nb_rows,
+ "n-columns", &nb_columns, NULL);
+
+ gtk_table_resize (GTK_TABLE (priv->table_common_settings), ++nb_rows,
+ nb_columns);
+
+#ifdef HAVE_MEEGO
+ gtk_table_attach (GTK_TABLE (priv->table_common_settings),
+ w,
+ 0, 1, nb_rows - 1, nb_rows,
+ GTK_FILL, 0, 0, 0);
+ gtk_table_attach (GTK_TABLE (priv->table_common_settings),
+ priv->enabled_checkbox,
+ 1, nb_columns, nb_rows - 1, nb_rows,
+ GTK_EXPAND | GTK_FILL, 0, 0, 0);
+#else
+ gtk_box_pack_start (GTK_BOX (vbox), priv->enabled_checkbox, FALSE, FALSE, 0);
+ gtk_box_reorder_child (GTK_BOX (vbox), priv->enabled_checkbox, 0);
+#endif /* HAVE_MEEGO */
+
+ gtk_widget_show (priv->enabled_checkbox);
+
+#ifdef HAVE_MEEGO
+ g_signal_connect (G_OBJECT (priv->enabled_checkbox), "switch-flipped",
+ G_CALLBACK (account_widget_switch_flipped_cb), self);
+#else
+ g_signal_connect (G_OBJECT (priv->enabled_checkbox), "released",
+ G_CALLBACK (account_widget_enabled_released_cb), self);
+#endif /* HAVE_MEEGO */
+}
+
+#ifndef HAVE_MEEGO
+/* Meego doesn't support registration */
+static void
+add_register_buttons (EmpathyAccountWidget *self,
+ TpAccount *account)
+{
+ EmpathyAccountWidgetPriv *priv = GET_PRIV (self);
+ const TpConnectionManagerProtocol *protocol;
+ GtkWidget *radiobutton_register;
+ GtkWidget *vbox = self->ui_details->widget;
+
+ if (!priv->creating_account)
+ return;
+
+ protocol = empathy_account_settings_get_tp_protocol (priv->settings);
+ if (protocol == NULL)
+ return;
+
+ if (!tp_connection_manager_protocol_can_register (protocol))
+ return;
+
+ if (account_widget_is_gtalk (self) || account_widget_is_facebook (self))
+ return;
+
+ if (priv->simple)
+ return;
+
+ 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 (priv->radiobutton_reuse)),
+ _("Create a new account on the server"));
+
+ gtk_box_pack_start (GTK_BOX (vbox), priv->radiobutton_reuse, FALSE, FALSE, 0);
+ gtk_box_pack_start (GTK_BOX (vbox), radiobutton_register, FALSE, FALSE, 0);
+ gtk_box_reorder_child (GTK_BOX (vbox), priv->radiobutton_reuse, 0);
+ gtk_box_reorder_child (GTK_BOX (vbox), radiobutton_register, 1);
+ gtk_widget_show (priv->radiobutton_reuse);
+ gtk_widget_show (radiobutton_register);
+}
+#endif /* HAVE_MEEGO */
+
+static void
+do_constructed (GObject *obj)
+{
+ EmpathyAccountWidget *self = EMPATHY_ACCOUNT_WIDGET (obj);
+ EmpathyAccountWidgetPriv *priv = GET_PRIV (self);
+ TpAccount *account;
+ const gchar *protocol, *cm_name;
+ const gchar *display_name, *default_display_name;
+ guint i = 0;
+ struct {
+ const gchar *cm_name;
+ const gchar *protocol;
+ const char *file;
+ void (*func)(EmpathyAccountWidget *self, const gchar *filename);
+ } widgets [] = {
+ { "salut", "local-xmpp", "empathy-account-widget-local-xmpp.ui",
+ account_widget_build_salut },
+ WIDGET (gabble, jabber),
+ WIDGET (butterfly, msn),
+ WIDGET (haze, icq),
+ WIDGET (haze, aim),
+ WIDGET (haze, yahoo),
+ WIDGET (haze, groupwise),
+ WIDGET (idle, irc),
+ WIDGET (sofiasip, sip),
+ };
+
+ cm_name = empathy_account_settings_get_cm (priv->settings);
+ protocol = empathy_account_settings_get_protocol (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");
+ 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");
+ account_widget_build_generic (self, filename);
+ g_free (filename);
+ }
/* handle default focus */
if (self->ui_details->default_focus != NULL)
self);
}
- /* handle apply button */
+ /* dup and init the account-manager */
+ priv->account_manager = tp_account_manager_dup ();
+
+ g_object_ref (self);
+ tp_account_manager_prepare_async (priv->account_manager, NULL,
+ account_manager_ready_cb, self);
+
+ /* handle apply and cancel button */
if (!priv->simple)
{
+ GtkWidget *hbox = gtk_hbox_new (TRUE, 3);
+
+ priv->cancel_button = gtk_button_new_from_stock (GTK_STOCK_CANCEL);
+
priv->apply_button = gtk_button_new_from_stock (GTK_STOCK_APPLY);
- gtk_box_pack_end (GTK_BOX (self->ui_details->widget), priv->apply_button,
- FALSE, FALSE, 3);
+ /* We'll change this button to a "Log in" one if we are creating a new
+ * account and are connected. */
+ empathy_signal_connect_weak (priv->account_manager,
+ "most-available-presence-changed",
+ G_CALLBACK (presence_changed_cb), obj);
+
+ gtk_box_pack_end (GTK_BOX (hbox), priv->apply_button, TRUE,
+ TRUE, 3);
+ gtk_box_pack_end (GTK_BOX (hbox), priv->cancel_button, TRUE,
+ TRUE, 3);
+
+ gtk_box_pack_end (GTK_BOX (self->ui_details->widget), hbox, FALSE,
+ FALSE, 3);
+
+ g_signal_connect (priv->cancel_button, "clicked",
+ G_CALLBACK (account_widget_cancel_clicked_cb),
+ self);
g_signal_connect (priv->apply_button, "clicked",
G_CALLBACK (account_widget_apply_clicked_cb),
self);
- account_widget_handle_apply_sensitivity (self);
- gtk_widget_show (priv->apply_button);
+ gtk_widget_show_all (hbox);
+
+ if (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);
}
+ account = empathy_account_settings_get_account (priv->settings);
+
+ if (account != NULL)
+ {
+ g_signal_connect (account, "notify::enabled",
+ G_CALLBACK (empathy_account_widget_enabled_cb), self);
+ }
+
+#ifndef HAVE_MEEGO
+ add_register_buttons (self, account);
+#endif /* HAVE_MEEGO */
+ add_enable_checkbox (self, account);
+
/* hook up to widget destruction to unref ourselves */
g_signal_connect (self->ui_details->widget, "destroy",
G_CALLBACK (account_widget_destroy_cb), self);
empathy_builder_unref_and_keep_widget (self->ui_details->gui,
self->ui_details->widget);
self->ui_details->gui = NULL;
+
+ display_name = empathy_account_settings_get_display_name (priv->settings);
+ default_display_name = empathy_account_widget_get_default_display_name (self);
+
+ if (tp_strdiff (display_name, default_display_name))
+ {
+ /* 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 (priv->settings, "display-name-overridden", TRUE, NULL);
+ }
}
static void
if (priv->settings != NULL)
{
+ TpAccount *account;
+ account = empathy_account_settings_get_account (priv->settings);
+
+ if (account != NULL)
+ {
+ g_signal_handlers_disconnect_by_func (account,
+ empathy_account_widget_enabled_cb, self);
+ }
+
g_object_unref (priv->settings);
priv->settings = NULL;
}
+ if (priv->account_manager != NULL)
+ {
+ g_object_unref (priv->account_manager);
+ priv->account_manager = NULL;
+ }
+
if (G_OBJECT_CLASS (empathy_account_widget_parent_class)->dispose != NULL)
G_OBJECT_CLASS (empathy_account_widget_parent_class)->dispose (obj);
}
do_finalize (GObject *obj)
{
EmpathyAccountWidget *self = EMPATHY_ACCOUNT_WIDGET (obj);
- EmpathyAccountWidgetPriv *priv = GET_PRIV (self);
g_free (self->ui_details->default_focus);
g_slice_free (EmpathyAccountWidgetUIDetails, self->ui_details);
- g_free (priv->protocol);
-
if (G_OBJECT_CLASS (empathy_account_widget_parent_class)->finalize != NULL)
G_OBJECT_CLASS (empathy_account_widget_parent_class)->finalize (obj);
}
param_spec = g_param_spec_string ("protocol",
"protocol", "The protocol of the account",
NULL,
- G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS | G_PARAM_CONSTRUCT_ONLY);
+ G_PARAM_READABLE | G_PARAM_STATIC_STRINGS);
g_object_class_install_property (oclass, PROP_PROTOCOL, param_spec);
param_spec = g_param_spec_object ("settings",
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_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_VOID__OBJECT,
+ 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_VOID__VOID,
+ G_TYPE_NONE,
+ 0);
+
g_type_class_add_private (klass, sizeof (EmpathyAccountWidgetPriv));
}
/* public methods */
+void
+empathy_account_widget_discard_pending_changes
+ (EmpathyAccountWidget *widget)
+{
+ EmpathyAccountWidgetPriv *priv = GET_PRIV (widget);
+
+ empathy_account_settings_discard_changes (priv->settings);
+ priv->contains_pending_changes = FALSE;
+}
+
+gboolean
+empathy_account_widget_contains_pending_changes (EmpathyAccountWidget *widget)
+{
+ EmpathyAccountWidgetPriv *priv = GET_PRIV (widget);
+
+ return priv->contains_pending_changes;
+}
+
void
empathy_account_widget_handle_params (EmpathyAccountWidget *self,
const gchar *first_widget,
}
GtkWidget *
-empathy_account_widget_new_for_protocol (const char *protocol,
- EmpathyAccountSettings *settings)
+empathy_account_widget_get_widget (EmpathyAccountWidget *widget)
+{
+ return widget->ui_details->widget;
+}
+
+EmpathyAccountWidget *
+empathy_account_widget_new_for_protocol (EmpathyAccountSettings *settings,
+ gboolean simple)
{
EmpathyAccountWidget *self;
- EmpathyAccountWidgetPriv *priv;
g_return_val_if_fail (EMPATHY_IS_ACCOUNT_SETTINGS (settings), NULL);
- g_return_val_if_fail (settings != NULL, NULL);
self = g_object_new
- (EMPATHY_TYPE_ACCOUNT_WIDGET, "protocol", protocol,
- "settings", settings, NULL);
- priv = GET_PRIV (self);
+ (EMPATHY_TYPE_ACCOUNT_WIDGET,
+ "settings", settings, "simple", simple,
+ "creating-account",
+ empathy_account_settings_get_account (settings) == NULL,
+ NULL);
- return self->ui_details->widget;
+ return self;
}
-GtkWidget *
-empathy_account_widget_simple_new_for_protocol (const char *protocol,
- EmpathyAccountSettings *settings, EmpathyAccountWidget **object)
+gchar *
+empathy_account_widget_get_default_display_name (EmpathyAccountWidget *self)
{
- EmpathyAccountWidget *self;
+ EmpathyAccountWidgetPriv *priv = GET_PRIV (self);
+ const gchar *login_id;
+ const gchar *protocol, *p;
+ gchar *default_display_name;
- g_return_val_if_fail (EMPATHY_IS_ACCOUNT_SETTINGS (settings), NULL);
- g_return_val_if_fail (protocol != NULL, NULL);
+ login_id = empathy_account_settings_get_string (priv->settings, "account");
+ protocol = empathy_account_settings_get_protocol (priv->settings);
- self = g_object_new
- (EMPATHY_TYPE_ACCOUNT_WIDGET, "protocol", protocol,
- "settings", settings, "simple", TRUE, NULL);
+ if (login_id != NULL)
+ {
+ /* TODO: this should be done in empathy-account-widget-irc */
+ if (!tp_strdiff (protocol, "irc"))
+ {
+ const gchar* server;
+ server = empathy_account_settings_get_string (priv->settings,
+ "server");
+
+ /* To translators: The first parameter is the login id and the
+ * second one is the server. The resulting string will be something
+ * like: "MyUserName on chat.freenode.net".
+ * 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, server);
+ }
+ else if (account_widget_is_facebook (self))
+ {
+ gchar *tmp;
+
+ tmp = remove_facebook_suffix (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;
- *object = self;
+ 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"));
+ }
+
+ return default_display_name;
+}
+
+/* Used by subclass to indicate that widget contains pending changes */
+void
+empathy_account_widget_changed (EmpathyAccountWidget *self)
+{
+ EmpathyAccountWidgetPriv *priv = GET_PRIV (self);
+
+ account_widget_handle_control_buttons_sensitivity (self);
+ priv->contains_pending_changes = TRUE;
+}
+
+void
+empathy_account_widget_set_account_param (EmpathyAccountWidget *self,
+ const gchar *account)
+{
+ EmpathyAccountWidgetPriv *priv = GET_PRIV (self);
+
+ if (priv->param_account_widget == NULL)
+ return;
+
+ gtk_entry_set_text (GTK_ENTRY (priv->param_account_widget), account);
+}
+
+void
+empathy_account_widget_set_password_param (EmpathyAccountWidget *self,
+ const gchar *account)
+{
+ EmpathyAccountWidgetPriv *priv = GET_PRIV (self);
+
+ if (priv->param_password_widget == NULL)
+ return;
- return self->ui_details->widget;
+ gtk_entry_set_text (GTK_ENTRY (priv->param_password_widget), account);
}
projects / empathy.git / blobdiff