From 000a7c0ca4dc343b42e628323ddd1ca0f2a08e3f Mon Sep 17 00:00:00 2001 From: Cosimo Cecchi Date: Mon, 27 Jul 2009 00:54:23 +0200 Subject: First cut at GObject-ifying EmpathyAccountWidget --- libempathy-gtk/empathy-account-widget.c | 642 ++++++++++++++++++-------------- 1 file changed, 366 insertions(+), 276 deletions(-) (limited to 'libempathy-gtk/empathy-account-widget.c') diff --git a/libempathy-gtk/empathy-account-widget.c b/libempathy-gtk/empathy-account-widget.c index 21e3d3ee3..76145c483 100644 --- a/libempathy-gtk/empathy-account-widget.c +++ b/libempathy-gtk/empathy-account-widget.c @@ -33,21 +33,60 @@ #include #include +#include #include #include "empathy-account-widget.h" +#include "empathy-account-widget-private.h" +#include "empathy-account-widget-sip.h" +#include "empathy-account-widget-irc.h" #include "empathy-ui-utils.h" #define DEBUG_FLAG EMPATHY_DEBUG_ACCOUNT #include +G_DEFINE_TYPE (EmpathyAccountWidget, empathy_account_widget, G_TYPE_OBJECT) + +typedef struct { + GtkWidget *widget; + + char *protocol; + EmpathyAccountSettings *settings; + + GtkWidget *apply_button; + GtkWidget *entry_password; + GtkWidget *button_forget; + GtkWidget *spinbutton_port; + + GtkBuilder *gui; + char *default_focus; + gboolean add_forget; +} EmpathyAccountWidgetPriv; + +enum { + PROP_PROTOCOL = 1, + PROP_SETTINGS +}; + +#define GET_PRIV(obj) EMPATHY_GET_PRIV (obj, EmpathyAccountWidget) + +static void +account_widget_handle_apply_sensitivity (EmpathyAccountWidget *self) +{ + EmpathyAccountWidgetPriv *priv = GET_PRIV (self); + + gtk_widget_set_sensitive (priv->apply_button, + empathy_account_settings_is_valid (priv->settings)); +} + static gboolean account_widget_entry_focus_cb (GtkWidget *widget, GdkEventFocus *event, - EmpathyAccountSettings *settings) + EmpathyAccountWidget *self) { const gchar *str; const gchar *param_name; + EmpathyAccountWidgetPriv *priv = GET_PRIV (self); str = gtk_entry_get_text (GTK_ENTRY (widget)); param_name = g_object_get_data (G_OBJECT (widget), "param_name"); @@ -55,31 +94,34 @@ account_widget_entry_focus_cb (GtkWidget *widget, if (EMP_STR_EMPTY (str)) { const gchar *value = NULL; - empathy_account_settings_unset (settings, param_name); - value = empathy_account_settings_get_string (settings, param_name); + empathy_account_settings_unset (priv->settings, param_name); + value = empathy_account_settings_get_string (priv->settings, param_name); DEBUG ("Unset %s and restore to %s", param_name, value); gtk_entry_set_text (GTK_ENTRY (widget), value ? value : ""); } else { DEBUG ("Setting %s to %s", param_name, strstr (param_name, "password") ? "***" : str); - empathy_account_settings_set_string (settings, param_name, str); + empathy_account_settings_set_string (priv->settings, param_name, str); } + account_widget_handle_apply_sensitivity (self); + return FALSE; } static void account_widget_int_changed_cb (GtkWidget *widget, - EmpathyAccountSettings *settings) + EmpathyAccountWidget *self) { const gchar *param_name; - gint value; + gint value; const gchar *signature; + EmpathyAccountWidgetPriv *priv = GET_PRIV (self); value = gtk_spin_button_get_value_as_int (GTK_SPIN_BUTTON (widget)); param_name = g_object_get_data (G_OBJECT (widget), "param_name"); - signature = empathy_settings_get_dbus_signature (settings, param_name); + signature = empathy_settings_get_dbus_signature (priv->settings, param_name); g_return_if_fail (signature != NULL); DEBUG ("Setting %s to %d", param_name, value); @@ -88,30 +130,33 @@ account_widget_int_changed_cb (GtkWidget *widget, { case DBUS_TYPE_INT16: case DBUS_TYPE_INT32: - empathy_account_settings_set_int32 (settings, param_name, value); + empathy_account_settings_set_int32 (priv->settings, param_name, value); break; case DBUS_TYPE_INT64: - empathy_account_settings_set_int64 (settings, param_name, value); + empathy_account_settings_set_int64 (priv->settings, param_name, value); break; case DBUS_TYPE_UINT16: case DBUS_TYPE_UINT32: - empathy_account_settings_set_uint32 (settings, param_name, value); + empathy_account_settings_set_uint32 (priv->settings, param_name, value); break; case DBUS_TYPE_UINT64: - empathy_account_settings_set_uint64 (settings, param_name, value); + empathy_account_settings_set_uint64 (priv->settings, param_name, value); break; default: g_return_if_reached (); - } + } + + account_widget_handle_apply_sensitivity (self); } static void account_widget_checkbutton_toggled_cb (GtkWidget *widget, - EmpathyAccountSettings *settings) + EmpathyAccountWidget *self) { gboolean value; gboolean default_value; const gchar *param_name; + EmpathyAccountWidgetPriv *priv = GET_PRIV (self); value = gtk_toggle_button_get_active (GTK_TOGGLE_BUTTON (widget)); param_name = g_object_get_data (G_OBJECT (widget), "param_name"); @@ -119,30 +164,33 @@ account_widget_checkbutton_toggled_cb (GtkWidget *widget, /* FIXME: This is ugly! checkbox don't have a "not-set" value so we * always unset the param and set the value if different from the * default value. */ - empathy_account_settings_unset (settings, param_name); - default_value = empathy_account_settings_get_boolean (settings, param_name); + empathy_account_settings_unset (priv->settings, param_name); + default_value = empathy_account_settings_get_boolean (priv->settings, param_name); if (default_value == value) { DEBUG ("Unset %s and restore to %d", param_name, default_value); } else { DEBUG ("Setting %s to %d", param_name, value); - empathy_account_settings_set_boolean (settings, param_name, value); + empathy_account_settings_set_boolean (priv->settings, param_name, value); } + + account_widget_handle_apply_sensitivity (self); } static void account_widget_forget_clicked_cb (GtkWidget *button, - GtkWidget *entry) + EmpathyAccountWidget *self) { - EmpathyAccountSettings *settings; + EmpathyAccountWidgetPriv *priv = GET_PRIV (self); const gchar *param_name; - param_name = g_object_get_data (G_OBJECT (entry), "param_name"); - settings = g_object_get_data (G_OBJECT (entry), "settings"); + param_name = g_object_get_data (G_OBJECT (priv->entry_password), "param_name"); DEBUG ("Unset %s", param_name); - empathy_account_settings_unset (settings, param_name); - gtk_entry_set_text (GTK_ENTRY (entry), ""); + empathy_account_settings_unset (priv->settings, param_name); + gtk_entry_set_text (GTK_ENTRY (priv->entry_password), ""); + + account_widget_handle_apply_sensitivity (self); } static void @@ -157,15 +205,14 @@ account_widget_password_changed_cb (GtkWidget *entry, static void account_widget_jabber_ssl_toggled_cb (GtkWidget *checkbutton_ssl, - GtkWidget *spinbutton_port) + EmpathyAccountWidget *self) { - EmpathyAccountSettings *settings; + EmpathyAccountWidgetPriv *priv = GET_PRIV (self); gboolean value; gint32 port = 0; value = gtk_toggle_button_get_active (GTK_TOGGLE_BUTTON (checkbutton_ssl)); - settings = g_object_get_data (G_OBJECT (spinbutton_port), "settings"); - port = empathy_account_settings_get_uint32 (settings, "port"); + port = empathy_account_settings_get_uint32 (priv->settings, "port"); if (value) { if (port == 5222 || port == 0) { @@ -177,41 +224,41 @@ account_widget_jabber_ssl_toggled_cb (GtkWidget *checkbutton_ssl, } } - gtk_spin_button_set_value (GTK_SPIN_BUTTON (spinbutton_port), port); + gtk_spin_button_set_value (GTK_SPIN_BUTTON (priv->spinbutton_port), port); } static void -account_widget_setup_widget (GtkWidget *widget, - EmpathyAccountSettings *settings, +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); - g_object_set_data_full (G_OBJECT (widget), "settings", - g_object_ref (settings), g_object_unref); if (GTK_IS_SPIN_BUTTON (widget)) { gint value = 0; const gchar *signature; - signature = empathy_settings_get_dbus_signature (settings, param_name); + signature = empathy_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 (settings, param_name); + value = empathy_account_settings_get_int32 (priv->settings, param_name); break; case DBUS_TYPE_INT64: - value = empathy_account_settings_get_int64 (settings, param_name); + 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 (settings, param_name); + value = empathy_account_settings_get_uint32 (priv->settings, param_name); break; case DBUS_TYPE_UINT64: - value = empathy_account_settings_get_uint64 (settings, param_name); + value = empathy_account_settings_get_uint64 (priv->settings, param_name); break; default: g_return_if_reached (); @@ -221,12 +268,12 @@ account_widget_setup_widget (GtkWidget *widget, g_signal_connect (widget, "value-changed", G_CALLBACK (account_widget_int_changed_cb), - settings); + self); } else if (GTK_IS_ENTRY (widget)) { const gchar *str = NULL; - str = empathy_account_settings_get_string (settings, param_name); + str = empathy_account_settings_get_string (priv->settings, param_name); gtk_entry_set_text (GTK_ENTRY (widget), str ? str : ""); if (strstr (param_name, "password")) { @@ -235,17 +282,17 @@ account_widget_setup_widget (GtkWidget *widget, g_signal_connect (widget, "focus-out-event", G_CALLBACK (account_widget_entry_focus_cb), - settings); + self); } else if (GTK_IS_TOGGLE_BUTTON (widget)) { gboolean value = FALSE; - value = empathy_account_settings_get_boolean (settings, param_name); + 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), - settings); + self); } else { DEBUG ("Unknown type of widget for param %s", param_name); } @@ -276,13 +323,14 @@ account_widget_generic_format_param_name (const gchar *param_name) } static void -accounts_widget_generic_setup (EmpathyAccountSettings *settings, +accounts_widget_generic_setup (EmpathyAccountWidget *self, GtkWidget *table_common_settings, GtkWidget *table_advanced_settings) { TpConnectionManagerParam *params, *param; + EmpathyAccountWidgetPriv *priv = GET_PRIV (self); - params = empathy_account_settings_get_tp_params (settings); + params = empathy_account_settings_get_tp_params (priv->settings); for (param = params; param != NULL && param->name != NULL; param++) { GtkWidget *table_settings; @@ -391,7 +439,7 @@ accounts_widget_generic_setup (EmpathyAccountSettings *settings, } if (widget) { - account_widget_setup_widget (widget, settings, param->name); + account_widget_setup_widget (self, widget, param->name); } g_free (param_name_formatted); @@ -399,168 +447,93 @@ accounts_widget_generic_setup (EmpathyAccountSettings *settings, } static void -account_widget_handle_params_valist (EmpathyAccountSettings *settings, - GtkBuilder *gui, +account_widget_handle_params_valist (EmpathyAccountWidget *self, const gchar *first_widget, va_list args) { GObject *object; const gchar *name; + EmpathyAccountWidgetPriv *priv = GET_PRIV (self); for (name = first_widget; name; name = va_arg (args, const gchar *)) { const gchar *param_name; param_name = va_arg (args, const gchar *); - object = gtk_builder_get_object (gui, name); + object = gtk_builder_get_object (priv->gui, name); if (!object) { g_warning ("Builder is missing object '%s'.", name); continue; } - account_widget_setup_widget (GTK_WIDGET (object), settings, param_name); + account_widget_setup_widget (self, GTK_WIDGET (object), param_name); } } -void -empathy_account_widget_handle_params (EmpathyAccountSettings *settings, - GtkBuilder *gui, - const gchar *first_widget, - ...) -{ - va_list args; - - g_return_if_fail (GTK_IS_BUILDER (gui)); - - va_start (args, first_widget); - account_widget_handle_params_valist (settings, gui, first_widget, args); - va_end (args); -} - static void account_widget_apply_clicked_cb (GtkWidget *button, - EmpathyAccountSettings *settings) + EmpathyAccountWidget *self) { - empathy_account_settings_apply_async (settings, NULL, NULL); -} - -void -empathy_account_widget_add_apply_button (EmpathyAccountSettings *settings, - GtkWidget *vbox) -{ - GtkWidget *button; - - button = gtk_button_new_from_stock (GTK_STOCK_APPLY); - - gtk_box_pack_end (GTK_BOX (vbox), button, FALSE, FALSE, 3); - - g_signal_connect (button, "clicked", - G_CALLBACK (account_widget_apply_clicked_cb), - settings); - gtk_widget_show (button); -} - -void -empathy_account_widget_add_forget_button (EmpathyAccountSettings *settings, - GtkBuilder *gui, - const gchar *button, - const gchar *entry) -{ - GtkWidget *button_forget; - GtkWidget *entry_password; - const gchar *password = NULL; - - button_forget = GTK_WIDGET (gtk_builder_get_object (gui, button)); - entry_password = GTK_WIDGET (gtk_builder_get_object (gui, entry)); - - password = empathy_account_settings_get_string (settings, "password"); - gtk_widget_set_sensitive (button_forget, !EMP_STR_EMPTY (password)); - - g_signal_connect (button_forget, "clicked", - G_CALLBACK (account_widget_forget_clicked_cb), - entry_password); - g_signal_connect (entry_password, "changed", - G_CALLBACK (account_widget_password_changed_cb), - button_forget); -} - -void -empathy_account_widget_set_default_focus (GtkBuilder *gui, - const gchar *entry) -{ - GObject *default_focus_entry; - - default_focus_entry = gtk_builder_get_object (gui, entry); - g_signal_connect (default_focus_entry, "realize", - G_CALLBACK (gtk_widget_grab_focus), - NULL); + EmpathyAccountWidgetPriv *priv = GET_PRIV (self); + + empathy_account_settings_apply_async (priv->settings, NULL, NULL); } static void -account_widget_setup_generic (EmpathyAccountSettings *settings, - GtkBuilder *builder) +account_widget_setup_generic (EmpathyAccountWidget *self) { GtkWidget *table_common_settings; GtkWidget *table_advanced_settings; + EmpathyAccountWidgetPriv *priv = GET_PRIV (self); - table_common_settings = GTK_WIDGET (gtk_builder_get_object (builder, + table_common_settings = GTK_WIDGET (gtk_builder_get_object (priv->gui, "table_common_settings")); - table_advanced_settings = GTK_WIDGET (gtk_builder_get_object (builder, + table_advanced_settings = GTK_WIDGET (gtk_builder_get_object (priv->gui, "table_advanced_settings")); - accounts_widget_generic_setup (settings, table_common_settings, + accounts_widget_generic_setup (self, table_common_settings, table_advanced_settings); } static void account_widget_settings_ready_cb (EmpathyAccountSettings *settings, - GParamSpec *pspec, gpointer user_data) + GParamSpec *pspec, + gpointer user_data) { - GtkBuilder *builder = GTK_BUILDER (user_data); + EmpathyAccountWidget *self = user_data; + EmpathyAccountWidgetPriv *priv = GET_PRIV (self); - if (empathy_account_settings_is_ready (settings)) - account_widget_setup_generic (settings, builder); + if (empathy_account_settings_is_ready (priv->settings)) + account_widget_setup_generic (self); } -GtkWidget * -empathy_account_widget_generic_new (EmpathyAccountSettings *settings) +static void +account_widget_build_generic (EmpathyAccountWidget *self, + const char *filename) { - GtkBuilder *gui; - GtkWidget *widget; - gchar *filename; - - filename = empathy_file_lookup ("empathy-account-widget-generic.ui", - "libempathy-gtk"); - gui = empathy_builder_get_file (filename, - "vbox_generic_settings", &widget, + EmpathyAccountWidgetPriv *priv = GET_PRIV (self); + priv->gui = empathy_builder_get_file (filename, + "vbox_generic_settings", &self->ui_details->widget, NULL); - if (empathy_account_settings_is_ready (settings)) - account_widget_setup_generic (settings, gui); + if (empathy_account_settings_is_ready (priv->settings)) + account_widget_setup_generic (self); else - g_signal_connect (settings, "notify::ready", - G_CALLBACK (account_widget_settings_ready_cb), gui); - - empathy_account_widget_add_apply_button (settings, widget); - - return g_object_ref (widget); + g_signal_connect (priv->settings, "notify::ready", + G_CALLBACK (account_widget_settings_ready_cb), self); } -GtkWidget * -empathy_account_widget_salut_new (EmpathyAccountSettings *settings) +static void +account_widget_build_salut (EmpathyAccountWidget *self, + const char *filename) { - GtkBuilder *gui; - GtkWidget *widget; - gchar *filename; - - filename = empathy_file_lookup ("empathy-account-widget-salut.ui", - "libempathy-gtk"); - gui = empathy_builder_get_file (filename, - "vbox_salut_settings", &widget, + EmpathyAccountWidgetPriv *priv = GET_PRIV (self); + + priv->gui = empathy_builder_get_file (filename, + "vbox_salut_settings", &self->ui_details->widget, NULL); - g_free (filename); - empathy_account_widget_handle_params (settings, gui, + empathy_account_widget_handle_params (self, "entry_published", "published-name", "entry_nickname", "nickname", "entry_first_name", "first-name", @@ -569,61 +542,44 @@ empathy_account_widget_salut_new (EmpathyAccountSettings *settings) "entry_jid", "jid", NULL); - empathy_account_widget_set_default_focus (gui, "entry_nickname"); - empathy_account_widget_add_apply_button (settings, widget); - - return empathy_builder_unref_and_keep_widget (gui, widget); + self->ui_details->default_focus = g_strdup ("entry_nickname"); } -GtkWidget * -empathy_account_widget_msn_new (EmpathyAccountSettings *settings) +static void +account_widget_build_msn (EmpathyAccountWidget *self, + const char *filename) { - GtkBuilder *gui; - GtkWidget *widget; - gchar *filename; - - filename = empathy_file_lookup ("empathy-account-widget-msn.ui", - "libempathy-gtk"); - gui = empathy_builder_get_file (filename, - "vbox_msn_settings", &widget, + EmpathyAccountWidgetPriv *priv = GET_PRIV (self); + priv->gui = empathy_builder_get_file (filename, + "vbox_msn_settings", &self->ui_details->widget, NULL); - g_free (filename); - empathy_account_widget_handle_params (settings, gui, + empathy_account_widget_handle_params (self, "entry_id", "account", "entry_password", "password", "entry_server", "server", "spinbutton_port", "port", NULL); - empathy_account_widget_add_forget_button (settings, gui, - "button_forget", - "entry_password"); - - empathy_account_widget_set_default_focus (gui, "entry_id"); - - return empathy_builder_unref_and_keep_widget (gui, widget); + self->ui_details->default_focus = g_strdup ("entry_id"); + self->ui_details->add_forget = TRUE; } -GtkWidget * -empathy_account_widget_jabber_new (EmpathyAccountSettings *settings) +static void +account_widget_build_jabber (EmpathyAccountWidget *self, + const char *filename) { - GtkBuilder *gui; - GtkWidget *widget; + EmpathyAccountWidgetPriv *priv = GET_PRIV (self); GtkWidget *spinbutton_port; GtkWidget *checkbutton_ssl; - gchar *filename; - filename = empathy_file_lookup ("empathy-account-widget-jabber.ui", - "libempathy-gtk"); - gui = empathy_builder_get_file (filename, - "vbox_jabber_settings", &widget, + priv->gui = empathy_builder_get_file (filename, + "vbox_jabber_settings", &self->ui_details->widget, "spinbutton_port", &spinbutton_port, "checkbutton_ssl", &checkbutton_ssl, NULL); - g_free (filename); - empathy_account_widget_handle_params (settings, gui, + empathy_account_widget_handle_params (self, "entry_id", "account", "entry_password", "password", "entry_resource", "resource", @@ -635,38 +591,28 @@ empathy_account_widget_jabber_new (EmpathyAccountSettings *settings) "checkbutton_encryption", "require-encryption", NULL); - empathy_account_widget_add_forget_button (settings, gui, - "button_forget", - "entry_password"); - - empathy_account_widget_set_default_focus (gui, "entry_id"); + self->ui_details->default_focus = g_strdup ("entry_id"); + self->ui_details->add_forget = TRUE; + priv->spinbutton_port = spinbutton_port; g_signal_connect (checkbutton_ssl, "toggled", G_CALLBACK (account_widget_jabber_ssl_toggled_cb), - spinbutton_port); - - empathy_account_widget_add_apply_button (settings, widget); - - return empathy_builder_unref_and_keep_widget (gui, widget); + self); } -GtkWidget * -empathy_account_widget_icq_new (EmpathyAccountSettings *settings) +static void +account_widget_build_icq (EmpathyAccountWidget *self, + const char *filename) { - GtkBuilder *gui; - GtkWidget *widget; + EmpathyAccountWidgetPriv *priv = GET_PRIV (self); GtkWidget *spinbutton_port; - gchar *filename; - filename = empathy_file_lookup ("empathy-account-widget-icq.ui", - "libempathy-gtk"); - gui = empathy_builder_get_file (filename, - "vbox_icq_settings", &widget, + priv->gui = empathy_builder_get_file (filename, + "vbox_icq_settings", &self->ui_details->widget, "spinbutton_port", &spinbutton_port, NULL); - g_free (filename); - empathy_account_widget_handle_params (settings, gui, + empathy_account_widget_handle_params (self, "entry_uin", "account", "entry_password", "password", "entry_server", "server", @@ -674,65 +620,44 @@ empathy_account_widget_icq_new (EmpathyAccountSettings *settings) "entry_charset", "charset", NULL); - empathy_account_widget_add_forget_button (settings, gui, - "button_forget", - "entry_password"); - - empathy_account_widget_set_default_focus (gui, "entry_uin"); - - empathy_account_widget_add_apply_button (settings, widget); - - return empathy_builder_unref_and_keep_widget (gui, widget); + self->ui_details->default_focus = g_strdup ("entry_uin"); + self->ui_details->add_forget = TRUE; } -GtkWidget * -empathy_account_widget_aim_new (EmpathyAccountSettings *settings) +static void +account_widget_build_aim (EmpathyAccountWidget *self, + const char *filename) { - GtkBuilder *gui; - GtkWidget *widget; + EmpathyAccountWidgetPriv *priv = GET_PRIV (self); GtkWidget *spinbutton_port; - gchar *filename; - filename = empathy_file_lookup ("empathy-account-widget-aim.ui", - "libempathy-gtk"); - gui = empathy_builder_get_file (filename, - "vbox_aim_settings", &widget, + priv->gui = empathy_builder_get_file (filename, + "vbox_aim_settings", &self->ui_details->widget, "spinbutton_port", &spinbutton_port, NULL); - g_free (filename); - empathy_account_widget_handle_params (settings, gui, + empathy_account_widget_handle_params (self, "entry_screenname", "account", "entry_password", "password", "entry_server", "server", "spinbutton_port", "port", NULL); - empathy_account_widget_add_forget_button (settings, gui, - "button_forget", - "entry_password"); - - empathy_account_widget_set_default_focus (gui, "entry_screenname"); - empathy_account_widget_add_apply_button (settings, widget); - - return empathy_builder_unref_and_keep_widget (gui, widget); + self->ui_details->default_focus = g_strdup ("entry_screenname"); + self->ui_details->add_forget = TRUE; } -GtkWidget * -empathy_account_widget_yahoo_new (EmpathyAccountSettings *settings) +static void +account_widget_build_yahoo (EmpathyAccountWidget *self, + const char *filename) { - GtkBuilder *gui; - GtkWidget *widget; - gchar *filename; + EmpathyAccountWidgetPriv *priv = GET_PRIV (self); - filename = empathy_file_lookup ("empathy-account-widget-yahoo.ui", - "libempathy-gtk"); - gui = empathy_builder_get_file (filename, - "vbox_yahoo_settings", &widget, + priv->gui = empathy_builder_get_file (filename, + "vbox_yahoo_settings", &self->ui_details->widget, NULL); - g_free (filename); - empathy_account_widget_handle_params (settings, gui, + empathy_account_widget_handle_params (self, "entry_id", "account", "entry_password", "password", "entry_server", "server", @@ -743,44 +668,209 @@ empathy_account_widget_yahoo_new (EmpathyAccountSettings *settings) "checkbutton_ignore_invites", "ignore-invites", NULL); - empathy_account_widget_add_forget_button (settings, gui, - "button_forget", - "entry_password"); - - empathy_account_widget_set_default_focus (gui, "entry_id"); - empathy_account_widget_add_apply_button (settings, widget); - - return empathy_builder_unref_and_keep_widget (gui, widget); + self->ui_details->default_focus = g_strdup ("entry_id"); + self->ui_details->add_forget = TRUE; } -GtkWidget * -empathy_account_widget_groupwise_new (EmpathyAccountSettings *settings) +static void +account_widget_build_groupwise (EmpathyAccountWidget *self, + const char *filename) { - GtkBuilder *gui; - GtkWidget *widget; - gchar *filename; + EmpathyAccountWidgetPriv *priv = GET_PRIV (self); - filename = empathy_file_lookup ("empathy-account-widget-groupwise.ui", - "libempathy-gtk"); - gui = empathy_builder_get_file (filename, - "vbox_groupwise_settings", &widget, - NULL); - g_free (filename); + priv->gui = empathy_builder_get_file (filename, + "vbox_groupwise_settings", &self->ui_details->widget, + NULL); - empathy_account_widget_handle_params (settings, gui, + empathy_account_widget_handle_params (self, "entry_id", "account", "entry_password", "password", "entry_server", "server", "spinbutton_port", "port", NULL); - empathy_account_widget_add_forget_button (settings, gui, - "button_forget", - "entry_password"); + self->ui_details->default_focus = g_strdup ("entry_id"); + self->ui_details->add_forget = TRUE; +} - empathy_account_widget_set_default_focus (gui, "entry_id"); - empathy_account_widget_add_apply_button (settings, widget); +static void +do_set_property (GObject *object, + guint prop_id, + const GValue *value, + GParamSpec *pspec) +{ + EmpathyAccountWidgetPriv *priv = GET_PRIV (object); + + switch (prop_id) { + case PROP_PROTOCOL: + priv->protocol = g_value_dup_string (value); + break; + case PROP_SETTINGS: + priv->settings = g_value_dup_object (value); + break; + default: + G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec); + } +} + +static void +do_get_property (GObject *object, + guint prop_id, + GValue *value, + GParamSpec *pspec) +{ + EmpathyAccountWidgetPriv *priv = GET_PRIV (object); + + switch (prop_id) { + case PROP_PROTOCOL: + g_value_set_string (value, priv->protocol); + break; + case PROP_SETTINGS: + g_value_set_object (value, priv->settings); + break; + default: + G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec); + } +} + +static void +do_constructed (GObject *obj) +{ + EmpathyAccountWidget *self = EMPATHY_ACCOUNT_WIDGET (obj); + EmpathyAccountWidgetPriv *priv = GET_PRIV (self); + char *uiname, *filename; + + uiname = g_strconcat ("empathy-account-widget-", priv->protocol, + ".ui", NULL); + filename = empathy_file_lookup (uiname, "libempathy-gtk"); + + if (!tp_strdiff (priv->protocol, "local-xmpp")) + account_widget_build_salut (self, filename); + else if (!tp_strdiff (priv->protocol, "msn")) + account_widget_build_msn (self, filename); + else if (!tp_strdiff (priv->protocol, "jabber")) + account_widget_build_jabber (self, filename); + else if (!tp_strdiff (priv->protocol, "icq")) + account_widget_build_icq (self, filename); + else if (!tp_strdiff (priv->protocol, "aim")) + account_widget_build_aim (self, filename); + else if (!tp_strdiff (priv->protocol, "yahoo")) + account_widget_build_yahoo (self, filename); + else if (!tp_strdiff (priv->protocol, "groupwise")) + account_widget_build_groupwise (self, filename); + else if (!tp_strdiff (priv->protocol, "irc")) + empathy_account_widget_irc_build (self, filename); + else if (!tp_strdiff (priv->protocol, "sip")) + empathy_account_widget_sip_build (self, filename); + else + account_widget_build_generic (self, filename); + + g_free (uiname); + g_free (filename); + + /* handle default focus */ + if (self->ui_details->default_focus != NULL) + { + GObject *default_focus_entry; + + default_focus_entry = gtk_builder_get_object + (priv->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 (priv->gui, "button_forget")); + priv->entry_password = GTK_WIDGET (gtk_builder_get_object (priv->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 button */ + priv->apply_button = gtk_button_new_from_stock (GTK_STOCK_APPLY); + gtk_box_pack_end (GTK_BOX (self->ui_details->widget), priv->apply_button, FALSE, FALSE, 3); + + g_signal_connect (priv->apply_button, "clicked", + G_CALLBACK (account_widget_apply_clicked_cb), + self); + gtk_widget_show (priv->apply_button); +} + +static void +empathy_account_widget_class_init (EmpathyAccountWidgetClass *klass) +{ + GObjectClass *oclass = G_OBJECT_CLASS (klass); + GParamSpec *param_spec; + + oclass->get_property = do_get_property; + oclass->set_property = do_set_property; + oclass->constructed = do_constructed; + + param_spec = g_param_spec_string ("protocol", + "protocol", "The protocol of the account", + NULL, + G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS | G_PARAM_CONSTRUCT_ONLY); + g_object_class_install_property (oclass, PROP_PROTOCOL, param_spec); + + param_spec = g_param_spec_object ("settings", + "settings", "The settings of the account", + EMPATHY_TYPE_ACCOUNT_SETTINGS, + G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS | G_PARAM_CONSTRUCT_ONLY); + g_object_class_install_property (oclass, PROP_SETTINGS, param_spec); + + g_type_class_add_private (klass, sizeof (EmpathyAccountWidgetPriv)); +} - return empathy_builder_unref_and_keep_widget (gui, widget); +static void +empathy_account_widget_init (EmpathyAccountWidget *self) +{ + EmpathyAccountWidgetPriv *priv = + G_TYPE_INSTANCE_GET_PRIVATE ((self), EMPATHY_TYPE_ACCOUNT_WIDGET, + EmpathyAccountWidgetPriv); + + self->priv = priv; + self->ui_details = g_slice_new0 (EmpathyAccountWidgetUIDetails); } +void +empathy_account_widget_handle_params (EmpathyAccountWidget *self, + const gchar *first_widget, + ...) +{ + va_list args; + + va_start (args, first_widget); + account_widget_handle_params_valist (self, first_widget, args); + va_end (args); +} + +GtkWidget * +empathy_account_widget_new_for_protocol (const char *protocol, + EmpathyAccountSettings *settings) +{ + EmpathyAccountWidget *self; + EmpathyAccountWidgetPriv *priv; + + g_return_val_if_fail (EMPATHY_IS_ACCOUNT_SETTINGS (settings), NULL); + g_return_val_if_fail (settings != NULL, NULL); + + self = g_object_new + (EMPATHY_TYPE_ACCOUNT_WIDGET, "protocol", protocol, + "settings", settings, NULL); + priv = GET_PRIV (self); + + return self->ui_details->widget; +} \ No newline at end of file -- cgit v1.2.3