git.maemo.org Git - modest/blob - src/gtk/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_PROT,
  31         ACCOUNT_COLUMNS
  32 };
  33
  34 typedef struct _CallbackData CallbackData;
  35
  36 struct _CallbackData {
  37         GtkTreeView     *id_tree_view;
  38         GtkTreeView     *acc_tree_view;
  39         ModestUI        *modest_ui;
  40         GladeXML        *glade_xml;
  41 };
  42
  43 static void
  44 identity_setup_dialog (ModestUI *, GtkTreeModel *, gchar *);
  45
  46 static void
  47 account_setup_dialog (ModestUI *, gchar *);
  48
  49 static void
  50 missing_notification(GtkWindow *, gchar *);
  51
  52 static GtkTreeModel *
  53 create_identities_model(ModestIdentityMgr *);
  54
  55 static GtkTreeModel *
  56 create_accounts_model(ModestAccountMgr *);
  57
  58 static void
  59 refresh_identities(ModestIdentityMgr *,
  60                    GladeXML *);
  61
  62 static void
  63 refresh_accounts(ModestAccountMgr *, GladeXML *glade_xml);
  64
  65 /* CALLBACKS */
  66
  67 static gboolean
  68 filter_transports (GtkTreeModel *model,
  69                    GtkTreeIter *iter,
  70                    gpointer userdata) {
  71
  72         gchar *name;
  73         gboolean retval;
  74
  75         gtk_tree_model_get(model,
  76                            iter,
  77                            ACCOUNT_PROT, &name,
  78                            -1);
  79
  80         retval = strcasecmp(name, "SMTP")==0;
  81         g_free(name);
  82         return retval;
  83 }
  84
  85
  86 static void
  87 account_edit_action(GtkWidget *button,
  88                     gpointer userdata) {
  89
  90         CallbackData *cb_data;
  91         GtkTreeModel *acc_liststore;
  92         GtkTreeSelection *selection;
  93         GtkTreeIter selected_iter;
  94         gchar *account_name;
  95
  96         cb_data = (CallbackData *) userdata;
  97         selection = gtk_tree_view_get_selection (GTK_TREE_VIEW(cb_data->acc_tree_view));
  98
  99         gtk_tree_selection_get_selected(selection,
 100                                         &acc_liststore,
 101                                         &selected_iter);
 102         gtk_tree_model_get(GTK_TREE_MODEL(acc_liststore),
 103                            &selected_iter,
 104                            ACCOUNT_NAME, &account_name,
 105                            -1);
 106
 107         account_setup_dialog (cb_data->modest_ui, account_name);
 108         g_free(account_name);
 109 }
 110
 111 static void
 112 account_create_action(GtkWidget *button,
 113                       gpointer userdata) {
 114         CallbackData *cb_data;
 115
 116         cb_data = (CallbackData *) userdata;
 117
 118         account_setup_dialog(cb_data->modest_ui, NULL);
 119 }
 120
 121 static void
 122 account_delete_action(GtkWidget *button,
 123                       gpointer userdata) {
 124         CallbackData *cb_data;
 125         GtkTreeSelection *selection;
 126         GtkTreeIter selected_iter;
 127         GtkTreeModel *acc_liststore;
 128         GtkWidget *confirmation_dialog;
 129         GtkWidget *confirmation_message;
 130         ModestUIPrivate *priv;
 131         gchar *account_name;
 132         gchar *message;
 133         gint result;
 134
 135         cb_data = (CallbackData *) userdata;
 136         priv = MODEST_UI_GET_PRIVATE(cb_data->modest_ui);
 137         selection = gtk_tree_view_get_selection (GTK_TREE_VIEW(cb_data->acc_tree_view));
 138
 139         gtk_tree_selection_get_selected(selection,
 140                                         &acc_liststore,
 141                                         &selected_iter);
 142         gtk_tree_model_get(GTK_TREE_MODEL(acc_liststore),
 143                            &selected_iter,
 144                            ACCOUNT_NAME, &account_name,
 145                            -1);
 146
 147         confirmation_dialog = gtk_dialog_new_with_buttons ("Confirm removal of account",
 148                                                            GTK_WINDOW(gtk_widget_get_toplevel(button)),
 149                                                            GTK_DIALOG_MODAL | GTK_DIALOG_DESTROY_WITH_PARENT,
 150                                                            GTK_STOCK_OK,
 151                                                            GTK_RESPONSE_OK,
 152                                                            GTK_STOCK_CANCEL,
 153                                                            GTK_RESPONSE_CANCEL,
 154                                                            NULL);
 155
 156         message = g_strdup_printf("Remove selected account '%s'?", account_name);
 157         confirmation_message = gtk_label_new_with_mnemonic (message);
 158
 159         gtk_box_pack_start(GTK_BOX(GTK_DIALOG(confirmation_dialog)->vbox), confirmation_message, FALSE, FALSE, 10);
 160
 161         gtk_widget_show_all(confirmation_dialog);
 162
 163         result=gtk_dialog_run(GTK_DIALOG(confirmation_dialog));
 164         if (result==GTK_RESPONSE_OK)
 165         {
 166                 modest_account_mgr_remove_server_account(priv->modest_acc_mgr,
 167                                                          account_name,
 168                                                          NULL);
 169         }
 170
 171         gtk_widget_destroy(confirmation_dialog);
 172         g_free(account_name);
 173         g_free(message);
 174 }
 175
 176
 177 static void
 178 identity_edit_action(GtkWidget *button,
 179                      gpointer userdata)
 180 {
 181         CallbackData *cb_data;
 182         GtkTreeModel *acc_liststore;
 183         GtkTreeModel *id_liststore;
 184         GtkTreeSelection *selection;
 185         GtkTreeIter selected_iter;
 186         gchar *identity_name;
 187
 188         cb_data = (CallbackData *) userdata;
 189         selection = gtk_tree_view_get_selection (GTK_TREE_VIEW(cb_data->id_tree_view));
 190
 191         gtk_tree_selection_get_selected(selection,
 192                                         &id_liststore,
 193                                         &selected_iter);
 194         gtk_tree_model_get(GTK_TREE_MODEL(id_liststore),
 195                            &selected_iter,
 196                            IDENTITY_NAME, &identity_name,
 197                            -1);
 198         /* We use the available tree model from the accounts page to display a selection
 199          * of transports in the identities. Since we only want the transport accounts,
 200          * we derive a gtk_tree_model_filter and apply filter_transports function.
 201          */
 202         acc_liststore = gtk_tree_model_filter_new(gtk_tree_view_get_model(cb_data->acc_tree_view),
 203                                                   NULL);
 204         gtk_tree_model_filter_set_visible_func(GTK_TREE_MODEL_FILTER(acc_liststore),
 205                                                filter_transports,
 206                                                NULL,
 207                                                NULL);
 208
 209         identity_setup_dialog (cb_data->modest_ui, acc_liststore, identity_name);
 210         g_free(identity_name);
 211 }
 212
 213 static void
 214 identity_create_action(GtkWidget *button,
 215                        gpointer userdata)
 216 {
 217         CallbackData *cb_data;
 218         GtkTreeModel *acc_liststore;
 219
 220         cb_data = (CallbackData *) userdata;
 221
 222         /* Works as in identity_edit_action. */
 223         acc_liststore = gtk_tree_model_filter_new(gtk_tree_view_get_model(cb_data->acc_tree_view),
 224                                                   NULL);
 225         gtk_tree_model_filter_set_visible_func(GTK_TREE_MODEL_FILTER(acc_liststore),
 226                                                filter_transports,
 227                                                NULL,
 228                                                NULL);
 229
 230         identity_setup_dialog(cb_data->modest_ui, acc_liststore, NULL);
 231         g_object_unref(acc_liststore);
 232 }
 233
 234 static void
 235 identity_delete_action(GtkWidget *button,
 236                        gpointer userdata)
 237 {
 238         CallbackData *cb_data;
 239         GtkTreeSelection *selection;
 240         GtkTreeIter selected_iter;
 241         GtkTreeModel *id_liststore;
 242         GtkWidget *confirmation_dialog;
 243         GtkWidget *confirmation_message;
 244         ModestUIPrivate *priv;
 245         gchar *identity_name;
 246         gchar *message;
 247         gint result;
 248
 249         cb_data = (CallbackData *) userdata;
 250         priv = MODEST_UI_GET_PRIVATE(cb_data->modest_ui);
 251         selection = gtk_tree_view_get_selection (GTK_TREE_VIEW(cb_data->id_tree_view));
 252
 253         gtk_tree_selection_get_selected(selection,
 254                                         &id_liststore,
 255                                         &selected_iter);
 256         gtk_tree_model_get(GTK_TREE_MODEL(id_liststore),
 257                            &selected_iter,
 258                            ACCOUNT_NAME, &identity_name,
 259                            -1);
 260
 261         confirmation_dialog = gtk_dialog_new_with_buttons ("Confirm removal of identity",
 262                                                            GTK_WINDOW(gtk_widget_get_toplevel(button)),
 263                                                            GTK_DIALOG_MODAL | GTK_DIALOG_DESTROY_WITH_PARENT,
 264                                                            GTK_STOCK_OK,
 265                                                            GTK_RESPONSE_OK,
 266                                                            GTK_STOCK_CANCEL,
 267                                                            GTK_RESPONSE_CANCEL,
 268                                                            NULL);
 269
 270         message = g_strdup_printf("Remove selected identity '%s'?", identity_name);
 271         confirmation_message = gtk_label_new_with_mnemonic (message);
 272
 273         gtk_box_pack_start(GTK_BOX(GTK_DIALOG(confirmation_dialog)->vbox), confirmation_message, FALSE, FALSE, 10);
 274
 275         gtk_widget_show_all(confirmation_dialog);
 276
 277         result=gtk_dialog_run(GTK_DIALOG(confirmation_dialog));
 278         if (result==GTK_RESPONSE_OK)
 279         {
 280                 modest_identity_mgr_remove_identity(priv->modest_id_mgr,
 281                                                     identity_name,
 282                                                     NULL);
 283         }
 284
 285         gtk_widget_destroy(confirmation_dialog);
 286         g_free(identity_name);
 287         g_free(message);
 288 }
 289
 290 static void
 291 activate_buttons_on_identity(GtkTreeView *tree_view,
 292                              gpointer user_data)
 293 {
 294         GtkWidget *button;
 295         GladeXML *glade_xml;
 296
 297         glade_xml=(GladeXML *) user_data;
 298
 299         button = glade_xml_get_widget(GLADE_XML(glade_xml), "IdentityEditButton");
 300         gtk_widget_set_sensitive(GTK_WIDGET(button), TRUE);
 301         button = glade_xml_get_widget(GLADE_XML(glade_xml), "IdentityDeleteButton");
 302         gtk_widget_set_sensitive(GTK_WIDGET(button), TRUE);
 303 }
 304
 305 static void
 306 activate_buttons_on_account(GtkTreeView *tree_view,
 307                             gpointer user_data)
 308 {
 309         GtkWidget *button;
 310         GladeXML *glade_xml;
 311
 312         glade_xml=(GladeXML *) user_data;
 313
 314         button = glade_xml_get_widget(GLADE_XML(glade_xml), "AccountEditButton");
 315         gtk_widget_set_sensitive(GTK_WIDGET(button), TRUE);
 316         button = glade_xml_get_widget(GLADE_XML(glade_xml), "AccountDeleteButton");
 317         gtk_widget_set_sensitive(GTK_WIDGET(button), TRUE);
 318 }
 319
 320 static void
 321 use_sig_toggled(GtkToggleButton *button,
 322                 gpointer userdata) {
 323
 324         GtkWidget *awidget;
 325         GladeXML *glade_xml = (GladeXML *) userdata;
 326
 327         awidget=glade_xml_get_widget(glade_xml, "ISSignatureTextView");
 328         gtk_widget_set_sensitive(awidget, gtk_toggle_button_get_active(button));
 329 }
 330
 331 static void
 332 refresh_accounts_on_add(ModestAccountMgr *modest_acc_mgr,
 333                         void *nu1,
 334                         gpointer userdata)
 335 {
 336         refresh_accounts(modest_acc_mgr, (GladeXML *) userdata);
 337 }
 338
 339 static void
 340 refresh_accounts_on_remove(ModestAccountMgr *modest_acc_mgr,
 341                         void *nu1,
 342                         gpointer userdata) {
 343
 344         GladeXML *glade_xml = (GladeXML *) userdata;
 345         GtkWidget *button;
 346
 347         refresh_accounts(modest_acc_mgr, (GladeXML *) userdata);
 348         /* Since we loose the selection through the delete operation, we need to
 349          * change the buttons sensitivity .
 350          */
 351         button = glade_xml_get_widget(GLADE_XML(glade_xml), "AccountEditButton");
 352         gtk_widget_set_sensitive(GTK_WIDGET(button), FALSE);
 353         button = glade_xml_get_widget(GLADE_XML(glade_xml), "AccountDeleteButton");
 354         gtk_widget_set_sensitive(GTK_WIDGET(button), FALSE);
 355 }
 356
 357 static void
 358 refresh_accounts_on_change(ModestAccountMgr *modest_acc_mgr,
 359                            void *nu1,
 360                            void *nu2,
 361                            void *nu3,
 362                            gpointer userdata)
 363 {
 364         refresh_accounts(modest_acc_mgr, (GladeXML *) userdata);
 365 }
 366
 367 static void
 368 refresh_identities_on_add(ModestIdentityMgr *modest_id_mgr,
 369                           void *nu1,
 370                           gpointer userdata) {
 371         refresh_identities(modest_id_mgr, (GladeXML *) userdata);
 372 }
 373
 374 static void
 375 refresh_identities_on_remove(ModestIdentityMgr *modest_id_mgr,
 376                              void *nu1,
 377                              gpointer userdata) {
 378
 379         GladeXML *glade_xml = (GladeXML *) userdata;
 380         GtkWidget *button;
 381
 382         refresh_identities(modest_id_mgr, glade_xml);
 383
 384         /* Since we loose the selection through the delete operation, we need to
 385          * change the buttons sensitivity .
 386          */
 387         button = glade_xml_get_widget(GLADE_XML(glade_xml), "IdentityEditButton");
 388         gtk_widget_set_sensitive(GTK_WIDGET(button), FALSE);
 389         button = glade_xml_get_widget(GLADE_XML(glade_xml), "IdentityDeleteButton");
 390         gtk_widget_set_sensitive(GTK_WIDGET(button), FALSE);
 391 }
 392
 393 static void
 394 refresh_identities_on_change(ModestIdentityMgr *modest_id_mgr,
 395                              void *nu1,
 396                              void *nu2,
 397                              void *nu3,
 398                              gpointer userdata) {
 399         refresh_identities(modest_id_mgr, (GladeXML *) userdata);
 400 }
 401
 402 /* METHODS */
 403
 404 static gboolean
 405 search_model_column_for_string_advanced(GtkTreeModel *model, GtkTreeIter *iter, gint ColNum, gchar *search, gboolean mcase) {
 406
 407         gchar *tmptext;
 408         gboolean iter_true;
 409
 410         iter_true = gtk_tree_model_get_iter_first(model, iter);
 411         while (iter_true) {
 412                 gtk_tree_model_get(model,
 413                                    iter,
 414                                    ColNum, &tmptext,
 415                                    -1);
 416                 if ((mcase && strcasecmp(tmptext, search)==0)
 417                     || strcmp(tmptext, search)==0) {
 418                         g_free(tmptext);
 419                         break;
 420                 }
 421                 g_free(tmptext);
 422                 iter_true = gtk_tree_model_iter_next(model, iter);
 423                 if (!iter_true) {
 424                         break;
 425                 }
 426         }
 427         return iter_true;
 428 }
 429
 430 static gboolean
 431 search_model_column_for_string(GtkTreeModel *model, GtkTreeIter *iter, gint ColNum, gchar *search) {
 432         return search_model_column_for_string_advanced(model, iter, ColNum, search, FALSE);
 433 }
 434
 435 static gboolean
 436 case_search_model_column_for_string(GtkTreeModel *model, GtkTreeIter *iter, gint ColNum, gchar *search) {
 437         return search_model_column_for_string_advanced(model, iter, ColNum, search, TRUE);
 438 }
 439
 440 static void
 441 refresh_identities(ModestIdentityMgr *modest_id_mgr,
 442                    GladeXML *glade_xml) {
 443
 444         GtkTreeModel *id_liststore;
 445         GtkTreeView *id_treeview;
 446
 447         id_treeview = GTK_TREE_VIEW(glade_xml_get_widget(glade_xml, "IdentitiesTreeview"));
 448
 449         id_liststore=create_identities_model(modest_id_mgr);
 450         gtk_tree_view_set_model(GTK_TREE_VIEW(id_treeview), id_liststore);
 451 }
 452
 453 static void
 454 refresh_accounts(ModestAccountMgr *modest_acc_mgr,
 455                  GladeXML *glade_xml) {
 456
 457         GtkTreeModel *acc_liststore;
 458         GtkTreeView *acc_treeview;
 459
 460         acc_treeview = GTK_TREE_VIEW(glade_xml_get_widget(glade_xml, "AccountsTreeview"));
 461
 462         acc_liststore=create_accounts_model(modest_acc_mgr);
 463         gtk_tree_view_set_model(GTK_TREE_VIEW(acc_treeview), acc_liststore);
 464 }
 465
 466 static void
 467 missing_notification(GtkWindow *parent, gchar *info_message) {
 468
 469         GtkWidget *DenyDialog;
 470
 471         DenyDialog=gtk_message_dialog_new(parent,
 472                                           GTK_DIALOG_MODAL,
 473                                           GTK_MESSAGE_INFO,
 474                                           GTK_BUTTONS_OK,
 475                                           "%s",
 476                                           info_message);
 477
 478         gtk_dialog_run(GTK_DIALOG(DenyDialog));
 479
 480         gtk_widget_destroy(DenyDialog);
 481 }
 482
 483 static gboolean
 484 write_identity(GladeXML *glade_xml, ModestUI *modest_ui, GtkTreeModel *accounts_model, gboolean newidentity) {
 485
 486         GtkTextBuffer *sigbuff;
 487         GtkTextIter start_iter;
 488         GtkTextIter end_iter;
 489         GtkTreeIter transport_iter;
 490         ModestUIPrivate *priv;
 491         const gchar *identity;
 492         gchar *reply_to;
 493         gchar *signature;
 494         gchar *transport;
 495
 496         priv = MODEST_UI_GET_PRIVATE(MODEST_UI(modest_ui));
 497
 498         reply_to = g_strdup_printf("%s", gtk_entry_get_text(GTK_ENTRY(glade_xml_get_widget(glade_xml, "ISReplyToEntry"))));
 499
 500         if (gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(glade_xml_get_widget(glade_xml, "ISUseSignatureCheckButton"))))
 501         {
 502                 sigbuff = gtk_text_view_get_buffer(GTK_TEXT_VIEW(glade_xml_get_widget(glade_xml, "ISSignatureTextView")));
 503                 gtk_text_buffer_get_bounds(sigbuff,
 504                                            &start_iter,
 505                                            &end_iter);
 506                 signature = gtk_text_buffer_get_text(sigbuff,
 507                                                      &start_iter,
 508                                                      &end_iter,
 509                                                      FALSE);
 510         }
 511         else
 512                 signature = NULL;
 513
 514         if (gtk_combo_box_get_active_iter(GTK_COMBO_BOX(glade_xml_get_widget(glade_xml, "ISOutServerComboBox")), &transport_iter)) {
 515                 gtk_tree_model_get(GTK_TREE_MODEL(accounts_model),
 516                                    &transport_iter,
 517                                    ACCOUNT_NAME, &transport,
 518                                    -1);
 519         }
 520         else {
 521                 missing_notification(NULL, "Please select an outgoing server!");
 522                 return FALSE;
 523         }
 524
 525         identity = gtk_entry_get_text(GTK_ENTRY(glade_xml_get_widget(glade_xml, "ISIdentityEntry")));
 526
 527         if (newidentity) {
 528
 529                 if (modest_identity_mgr_add_identity (priv->modest_id_mgr,
 530                                                       identity,
 531                                                       NULL,
 532                                                       gtk_entry_get_text(GTK_ENTRY(glade_xml_get_widget(glade_xml, "ISEMailAddress"))),
 533                                                       NULL,
 534                                                       NULL,
 535                                                       FALSE,
 536                                                       NULL,
 537                                                       FALSE));
 538                 else
 539                         return FALSE;
 540         }
 541         if (!modest_identity_mgr_set_identity_string(priv->modest_id_mgr,
 542                                                      identity,
 543                                                      MODEST_IDENTITY_REALNAME,
 544                                                      gtk_entry_get_text(GTK_ENTRY(glade_xml_get_widget(glade_xml, "ISNameEntry"))),
 545                                                      NULL))
 546                 return FALSE;
 547         if (!modest_identity_mgr_set_identity_string(priv->modest_id_mgr,
 548                                                      identity,
 549                                                      MODEST_IDENTITY_EMAIL,
 550                                                      gtk_entry_get_text(GTK_ENTRY(glade_xml_get_widget(glade_xml, "ISEMailAddress"))),
 551                                                      NULL))
 552                 return FALSE;
 553         if (!modest_identity_mgr_set_identity_string(priv->modest_id_mgr,
 554                                                      identity,
 555                                                      MODEST_IDENTITY_REPLYTO,
 556                                                      reply_to,
 557                                                      NULL))
 558                 return FALSE;
 559         if (!modest_identity_mgr_set_identity_string(priv->modest_id_mgr,
 560                                                      identity,
 561                                                      MODEST_IDENTITY_SIGNATURE,
 562                                                      signature,
 563                                                      NULL))
 564                 return FALSE;
 565         if (!modest_identity_mgr_set_identity_bool(priv->modest_id_mgr,
 566                                                    identity,
 567                                                    MODEST_IDENTITY_USE_SIGNATURE,
 568                                                    gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(glade_xml_get_widget(glade_xml,
 569                                                                                                                        "ISUseSignatureCheckButton"))),
 570                                                    NULL))
 571                 return FALSE;
 572         if (!modest_identity_mgr_set_identity_string(priv->modest_id_mgr,
 573                                                      identity,
 574                                                      MODEST_IDENTITY_ID_VIA,
 575                                                      transport,
 576                                                      NULL))
 577                 return FALSE;
 578         if (!modest_identity_mgr_set_identity_bool(priv->modest_id_mgr,
 579                                                    identity,
 580                                                    MODEST_IDENTITY_USE_ID_VIA,
 581                                                    TRUE, /* FIXME: for now */
 582                                                    NULL))
 583                 return FALSE;
 584         g_free(transport);
 585         return TRUE;
 586 }
 587
 588 static gboolean
 589 write_account(GladeXML *glade_xml, ModestUI *modest_ui, gboolean newaccount) {
 590
 591         ModestUIPrivate *priv;
 592         const gchar *account;
 593         gchar *protocol;
 594         gchar *tmptext;
 595         gint retval;
 596
 597         priv = MODEST_UI_GET_PRIVATE(MODEST_UI(modest_ui));
 598
 599         account = gtk_entry_get_text(GTK_ENTRY(glade_xml_get_widget(glade_xml, "ASDisplaynameEntry")));
 600
 601         if (newaccount) {
 602                 tmptext = gtk_combo_box_get_active_text(GTK_COMBO_BOX(glade_xml_get_widget(glade_xml, "ASProtocolComboBox")));
 603                 protocol = g_utf8_strdown(tmptext, -1);
 604                 g_free(tmptext);
 605
 606                 retval = modest_account_mgr_add_server_account (priv->modest_acc_mgr,
 607                                                                 account,
 608                                                                 gtk_entry_get_text(GTK_ENTRY(glade_xml_get_widget(glade_xml, "ASHostnameEntry"))),
 609                                                                 gtk_entry_get_text(GTK_ENTRY(glade_xml_get_widget(glade_xml, "ASUsernameEntry"))),
 610                                                                 gtk_entry_get_text(GTK_ENTRY(glade_xml_get_widget(glade_xml, "ASPasswordEntry"))),
 611                                                                 protocol);
 612                 g_free(protocol);
 613                 return retval;
 614         }
 615         if (!modest_account_mgr_set_server_account_string(priv->modest_acc_mgr,
 616                                                           account,
 617                                                           MODEST_ACCOUNT_HOSTNAME,
 618                                                           gtk_entry_get_text(GTK_ENTRY(glade_xml_get_widget(glade_xml, "ASHostnameEntry"))),
 619                                                           NULL))
 620                 return FALSE;
 621         if (!modest_account_mgr_set_server_account_string(priv->modest_acc_mgr,
 622                                                           account,
 623                                                           MODEST_ACCOUNT_USERNAME,
 624                                                           gtk_entry_get_text(GTK_ENTRY(glade_xml_get_widget(glade_xml, "ASUsernameEntry"))),
 625                                                           NULL))
 626                 return FALSE;
 627         if (!modest_account_mgr_set_server_account_string(priv->modest_acc_mgr,
 628                                                           account,
 629                                                           MODEST_ACCOUNT_PASSWORD,
 630                                                           gtk_entry_get_text(GTK_ENTRY(glade_xml_get_widget(glade_xml, "ASPasswordEntry"))),
 631                                                           NULL))
 632                 return FALSE;
 633         return TRUE;
 634 }
 635
 636 static void
 637 identity_setup_dialog (ModestUI *modest_ui, GtkTreeModel *accounts_model, gchar *identity)
 638 {
 639
 640         GladeXML *glade_xml;
 641         GtkWidget *id_dialog;
 642         GtkWidget *outgoing_server;
 643         GtkWidget *awidget;
 644         GtkCellRenderer *renderer;
 645         ModestIdentityMgr *id_mgr;
 646         GtkTextBuffer *sigbuff;
 647         GtkTreeIter out_iter;
 648         gchar *outacc_name;
 649         gchar *tmptext;
 650         gint identity_added_successfully;
 651         gint result;
 652         gboolean newidentity;
 653
 654         glade_xml = glade_xml_new(MODEST_GLADE, "IdentitySetupDialog", NULL);
 655         id_dialog = glade_xml_get_widget(glade_xml, "IdentitySetupDialog");
 656
 657         outgoing_server = glade_xml_get_widget(glade_xml, "ISOutServerComboBox");
 658         gtk_combo_box_set_model(GTK_COMBO_BOX(outgoing_server), GTK_TREE_MODEL(accounts_model));
 659         renderer = gtk_cell_renderer_text_new ();
 660         gtk_cell_layout_pack_start (GTK_CELL_LAYOUT (outgoing_server), renderer, TRUE);
 661         gtk_cell_layout_set_attributes (GTK_CELL_LAYOUT (outgoing_server), renderer,
 662                                         "text", 0,
 663                                         NULL);
 664         awidget=glade_xml_get_widget(glade_xml, "ISUseSignatureCheckButton");
 665         g_signal_connect(awidget,
 666                          "toggled",
 667                          G_CALLBACK(use_sig_toggled),
 668                          glade_xml);
 669
 670         newidentity = identity==NULL;
 671         if (!newidentity) {
 672                 id_mgr = MODEST_UI_GET_PRIVATE(modest_ui)->modest_id_mgr;
 673
 674                 outacc_name = modest_identity_mgr_get_identity_string(id_mgr,
 675                                                                       identity,
 676                                                                       MODEST_IDENTITY_ID_VIA,
 677                                                                       NULL);
 678                 if (search_model_column_for_string(GTK_TREE_MODEL(accounts_model),
 679                                                    &out_iter,
 680                                                    ACCOUNT_NAME,
 681                                                    outacc_name))
 682                         gtk_combo_box_set_active_iter(GTK_COMBO_BOX(outgoing_server), &out_iter);
 683
 684                 awidget=glade_xml_get_widget(glade_xml, "ISIdentityEntry");
 685                 gtk_widget_set_sensitive(awidget, FALSE);
 686                 gtk_entry_set_text(GTK_ENTRY(awidget), identity);
 687                 tmptext = modest_identity_mgr_get_identity_string(id_mgr,
 688                                                                   identity,
 689                                                                   MODEST_IDENTITY_EMAIL,
 690                                                                   NULL);
 691                 awidget=glade_xml_get_widget(glade_xml, "ISEMailAddress");
 692                 gtk_entry_set_text(GTK_ENTRY(awidget), tmptext);
 693                 g_free(tmptext);
 694
 695                 if (modest_identity_mgr_get_identity_bool(id_mgr,
 696                                                           identity,
 697                                                           MODEST_IDENTITY_USE_SIGNATURE,
 698                                                           NULL)) {
 699                         awidget=glade_xml_get_widget(glade_xml, "ISUseSignatureCheckButton");
 700                         gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(awidget), TRUE);
 701                         awidget=glade_xml_get_widget(glade_xml, "ISSignatureTextView");
 702                         gtk_widget_set_sensitive(awidget, TRUE);
 703                 }
 704
 705                 sigbuff=gtk_text_buffer_new(NULL);
 706                 tmptext = modest_identity_mgr_get_identity_string(id_mgr,
 707                                                                   identity,
 708                                                                   MODEST_IDENTITY_SIGNATURE,
 709                                                                   NULL),
 710                 gtk_text_buffer_set_text(sigbuff, tmptext, -1);
 711                 gtk_text_view_set_buffer(GTK_TEXT_VIEW(glade_xml_get_widget(glade_xml, "ISSignatureTextView")),
 712                                                        sigbuff);
 713                 g_object_unref(sigbuff);
 714                 g_free(tmptext);
 715
 716                 tmptext = modest_identity_mgr_get_identity_string(id_mgr,
 717                                                                   identity,
 718                                                                   MODEST_IDENTITY_EMAIL,
 719                                                                   NULL);
 720                 awidget=glade_xml_get_widget(glade_xml, "ISEMailAddress");
 721                 gtk_entry_set_text(GTK_ENTRY(awidget), tmptext);
 722                 g_free(tmptext);
 723
 724                 tmptext = modest_identity_mgr_get_identity_string(id_mgr,
 725                                                                   identity,
 726                                                                   MODEST_IDENTITY_REALNAME,
 727                                                                   NULL);
 728                 awidget=glade_xml_get_widget(glade_xml, "ISNameEntry");
 729                 gtk_entry_set_text(GTK_ENTRY(awidget), tmptext);
 730                 g_free(tmptext);
 731
 732                 tmptext = modest_identity_mgr_get_identity_string(id_mgr,
 733                                                                   identity,
 734                                                                   MODEST_IDENTITY_REPLYTO,
 735                                                                   NULL);
 736                 awidget=glade_xml_get_widget(glade_xml, "ISReplyToEntry");
 737                 gtk_entry_set_text(GTK_ENTRY(awidget), tmptext);
 738
 739                 g_free(tmptext);
 740                 g_free(outacc_name);
 741         }
 742
 743         gtk_widget_show_all(id_dialog);
 744
 745         do {
 746                 result=gtk_dialog_run(GTK_DIALOG(id_dialog));
 747
 748                 switch (result) {
 749                 case GTK_RESPONSE_OK:
 750                         identity_added_successfully = write_identity(glade_xml, modest_ui, accounts_model, newidentity);
 751                         break;
 752                 default:
 753                         identity_added_successfully = FALSE;
 754                         break;
 755                 }
 756         } while(result!=GTK_RESPONSE_DELETE_EVENT && result!=GTK_RESPONSE_CANCEL && identity_added_successfully!=TRUE);
 757
 758         gtk_widget_destroy(id_dialog);
 759         g_object_unref(glade_xml);
 760 }
 761
 762 static void
 763 account_setup_dialog (ModestUI *modest_ui, gchar *account) {
 764
 765         GladeXML *glade_xml;
 766         GtkWidget *acc_dialog;
 767         GtkWidget *awidget;
 768         ModestAccountMgr *acc_mgr;
 769         GtkTreeModel *typemodel;
 770         GtkTreeIter proto_iter;
 771         gchar *tmptext;
 772         gint account_added_successfully;
 773         gint result;
 774         gboolean newaccount;
 775
 776         glade_xml = glade_xml_new(MODEST_GLADE, "AccountSetupDialog", NULL);
 777         acc_dialog = glade_xml_get_widget(glade_xml, "AccountSetupDialog");
 778
 779         newaccount = account==NULL;
 780         if (!newaccount) {
 781                 acc_mgr = MODEST_UI_GET_PRIVATE(modest_ui)->modest_acc_mgr;
 782
 783                 awidget=glade_xml_get_widget(glade_xml, "ASDisplaynameEntry");
 784                 gtk_widget_set_sensitive(awidget, FALSE);
 785                 gtk_entry_set_text(GTK_ENTRY(awidget), account);
 786
 787                 tmptext = modest_account_mgr_get_server_account_string(acc_mgr,
 788                                                                        account,
 789                                                                        MODEST_ACCOUNT_PROTO,
 790                                                                        NULL);
 791                 awidget=glade_xml_get_widget(glade_xml, "ASProtocolComboBox");
 792                 gtk_widget_set_sensitive(awidget, FALSE);
 793                 typemodel = gtk_combo_box_get_model(GTK_COMBO_BOX(awidget));
 794                 if (case_search_model_column_for_string(typemodel, &proto_iter, 0, tmptext))
 795                         gtk_combo_box_set_active_iter(GTK_COMBO_BOX(awidget), &proto_iter);
 796
 797                 g_free(tmptext);
 798
 799                 tmptext = modest_account_mgr_get_server_account_string(acc_mgr,
 800                                                                 account,
 801                                                                 MODEST_ACCOUNT_HOSTNAME,
 802                                                                 NULL);
 803                 awidget=glade_xml_get_widget(glade_xml, "ASHostnameEntry");
 804                 gtk_entry_set_text(GTK_ENTRY(awidget), tmptext);
 805                 g_free(tmptext);
 806
 807                 tmptext = modest_account_mgr_get_server_account_string(acc_mgr,
 808                                                                 account,
 809                                                                 MODEST_ACCOUNT_USERNAME,
 810                                                                 NULL);
 811                 awidget=glade_xml_get_widget(glade_xml, "ASUsernameEntry");
 812                 gtk_entry_set_text(GTK_ENTRY(awidget), tmptext);
 813                 g_free(tmptext);
 814
 815                 tmptext = modest_account_mgr_get_server_account_string(acc_mgr,
 816                                                                 account,
 817                                                                 MODEST_ACCOUNT_PASSWORD,
 818                                                                 NULL);
 819                 awidget=glade_xml_get_widget(glade_xml, "ASPasswordEntry");
 820                 gtk_entry_set_text(GTK_ENTRY(awidget), tmptext);
 821                 g_free(tmptext);
 822         }
 823
 824         gtk_widget_show_all(acc_dialog);
 825
 826         do {
 827                 result=gtk_dialog_run(GTK_DIALOG(acc_dialog));
 828
 829                 switch (result) {
 830                 case GTK_RESPONSE_OK:
 831                         account_added_successfully = write_account(glade_xml, modest_ui, newaccount);
 832
 833                         break;
 834                 default:
 835                         account_added_successfully = FALSE;
 836                         break;
 837                 }
 838         } while(result!=GTK_RESPONSE_DELETE_EVENT && result!=GTK_RESPONSE_CANCEL && account_added_successfully!=TRUE);
 839
 840         gtk_widget_destroy(acc_dialog);
 841         g_object_unref(glade_xml);
 842 }
 843
 844
 845 static CallbackData *
 846 setup_callback_data(GtkTreeView *id_tree_view,
 847                     GtkTreeView *acc_tree_view,
 848                     ModestUI *modest_ui,
 849                     GladeXML *glade_xml)
 850 {
 851         CallbackData *self;
 852         self = g_malloc(sizeof(CallbackData));
 853         self->modest_ui=modest_ui;
 854         self->id_tree_view=id_tree_view;
 855         self->acc_tree_view=acc_tree_view;
 856         self->glade_xml=glade_xml;
 857         return self;
 858 }
 859
 860 static void
 861 free_callback_data(CallbackData *data)
 862 {
 863         g_free(data);
 864 }
 865
 866 static GtkTreeModel *
 867 create_identities_model(ModestIdentityMgr *id_mgr) {
 868
 869         GSList *id_names_list;
 870         GSList *id_names_list_iter;
 871         GtkListStore *id_list_store;
 872         GtkTreeIter id_list_store_iter;
 873         gchar *tmptext1;
 874         gchar *tmptext2;
 875
 876         id_names_list = modest_identity_mgr_identity_names(id_mgr, NULL);
 877         id_list_store = gtk_list_store_new(IDENTITY_COLUMNS, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_STRING);
 878
 879         for (id_names_list_iter=id_names_list;
 880              id_names_list_iter!=NULL;
 881              id_names_list_iter=g_slist_next(id_names_list_iter)) {
 882                 gtk_list_store_append(id_list_store, &id_list_store_iter);
 883                 tmptext1=modest_identity_mgr_get_identity_string(id_mgr,
 884                                                                  id_names_list_iter->data,
 885                                                                  MODEST_IDENTITY_EMAIL,
 886                                                                  NULL);
 887                 tmptext2=modest_identity_mgr_get_identity_string(id_mgr,
 888                                                                  id_names_list_iter->data,
 889                                                                  MODEST_IDENTITY_ID_VIA,
 890                                                                  NULL);
 891                 gtk_list_store_set(id_list_store, &id_list_store_iter,
 892                                    IDENTITY_NAME, id_names_list_iter->data,
 893                                    IDENTITY_ADDRESS, tmptext1,
 894                                    IDENTITY_VIA, tmptext2,
 895                                    -1);
 896                 g_free(tmptext1);
 897                 g_free(tmptext2);
 898         }
 899
 900         g_slist_free(id_names_list);
 901
 902         return GTK_TREE_MODEL(id_list_store);
 903 }
 904
 905 static GtkTreeModel *
 906 create_accounts_model(ModestAccountMgr *acc_mgr) {
 907
 908         GSList *acc_names_list;
 909         GSList *acc_names_list_iter;
 910         GtkListStore *acc_list_store;
 911         GtkTreeIter acc_list_store_iter;
 912         gchar *hostname;
 913         gchar *protocol;
 914
 915         acc_names_list = modest_account_mgr_server_account_names(acc_mgr,
 916                                                                  NULL,
 917                                                                  MODEST_PROTO_TYPE_ANY,
 918                                                                  NULL,
 919                                                                  FALSE);
 920         acc_list_store = gtk_list_store_new(ACCOUNT_COLUMNS, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_STRING);
 921
 922         for (acc_names_list_iter=acc_names_list;
 923              acc_names_list_iter!=NULL;
 924              acc_names_list_iter=g_slist_next(acc_names_list_iter)) {
 925                 gtk_list_store_append(acc_list_store, &acc_list_store_iter);
 926                 hostname=modest_account_mgr_get_server_account_string(acc_mgr,
 927                                                                       acc_names_list_iter->data,
 928                                                                       MODEST_ACCOUNT_HOSTNAME,
 929                                                                       NULL);
 930                 protocol=modest_account_mgr_get_server_account_string(acc_mgr,
 931                                                                       acc_names_list_iter->data,
 932                                                                       MODEST_ACCOUNT_PROTO,
 933                                                                       NULL);
 934                 gtk_list_store_set(acc_list_store, &acc_list_store_iter,
 935                                    ACCOUNT_NAME, acc_names_list_iter->data,
 936                                    ACCOUNT_HOST, hostname,
 937                                    ACCOUNT_PROT, protocol,
 938                                    -1);
 939                 g_free(hostname);
 940                 g_free(protocol);
 941         }
 942
 943         g_slist_free(acc_names_list);
 944
 945         return GTK_TREE_MODEL(acc_list_store);
 946 }
 947
 948
 949 static void
 950 accounts_and_identities_dialog (gpointer user_data)
 951 {
 952         GladeXML *glade_xml;
 953         GtkWidget *main_dialog;
 954         GtkTreeView *identities_tree_view;
 955         GtkTreeView *accounts_tree_view;
 956         ModestUI *modest_ui;
 957         ModestUIPrivate *priv;
 958         gint sig_coll[6];
 959         gint retval;
 960         GtkCellRenderer *renderer;
 961         GtkTreeViewColumn *column;
 962         CallbackData *cb_data;
 963         GtkWidget *abutton;
 964
 965         g_return_if_fail(MODEST_IS_UI(user_data));
 966         modest_ui = (ModestUI *) user_data;
 967         priv = MODEST_UI_GET_PRIVATE(modest_ui);
 968
 969         glade_xml = glade_xml_new(MODEST_GLADE, "IdentitiesAndAccountsDialog", NULL);
 970         main_dialog = glade_xml_get_widget(glade_xml, "IdentitiesAndAccountsDialog");
 971
 972         /* Accounts */
 973         accounts_tree_view = GTK_TREE_VIEW(glade_xml_get_widget(glade_xml, "AccountsTreeview"));
 974         /* Account -> Accountname */
 975         renderer = gtk_cell_renderer_text_new ();
 976         column = gtk_tree_view_column_new_with_attributes ("Account",
 977                                                            renderer,
 978                                                            "text", ACCOUNT_NAME,
 979                                                            NULL);
 980         gtk_tree_view_append_column (accounts_tree_view, column);
 981         /* Account -> Hostname */
 982         renderer = gtk_cell_renderer_text_new ();
 983         column = gtk_tree_view_column_new_with_attributes ("Hostname",
 984                                                            renderer,
 985                                                            "text", ACCOUNT_HOST,
 986                                                            NULL);
 987         gtk_tree_view_append_column (accounts_tree_view, column);
 988
 989         /* Identities */
 990         identities_tree_view = GTK_TREE_VIEW(glade_xml_get_widget(glade_xml, "IdentitiesTreeview"));
 991
 992         /* Identities -> Identityname */
 993         renderer = gtk_cell_renderer_text_new ();
 994         column = gtk_tree_view_column_new_with_attributes ("Identity",
 995                                                            renderer,
 996                                                            "text", IDENTITY_NAME,
 997                                                            NULL);
 998         gtk_tree_view_append_column (identities_tree_view, column);
 999
1000         /* Identities -> E-mail address */
1001         renderer = gtk_cell_renderer_text_new ();
1002         column = gtk_tree_view_column_new_with_attributes ("E-mail address",
1003                                                            renderer,
1004                                                            "text", IDENTITY_ADDRESS,
1005                                                            NULL);
1006         gtk_tree_view_append_column (identities_tree_view, column);
1007
1008         /* Identities -> Relay */
1009         renderer = gtk_cell_renderer_text_new ();
1010         column = gtk_tree_view_column_new_with_attributes ("Transport",
1011                                                            renderer,
1012                                                            "text", IDENTITY_VIA,
1013                                                            NULL);
1014         gtk_tree_view_append_column (identities_tree_view, column);
1015
1016         cb_data=setup_callback_data(identities_tree_view, accounts_tree_view, modest_ui, glade_xml);
1017
1018         refresh_accounts(priv->modest_acc_mgr,
1019                          glade_xml);
1020
1021         refresh_identities(priv->modest_id_mgr,
1022                            glade_xml);
1023
1024         /* Identities */
1025         abutton=glade_xml_get_widget(glade_xml, "IdentityCreateButton");
1026         g_signal_connect(abutton,
1027                          "clicked",
1028                          G_CALLBACK(identity_create_action),
1029                          cb_data);
1030         abutton=glade_xml_get_widget(glade_xml, "IdentityEditButton");
1031         g_signal_connect(abutton,
1032                          "clicked",
1033                          G_CALLBACK(identity_edit_action),
1034                          cb_data);
1035         abutton=glade_xml_get_widget(glade_xml, "IdentityDeleteButton");
1036         g_signal_connect(abutton,
1037                          "clicked",
1038                          G_CALLBACK(identity_delete_action),
1039                          cb_data);
1040
1041         /* Accounts */
1042         abutton=glade_xml_get_widget(glade_xml, "AccountCreateButton");
1043         g_signal_connect(abutton,
1044                          "clicked",
1045                          G_CALLBACK(account_create_action),
1046                          cb_data);
1047         abutton=glade_xml_get_widget(glade_xml, "AccountEditButton");
1048         g_signal_connect(abutton,
1049                          "clicked",
1050                          G_CALLBACK(account_edit_action),
1051                          cb_data);
1052         abutton=glade_xml_get_widget(glade_xml, "AccountDeleteButton");
1053         g_signal_connect(abutton,
1054                          "clicked",
1055                          G_CALLBACK(account_delete_action),
1056                          cb_data);
1057
1058         g_signal_connect(glade_xml_get_widget(glade_xml, "IdentitiesTreeview"),
1059                          "cursor-changed",
1060                          G_CALLBACK(activate_buttons_on_identity),
1061                          glade_xml);
1062         g_signal_connect(glade_xml_get_widget(glade_xml, "AccountsTreeview"),
1063                          "cursor-changed",
1064                          G_CALLBACK(activate_buttons_on_account),
1065                          glade_xml);
1066
1067         sig_coll[0] = g_signal_connect(priv->modest_id_mgr,
1068                                        "identity-change",
1069                                        G_CALLBACK(refresh_identities_on_change),
1070                                        glade_xml);
1071         sig_coll[1] = g_signal_connect(priv->modest_id_mgr,
1072                                        "identity-add",
1073                                        G_CALLBACK(refresh_identities_on_add),
1074                                        glade_xml);
1075         sig_coll[2] = g_signal_connect(priv->modest_id_mgr,
1076                                        "identity-remove",
1077                                        G_CALLBACK(refresh_identities_on_remove),
1078                                        glade_xml);
1079
1080         sig_coll[3] = g_signal_connect(priv->modest_acc_mgr,
1081                                        "account-change",
1082                                        G_CALLBACK(refresh_accounts_on_change),
1083                                        glade_xml);
1084         sig_coll[4] = g_signal_connect(priv->modest_acc_mgr,
1085                                        "account-add",
1086                                        G_CALLBACK(refresh_accounts_on_add),
1087                                        glade_xml);
1088         sig_coll[5] = g_signal_connect(priv->modest_acc_mgr,
1089                                        "account-remove",
1090                                        G_CALLBACK(refresh_accounts_on_remove),
1091                                        glade_xml);
1092
1093         gtk_widget_show_all(GTK_WIDGET(main_dialog));
1094
1095         retval=gtk_dialog_run(GTK_DIALOG(main_dialog));
1096
1097         g_signal_handler_disconnect(priv->modest_id_mgr, sig_coll[0]);
1098         g_signal_handler_disconnect(priv->modest_id_mgr, sig_coll[1]);
1099         g_signal_handler_disconnect(priv->modest_id_mgr, sig_coll[2]);
1100         g_signal_handler_disconnect(priv->modest_acc_mgr, sig_coll[3]);
1101         g_signal_handler_disconnect(priv->modest_acc_mgr, sig_coll[4]);
1102         g_signal_handler_disconnect(priv->modest_acc_mgr, sig_coll[5]);
1103
1104         gtk_widget_destroy(GTK_WIDGET(main_dialog));
1105         free_callback_data(cb_data);
1106         g_object_unref(glade_xml);
1107 }
1108
1109 void account_settings (GtkWidget *widget,
1110                        gpointer user_data)
1111 {
1112         accounts_and_identities_dialog (MODEST_UI(user_data));
1113 }
1114