#include <gtk/gtk.h>
#include <glib/gi18n-lib.h>
-#ifdef HAVE_MOBLIN
-#include <nbtk/nbtk-gtk.h>
-#endif
+#ifdef HAVE_MEEGO
+#include <mx/mx-gtk.h>
+#endif /* HAVE_MEEGO */
#include <libempathy/empathy-utils.h>
GtkWidget *button_forget;
GtkWidget *spinbutton_port;
GtkWidget *enabled_checkbox;
+ GtkWidget *radiobutton_reuse;
gboolean simple;
/* 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;
- /* If we are creating a new account, this member is set to TRUE once the
- * account has been created */
- gboolean account_created;
+
+ /* 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
empathy_account_settings_set_string (priv->settings, param_name, value);
}
- account_widget_handle_control_buttons_sensitivity (self);
+ empathy_account_widget_changed (self);
}
void
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);
{
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);
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
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, NULL);
- priv->account_created = TRUE;
- g_signal_emit (widget, signals[ACCOUNT_CREATED], 0);
+ 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 =
-#ifndef HAVE_MOBLIN
+#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));
-#else
- nbtk_gtk_light_switch_get_active (
- NBTK_GTK_LIGHT_SWITCH (priv->enabled_checkbox));
-#endif
+#endif /* HAVE_MEEGO */
if (tp_account_is_enabled (account) && enabled_checked)
{
}
}
- 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);
+ if (priv->simple)
+ gtk_widget_hide (expander_advanced);
+
self->ui_details->default_focus = g_strdup ("entry_first_name");
}
}
}
+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);
}
if (priv->enabled_checkbox != NULL)
{
-#ifndef HAVE_MOBLIN
- gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (priv->enabled_checkbox),
+#ifdef HAVE_MEEGO
+ mx_gtk_light_switch_set_active (
+ MX_GTK_LIGHT_SWITCH (priv->enabled_checkbox),
enabled);
#else
- nbtk_gtk_light_switch_set_active (
- NBTK_GTK_LIGHT_SWITCH (priv->enabled_checkbox),
+ gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (priv->enabled_checkbox),
enabled);
-#endif /* HAVE_MOBLIN */
+#endif /* HAVE_MEEGO */
}
}
static void
-#ifndef HAVE_MOBLIN
-account_widget_enabled_released_cb (GtkToggleButton *toggle_button,
+#ifdef HAVE_MEEGO
+account_widget_switch_flipped_cb (MxGtkLightSwitch *sw,
+ gboolean state,
gpointer user_data)
#else
-account_widget_switch_flipped_cb (NbtkGtkLightSwitch *sw,
- gboolean state,
+account_widget_enabled_released_cb (GtkToggleButton *toggle_button,
gpointer user_data)
-#endif /* HAVE_MOBLIN */
+#endif /* HAVE_MEEGO */
{
EmpathyAccountWidgetPriv *priv = GET_PRIV (user_data);
TpAccount *account;
-#ifndef HAVE_MOBLIN
+#ifndef HAVE_MEEGO
gboolean state;
state = gtk_toggle_button_get_active (toggle_button);
-#endif
+#endif /* HAVE_MEEGO */
account = empathy_account_settings_get_account (priv->settings);
/* Enable the account according to the value of the "Enabled" checkbox */
- tp_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);
}
{
EmpathyAccountWidgetPriv *priv = GET_PRIV (self);
- if (state > TP_CONNECTION_PRESENCE_TYPE_OFFLINE)
+ 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, display a Login button */
+ /* 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);
}
else
{
- /* We are offline, display a Save button */
+ /* 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_SAVE);
+ gtk_button_set_label (GTK_BUTTON (priv->apply_button), GTK_STOCK_APPLY);
}
}
{
DEBUG ("Failed to prepare account manager: %s", error->message);
g_error_free (error);
- return;
+ goto out;
}
state = tp_account_manager_get_most_available_presence (account_manager, 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)
{
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;
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)
{
priv->cancel_button = gtk_button_new_from_stock (GTK_STOCK_CANCEL);
- if (priv->creating_account)
- {
- priv->account_manager = tp_account_manager_dup ();
-
- empathy_signal_connect_weak (priv->account_manager,
- "most-available-presence-changed",
- G_CALLBACK (presence_changed_cb), obj);
-
- tp_account_manager_prepare_async (priv->account_manager, NULL,
- account_manager_ready_cb, self);
+ priv->apply_button = gtk_button_new_from_stock (GTK_STOCK_APPLY);
- /* Assumre we are offline, display a Save button. We'll update
- * it once the account manager is ready if needed */
- priv->apply_button = gtk_button_new_from_stock (GTK_STOCK_SAVE);
- }
- else
- {
- /* We are editing an existing account, display an Apply button */
- 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)
- {
-#ifdef HAVE_MOBLIN
- GtkWidget *w;
-#endif
- guint nb_rows, nb_columns;
- gboolean is_enabled;
-
- is_enabled = tp_account_is_enabled (account);
-
-#ifndef HAVE_MOBLIN
- priv->enabled_checkbox =
- gtk_check_button_new_with_label (_("Enabled"));
-
- gtk_toggle_button_set_active (
- GTK_TOGGLE_BUTTON (priv->enabled_checkbox), is_enabled);
-#else
- /* Translators: this is used only when built on a moblin platform */
- w = gtk_label_new (_("Account:"));
- gtk_misc_set_alignment (GTK_MISC (w), 0, 0.5);
-
- priv->enabled_checkbox = nbtk_gtk_light_switch_new ();
-
- nbtk_gtk_light_switch_set_active (
- NBTK_GTK_LIGHT_SWITCH (priv->enabled_checkbox), is_enabled);
-
- gtk_widget_show (w);
-#endif /* HAVE_MOBLIN */
-
- 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);
-
-#ifndef HAVE_MOBLIN
- 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);
-#else
- 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);
-#endif /* HAVE_MOBLIN */
-
- gtk_widget_show (priv->enabled_checkbox);
-
-#ifndef HAVE_MOBLIN
- g_signal_connect (G_OBJECT (priv->enabled_checkbox), "released",
- G_CALLBACK (account_widget_enabled_released_cb), self);
-#else
- g_signal_connect (G_OBJECT (priv->enabled_checkbox), "switch-flipped",
- G_CALLBACK (account_widget_switch_flipped_cb), self);
-#endif /* HAVE_MOBLIN */
- }
+#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)
{
TpAccount *account;
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);
- if (priv->creating_account && !priv->account_created)
- /* We always want to warn the user if he's in the process of creating a
- * new account which hasn't been actually created yet. */
- return TRUE;
-
return priv->contains_pending_changes;
}
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;
}
+
+/* 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);
+}
projects / empathy.git / blobdiff