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; }