static void
do_dispose (GObject *obj)
{
EmpathyAccountWidget *self = EMPATHY_ACCOUNT_WIDGET (obj);
EmpathyAccountWidgetPriv *priv = GET_PRIV (self);
if (priv->dispose_run)
return;
priv->dispose_run = TRUE;
empathy_account_settings_is_ready (priv->settings);
if (priv->settings != NULL)
{
EmpathyAccount *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 (G_OBJECT_CLASS (empathy_account_widget_parent_class)->dispose != NULL)
G_OBJECT_CLASS (empathy_account_widget_parent_class)->dispose (obj);
}
static void
account_assistant_apply_account_cb (GObject *source,
GAsyncResult *result,
gpointer user_data)
{
GError *error = NULL;
EmpathyAccountAssistant *self = user_data;
EmpathyAccountAssistantPriv *priv = GET_PRIV (self);
EmpathyAccountSettings *settings = EMPATHY_ACCOUNT_SETTINGS (source);
EmpathyAccount *account;
empathy_account_settings_apply_finish (settings, result, &error);
priv->is_creating = FALSE;
if (error != NULL)
{
account_assistant_present_error_page (self, error,
gtk_assistant_get_current_page (GTK_ASSISTANT (self)));
g_error_free (error);
return;
}
/* enable the newly created account */
account = empathy_account_settings_get_account (settings);
empathy_account_set_enabled_async (account, TRUE,
account_assistant_account_enabled_cb, self);
}
static void
account_widget_applied_cb (GObject *source_object,
GAsyncResult *res,
gpointer user_data)
{
GError *error = NULL;
TpAccount *account;
EmpathyAccountSettings *settings = EMPATHY_ACCOUNT_SETTINGS (source_object);
EmpathyAccountWidget *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. */
tp_account_set_enabled_async (account, TRUE,
account_widget_account_enabled_cb, widget);
}
else if (priv->enabled_checkbox != NULL)
{
gboolean enabled_checked;
enabled_checked =
#ifndef HAVE_MOBLIN
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
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);
}
}
}
account_widget_set_control_buttons_sensitivity (widget, FALSE);
}
EmpathyAccountWidget *
empathy_account_widget_new_for_protocol (EmpathyAccountSettings *settings,
gboolean simple)
{
EmpathyAccountWidget *self;
g_return_val_if_fail (EMPATHY_IS_ACCOUNT_SETTINGS (settings), NULL);
self = g_object_new
(EMPATHY_TYPE_ACCOUNT_WIDGET,
"settings", settings, "simple", simple,
"creating-account",
empathy_account_settings_get_account (settings) == NULL,
NULL);
return self;
}
account_widget_switch_flipped_cb (NbtkGtkLightSwitch *sw,
gboolean state,
gpointer user_data)
#endif /* HAVE_MOBLIN */
{
EmpathyAccountWidgetPriv *priv = GET_PRIV (user_data);
TpAccount *account;
#ifndef HAVE_MOBLIN
gboolean state;
state = gtk_toggle_button_get_active (toggle_button);
#endif
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);
}
static void
salut_account_created (GObject *source,
GAsyncResult *result,
gpointer user_data)
{
EmpathyAccountSettings *settings = EMPATHY_ACCOUNT_SETTINGS (source);
TpAccount *account;
GError *error = NULL;
if (!empathy_account_settings_apply_finish (settings, result, &error))
{
DEBUG ("Failed to create salut account: %s", error->message);
g_error_free (error);
return;
}
account = empathy_account_settings_get_account (settings);
tp_account_set_enabled_async (account, TRUE, NULL, NULL);
empathy_conf_set_bool (empathy_conf_get (),
EMPATHY_PREFS_SALUT_ACCOUNT_CREATED,
TRUE);
}
static void
do_constructed (GObject *obj)
{
EmpathyAccountWidget *self = EMPATHY_ACCOUNT_WIDGET (obj);
EmpathyAccountWidgetPriv *priv = GET_PRIV (self);
TpAccount *account;
const gchar *protocol, *cm_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)
{
GObject *default_focus_entry;
default_focus_entry = gtk_builder_get_object
(self->ui_details->gui, self->ui_details->default_focus);
g_signal_connect (default_focus_entry, "realize",
G_CALLBACK (gtk_widget_grab_focus),
NULL);
}
/* handle forget button */
if (self->ui_details->add_forget)
{
const gchar *password = NULL;
priv->button_forget = GTK_WIDGET (gtk_builder_get_object
(self->ui_details->gui, "button_forget"));
priv->entry_password = GTK_WIDGET (gtk_builder_get_object
(self->ui_details->gui, "entry_password"));
password = empathy_account_settings_get_string (priv->settings,
"password");
gtk_widget_set_sensitive (priv->button_forget,
!EMP_STR_EMPTY (password));
g_signal_connect (priv->button_forget, "clicked",
G_CALLBACK (account_widget_forget_clicked_cb),
self);
g_signal_connect (priv->entry_password, "changed",
G_CALLBACK (account_widget_password_changed_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);
if (priv->creating_account)
{
TpConnectionPresenceType state;
priv->idle = empathy_idle_dup_singleton ();
empathy_signal_connect_weak (priv->idle, "notify::state",
G_CALLBACK (idle_state_change_cb), obj);
state = empathy_idle_get_state (priv->idle);
if (state > TP_CONNECTION_PRESENCE_TYPE_OFFLINE)
{
/* We are online, display a Login button */
GtkWidget *image;
priv->apply_button = gtk_button_new_with_mnemonic (_("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, display a Save button */
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);
}
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);
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);
}
/* 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 */
}
/* 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;
}
