git.maemo.org Git - modest/blob - src/hildon/modest-ui-account-setup.c

   1 /* modest-ui-wizard.c */
   2
   3 /* insert (c)/licensing information) */
   4
   5 #include <gtk/gtk.h>
   6 #include <glade/glade.h>
   7 #include <glib/gi18n.h>
   8 #include <string.h>
   9
  10 #ifdef HAVE_CONFIG_H
  11 #include <config.h>
  12 #endif /*HAVE_CONFIG_H*/
  13
  14 #include "../modest-account-mgr.h"
  15 #include "../modest-identity-mgr.h"
  16
  17 #include "modest-ui-glade.h"
  18 #include "modest-ui-account-setup.h"
  19
  20 enum {
  21         IDENTITY_NAME,
  22         IDENTITY_ADDRESS,
  23         IDENTITY_VIA,
  24         IDENTITY_COLUMNS
  25 };
  26
  27 enum {
  28         ACCOUNT_NAME,
  29         ACCOUNT_HOST,
  30         ACCOUNT_COLUMNS
  31 };
  32
  33 typedef struct _CallbackData CallbackData;
  34
  35 struct _CallbackData {
  36         GtkWidget       *id_tree_view;
  37         GtkWidget       *acc_tree_view;
  38         ModestUI        *modest_ui;
  39         GladeXML        *glade_xml;
  40 };
  41
  42 static void
  43 identity_setup_dialog (ModestUI *, GtkListStore *, gchar *);
  44
  45 static void
  46 missing_notification(GtkWindow *, gchar *);
  47
  48 /* CALLBACKS */
  49
  50 static void
  51 edit_action(GtkWidget *button,
  52             gpointer userdata)
  53 {
  54         CallbackData *cb_data;
  55         GtkListStore *acc_liststore;
  56         GtkTreeModel *id_liststore;
  57         GtkTreeSelection *selection;
  58         GtkTreeIter selected_iter;
  59         gchar *identity_name;
  60
  61         cb_data = (CallbackData *) userdata;
  62         selection = gtk_tree_view_get_selection (GTK_TREE_VIEW(cb_data->id_tree_view));
  63
  64         gtk_tree_selection_get_selected(selection,
  65                                         &id_liststore,
  66                                         &selected_iter);
  67         gtk_tree_model_get(GTK_TREE_MODEL(id_liststore),
  68                            &selected_iter,
  69                            ACCOUNT_NAME, &identity_name,
  70                            -1);
  71         acc_liststore=GTK_LIST_STORE(gtk_tree_view_get_model (GTK_TREE_VIEW(cb_data->acc_tree_view)));
  72
  73         identity_setup_dialog (cb_data->modest_ui, acc_liststore, identity_name);
  74         g_free(identity_name);
  75 }
  76
  77 static void
  78 create_action(GtkWidget *button,
  79               gpointer userdata)
  80 {
  81         CallbackData *cb_data;
  82         GtkListStore *acc_liststore;
  83
  84         cb_data = (CallbackData *) userdata;
  85
  86         acc_liststore=GTK_LIST_STORE(gtk_tree_view_get_model (GTK_TREE_VIEW(cb_data->acc_tree_view)));
  87
  88         identity_setup_dialog(cb_data->modest_ui, acc_liststore, NULL);
  89 }
  90
  91 static void
  92 delete_action(GtkWidget *button,
  93               gpointer userdata)
  94 {
  95         CallbackData *cb_data;
  96         GtkTreeSelection *selection;
  97         GtkTreeIter selected_iter;
  98         GtkTreeModel *id_liststore;
  99         gchar *identity_name;
 100         GtkWidget *confirmation_dialog;
 101         GtkWidget *confirmation_message;
 102         gint result;
 103
 104         cb_data = (CallbackData *) userdata;
 105         selection = gtk_tree_view_get_selection (GTK_TREE_VIEW(cb_data->id_tree_view));
 106
 107         gtk_tree_selection_get_selected(selection,
 108                                         &id_liststore,
 109                                         &selected_iter);
 110         gtk_tree_model_get(GTK_TREE_MODEL(id_liststore),
 111                            &selected_iter,
 112                            ACCOUNT_NAME, &identity_name,
 113                            -1);
 114
 115         confirmation_dialog = gtk_dialog_new_with_buttons ("Confirm removal of identity",
 116                                                            GTK_WINDOW(gtk_widget_get_toplevel(button)),
 117                                                            GTK_DIALOG_MODAL | GTK_DIALOG_DESTROY_WITH_PARENT,
 118                                                            GTK_STOCK_OK,
 119                                                            GTK_RESPONSE_OK,
 120                                                            GTK_STOCK_CANCEL,
 121                                                            GTK_RESPONSE_CANCEL,
 122                                                            NULL);
 123
 124         gchar *messy = g_strdup_printf("Remove selected identity '%s'?", identity_name);
 125         confirmation_message = gtk_label_new_with_mnemonic (messy);
 126
 127         gtk_container_add(GTK_CONTAINER(confirmation_dialog),
 128                           confirmation_message);
 129
 130         gtk_widget_show_all(confirmation_dialog);
 131
 132         result=gtk_dialog_run(GTK_DIALOG(confirmation_dialog));
 133         if (result==GTK_RESPONSE_OK)
 134         {
 135                 modest_identity_mgr_remove_identity(MODEST_UI_GET_PRIVATE(cb_data->modest_ui)->modest_id_mgr,
 136                                                     identity_name,
 137                                                     NULL);
 138         }
 139         gtk_widget_destroy(confirmation_dialog);
 140         g_free(identity_name);
 141         g_free(messy);
 142
 143 }
 144
 145 static void
 146 activate_buttons_on_identity(GtkTreeView *tree_view,
 147                              gpointer user_data)
 148 {
 149         GtkWidget *button;
 150         GladeXML *glade_xml;
 151
 152         glade_xml=(GladeXML *) user_data;
 153
 154         button = glade_xml_get_widget(GLADE_XML(glade_xml), "IdentityEditButton");
 155         gtk_widget_set_sensitive(GTK_WIDGET(button), TRUE);
 156         button = glade_xml_get_widget(GLADE_XML(glade_xml), "IdentityDeleteButton");
 157         gtk_widget_set_sensitive(GTK_WIDGET(button), TRUE);
 158 }
 159
 160 static void
 161 use_sig_toggled(GtkToggleButton *button,
 162                 gpointer userdata) {
 163
 164         GtkWidget *awidget;
 165         GladeXML *glade_xml = (GladeXML *) userdata;
 166
 167         awidget=glade_xml_get_widget(glade_xml, "ISSignatureTextView");
 168         gtk_widget_set_sensitive(awidget, gtk_toggle_button_get_active(button));
 169 }
 170
 171 /* METHODS */
 172
 173 static void
 174 missing_notification(GtkWindow *parent, gchar *info_message) {
 175         GtkWidget *DenyDialog;
 176
 177         DenyDialog=gtk_message_dialog_new(parent,
 178                                           GTK_DIALOG_MODAL,
 179                                           GTK_MESSAGE_INFO,
 180                                           GTK_BUTTONS_OK,
 181                                           "%s",
 182                                           info_message);
 183
 184         gtk_dialog_run(GTK_DIALOG(DenyDialog));
 185
 186         gtk_widget_destroy(DenyDialog);
 187 }
 188
 189 static gboolean
 190 add_identity(GladeXML *glade_xml, ModestUI *modest_ui, GtkListStore *accounts_model)
 191 {
 192         gchar *reply_to;
 193         GtkTextBuffer *sigbuff;
 194         gchar *signature;
 195         GtkTextIter start_iter;
 196         GtkTextIter end_iter;
 197         GtkTreeIter transport_iter;
 198         ModestUIPrivate *priv;
 199         gchar *transport;
 200         gint retval;
 201
 202         priv = MODEST_UI_GET_PRIVATE(MODEST_UI(modest_ui));
 203
 204         reply_to = g_strdup_printf("%s", gtk_entry_get_text(GTK_ENTRY(glade_xml_get_widget(glade_xml, "ISReplyToEntry"))));
 205
 206         if (gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(glade_xml_get_widget(glade_xml, "ISUseSignatureCheckButton"))))
 207         {
 208                 sigbuff = gtk_text_view_get_buffer(GTK_TEXT_VIEW(glade_xml_get_widget(glade_xml, "ISSignatureTextView")));
 209                 gtk_text_buffer_get_bounds(sigbuff,
 210                                            &start_iter,
 211                                            &end_iter);
 212                 signature = gtk_text_buffer_get_text(sigbuff,
 213                                                      &start_iter,
 214                                                      &end_iter,
 215                                                      FALSE);
 216         }
 217         else
 218                 signature = NULL;
 219
 220         if (gtk_combo_box_get_active_iter(GTK_COMBO_BOX(glade_xml_get_widget(glade_xml, "ISOutServerComboBox")), &transport_iter)) {
 221                 gtk_tree_model_get(GTK_TREE_MODEL(accounts_model),
 222                                    &transport_iter,
 223                                    ACCOUNT_NAME, &transport,
 224                                    -1);
 225         }
 226         else {
 227                 missing_notification(NULL, "Please select an outgoing server!");
 228                 return FALSE;
 229         }
 230
 231         if (modest_identity_mgr_add_identity (priv->modest_id_mgr,
 232                                               gtk_entry_get_text(GTK_ENTRY(glade_xml_get_widget(glade_xml, "ISIdentityEntry"))),
 233                                               gtk_entry_get_text(GTK_ENTRY(glade_xml_get_widget(glade_xml, "ISNameEntry"))),
 234                                               gtk_entry_get_text(GTK_ENTRY(glade_xml_get_widget(glade_xml, "ISEMailAddress"))),
 235                                               reply_to,
 236                                               signature,
 237                                               gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(glade_xml_get_widget(glade_xml, "ISUseSignatureCheckButton"))),
 238                                               transport,
 239                                               FALSE ))
 240                 retval=TRUE;
 241         else
 242                 retval=FALSE;
 243         g_free(transport);
 244         return retval;
 245 }
 246
 247 static void
 248 identity_setup_dialog (ModestUI *modest_ui, GtkListStore *accounts_model, gchar *identity)
 249 {
 250
 251         GladeXML *glade_xml;
 252         GtkWidget *id_dialog;
 253         GtkWidget *outgoing_server;
 254         GtkWidget *awidget;
 255         GtkCellRenderer *renderer;
 256         ModestIdentityMgr *id_mgr;
 257         GtkTextBuffer *sigbuff;
 258         gchar *tmptext;
 259         gint account_added_successfully;
 260         gint result;
 261
 262         glade_xml = glade_xml_new(MODEST_GLADE, "IdentitySetupDialog", NULL);
 263         id_dialog = glade_xml_get_widget(glade_xml, "IdentitySetupDialog");
 264
 265         outgoing_server = glade_xml_get_widget(glade_xml, "ISOutServerComboBox");
 266         gtk_combo_box_set_model(GTK_COMBO_BOX(outgoing_server), GTK_TREE_MODEL(accounts_model));
 267         renderer = gtk_cell_renderer_text_new ();
 268         gtk_cell_layout_pack_start (GTK_CELL_LAYOUT (outgoing_server), renderer, TRUE);
 269         gtk_cell_layout_set_attributes (GTK_CELL_LAYOUT (outgoing_server), renderer,
 270                                         "text", 0,
 271                                         NULL);
 272         awidget=glade_xml_get_widget(glade_xml, "ISUseSignatureCheckButton");
 273         g_signal_connect(awidget,
 274                          "toggled",
 275                          G_CALLBACK(use_sig_toggled),
 276                          glade_xml);
 277
 278         if (identity!=NULL) {
 279                 id_mgr = MODEST_UI_GET_PRIVATE(modest_ui)->modest_id_mgr;
 280
 281                 awidget=glade_xml_get_widget(glade_xml, "ISIdentityEntry");
 282                 gtk_widget_set_sensitive(awidget, FALSE);
 283                 gtk_entry_set_text(GTK_ENTRY(awidget), identity);
 284                 tmptext = modest_identity_mgr_get_identity_string(id_mgr,
 285                                                                   identity,
 286                                                                   MODEST_IDENTITY_EMAIL,
 287                                                                   NULL);
 288                 awidget=glade_xml_get_widget(glade_xml, "ISEMailAddress");
 289                 gtk_entry_set_text(GTK_ENTRY(awidget), tmptext);
 290                 g_free(tmptext);
 291
 292                 if (modest_identity_mgr_get_identity_bool(id_mgr,
 293                                                           identity,
 294                                                           MODEST_IDENTITY_USE_SIGNATURE,
 295                                                           NULL)) {
 296                         awidget=glade_xml_get_widget(glade_xml, "ISUseSignatureCheckButton");
 297                         gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(awidget), TRUE);
 298                         awidget=glade_xml_get_widget(glade_xml, "ISSignatureTextView");
 299                         gtk_widget_set_sensitive(awidget, TRUE);
 300                 }
 301
 302                 sigbuff=gtk_text_buffer_new(NULL);
 303                 tmptext = modest_identity_mgr_get_identity_string(id_mgr,
 304                                                                   identity,
 305                                                                   MODEST_IDENTITY_SIGNATURE,
 306                                                                   NULL),
 307                 gtk_text_buffer_set_text(sigbuff, tmptext, -1);
 308                 gtk_text_view_set_buffer(GTK_TEXT_VIEW(glade_xml_get_widget(glade_xml, "ISSignatureTextView")),
 309                                                        sigbuff);
 310                 g_object_unref(sigbuff);
 311                 g_free(tmptext);
 312
 313                 tmptext = modest_identity_mgr_get_identity_string(id_mgr,
 314                                                                   identity,
 315                                                                   MODEST_IDENTITY_EMAIL,
 316                                                                   NULL);
 317                 awidget=glade_xml_get_widget(glade_xml, "ISEMailAddress");
 318                 gtk_entry_set_text(GTK_ENTRY(awidget), tmptext);
 319                 g_free(tmptext);
 320
 321                 tmptext = modest_identity_mgr_get_identity_string(id_mgr,
 322                                                                   identity,
 323                                                                   MODEST_IDENTITY_REALNAME,
 324                                                                   NULL);
 325                 awidget=glade_xml_get_widget(glade_xml, "ISNameEntry");
 326                 gtk_entry_set_text(GTK_ENTRY(awidget), tmptext);
 327                 g_free(tmptext);
 328
 329                 tmptext = modest_identity_mgr_get_identity_string(id_mgr,
 330                                                                   identity,
 331                                                                   MODEST_IDENTITY_REALNAME,
 332                                                                   NULL);
 333                 awidget=glade_xml_get_widget(glade_xml, "ISNameEntry");
 334                 gtk_entry_set_text(GTK_ENTRY(awidget), tmptext);
 335
 336                 g_free(tmptext);
 337
 338                 tmptext = modest_identity_mgr_get_identity_string(id_mgr,
 339                                                                   identity,
 340                                                                   MODEST_IDENTITY_REPLYTO,
 341                                                                   NULL);
 342                 awidget=glade_xml_get_widget(glade_xml, "ISReplyToEntry");
 343                 gtk_entry_set_text(GTK_ENTRY(awidget), tmptext);
 344
 345                 g_free(tmptext);
 346         }
 347
 348         gtk_widget_show_all(id_dialog);
 349
 350         do {
 351                 result=gtk_dialog_run(GTK_DIALOG(id_dialog));
 352
 353                 switch (result) {
 354                 case GTK_RESPONSE_OK:
 355                         account_added_successfully = add_identity(glade_xml, modest_ui, accounts_model);
 356                         break;
 357                 default:
 358                         account_added_successfully = FALSE;
 359                         break;
 360                 }
 361         } while(result!=GTK_RESPONSE_DELETE_EVENT && result!=GTK_RESPONSE_CANCEL && account_added_successfully!=TRUE);
 362
 363         gtk_widget_destroy(id_dialog);
 364         g_object_unref(glade_xml);
 365 }
 366
 367
 368 static CallbackData *
 369 setup_callback_data(GtkWidget *id_tree_view,
 370                     GtkWidget *acc_tree_view,
 371                     ModestUI *modest_ui)
 372 {
 373         CallbackData *self;
 374         self = g_malloc(sizeof(CallbackData));
 375         self->modest_ui=modest_ui;
 376         self->id_tree_view=id_tree_view;
 377         self->acc_tree_view=acc_tree_view;
 378         return self;
 379 }
 380
 381 static void
 382 free_callback_data(CallbackData *data)
 383 {
 384         g_free(data);
 385 }
 386
 387 static GtkTreeModel *
 388 create_identities_model(ModestIdentityMgr *id_mgr) {
 389
 390         GSList *id_names_list;
 391         GSList *id_names_list_iter;
 392         GtkListStore *id_list_store;
 393         GtkTreeIter id_list_store_iter;
 394         gchar *tmptext1;
 395         gchar *tmptext2;
 396
 397         id_names_list = modest_identity_mgr_identity_names(id_mgr, NULL);
 398         id_list_store = gtk_list_store_new(IDENTITY_COLUMNS, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_STRING);
 399
 400         for (id_names_list_iter=id_names_list;
 401              id_names_list_iter!=NULL;
 402              id_names_list_iter=g_slist_next(id_names_list_iter)) {
 403                 gtk_list_store_append(id_list_store, &id_list_store_iter);
 404                 tmptext1=modest_identity_mgr_get_identity_string(id_mgr,
 405                                                                  id_names_list_iter->data,
 406                                                                  MODEST_IDENTITY_EMAIL,
 407                                                                  NULL);
 408                 tmptext2=modest_identity_mgr_get_identity_string(id_mgr,
 409                                                                  id_names_list_iter->data,
 410                                                                  MODEST_IDENTITY_ID_VIA,
 411                                                                  NULL);
 412                 gtk_list_store_set(id_list_store, &id_list_store_iter,
 413                                    IDENTITY_NAME, id_names_list_iter->data,
 414                                    IDENTITY_ADDRESS, tmptext1,
 415                                    IDENTITY_VIA, tmptext2,
 416                                    -1);
 417                 g_free(tmptext1);
 418                 g_free(tmptext2);
 419         }
 420
 421         g_slist_free(id_names_list);
 422
 423         return GTK_TREE_MODEL(id_list_store);
 424 }
 425
 426 static GtkTreeModel *
 427 create_accounts_model(ModestAccountMgr *acc_mgr) {
 428
 429         GSList *acc_names_list;
 430         GSList *acc_names_list_iter;
 431         GtkListStore *acc_list_store;
 432         GtkTreeIter acc_list_store_iter;
 433         gchar *tmptext;
 434
 435         acc_names_list = modest_account_mgr_server_account_names(acc_mgr,
 436                                                                  NULL,
 437                                                                  MODEST_PROTO_TYPE_ANY,
 438                                                                  NULL,
 439                                                                  FALSE);
 440         acc_list_store = gtk_list_store_new(ACCOUNT_COLUMNS, G_TYPE_STRING, G_TYPE_STRING);
 441
 442         for (acc_names_list_iter=acc_names_list;
 443              acc_names_list_iter!=NULL;
 444              acc_names_list_iter=g_slist_next(acc_names_list_iter)) {
 445                 gtk_list_store_append(acc_list_store, &acc_list_store_iter);
 446                 tmptext=modest_account_mgr_get_server_account_string(acc_mgr,
 447                                                                      acc_names_list_iter->data,
 448                                                                      MODEST_ACCOUNT_HOSTNAME,
 449                                                                      NULL);
 450                 gtk_list_store_set(acc_list_store, &acc_list_store_iter,
 451                                    ACCOUNT_NAME, acc_names_list_iter->data,
 452                                    ACCOUNT_HOST, tmptext,
 453                                    -1);
 454                 g_free(tmptext);
 455         }
 456
 457         g_slist_free(acc_names_list);
 458
 459         return GTK_TREE_MODEL(acc_list_store);
 460 }
 461
 462
 463 static void
 464 accounts_and_identities_dialog (gpointer user_data)
 465 {
 466         GladeXML *glade_xml;
 467         GtkWidget *main_dialog;
 468         GtkWidget *identities_tree_view;
 469         GtkWidget *accounts_tree_view;
 470         GtkTreeModel *identities_model;
 471         GtkTreeModel *accounts_model;
 472         ModestUI *modest_ui;
 473         ModestUIPrivate *priv;
 474         gint retval;
 475         GtkCellRenderer *renderer;
 476         GtkTreeViewColumn *column;
 477         CallbackData *cb_data;
 478         GtkWidget *abutton;
 479
 480         g_return_if_fail(MODEST_IS_UI(user_data));
 481         modest_ui = (ModestUI *) user_data;
 482         priv = MODEST_UI_GET_PRIVATE(modest_ui);
 483
 484         glade_xml = glade_xml_new(MODEST_GLADE, "IdentitiesAndAccountsDialog", NULL);
 485         main_dialog = glade_xml_get_widget(glade_xml, "IdentitiesAndAccountsDialog");
 486
 487         /* Accounts */
 488         accounts_tree_view = glade_xml_get_widget(glade_xml, "AccountsTreeview");
 489         accounts_model=create_accounts_model(priv->modest_acc_mgr);
 490         gtk_tree_view_set_model(GTK_TREE_VIEW(accounts_tree_view), accounts_model);
 491         /* Account -> Accountname */
 492         renderer = gtk_cell_renderer_text_new ();
 493         column = gtk_tree_view_column_new_with_attributes ("Account",
 494                                                            renderer,
 495                                                            "text", ACCOUNT_NAME,
 496                                                            NULL);
 497         gtk_tree_view_append_column (GTK_TREE_VIEW(accounts_tree_view), column);
 498         /* Account -> Hostname */
 499         renderer = gtk_cell_renderer_text_new ();
 500         column = gtk_tree_view_column_new_with_attributes ("Hostname",
 501                                                            renderer,
 502                                                            "text", ACCOUNT_HOST,
 503                                                            NULL);
 504         gtk_tree_view_append_column (GTK_TREE_VIEW(accounts_tree_view), column);
 505
 506         /* Identities */
 507         identities_tree_view = glade_xml_get_widget(glade_xml, "IdentitiesTreeview");
 508         identities_model=create_identities_model(priv->modest_id_mgr);
 509         gtk_tree_view_set_model(GTK_TREE_VIEW(identities_tree_view), identities_model);
 510
 511         /* Identities -> Identityname */
 512         renderer = gtk_cell_renderer_text_new ();
 513         column = gtk_tree_view_column_new_with_attributes ("Identity",
 514                                                            renderer,
 515                                                            "text", IDENTITY_NAME,
 516                                                            NULL);
 517         gtk_tree_view_append_column (GTK_TREE_VIEW(identities_tree_view), column);
 518
 519         /* Identities -> E-mail address */
 520         renderer = gtk_cell_renderer_text_new ();
 521         column = gtk_tree_view_column_new_with_attributes ("E-mail address",
 522                                                            renderer,
 523                                                            "text", IDENTITY_ADDRESS,
 524                                                            NULL);
 525         gtk_tree_view_append_column (GTK_TREE_VIEW(identities_tree_view), column);
 526
 527         /* Identities -> Relay */
 528         renderer = gtk_cell_renderer_text_new ();
 529         column = gtk_tree_view_column_new_with_attributes ("Transport",
 530                                                            renderer,
 531                                                            "text", IDENTITY_VIA,
 532                                                            NULL);
 533         gtk_tree_view_append_column (GTK_TREE_VIEW(identities_tree_view), column);
 534
 535         cb_data=setup_callback_data(identities_tree_view, accounts_tree_view, modest_ui);
 536
 537         abutton=glade_xml_get_widget(glade_xml, "IdentityCreateButton");
 538         g_signal_connect(abutton,
 539                          "clicked",
 540                          G_CALLBACK(create_action),
 541                          cb_data);
 542         abutton=glade_xml_get_widget(glade_xml, "IdentityEditButton");
 543         g_signal_connect(abutton,
 544                          "clicked",
 545                          G_CALLBACK(edit_action),
 546                          cb_data);
 547         abutton=glade_xml_get_widget(glade_xml, "IdentityDeleteButton");
 548         g_signal_connect(abutton,
 549                          "clicked",
 550                          G_CALLBACK(delete_action),
 551                          cb_data);
 552
 553         /* FIXME: the edit/delete buttons are sensitive by default
 554          * but we have no selection by default.
 555          */
 556
 557         activate_buttons_on_identity(NULL, glade_xml);
 558
 559         gtk_widget_show_all(GTK_WIDGET(main_dialog));
 560
 561         retval=gtk_dialog_run(GTK_DIALOG(main_dialog));
 562
 563         gtk_widget_destroy(GTK_WIDGET(main_dialog));
 564         g_object_unref(accounts_model);
 565         g_object_unref(identities_model);
 566         free_callback_data(cb_data);
 567         g_object_unref(glade_xml);
 568 }
 569
 570 void account_settings (GtkWidget *widget,
 571                        gpointer user_data)
 572 {
 573         accounts_and_identities_dialog (MODEST_UI(user_data));
 574 }
 575