#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>
GtkWidget *button_forget;
GtkWidget *spinbutton_port;
GtkWidget *enabled_checkbox;
+ GtkWidget *radiobutton_reuse;
gboolean simple;
gboolean contains_pending_changes;
- gboolean original_enabled_checkbox_value;
/* 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;
PROP_PROTOCOL = 1,
PROP_SETTINGS,
PROP_SIMPLE,
- PROP_CREATING_ACCOUNT
+ PROP_CREATING_ACCOUNT,
+ PROP_OTHER_ACCOUNTS_EXIST,
};
enum {
if (!priv->simple)
{
- gtk_widget_set_sensitive (priv->apply_button, sensitive);
- gtk_widget_set_sensitive (
- priv->cancel_button, sensitive || priv->creating_account);
+ /* 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;
- priv->contains_pending_changes = sensitive;
+ gtk_widget_set_sensitive (priv->apply_button, sensitive);
+ gtk_widget_set_sensitive (priv->cancel_button,
+ (sensitive || priv->creating_account) && priv->other_accounts_exist);
}
}
EmpathyAccountWidget *self)
{
account_widget_entry_changed_common (self, GTK_ENTRY (entry), FALSE);
- account_widget_handle_control_buttons_sensitivity (self);
+ empathy_account_widget_changed (self);
}
static void
g_return_if_reached ();
}
- account_widget_handle_control_buttons_sensitivity (self);
+ empathy_account_widget_changed (self);
}
static void
empathy_account_settings_set_boolean (priv->settings, param_name, value);
}
- account_widget_handle_control_buttons_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_control_buttons_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_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 (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);
}
}
gpointer user_data)
{
GError *error = NULL;
- EmpathyAccount *account = EMPATHY_ACCOUNT (source_object);
+ TpAccount *account = TP_ACCOUNT (source_object);
EmpathyAccountWidget *widget = EMPATHY_ACCOUNT_WIDGET (user_data);
+ EmpathyAccountWidgetPriv *priv = GET_PRIV (widget);
- empathy_account_set_enabled_finish (account, res, &error);
+ tp_account_set_enabled_finish (account, res, &error);
if (error != NULL)
{
- DEBUG ("Could not automatically enable new account: %s", error->message);
+ DEBUG ("Could not enable the account: %s", error->message);
g_error_free (error);
}
else
{
- g_signal_emit (widget, signals[ACCOUNT_CREATED], 0);
+ empathy_connect_new_account (account, priv->account_manager);
}
+
+ /* unref widget - part of the workaround */
+ g_object_unref (widget);
}
static void
gpointer user_data)
{
GError *error = NULL;
- EmpathyAccount *account;
+ TpAccount *account;
EmpathyAccountSettings *settings = EMPATHY_ACCOUNT_SETTINGS (source_object);
EmpathyAccountWidget *widget = EMPATHY_ACCOUNT_WIDGET (user_data);
EmpathyAccountWidgetPriv *priv = GET_PRIV (widget);
if (priv->creating_account)
{
/* By default, when an account is created, we enable it. */
- empathy_account_set_enabled_async (account, TRUE,
+
+ /* 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 = gtk_toggle_button_get_active (
- GTK_TOGGLE_BUTTON (priv->enabled_checkbox));
+ 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 (empathy_account_is_enabled (account) && enabled_checked)
+ 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. */
- empathy_account_reconnect_async (account, NULL, NULL);
+ tp_account_reconnect_async (account, NULL, NULL);
}
}
}
- account_widget_set_control_buttons_sensitivity (widget, FALSE);
+ 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;
+
+ /* 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);
}
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
}
}
+static gboolean
+account_widget_is_gtalk (EmpathyAccountWidget *self)
+{
+ EmpathyAccountWidgetPriv *priv = GET_PRIV (self);
+
+ return !tp_strdiff (empathy_account_settings_get_icon_name (priv->settings),
+ "im-google-talk");
+}
+
+static gboolean
+account_widget_is_facebook (EmpathyAccountWidget *self)
+{
+ EmpathyAccountWidgetPriv *priv = GET_PRIV (self);
+
+ return !tp_strdiff (empathy_account_settings_get_icon_name (priv->settings),
+ "im-facebook");
+}
+
+#define FACEBOOK_SUFFIX "@chat.facebook.com"
+
+static void
+facebook_id_widget_changed_cb (GtkWidget *entry,
+ EmpathyAccountWidget *self)
+{
+ EmpathyAccountWidgetPriv *priv = GET_PRIV (self);
+ const gchar *account;
+
+ account_widget_entry_changed_common (self, GTK_ENTRY (entry), FALSE);
+
+ account = empathy_account_settings_get_string (priv->settings, "account");
+ if (!EMP_STR_EMPTY (account) &&
+ !g_str_has_suffix (account, FACEBOOK_SUFFIX))
+ {
+ gchar *tmp;
+
+ tmp = g_strdup_printf ("%s%s", account, FACEBOOK_SUFFIX);
+
+ DEBUG ("Change account from '%s' to '%s'", account, tmp);
+
+ empathy_account_settings_set_string (priv->settings, "account", tmp);
+ g_free (tmp);
+ }
+
+ empathy_account_widget_changed (self);
+}
+
+static gchar *
+remove_facebook_suffix (const gchar *str)
+{
+ if (!g_str_has_suffix (str, FACEBOOK_SUFFIX))
+ return g_strdup (str);
+
+ return g_strndup (str, strlen (str) - strlen (FACEBOOK_SUFFIX));
+}
+
+static void
+setup_facebook_id_widget (EmpathyAccountWidget *self,
+ GtkWidget *widget)
+{
+ EmpathyAccountWidgetPriv *priv = GET_PRIV (self);
+ const gchar *str = NULL;
+
+ g_object_set_data_full (G_OBJECT (widget), "param_name",
+ g_strdup ("account"), g_free);
+
+ str = empathy_account_settings_get_string (priv->settings, "account");
+ if (str != NULL)
+ {
+ gchar *tmp;
+
+ tmp = remove_facebook_suffix (str);
+ gtk_entry_set_text (GTK_ENTRY (widget), tmp);
+ g_free (tmp);
+ }
+
+ priv->param_account_widget = widget;
+
+ g_signal_connect (widget, "changed",
+ G_CALLBACK (facebook_id_widget_changed_cb), self);
+}
+
static void
account_widget_build_jabber (EmpathyAccountWidget *self,
const char *filename)
GtkWidget *checkbutton_ssl;
GtkWidget *label_id, *label_password;
GtkWidget *label_id_create, *label_password_create;
- GtkWidget *label_example_gtalk, *label_example_jabber;
- gboolean is_gtalk;
+ GtkWidget *label_example_gtalk, *label_example_jabber, *label_example_fb;
+ gboolean is_gtalk, is_facebook;
+ GtkWidget *expander_advanced;
+ GtkWidget *entry_id;
- is_gtalk = !tp_strdiff (
- empathy_account_settings_get_icon_name (priv->settings),
- "im-google-talk");
+ is_gtalk = account_widget_is_gtalk (self);
+ is_facebook = account_widget_is_facebook (self);
- if (priv->simple && !is_gtalk)
+ 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,
}
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);
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,
"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_id", "account",
"entry_password", "password",
"entry_resource", "resource",
"entry_server", "server",
"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;
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);
+ }
}
}
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 (EmpathyAccount *account,
+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 = empathy_account_is_enabled (account);
+ 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);
- EmpathyAccount *account;
+ 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 */
- empathy_account_set_enabled_async (account, state, NULL, NULL);
+ /* 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
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);
}
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);
- EmpathyAccount *account;
+ TpAccount *account;
const gchar *protocol, *cm_name;
- int i = 0;
+ const gchar *display_name, *default_display_name;
+ guint i = 0;
struct {
const gchar *cm_name;
const gchar *protocol;
self);
}
+ /* 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 (
- priv->creating_account ? GTK_STOCK_CONNECT : GTK_STOCK_APPLY);
+
+ priv->apply_button = gtk_button_new_from_stock (GTK_STOCK_APPLY);
+
+ /* 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);
G_CALLBACK (empathy_account_widget_enabled_cb), self);
}
- /* handle the "Enabled" checkbox. We only add it when modifying an account */
- if (!priv->creating_account && priv->table_common_settings != NULL)
- {
- guint nb_rows, nb_columns;
-
- priv->enabled_checkbox =
- gtk_check_button_new_with_label (_("Enabled"));
- priv->original_enabled_checkbox_value =
- empathy_account_is_enabled (account);
- gtk_toggle_button_set_active (
- GTK_TOGGLE_BUTTON (priv->enabled_checkbox),
- priv->original_enabled_checkbox_value);
-
- 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);
-
- gtk_table_attach (GTK_TABLE (priv->table_common_settings),
- priv->enabled_checkbox, 0, nb_columns, nb_rows - 1, nb_rows,
- GTK_EXPAND | GTK_FILL, 0, 0, 0);
-
- gtk_widget_show (priv->enabled_checkbox);
-
- g_signal_connect (G_OBJECT (priv->enabled_checkbox), "released",
- G_CALLBACK (account_widget_enabled_released_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",
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
priv->dispose_run = TRUE;
- empathy_account_settings_is_ready (priv->settings);
-
if (priv->settings != NULL)
{
- EmpathyAccount *account;
+ TpAccount *account;
account = empathy_account_settings_get_account (priv->settings);
if (account != NULL)
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);
}
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,
signals[ACCOUNT_CREATED] =
g_signal_new ("account-created", G_TYPE_FROM_CLASS (klass),
G_SIGNAL_RUN_LAST, 0, NULL, NULL,
- g_cclosure_marshal_VOID__VOID,
+ g_cclosure_marshal_VOID__OBJECT,
G_TYPE_NONE,
- 0);
+ 1, G_TYPE_OBJECT);
signals[CANCELLED] =
g_signal_new ("cancelled", G_TYPE_FROM_CLASS (klass),
EmpathyAccountWidgetPriv *priv = GET_PRIV (widget);
empathy_account_settings_discard_changes (priv->settings);
- gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (priv->enabled_checkbox),
- priv->original_enabled_checkbox_value);
priv->contains_pending_changes = FALSE;
}
return self;
}
+
+gchar *
+empathy_account_widget_get_default_display_name (EmpathyAccountWidget *self)
+{
+ EmpathyAccountWidgetPriv *priv = GET_PRIV (self);
+ const gchar *login_id;
+ const gchar *protocol, *p;
+ gchar *default_display_name;
+
+ login_id = empathy_account_settings_get_string (priv->settings, "account");
+ protocol = empathy_account_settings_get_protocol (priv->settings);
+
+ 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;
+
+ 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;
+
+ gtk_entry_set_text (GTK_ENTRY (priv->param_password_widget), account);
+}