static void account_widget_irc_setup (EmpathyAccountWidgetIrc *settings) { const gchar *nick = NULL; const gchar *fullname = NULL; EmpathyAccountSettings *ac_settings; g_object_get (settings->self, "settings", &ac_settings, NULL); nick = empathy_account_settings_get_string (ac_settings, "account"); fullname = empathy_account_settings_get_string (ac_settings, "fullname"); if (!nick) { nick = g_strdup (g_get_user_name ()); empathy_account_settings_set_string (ac_settings, "account", nick); } if (!fullname) { fullname = g_strdup (g_get_real_name ()); if (!fullname) { fullname = g_strdup (nick); } empathy_account_settings_set_string (ac_settings, "fullname", fullname); } }
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 (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); 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, tp_strdiff (param_name, "password") ? str : "***"); empathy_account_settings_set_string (priv->settings, param_name, str); } }
static void set_label_from_settings (EmpathyIrcNetworkChooser *self) { EmpathyIrcNetworkChooserPriv *priv = GET_PRIV (self); const gchar *server; tp_clear_object (&priv->network); server = empathy_account_settings_get_string (priv->settings, "server"); if (server != NULL) { EmpathyIrcServer *srv; gint port; gboolean ssl; priv->network = empathy_irc_network_manager_find_network_by_address ( priv->network_manager, server); if (priv->network != NULL) { /* The network is known */ g_object_ref (priv->network); set_label (self); return; } /* We don't have this network. Let's create it */ port = empathy_account_settings_get_uint32 (priv->settings, "port"); ssl = empathy_account_settings_get_boolean (priv->settings, "use-ssl"); DEBUG ("Create a network %s", server); priv->network = empathy_irc_network_new (server); srv = empathy_irc_server_new (server, port, ssl); empathy_irc_network_append_server (priv->network, srv); empathy_irc_network_manager_add (priv->network_manager, priv->network); set_label (self); g_object_unref (srv); return; } /* Set default network */ priv->network = empathy_irc_network_manager_find_network_by_address ( priv->network_manager, DEFAULT_IRC_NETWORK); g_assert (priv->network != NULL); set_label (self); update_server_params (self); g_object_ref (priv->network); }
static void account_widget_irc_setup (EmpathyAccountWidgetIrc *settings) { const gchar *nick = NULL; const gchar *fullname = NULL; const gchar *server = NULL; gint port = 6667; const gchar *charset; gboolean ssl = FALSE; EmpathyIrcNetwork *network = NULL; EmpathyAccountSettings *ac_settings; g_object_get (settings->self, "settings", &ac_settings, NULL); nick = empathy_account_settings_get_string (ac_settings, "account"); fullname = empathy_account_settings_get_string (ac_settings, "fullname"); server = empathy_account_settings_get_string (ac_settings, "server"); charset = empathy_account_settings_get_string (ac_settings, "charset"); port = empathy_account_settings_get_uint32 (ac_settings, "port"); ssl = empathy_account_settings_get_boolean (ac_settings, "use-ssl"); if (!nick) { nick = g_strdup (g_get_user_name ()); empathy_account_settings_set_string (ac_settings, "account", nick); } if (!fullname) { fullname = g_strdup (g_get_real_name ()); if (!fullname) { fullname = g_strdup (nick); } empathy_account_settings_set_string (ac_settings, "fullname", fullname); } if (server != NULL) { GtkListStore *store; network = empathy_irc_network_manager_find_network_by_address ( settings->network_manager, server); store = GTK_LIST_STORE (gtk_combo_box_get_model ( GTK_COMBO_BOX (settings->combobox_network))); if (network != NULL) { gchar *name; g_object_set (network, "charset", charset, NULL); g_object_get (network, "name", &name, NULL); DEBUG ("Account use network %s", name); g_free (name); } else { /* We don't have this network. Let's create it */ EmpathyIrcServer *srv; GtkTreeIter iter; DEBUG ("Create a network %s", server); network = empathy_irc_network_new (server); srv = empathy_irc_server_new (server, port, ssl); empathy_irc_network_append_server (network, srv); empathy_irc_network_manager_add (settings->network_manager, network); gtk_list_store_insert_with_values (store, &iter, -1, COL_NETWORK_OBJ, network, COL_NETWORK_NAME, server, -1); gtk_combo_box_set_active_iter ( GTK_COMBO_BOX (settings->combobox_network), &iter); g_object_unref (srv); g_object_unref (network); } } fill_networks_model (settings, network); }
static void account_widget_setup_widget (EmpathyAccountWidget *self, GtkWidget *widget, const gchar *param_name) { EmpathyAccountWidgetPriv *priv = GET_PRIV (self); g_object_set_data_full (G_OBJECT (widget), "param_name", g_strdup (param_name), g_free); if (GTK_IS_SPIN_BUTTON (widget)) { gint value = 0; const gchar *signature; signature = empathy_account_settings_get_dbus_signature (priv->settings, param_name); g_return_if_fail (signature != NULL); switch ((int)*signature) { case DBUS_TYPE_INT16: case DBUS_TYPE_INT32: value = empathy_account_settings_get_int32 (priv->settings, param_name); break; case DBUS_TYPE_INT64: value = empathy_account_settings_get_int64 (priv->settings, param_name); break; case DBUS_TYPE_UINT16: case DBUS_TYPE_UINT32: value = empathy_account_settings_get_uint32 (priv->settings, param_name); break; case DBUS_TYPE_UINT64: value = empathy_account_settings_get_uint64 (priv->settings, param_name); break; default: g_return_if_reached (); } gtk_spin_button_set_value (GTK_SPIN_BUTTON (widget), value); g_signal_connect (widget, "value-changed", G_CALLBACK (account_widget_int_changed_cb), self); } else if (GTK_IS_ENTRY (widget)) { const gchar *str = NULL; str = empathy_account_settings_get_string (priv->settings, param_name); gtk_entry_set_text (GTK_ENTRY (widget), str ? str : ""); if (strstr (param_name, "password")) { gtk_entry_set_visibility (GTK_ENTRY (widget), FALSE); } g_signal_connect (widget, "changed", G_CALLBACK (account_widget_entry_changed_cb), self); } else if (GTK_IS_TOGGLE_BUTTON (widget)) { gboolean value = FALSE; value = empathy_account_settings_get_boolean (priv->settings, param_name); gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (widget), value); g_signal_connect (widget, "toggled", G_CALLBACK (account_widget_checkbutton_toggled_cb), self); } else { DEBUG ("Unknown type of widget for param %s", param_name); } }
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; }
EmpathyIrcNetworkChooser * empathy_account_widget_irc_build (EmpathyAccountWidget *self, const char *filename, GtkWidget **table_common_settings) { EmpathyAccountWidgetIrc *settings; EmpathyAccountSettings *ac_settings; GtkWidget *entry_password; const gchar *password; settings = g_slice_new0 (EmpathyAccountWidgetIrc); settings->self = self; self->ui_details->gui = empathy_builder_get_file (filename, "table_irc_settings", table_common_settings, "vbox_irc", &self->ui_details->widget, "table_irc_settings", &settings->vbox_settings, "entry_password", &entry_password, NULL); /* Add network chooser button */ g_object_get (settings->self, "settings", &ac_settings, NULL); settings->network_chooser = empathy_irc_network_chooser_new (ac_settings); g_signal_connect (settings->network_chooser, "changed", G_CALLBACK (network_changed_cb), settings); gtk_table_attach (GTK_TABLE (*table_common_settings), settings->network_chooser, 1, 2, 0, 1, GTK_EXPAND | GTK_FILL, 0, 0, 0); gtk_widget_show (settings->network_chooser); account_widget_irc_setup (settings); empathy_account_widget_handle_params (self, "entry_nick", "account", "entry_fullname", "fullname", "entry_password", "password", "entry_quit_message", "quit-message", NULL); empathy_builder_connect (self->ui_details->gui, settings, "table_irc_settings", "destroy", account_widget_irc_destroy_cb, NULL); self->ui_details->default_focus = g_strdup ("entry_nick"); g_object_unref (ac_settings); /* Automatically set password-prompt when needed */ password = empathy_account_settings_get_string (ac_settings, "password"); if (set_password_prompt_if_needed (ac_settings, password)) { /* Apply right now to save password-prompt */ empathy_account_settings_apply_async (ac_settings, NULL, NULL); } g_signal_connect (entry_password, "changed", G_CALLBACK (entry_password_changed_cb), settings); return EMPATHY_IRC_NETWORK_CHOOSER (settings->network_chooser); }
static void protocol_changed_cb (GtkComboBox *chooser, EmpathyNewAccountDialog *self) { EmpathyAccountSettings *settings; GtkWidget *account_widget; EmpathyAccountWidget *widget_object; gchar *password = NULL, *account = NULL; settings = empathy_protocol_chooser_create_account_settings ( EMPATHY_PROTOCOL_CHOOSER (chooser)); if (settings == NULL) return; /* Save "account" and "password" parameters */ if (self->priv->settings != NULL) { account = g_strdup (empathy_account_settings_get_string ( self->priv->settings, "account")); password = g_strdup (empathy_account_settings_get_string ( self->priv->settings, "password")); g_object_unref (self->priv->settings); } widget_object = empathy_account_widget_new_for_protocol (settings, TRUE); account_widget = empathy_account_widget_get_widget (widget_object); if (self->priv->current_account_widget != NULL) { g_signal_handlers_disconnect_by_func (self->priv->current_widget_object, account_created_cb, self); g_signal_handlers_disconnect_by_func (self->priv->current_widget_object, cancelled_cb, self); gtk_widget_destroy (self->priv->current_account_widget); } self->priv->current_account_widget = account_widget; self->priv->current_widget_object = widget_object; self->priv->settings = settings; g_signal_connect (self->priv->current_widget_object, "account-created", G_CALLBACK (account_created_cb), self); g_signal_connect (self->priv->current_widget_object, "cancelled", G_CALLBACK (cancelled_cb), self); /* Restore "account" and "password" parameters in the new widget */ if (account != NULL) { empathy_account_widget_set_account_param (widget_object, account); g_free (account); } if (password != NULL) { empathy_account_widget_set_password_param (widget_object, password); g_free (password); } gtk_box_pack_start (GTK_BOX (self->priv->main_vbox), account_widget, FALSE, FALSE, 0); gtk_widget_show (account_widget); }