git.maemo.org Git - modest/blob - src/gtk-glade/modest-ui.c

   1 /* modest-ui.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 /* TODO: put in auto* */
  15 #include <tny-text-buffer-stream.h>
  16 #include <tny-msg-folder.h>
  17
  18 #include "../modest-ui.h"
  19 #include "../modest-window-mgr.h"
  20 #include "../modest-account-mgr.h"
  21 #include "../modest-identity-mgr.h"
  22
  23 #include "../modest-tny-account-store.h"
  24 #include "../modest-tny-folder-tree-view.h"
  25 #include "../modest-tny-header-tree-view.h"
  26 #include "../modest-tny-msg-view.h"
  27 #include "../modest-tny-transport-actions.h"
  28 #include "../modest-tny-store-actions.h"
  29
  30 #include "../modest-text-utils.h"
  31 #include "../modest-tny-msg-actions.h"
  32
  33 #include "../modest-editor-window.h"
  34
  35 #include "modest-ui-glade.h"
  36 #include "modest-ui-wizard.h"
  37
  38 /* 'private'/'protected' functions */
  39 static void   modest_ui_class_init     (ModestUIClass *klass);
  40 static void   modest_ui_init           (ModestUI *obj);
  41 static void   modest_ui_finalize       (GObject *obj);
  42
  43 static void    modest_ui_window_destroy    (GtkWidget *win, GdkEvent *event, gpointer data);
  44 static void    modest_ui_last_window_closed (GObject *obj, gpointer data);
  45
  46 static GtkWidget* modest_main_window_toolbar (void);
  47 static GtkWidget* modest_main_window_folder_tree (ModestAccountMgr *modest_acc_mgr,
  48                                                   TnyAccountStoreIface *account_store);
  49 static GtkWidget* modest_main_window_header_tree (TnyMsgFolderIface *folder);
  50
  51
  52 void on_account_settings1_activate (GtkMenuItem *,
  53                                     gpointer);
  54
  55 static void on_password_requested (ModestTnyAccountStore *account_store,
  56                                    const gchar *account_name, gpointer user_data);
  57
  58 static void on_folder_clicked (ModestTnyFolderTreeView *folder_tree,
  59                                TnyMsgFolderIface *folder,
  60                                gpointer data);
  61 static void on_message_clicked (ModestTnyFolderTreeView *folder_tree,
  62                                 TnyMsgIface *message,
  63                                 gpointer data);
  64 static void on_new_mail_clicked (GtkWidget *widget, ModestUI *modest_ui);
  65
  66 static void on_reply_clicked (GtkWidget *widget, ModestUI *modest_ui);
  67
  68 static void on_forward_clicked (GtkWidget *widget, ModestUI *modest_ui);
  69
  70 static void on_delete_clicked (GtkWidget *widget, ModestUI *modest_ui);
  71
  72 static void on_send_button_clicked (GtkWidget *widget, ModestUI *modest_ui);
  73
  74 static void on_sendreceive_button_clicked (GtkWidget *widget, ModestUI *modest_ui);
  75
  76 static void register_toolbar_callbacks (ModestUI *modest_ui);
  77
  78
  79 typedef enum {
  80         QUOTED_SEND_REPLY,
  81         QUOTED_SEND_REPLY_ALL,
  82         QUOTED_SEND_FORWARD
  83 } quoted_send_type;
  84
  85 static void quoted_send_msg (ModestUI *modest_ui, quoted_send_type qstype);
  86
  87
  88
  89 /* list my signals */
  90 enum {
  91         /* MY_SIGNAL_1, */
  92         /* MY_SIGNAL_2, */
  93         LAST_SIGNAL
  94 };
  95
  96 /* globals */
  97 static GObjectClass *parent_class = NULL;
  98
  99 /* uncomment the following if you have defined any signals */
 100 /* static guint signals[LAST_SIGNAL] = {0}; */
 101
 102 GType
 103 modest_ui_get_type (void)
 104 {
 105         static GType my_type = 0;
 106         if (!my_type) {
 107                 static const GTypeInfo my_info = {
 108                         sizeof(ModestUIClass),
 109                         NULL,           /* base init */
 110                         NULL,           /* base finalize */
 111                         (GClassInitFunc) modest_ui_class_init,
 112                         NULL,           /* class finalize */
 113                         NULL,           /* class data */
 114                         sizeof(ModestUI),
 115                         1,              /* n_preallocs */
 116                         (GInstanceInitFunc) modest_ui_init,
 117                 };
 118                 my_type = g_type_register_static (G_TYPE_OBJECT,
 119                                                   "ModestUI",
 120                                                   &my_info, 0);
 121         }
 122         return my_type;
 123 }
 124
 125
 126 static void
 127 modest_ui_class_init (ModestUIClass *klass)
 128 {
 129         GObjectClass *gobject_class;
 130         gobject_class = (GObjectClass*) klass;
 131
 132         parent_class            = g_type_class_peek_parent (klass);
 133         gobject_class->finalize = modest_ui_finalize;
 134
 135         g_type_class_add_private (gobject_class, sizeof(ModestUIPrivate));
 136
 137         /* signal definitions go here, e.g.: */
 138 /*      signals[MY_SIGNAL_1] = */
 139 /*              g_signal_new ("my_signal_1",....); */
 140 /*      signals[MY_SIGNAL_2] = */
 141 /*              g_signal_new ("my_signal_2",....); */
 142 /*      etc. */
 143 }
 144
 145
 146 static void
 147 modest_ui_init (ModestUI *obj)
 148 {
 149         ModestUIPrivate *priv = MODEST_UI_GET_PRIVATE(obj);
 150
 151         priv->modest_acc_mgr    = NULL;
 152         priv->modest_id_mgr     = NULL;
 153         priv->modest_conf       = NULL;
 154         priv->modest_window_mgr = NULL;
 155         priv->glade_xml         = NULL;
 156
 157 }
 158
 159
 160 static void
 161 modest_ui_finalize (GObject *obj)
 162 {
 163         ModestUIPrivate *priv = MODEST_UI_GET_PRIVATE(obj);
 164
 165         if (priv->modest_acc_mgr)
 166                 g_object_unref (priv->modest_acc_mgr);
 167         priv->modest_acc_mgr = NULL;
 168
 169         if (priv->modest_id_mgr)
 170                 g_object_unref (priv->modest_id_mgr);
 171         priv->modest_id_mgr = NULL;
 172
 173         if (priv->modest_conf)
 174                 g_object_unref (priv->modest_conf);
 175         priv->modest_conf = NULL;
 176
 177         if (priv->modest_window_mgr)
 178                 g_object_unref (priv->modest_window_mgr);
 179         priv->modest_window_mgr = NULL;
 180 }
 181
 182
 183 GObject*
 184 modest_ui_new (ModestConf *modest_conf)
 185 {
 186         GObject *obj;
 187         ModestUIPrivate *priv;
 188         ModestAccountMgr *modest_acc_mgr;
 189         ModestIdentityMgr *modest_id_mgr;
 190         TnyAccountStoreIface *account_store_iface;
 191
 192         g_return_val_if_fail (modest_conf, NULL);
 193
 194         obj = g_object_new(MODEST_TYPE_UI, NULL);
 195         priv = MODEST_UI_GET_PRIVATE(obj);
 196
 197         modest_acc_mgr =
 198                 MODEST_ACCOUNT_MGR(modest_account_mgr_new (modest_conf));
 199         if (!modest_acc_mgr) {
 200                 g_warning ("could not create ModestAccountMgr instance");
 201                 g_object_unref (obj);
 202                 return NULL;
 203         }
 204
 205         modest_id_mgr =
 206                 MODEST_IDENTITY_MGR(modest_identity_mgr_new (modest_conf));
 207         if (!modest_id_mgr) {
 208                 g_warning ("could not create ModestIdentityMgr instance");
 209                 g_object_unref (obj);
 210                 return NULL;
 211         }
 212
 213         account_store_iface =
 214                 TNY_ACCOUNT_STORE_IFACE(modest_tny_account_store_new (modest_acc_mgr));
 215         if (!account_store_iface) {
 216                 g_warning ("could not initialze ModestTnyAccountStore");
 217                 return NULL;
 218         }
 219         g_signal_connect (account_store_iface, "password_requested",
 220                           G_CALLBACK(on_password_requested),
 221                           NULL);
 222
 223         glade_init ();
 224         priv->glade_xml = glade_xml_new (MODEST_GLADE, NULL,NULL);
 225         if (!priv->glade_xml) {
 226                 g_warning ("failed to do glade stuff");
 227                 g_object_unref (obj);
 228                 return NULL;
 229         }
 230
 231         /* FIXME: could be used, but doesn't work atm.
 232          * glade_xml_signal_autoconnect(priv->glade_xml);
 233          */
 234
 235         priv->modest_acc_mgr = modest_acc_mgr;
 236         priv->modest_id_mgr  = modest_id_mgr;
 237         g_object_ref (priv->modest_conf = modest_conf);
 238
 239         priv->account_store = account_store_iface;
 240
 241         priv->modest_window_mgr = MODEST_WINDOW_MGR(modest_window_mgr_new());
 242         g_signal_connect (priv->modest_window_mgr, "last_window_closed",
 243                           G_CALLBACK(modest_ui_last_window_closed),
 244                           NULL);
 245         return obj;
 246 }
 247
 248
 249 gboolean
 250 modest_ui_show_main_window (ModestUI *modest_ui)
 251 {
 252         GtkWidget       *win;
 253         gint              height, width;
 254         ModestUIPrivate *priv;
 255         GtkWidget     *folder_view, *header_view;
 256         GtkWidget     *message_view;
 257         GtkWidget     *account_settings_item;
 258         GtkWidget     *new_account_item;
 259         GtkWidget     *delete_item;
 260         GtkWidget     *AccountWizardryMenu;
 261
 262         GtkWidget  *folder_view_holder,
 263                 *header_view_holder,
 264                 *mail_paned;
 265
 266         priv = MODEST_UI_GET_PRIVATE(modest_ui);
 267
 268         height = modest_conf_get_int (priv->modest_conf,
 269                                       MODEST_CONF_MAIN_WINDOW_HEIGHT,NULL);
 270         width  = modest_conf_get_int (priv->modest_conf,
 271                                       MODEST_CONF_MAIN_WINDOW_WIDTH,NULL);
 272
 273         win = glade_xml_get_widget (priv->glade_xml, "main");
 274         if (!win) {
 275                 g_warning ("could not create main window");
 276                 return FALSE;
 277         }
 278
 279         folder_view =
 280                 GTK_WIDGET(modest_main_window_folder_tree(priv->modest_acc_mgr,
 281                                                           priv->account_store));
 282         folder_view_holder = glade_xml_get_widget (priv->glade_xml, "folders");
 283         if (!folder_view||!folder_view_holder) {
 284                 g_warning ("failed to create folder tree");
 285                 return FALSE;
 286         }
 287         gtk_container_add (GTK_CONTAINER(folder_view_holder), folder_view);
 288
 289         header_view  =  GTK_WIDGET(modest_main_window_header_tree (NULL));
 290         header_view_holder = glade_xml_get_widget (priv->glade_xml, "mail_list");
 291         if (!header_view) {
 292                 g_warning ("failed to create header tree");
 293                 return FALSE;
 294         }
 295         gtk_container_add (GTK_CONTAINER(header_view_holder), header_view);
 296
 297         g_signal_connect (G_OBJECT(folder_view), "folder_selected",
 298                           G_CALLBACK(on_folder_clicked), modest_ui);
 299
 300         message_view  = GTK_WIDGET(modest_tny_msg_view_new (NULL));
 301         if (!message_view) {
 302                 g_warning ("failed to create message view");
 303                 return FALSE;
 304         }
 305         mail_paned = glade_xml_get_widget (priv->glade_xml, "mail_paned");
 306         gtk_paned_add2 (GTK_PANED(mail_paned), message_view);
 307
 308         g_signal_connect (header_view, "message_selected",
 309                           G_CALLBACK(on_message_clicked),
 310                           modest_ui);
 311
 312         account_settings_item = glade_xml_get_widget (priv->glade_xml, "AccountSettingsMenuItem");
 313         if (!account_settings_item)
 314         {
 315                 g_warning ("The account settings item isn't available!\n");
 316                 return FALSE;
 317         }
 318         g_signal_connect (account_settings_item, "activate",
 319                           G_CALLBACK(on_account_settings1_activate),
 320                           modest_ui);
 321
 322         new_account_item = glade_xml_get_widget (priv->glade_xml, "NewAccountWizardMenuItem");
 323         if (!new_account_item)
 324         {
 325                 g_warning ("The new account item isn't available!\n");
 326                 return FALSE;
 327         }
 328
 329         g_signal_connect (new_account_item, "activate",
 330                           G_CALLBACK(new_wizard_account),
 331                           modest_ui);
 332
 333         delete_item = glade_xml_get_widget (priv->glade_xml, "delete1");
 334         if (!delete_item)
 335         {
 336                 g_warning ("The delete item isn't available!\n");
 337                 return FALSE;
 338         }
 339
 340         g_signal_connect (delete_item, "activate", G_CALLBACK(on_delete_clicked),
 341                           modest_ui);
 342
 343         register_toolbar_callbacks (modest_ui);
 344
 345         modest_window_mgr_register (priv->modest_window_mgr,
 346                                     G_OBJECT(win), MODEST_MAIN_WINDOW, 0);
 347         g_signal_connect (win, "destroy-event", G_CALLBACK(modest_ui_window_destroy),
 348                           modest_ui);
 349         g_signal_connect (win, "delete-event", G_CALLBACK(modest_ui_window_destroy),
 350                           modest_ui);
 351         gtk_widget_set_usize (GTK_WIDGET(win), height, width);
 352         gtk_window_set_title (GTK_WINDOW(win), PACKAGE_STRING);
 353
 354         gtk_widget_show_all (win);
 355         return TRUE;
 356 }
 357
 358
 359 static void
 360 register_toolbar_callbacks (ModestUI *modest_ui)
 361 {
 362         ModestUIPrivate *priv;
 363         GtkWidget *button;
 364
 365         g_return_if_fail (modest_ui);
 366
 367         priv = MODEST_UI_GET_PRIVATE (modest_ui);
 368
 369         button = glade_xml_get_widget (priv->glade_xml, "toolb_new_mail");
 370         if (button)
 371                 g_signal_connect (button, "clicked",
 372                                   G_CALLBACK(on_new_mail_clicked), modest_ui);
 373
 374         button = glade_xml_get_widget (priv->glade_xml, "toolb_reply");
 375         if (button) {
 376                 g_signal_connect (button, "clicked",
 377                                   G_CALLBACK(on_reply_clicked), modest_ui);
 378                 gtk_widget_set_sensitive(button, FALSE);
 379         }
 380
 381         button = glade_xml_get_widget (priv->glade_xml, "toolb_reply_all");
 382         if (button) {
 383                 //g_signal_connect (button, "clicked",
 384                 //                G_CALLBACK(on_reply_all_clicked), modest_ui);
 385                 gtk_widget_set_sensitive(button, FALSE);
 386         }
 387
 388         button = glade_xml_get_widget (priv->glade_xml, "toolb_forward");
 389         if (button) {
 390                 g_signal_connect (button, "clicked",
 391                                   G_CALLBACK(on_forward_clicked), modest_ui);
 392                 gtk_widget_set_sensitive(button, FALSE);
 393         }
 394
 395         button = glade_xml_get_widget (priv->glade_xml, "toolb_move_to");
 396         if (button) {
 397                 //g_signal_connect (button, "clicked",
 398                 //                G_CALLBACK(on_move_to_clicked), modest_ui);
 399                 gtk_widget_set_sensitive(button, FALSE);
 400         }
 401
 402         button = glade_xml_get_widget (priv->glade_xml, "toolb_delete");
 403         if (button) {
 404                 g_signal_connect (button, "clicked",
 405                                   G_CALLBACK(on_delete_clicked), modest_ui);
 406                 gtk_widget_set_sensitive(button, FALSE);
 407         }
 408
 409         button = glade_xml_get_widget (priv->glade_xml, "toolb_send_receive");
 410         if (button) {
 411                 g_signal_connect (button, "clicked",
 412                                   G_CALLBACK(on_sendreceive_button_clicked), modest_ui);
 413                 gtk_widget_set_sensitive(button, TRUE);
 414         }
 415 }
 416
 417
 418 static void
 419 hide_edit_window (GtkWidget *win, GdkEvent *event, gpointer data)
 420 {
 421         ModestUIPrivate *priv;
 422
 423         priv = MODEST_UI_GET_PRIVATE(data);
 424         gtk_widget_hide (win);
 425         modest_window_mgr_unregister(priv->modest_window_mgr, G_OBJECT(win));
 426 }
 427
 428
 429 GtkContainer
 430 *modest_ui_new_editor_window (ModestUI *modest_ui, gpointer *user_data)
 431 {
 432         GtkWidget       *top_container, *to_entry, *subject_entry, *body_view;
 433
 434         ModestUIPrivate *priv;
 435         GladeXML                *ui_ref;
 436         GtkWidget       *btn, *dummy;
 437         GtkTextBuffer   *buf;
 438
 439         priv = MODEST_UI_GET_PRIVATE(modest_ui);
 440         int height = modest_conf_get_int (priv->modest_conf,
 441                                           MODEST_CONF_EDIT_WINDOW_HEIGHT,NULL);
 442         int width  = modest_conf_get_int (priv->modest_conf,
 443                                           MODEST_CONF_EDIT_WINDOW_WIDTH,NULL);
 444
 445         ui_ref = glade_xml_new(MODEST_GLADE, "new_mail", NULL);
 446         if (!ui_ref)
 447                 return NULL;
 448
 449         *user_data = ui_ref;
 450
 451         top_container = glade_xml_get_widget(ui_ref, "new_mail_top_container");
 452         if (!top_container) {
 453                 g_object_unref(G_OBJECT(ui_ref));
 454                 return NULL;
 455         }
 456
 457         return GTK_CONTAINER(top_container);
 458 }
 459
 460
 461 gboolean
 462 modest_ui_editor_window_set_to_header(ModestEditorWindow *edit_win, gchar *to)
 463 {
 464         GladeXML *glade_xml;
 465         GtkWidget *w;
 466
 467         glade_xml = (GladeXML *)modest_editor_window_get_data(edit_win);
 468         w = glade_xml_get_widget(glade_xml, "to_entry");
 469         gtk_entry_set_text(GTK_ENTRY(w), to);
 470
 471         return TRUE;
 472 }
 473
 474
 475 gboolean
 476 modest_ui_new_edit_window (ModestUI *modest_ui, const gchar* to,
 477                             const gchar* cc, const gchar* bcc,
 478                             const gchar* subject, const gchar *body,
 479                             const GSList* att)
 480 {
 481         GtkWidget       *win, *to_entry, *subject_entry, *body_view;
 482
 483         ModestUIPrivate *priv;
 484         GtkWidget       *btn, *dummy;
 485         GtkTextBuffer   *buf;
 486
 487         priv = MODEST_UI_GET_PRIVATE(modest_ui);
 488         int height = modest_conf_get_int (priv->modest_conf,
 489                                           MODEST_CONF_EDIT_WINDOW_HEIGHT,NULL);
 490         int width  = modest_conf_get_int (priv->modest_conf,
 491                                           MODEST_CONF_EDIT_WINDOW_WIDTH,NULL);
 492
 493         win = glade_xml_get_widget (priv->glade_xml, "new_mail");
 494         if (!win) {
 495                 g_warning ("could not create new mail  window");
 496                 return FALSE;
 497         }
 498
 499         /* FIXME: this also assumes that there can be only one edit window! */
 500         if (!modest_window_mgr_find_by_type(priv->modest_window_mgr, MODEST_EDIT_WINDOW)) {
 501                 /* there already is one edit win, maybe we should preserver its contents */
 502                 modest_window_mgr_register (priv->modest_window_mgr,
 503                                                                         G_OBJECT(win), MODEST_EDIT_WINDOW, 0);
 504         }
 505
 506         to_entry      = glade_xml_get_widget (priv->glade_xml, "to_entry");
 507         subject_entry = glade_xml_get_widget (priv->glade_xml, "subject_entry");
 508         body_view     = glade_xml_get_widget (priv->glade_xml, "body_view");
 509
 510         gtk_entry_set_text(GTK_ENTRY(subject_entry), subject);
 511         gtk_entry_set_text(GTK_ENTRY(to_entry), to);
 512
 513         buf = gtk_text_view_get_buffer(GTK_TEXT_VIEW(body_view));
 514         if (body) {
 515                 gtk_text_buffer_set_text(buf, body, -1);
 516         } else {
 517                 gtk_text_buffer_set_text(buf, "", -1);
 518         }
 519         g_signal_connect (win, "destroy-event", G_CALLBACK(hide_edit_window),
 520                           modest_ui);
 521         g_signal_connect (win, "delete-event", G_CALLBACK(hide_edit_window),
 522                           modest_ui);
 523
 524         gtk_widget_set_usize (GTK_WIDGET(win), height, width);
 525         gtk_window_set_title (GTK_WINDOW(win),
 526                               subject ? subject : "Untitled");
 527
 528
 529         btn = glade_xml_get_widget (priv->glade_xml, "toolb_send");
 530         g_signal_connect (btn, "clicked", G_CALLBACK(on_send_button_clicked),
 531                           modest_ui);
 532
 533         gtk_widget_show_all (win);
 534
 535         return TRUE;
 536 }
 537
 538
 539 static void
 540 modest_ui_window_destroy (GtkWidget *win, GdkEvent *event, gpointer data)
 541 {
 542         ModestUIPrivate *priv;
 543
 544         g_return_if_fail (data);
 545         g_return_if_fail(MODEST_IS_UI(data));
 546         priv = MODEST_UI_GET_PRIVATE((ModestUI *)data);
 547         g_return_if_fail(priv);
 548         if (!modest_window_mgr_unregister (priv->modest_window_mgr, G_OBJECT(win)))
 549                 g_warning ("modest window mgr: failed to unregister %p",
 550                            G_OBJECT(win));
 551         else
 552                 gtk_widget_hide(win);
 553 }
 554
 555
 556 static void
 557 modest_ui_last_window_closed (GObject *obj, gpointer data)
 558 {
 559         /* FIXME: Other cleanups todo? Finalize Tinymail? */
 560         gtk_main_quit ();
 561 }
 562
 563
 564 void
 565 on_account_selector_selection_changed (GtkWidget *widget,
 566                                        gpointer user_data)
 567 {
 568         GtkTreeModel *model = gtk_combo_box_get_model(GTK_COMBO_BOX(widget));
 569         GtkTreeIter iter;
 570
 571         gchar *account_name;
 572
 573         if (gtk_combo_box_get_active_iter(GTK_COMBO_BOX(widget), &iter))
 574         {
 575                 gtk_tree_model_get(GTK_TREE_MODEL(model),
 576                                    &iter,
 577                                    0, &account_name,
 578                                    -1);
 579         }
 580         else
 581         {
 582                 account_name="empty";
 583         }
 584
 585         g_message("Value: '%s'\n", account_name);
 586
 587         free(account_name);
 588 }
 589
 590
 591 void
 592 on_account_settings1_activate (GtkMenuItem *menuitem,
 593                                gpointer user_data)
 594 {
 595         GladeXML *glade_xml;
 596         GtkWidget *advanced_account_setup;
 597         ModestUIPrivate *priv;
 598         gint retval;
 599         GSList *account_name_list;
 600         GSList *account_name_list_iter;
 601         GtkListStore *account_names;
 602         GtkTreeIter account_names_iter;
 603         GtkWidget *account_selector;
 604         GtkCellRenderer *renderer;
 605
 606
 607         g_return_if_fail(MODEST_IS_UI(user_data));
 608         priv = MODEST_UI_GET_PRIVATE(MODEST_UI(user_data));
 609
 610         glade_xml = glade_xml_new(MODEST_GLADE, "mailbox_setup_advanced", NULL);
 611         advanced_account_setup = glade_xml_get_widget(glade_xml, "mailbox_setup_advanced");
 612
 613         account_name_list=modest_account_mgr_account_names(priv->modest_acc_mgr, NULL);
 614         account_names = gtk_list_store_new(1, G_TYPE_STRING);
 615
 616         for (account_name_list_iter=account_name_list;
 617              account_name_list_iter!=NULL;
 618              account_name_list_iter=g_slist_next(account_name_list_iter))
 619         {
 620                 gtk_list_store_append(account_names, &account_names_iter);
 621                 gtk_list_store_set(account_names, &account_names_iter,
 622                                    0, account_name_list_iter->data,
 623                                    -1);
 624         }
 625
 626         g_slist_free(account_name_list);
 627
 628         account_selector = glade_xml_get_widget(glade_xml, "account_selector");
 629         gtk_combo_box_set_model(GTK_COMBO_BOX(account_selector), GTK_TREE_MODEL(account_names));
 630
 631         renderer = gtk_cell_renderer_text_new ();
 632         gtk_cell_layout_pack_start (GTK_CELL_LAYOUT (account_selector), renderer, TRUE);
 633         gtk_cell_layout_set_attributes (GTK_CELL_LAYOUT (account_selector), renderer,
 634                                         "text", 0,
 635                                         NULL);
 636
 637         g_signal_connect(GTK_WIDGET(account_selector), "changed",
 638                          G_CALLBACK(on_account_selector_selection_changed),
 639                          GTK_WIDGET(advanced_account_setup));
 640
 641         gtk_combo_box_set_active(GTK_COMBO_BOX(account_selector), 0);
 642
 643         gtk_widget_show_all(GTK_WIDGET(advanced_account_setup));
 644
 645         retval=gtk_dialog_run(GTK_DIALOG(advanced_account_setup));
 646
 647         g_object_unref(account_names);
 648
 649         gtk_widget_destroy(GTK_WIDGET(advanced_account_setup));
 650
 651         g_object_unref(glade_xml);
 652 }
 653
 654
 655 static void
 656 on_folder_clicked (ModestTnyFolderTreeView *folder_tree,
 657                    TnyMsgFolderIface *folder,
 658                    gpointer data)
 659 {
 660         GtkWidget *win;
 661         GtkWidget *button;
 662         GtkWidget *paned;
 663         ModestTnyHeaderTreeView *tree_view;
 664         ModestTnyMsgView *msg_view;
 665         ModestUIPrivate *priv;
 666         GtkWidget *scrollview;
 667
 668         g_return_if_fail (folder);
 669         g_return_if_fail (data);
 670
 671         priv = MODEST_UI_GET_PRIVATE(data);
 672         scrollview = glade_xml_get_widget (priv->glade_xml,"mail_list");
 673
 674         tree_view = MODEST_TNY_HEADER_TREE_VIEW(
 675                 gtk_bin_get_child(GTK_BIN(scrollview)));
 676         win = glade_xml_get_widget (priv->glade_xml, "main");
 677         gtk_window_set_title (GTK_WINDOW(win),
 678                               tny_msg_folder_iface_get_name(folder));
 679
 680         modest_tny_header_tree_view_set_folder (tree_view,
 681                                                 folder);
 682
 683         button = glade_xml_get_widget (priv->glade_xml, "toolb_reply");
 684         if (button) {
 685                 gtk_widget_set_sensitive(button, FALSE);
 686         }
 687
 688         button = glade_xml_get_widget (priv->glade_xml, "toolb_forward");
 689         if (button) {
 690                 gtk_widget_set_sensitive(button, FALSE);
 691         }
 692
 693         button = glade_xml_get_widget (priv->glade_xml, "toolb_delete");
 694         if (button) {
 695                 gtk_widget_set_sensitive(button, FALSE);
 696         }
 697
 698         paned = glade_xml_get_widget (priv->glade_xml,"mail_paned");
 699         g_return_if_fail (paned);
 700
 701         msg_view = MODEST_TNY_MSG_VIEW(gtk_paned_get_child2 (GTK_PANED(paned)));
 702         g_return_if_fail (msg_view);
 703
 704         modest_tny_msg_view_set_message  (msg_view, NULL);
 705 }
 706
 707
 708 static void
 709 on_message_clicked (ModestTnyFolderTreeView *folder_tree,
 710                                 TnyMsgIface *message,
 711                                 gpointer data)
 712 {
 713         GtkWidget *paned;
 714         GtkWidget *button;
 715         ModestTnyMsgView *msg_view;
 716         ModestUIPrivate *priv;
 717
 718         g_return_if_fail (data);
 719
 720         priv = MODEST_UI_GET_PRIVATE(data);
 721         paned = glade_xml_get_widget (priv->glade_xml,"mail_paned");
 722         msg_view = MODEST_TNY_MSG_VIEW(gtk_paned_get_child2 (GTK_PANED(paned)));
 723
 724         modest_tny_msg_view_set_message (msg_view,
 725                                          message);
 726         button = glade_xml_get_widget (priv->glade_xml, "toolb_reply");
 727         if (button) {
 728                 gtk_widget_set_sensitive(button, TRUE);
 729         }
 730         button = glade_xml_get_widget (priv->glade_xml, "toolb_forward");
 731         if (button) {
 732                 gtk_widget_set_sensitive(button, TRUE);
 733         }
 734         button = glade_xml_get_widget (priv->glade_xml, "toolb_delete");
 735         if (button) {
 736                 gtk_widget_set_sensitive(button, TRUE);
 737         }
 738 }
 739
 740
 741 static void
 742 on_password_requested (ModestTnyAccountStore *account_store,
 743                        const gchar *account_name, gpointer user_data)
 744 {
 745
 746         GtkWidget *passdialog;
 747         GtkWidget *vbox;
 748         GtkWidget *infolabel;
 749         GtkWidget *passentry;
 750         gint retval;
 751         const gchar *infostring=g_strconcat("Please enter the password for ", account_name, ".", NULL);
 752
 753         passdialog = gtk_dialog_new_with_buttons("MyDialog",
 754                                                  NULL,
 755                                                  GTK_DIALOG_MODAL|GTK_DIALOG_DESTROY_WITH_PARENT,
 756                                                  GTK_STOCK_OK,
 757                                                  GTK_RESPONSE_ACCEPT,
 758                                                  GTK_STOCK_CANCEL,
 759                                                  GTK_RESPONSE_REJECT,
 760                                                  NULL);
 761
 762         vbox=gtk_vbox_new(FALSE, 0);
 763
 764         infolabel=gtk_label_new(infostring);
 765         passentry=gtk_entry_new();
 766
 767         gtk_box_pack_start(GTK_BOX(GTK_DIALOG(passdialog)->vbox), infolabel, FALSE, FALSE, 0);
 768         gtk_box_pack_start(GTK_BOX(GTK_DIALOG(passdialog)->vbox), passentry, FALSE, FALSE, 0);
 769         gtk_widget_show_all(passdialog);
 770
 771         retval = gtk_dialog_run (GTK_DIALOG(passdialog));
 772
 773         switch (retval)
 774         {
 775         case GTK_RESPONSE_ACCEPT:
 776                 modest_account_mgr_set_server_account_string(modest_tny_account_store_get_accout_mgr(account_store),
 777                                                              account_name,
 778                                                              "password",
 779                                                              gtk_entry_get_text(GTK_ENTRY(passentry)),
 780                                                              NULL);
 781                 break;
 782         case GTK_RESPONSE_CANCEL:
 783                 /* FIXME:
 784                  * What happens, if canceled?"
 785                  */
 786                 break;
 787         }
 788
 789         gtk_widget_destroy (passdialog);
 790 }
 791
 792
 793 static GtkWidget*
 794 modest_main_window_header_tree (TnyMsgFolderIface *folder)
 795 {
 796         int i;
 797         GSList *columns = NULL;
 798         GtkWidget *header_tree;
 799         ModestTnyHeaderTreeViewColumn cols[] = {
 800                 MODEST_TNY_HEADER_TREE_VIEW_COLUMN_MSGTYPE,
 801                 MODEST_TNY_HEADER_TREE_VIEW_COLUMN_ATTACH,
 802                 MODEST_TNY_HEADER_TREE_VIEW_COLUMN_COMPACT_HEADER
 803         };
 804
 805         for (i = 0 ; i != sizeof(cols)/sizeof(ModestTnyHeaderTreeViewColumn); ++i)
 806                 columns = g_slist_append (columns, GINT_TO_POINTER(cols[i]));
 807
 808         header_tree = GTK_WIDGET(modest_tny_header_tree_view_new(folder, columns,
 809                                                                  MODEST_TNY_HEADER_TREE_VIEW_STYLE_NORMAL));
 810         g_slist_free (columns);
 811
 812         if (!header_tree) {
 813                 g_warning ("could not create header tree");
 814                 return NULL;
 815         }
 816
 817         return GTK_WIDGET(header_tree);
 818 }
 819
 820
 821 static GtkWidget*
 822 modest_main_window_folder_tree (ModestAccountMgr *modest_acc_mgr,
 823                                 TnyAccountStoreIface *account_store)
 824 {
 825         GtkWidget *folder_tree;
 826
 827         folder_tree = GTK_WIDGET(modest_tny_folder_tree_view_new (account_store));
 828         if (!folder_tree) {
 829                 g_warning ("could not create folder list");
 830                 return NULL;
 831         }
 832
 833         return folder_tree;
 834 }
 835
 836
 837 static void
 838 on_new_mail_clicked (GtkWidget *widget, ModestUI *modest_ui)
 839 {
 840         g_return_if_fail (modest_ui);
 841         modest_ui_new_edit_window (modest_ui, "", "", "", "", "", NULL);
 842 }
 843
 844
 845 static void
 846 quoted_send_msg (ModestUI *modest_ui, quoted_send_type qstype) {
 847         GtkTreeSelection *sel;
 848         GtkWidget *paned;
 849         GtkTreeModel *model;
 850         GtkTreeIter iter;
 851         GtkScrolledWindow *scroll;
 852
 853         TnyMsgHeaderIface *header;
 854
 855         ModestTnyHeaderTreeView *header_view;
 856         ModestTnyMsgView *msg_view;
 857         ModestUIPrivate *priv;
 858
 859         const TnyMsgIface *msg;
 860         const TnyMsgFolderIface *folder;
 861         GString *re_sub;
 862         const gchar *subject, *from;
 863         gchar *unquoted, *quoted;
 864         time_t sent_date;
 865         gint line_limit = 76;
 866
 867         g_return_if_fail (modest_ui);
 868
 869         priv = MODEST_UI_GET_PRIVATE(modest_ui);
 870
 871         paned = glade_xml_get_widget (priv->glade_xml,"mail_paned");
 872         g_return_if_fail (paned);
 873
 874         scroll = GTK_SCROLLED_WINDOW(gtk_paned_get_child1 (GTK_PANED(paned)));
 875         g_return_if_fail (scroll);
 876
 877         msg_view = MODEST_TNY_MSG_VIEW(gtk_paned_get_child2 (GTK_PANED(paned)));
 878         g_return_if_fail (msg_view);
 879
 880         header_view = MODEST_TNY_HEADER_TREE_VIEW(gtk_bin_get_child (GTK_BIN(scroll)));
 881         g_return_if_fail (header_view);
 882
 883         sel = gtk_tree_view_get_selection (GTK_TREE_VIEW(header_view));
 884         g_return_if_fail (sel);
 885
 886         if (!gtk_tree_selection_get_selected (sel, &model, &iter)) {
 887                 g_warning("nothing to reply to");
 888                 return;
 889         }
 890
 891         gtk_tree_model_get (model, &iter,
 892                             TNY_MSG_HEADER_LIST_MODEL_INSTANCE_COLUMN,
 893                             &header, -1);
 894
 895         if (!header) {
 896                 g_warning("no header");
 897                 return;
 898         }
 899
 900         folder = tny_msg_header_iface_get_folder (TNY_MSG_HEADER_IFACE(header));
 901         if (!folder) {
 902                 g_warning ("cannot find folder");
 903                 return;
 904         }
 905
 906         msg = tny_msg_folder_iface_get_message (TNY_MSG_FOLDER_IFACE(folder), header);
 907         if (!msg) {
 908                 g_warning ("cannot find msg");
 909                 return;
 910         }
 911
 912         subject = tny_msg_header_iface_get_subject(header);
 913         re_sub = g_string_new(subject);
 914         /* FIXME: honor replyto, cc */
 915         from = tny_msg_header_iface_get_from(header);
 916         sent_date = tny_msg_header_iface_get_date_sent(header);
 917
 918         unquoted = modest_tny_msg_view_get_selected_text(msg_view);
 919         quoted = modest_tny_msg_actions_quote(msg, from, sent_date, line_limit, unquoted);
 920
 921         switch (qstype) {
 922                 case QUOTED_SEND_REPLY:
 923                         g_string_prepend(re_sub, _("Re: "));
 924                         modest_ui_new_edit_window (modest_ui, from, /* cc */ "", /* bcc */ "", re_sub->str, quoted, NULL);
 925                         break;
 926                 case QUOTED_SEND_FORWARD:
 927                         g_string_prepend(re_sub, _("Fwd: "));
 928                         modest_ui_new_edit_window (modest_ui, /* from */ "", /* cc */ "", /* bcc */ "", re_sub->str, quoted, NULL);
 929                         break;
 930                 default:
 931                         break;
 932         }
 933         g_free(quoted);
 934         g_free(unquoted);
 935         g_string_free(re_sub, TRUE);
 936 }
 937
 938
 939 static void
 940 on_reply_clicked (GtkWidget *widget, ModestUI *modest_ui)
 941 {
 942         quoted_send_msg (modest_ui, QUOTED_SEND_REPLY);
 943 }
 944
 945
 946 static void
 947 on_forward_clicked (GtkWidget *widget, ModestUI *modest_ui)
 948 {
 949         quoted_send_msg (modest_ui, QUOTED_SEND_FORWARD);
 950 }
 951
 952
 953
 954 /* FIXME: truly evil --> we cannot really assume that
 955  * there is only one edit window open...
 956  */
 957 static void
 958 on_send_button_clicked (GtkWidget *widget, ModestUI *modest_ui)
 959 {
 960         ModestTnyTransportActions *actions;
 961         ModestUIPrivate *priv;
 962         GtkWidget *to_entry, *subject_entry, *body_view;
 963         const gchar *to, *subject, *email_from;
 964         gchar *body;
 965         GtkTextIter start, end;
 966         GtkTextBuffer *buf;
 967         TnyAccountStoreIface *account_store;
 968         const GList *transport_accounts;
 969         TnyTransportAccountIface *transport_account;
 970         ModestConf       *conf;
 971         ModestIdentityMgr *id_mgr;
 972
 973         g_return_if_fail (modest_ui);
 974
 975         actions = MODEST_TNY_TRANSPORT_ACTIONS
 976                 (modest_tny_transport_actions_new ());
 977         priv = MODEST_UI_GET_PRIVATE(modest_ui);
 978
 979         account_store = priv->account_store;
 980         transport_accounts =
 981                 tny_account_store_iface_get_transport_accounts (account_store);
 982         if (!transport_accounts) {
 983                 g_message ("cannot send message: no transport account defined");
 984                 return;
 985         } else /* take the first one! */
 986                 transport_account =
 987                         TNY_TRANSPORT_ACCOUNT_IFACE(transport_accounts->data);
 988
 989         to_entry      = glade_xml_get_widget (priv->glade_xml, "to_entry");
 990         subject_entry = glade_xml_get_widget (priv->glade_xml, "subject_entry");
 991         body_view     = glade_xml_get_widget (priv->glade_xml, "body_view");
 992
 993         to      = gtk_entry_get_text (GTK_ENTRY(to_entry));
 994         subject = gtk_entry_get_text (GTK_ENTRY(subject_entry));
 995
 996         buf = gtk_text_view_get_buffer(GTK_TEXT_VIEW(body_view));
 997         gtk_text_buffer_get_bounds (buf, &start, &end);
 998         body    = gtk_text_buffer_get_text (buf, &start, &end, FALSE);
 999
1000         id_mgr = priv->modest_id_mgr;
1001         email_from = modest_identity_mgr_get_identity_string(id_mgr,
1002                                                              MODEST_IDENTITY_DEFAULT_IDENTITY,
1003                                                              MODEST_IDENTITY_EMAIL, NULL);
1004
1005         g_message("sending \"%s\" %s ==> %s", subject, email_from, to);
1006         modest_tny_transport_actions_send_message (actions,
1007                                                    transport_account,
1008                                                    email_from,
1009                                                    to, "", "", subject,
1010                                                    body);
1011         g_free (body);
1012         g_object_unref (G_OBJECT(actions));
1013
1014         gtk_entry_set_text (GTK_ENTRY(to_entry), "");
1015         gtk_entry_set_text (GTK_ENTRY(subject_entry), "");
1016         gtk_text_buffer_set_text (buf, "", 0);
1017
1018         gtk_widget_hide (glade_xml_get_widget (priv->glade_xml, "new_mail"));
1019 }
1020
1021
1022 static void
1023 on_delete_clicked (GtkWidget *widget, ModestUI *modest_ui)
1024 {
1025         GtkTreeSelection *sel;
1026         GtkWidget *paned;
1027         GtkTreeModel *model;
1028         GtkTreeIter iter;
1029         GtkScrolledWindow *scroll;
1030         GtkTreeModel *mymodel, *sortable;
1031
1032         ModestTnyHeaderTreeView *header_view;
1033         ModestTnyMsgView *msg_view;
1034         ModestUIPrivate *priv;
1035
1036         g_return_if_fail (modest_ui);
1037
1038         priv = MODEST_UI_GET_PRIVATE(modest_ui);
1039
1040         paned = glade_xml_get_widget (priv->glade_xml,"mail_paned");
1041         g_return_if_fail (paned);
1042
1043         scroll = GTK_SCROLLED_WINDOW(gtk_paned_get_child1 (GTK_PANED(paned)));
1044         g_return_if_fail (scroll);
1045
1046         msg_view = MODEST_TNY_MSG_VIEW(gtk_paned_get_child2 (GTK_PANED(paned)));
1047         g_return_if_fail (msg_view);
1048
1049         header_view = MODEST_TNY_HEADER_TREE_VIEW(gtk_bin_get_child (GTK_BIN(scroll)));
1050         g_return_if_fail (header_view);
1051
1052         sel = gtk_tree_view_get_selection (GTK_TREE_VIEW(header_view));
1053         g_return_if_fail (sel);
1054
1055         /* get all selected mails */
1056         if (G_LIKELY (gtk_tree_selection_get_selected (sel, &model, &iter)))
1057         {
1058                 TnyMsgHeaderIface *header;
1059
1060                 gtk_tree_model_get (model, &iter, TNY_MSG_HEADER_LIST_MODEL_INSTANCE_COLUMN,
1061                         &header, -1);
1062
1063                 if (G_LIKELY (header))
1064                 {
1065                         TnyMsgFolderIface *folder;
1066                         const TnyMsgIface *msg;
1067
1068                         if (GTK_IS_TREE_MODEL_SORT (model))
1069                         {
1070                                 mymodel = gtk_tree_model_sort_get_model
1071                                         (GTK_TREE_MODEL_SORT (model));
1072                         } else
1073                                 mymodel = model;
1074
1075                         folder = (TnyMsgFolderIface*)tny_msg_header_iface_get_folder (header);
1076
1077                         /* this will make the message as deleted */
1078                         /*      tny_msg_folder_iface_expunge (folder); will finally delete messages */
1079                         if (TNY_IS_MSG_FOLDER (folder))
1080                                 tny_msg_folder_iface_remove_message (folder, header);
1081                         gtk_widget_queue_draw (GTK_WIDGET (header_view));
1082                 }
1083         }
1084 }
1085
1086 static void
1087 on_sendreceive_button_clicked (GtkWidget *widget, ModestUI *modest_ui)
1088 {
1089         ModestUIPrivate *priv;
1090         ModestTnyStoreActions *store_actions;
1091         TnyAccountStoreIface *account_store;
1092         const GList *store_accounts;
1093         const GList *iter;
1094
1095         g_return_if_fail (modest_ui);
1096
1097         store_actions = MODEST_TNY_STORE_ACTIONS (modest_tny_store_actions_new ());
1098         priv = MODEST_UI_GET_PRIVATE(modest_ui);
1099
1100         account_store = priv->account_store;
1101         store_accounts =
1102                 tny_account_store_iface_get_store_accounts (account_store);
1103
1104         for (iter = store_accounts; iter; iter = iter->next)
1105                 modest_tny_store_actions_update_folders (store_actions,
1106                                                                                                  TNY_STORE_ACCOUNT_IFACE (iter->data));
1107
1108         /* TODO, lock, refresh display */
1109
1110         g_object_unref (store_actions);
1111
1112 }