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-account-mgr.h"
  22 #include "../modest-identity-mgr.h"
  23
  24 #include "../modest-tny-account-store.h"
  25 #include "../modest-tny-folder-tree-view.h"
  26 #include "../modest-tny-header-tree-view.h"
  27 #include "../modest-tny-msg-view.h"
  28 #include "../modest-tny-transport-actions.h"
  29 #include "../modest-tny-store-actions.h"
  30
  31 #include "../modest-text-utils.h"
  32 #include "../modest-tny-msg-actions.h"
  33
  34 #include "../modest-editor-window.h"
  35
  36 #include "modest-ui-glade.h"
  37 #include "modest-ui-wizard.h"
  38
  39 /* 'private'/'protected' functions */
  40 static void   modest_ui_class_init     (ModestUIClass *klass);
  41 static void   modest_ui_init           (ModestUI *obj);
  42 static void   modest_ui_finalize       (GObject *obj);
  43
  44 static void    modest_ui_window_destroy    (GtkWidget *win, GdkEvent *event, gpointer data);
  45 static void    modest_ui_last_window_closed (GObject *obj, gpointer data);
  46
  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 //static void on_account_settings1_activate (GtkMenuItem *,
  52 //                                  gpointer);
  53
  54 static void on_password_requested (ModestTnyAccountStore *account_store,
  55                                    const gchar *account_name, gpointer user_data);
  56
  57 static void on_folder_clicked (ModestTnyFolderTreeView *folder_tree,
  58                                TnyMsgFolderIface *folder,
  59                                gpointer data);
  60 static void on_message_clicked (ModestTnyFolderTreeView *folder_tree,
  61                                 TnyMsgIface *message,
  62                                 gpointer data);
  63 static void on_new_mail_clicked (GtkWidget *widget, ModestUI *modest_ui);
  64
  65 static void on_reply_clicked (GtkWidget *widget, ModestUI *modest_ui);
  66
  67 static void on_forward_clicked (GtkWidget *widget, ModestUI *modest_ui);
  68
  69 static void on_delete_clicked (GtkWidget *widget, ModestUI *modest_ui);
  70
  71 static void on_view_attachments_toggled(GtkWidget *widget, ModestUI *modest_ui);
  72
  73 #if 1
  74 static void on_send_button_clicked (GtkWidget *widget, ModestEditorWindow *modest_editwin);
  75 #else
  76 static void on_send_button_clicked (GtkWidget *widget, ModestUI *modest_ui);
  77 #endif
  78
  79 static void on_sendreceive_button_clicked (GtkWidget *widget, ModestUI *modest_ui);
  80
  81 static void register_toolbar_callbacks (ModestUI *modest_ui);
  82
  83 typedef enum {
  84         QUOTED_SEND_REPLY,
  85         QUOTED_SEND_REPLY_ALL,
  86         QUOTED_SEND_FORWARD
  87 } quoted_send_type;
  88
  89 static void quoted_send_msg (ModestUI *modest_ui, quoted_send_type qstype);
  90
  91
  92 typedef struct {
  93         ModestUI *modest_ui;
  94         ModestEditorWindow *edit_win;
  95         GladeXML *glade_xml;
  96 } EditWinData;
  97
  98
  99 /* list my signals */
 100 enum {
 101         /* MY_SIGNAL_1, */
 102         /* MY_SIGNAL_2, */
 103         LAST_SIGNAL
 104 };
 105
 106 /* globals */
 107 static GObjectClass *parent_class = NULL;
 108
 109 /* uncomment the following if you have defined any signals */
 110 /* static guint signals[LAST_SIGNAL] = {0}; */
 111
 112 GType
 113 modest_ui_get_type (void)
 114 {
 115         static GType my_type = 0;
 116         if (!my_type) {
 117                 static const GTypeInfo my_info = {
 118                         sizeof(ModestUIClass),
 119                         NULL,           /* base init */
 120                         NULL,           /* base finalize */
 121                         (GClassInitFunc) modest_ui_class_init,
 122                         NULL,           /* class finalize */
 123                         NULL,           /* class data */
 124                         sizeof(ModestUI),
 125                         1,              /* n_preallocs */
 126                         (GInstanceInitFunc) modest_ui_init,
 127                 };
 128                 my_type = g_type_register_static (G_TYPE_OBJECT,
 129                                                   "ModestUI",
 130                                                   &my_info, 0);
 131         }
 132         return my_type;
 133 }
 134
 135
 136 static void
 137 modest_ui_class_init (ModestUIClass *klass)
 138 {
 139         GObjectClass *gobject_class;
 140         gobject_class = (GObjectClass*) klass;
 141
 142         parent_class            = g_type_class_peek_parent (klass);
 143         gobject_class->finalize = modest_ui_finalize;
 144
 145         g_type_class_add_private (gobject_class, sizeof(ModestUIPrivate));
 146
 147         /* signal definitions go here, e.g.: */
 148 /*      signals[MY_SIGNAL_1] = */
 149 /*              g_signal_new ("my_signal_1",....); */
 150 /*      signals[MY_SIGNAL_2] = */
 151 /*              g_signal_new ("my_signal_2",....); */
 152 /*      etc. */
 153 }
 154
 155
 156 static void
 157 modest_ui_init (ModestUI *obj)
 158 {
 159         ModestUIPrivate *priv = MODEST_UI_GET_PRIVATE(obj);
 160
 161         priv->modest_acc_mgr    = NULL;
 162         priv->modest_id_mgr     = NULL;
 163         priv->modest_conf       = NULL;
 164         priv->modest_window_mgr = NULL;
 165         priv->glade_xml         = NULL;
 166         priv->folder_view       = NULL;
 167         priv->header_view       = NULL;
 168
 169 }
 170
 171
 172 static void
 173 modest_ui_finalize (GObject *obj)
 174 {
 175         ModestUIPrivate *priv = MODEST_UI_GET_PRIVATE(obj);
 176
 177         if (priv->modest_acc_mgr)
 178                 g_object_unref (priv->modest_acc_mgr);
 179         priv->modest_acc_mgr = NULL;
 180
 181         if (priv->modest_id_mgr)
 182                 g_object_unref (priv->modest_id_mgr);
 183         priv->modest_id_mgr = NULL;
 184
 185         if (priv->modest_conf)
 186                 g_object_unref (priv->modest_conf);
 187         priv->modest_conf = NULL;
 188
 189         if (priv->modest_window_mgr)
 190                 g_object_unref (priv->modest_window_mgr);
 191         priv->modest_window_mgr = NULL;
 192 }
 193
 194
 195 GObject*
 196 modest_ui_new (ModestConf *modest_conf)
 197 {
 198         GObject *obj;
 199         ModestUIPrivate *priv;
 200         ModestAccountMgr *modest_acc_mgr;
 201         ModestIdentityMgr *modest_id_mgr;
 202         TnyAccountStoreIface *account_store_iface;
 203         GSList *account_names_list;
 204         GSList *identities_list;
 205
 206         g_return_val_if_fail (modest_conf, NULL);
 207
 208         obj = g_object_new(MODEST_TYPE_UI, NULL);
 209         priv = MODEST_UI_GET_PRIVATE(obj);
 210
 211         modest_acc_mgr =
 212                 MODEST_ACCOUNT_MGR(modest_account_mgr_new (modest_conf));
 213         if (!modest_acc_mgr) {
 214                 g_warning ("could not create ModestAccountMgr instance");
 215                 g_object_unref (obj);
 216                 return NULL;
 217         }
 218
 219         modest_id_mgr =
 220                 MODEST_IDENTITY_MGR(modest_identity_mgr_new (modest_conf));
 221         if (!modest_id_mgr) {
 222                 g_warning ("could not create ModestIdentityMgr instance");
 223                 g_object_unref (obj);
 224                 return NULL;
 225         }
 226
 227         account_store_iface =
 228                 TNY_ACCOUNT_STORE_IFACE(modest_tny_account_store_new (modest_acc_mgr));
 229         if (!account_store_iface) {
 230                 g_warning ("could not initialze ModestTnyAccountStore");
 231                 return NULL;
 232         }
 233         g_signal_connect (account_store_iface, "password_requested",
 234                           G_CALLBACK(on_password_requested),
 235                           NULL);
 236
 237         glade_init ();
 238         priv->glade_xml = glade_xml_new (MODEST_GLADE, NULL,NULL);
 239         if (!priv->glade_xml) {
 240                 g_warning ("failed to do glade stuff");
 241                 g_object_unref (obj);
 242                 return NULL;
 243         }
 244
 245         /* FIXME: could be used, but doesn't work atm.
 246          * glade_xml_signal_autoconnect(priv->glade_xml);
 247          */
 248
 249         priv->modest_acc_mgr = modest_acc_mgr;
 250         priv->modest_id_mgr  = modest_id_mgr;
 251         g_object_ref (priv->modest_conf = modest_conf);
 252
 253         priv->account_store = account_store_iface;
 254
 255         priv->modest_window_mgr = MODEST_WINDOW_MGR(modest_window_mgr_new());
 256         g_signal_connect (priv->modest_window_mgr, "last_window_closed",
 257                           G_CALLBACK(modest_ui_last_window_closed),
 258                           NULL);
 259
 260         account_names_list=modest_account_mgr_server_account_names(modest_acc_mgr, NULL, MODEST_PROTO_TYPE_ANY, NULL, FALSE);
 261         identities_list=modest_identity_mgr_identity_names(modest_id_mgr, NULL);
 262         if (!(account_names_list!=NULL || identities_list!=NULL))
 263                 wizard_account_dialog(MODEST_UI(obj));
 264         g_slist_free(account_names_list);
 265         g_slist_free(identities_list);
 266
 267         return obj;
 268 }
 269
 270
 271 gboolean
 272 modest_ui_show_main_window (ModestUI *modest_ui)
 273 {
 274         GtkWidget       *win;
 275         gint              height, width;
 276         ModestUIPrivate *priv;
 277         GtkWidget     *folder_view, *header_view;
 278         GtkWidget     *message_view;
 279         GtkWidget     *account_settings_item;
 280         GtkWidget     *new_account_item;
 281         GtkWidget     *delete_item;
 282         GtkWidget     *view_attachments_item;
 283
 284         GtkWidget  *folder_view_holder,
 285                 *header_view_holder,
 286                 *mail_paned;
 287
 288         priv = MODEST_UI_GET_PRIVATE(modest_ui);
 289
 290         height = modest_conf_get_int (priv->modest_conf,
 291                                       MODEST_CONF_MAIN_WINDOW_HEIGHT,NULL);
 292         width  = modest_conf_get_int (priv->modest_conf,
 293                                       MODEST_CONF_MAIN_WINDOW_WIDTH,NULL);
 294
 295         win = glade_xml_get_widget (priv->glade_xml, "main");
 296         if (!win) {
 297                 g_warning ("could not create main window");
 298                 return FALSE;
 299         }
 300
 301         folder_view =
 302                 GTK_WIDGET(modest_main_window_folder_tree(priv->modest_acc_mgr,
 303                                                           priv->account_store));
 304         priv->folder_view = folder_view;
 305         folder_view_holder = glade_xml_get_widget (priv->glade_xml, "folders");
 306         if (!folder_view||!folder_view_holder) {
 307                 g_warning ("failed to create folder tree");
 308                 return FALSE;
 309         }
 310         gtk_container_add (GTK_CONTAINER(folder_view_holder), folder_view);
 311
 312         header_view  =  GTK_WIDGET(modest_main_window_header_tree (NULL));
 313         priv->header_view = header_view;
 314         header_view_holder = glade_xml_get_widget (priv->glade_xml, "mail_list");
 315         if (!header_view) {
 316                 g_warning ("failed to create header tree");
 317                 return FALSE;
 318         }
 319         gtk_container_add (GTK_CONTAINER(header_view_holder), header_view);
 320
 321         g_signal_connect (G_OBJECT(folder_view), "folder_selected",
 322                           G_CALLBACK(on_folder_clicked), modest_ui);
 323
 324         message_view  = GTK_WIDGET(modest_tny_msg_view_new (NULL, priv->modest_conf));
 325         if (!message_view) {
 326                 g_warning ("failed to create message view");
 327                 return FALSE;
 328         }
 329         mail_paned = glade_xml_get_widget (priv->glade_xml, "mail_paned");
 330         gtk_paned_add2 (GTK_PANED(mail_paned), message_view);
 331
 332         g_signal_connect (header_view, "message_selected",
 333                           G_CALLBACK(on_message_clicked),
 334                           modest_ui);
 335
 336         account_settings_item = glade_xml_get_widget (priv->glade_xml, "AccountSettingsMenuItem");
 337         if (!account_settings_item)
 338         {
 339                 g_warning ("The account settings item isn't available!\n");
 340                 return FALSE;
 341         }
 342         /*
 343         g_signal_connect (account_settings_item, "activate",
 344                           G_CALLBACK(on_account_settings1_activate),
 345                           modest_ui);
 346         */
 347
 348         new_account_item = glade_xml_get_widget (priv->glade_xml, "NewAccountWizardMenuItem");
 349         if (!new_account_item)
 350         {
 351                 g_warning ("The new account item isn't available!\n");
 352                 return FALSE;
 353         }
 354
 355         g_signal_connect (new_account_item, "activate",
 356                           G_CALLBACK(new_wizard_account),
 357                           modest_ui);
 358
 359         delete_item = glade_xml_get_widget (priv->glade_xml, "delete1");
 360         if (!delete_item)
 361         {
 362                 g_warning ("The delete item isn't available!\n");
 363                 return FALSE;
 364         }
 365
 366         g_signal_connect (delete_item, "activate", G_CALLBACK(on_delete_clicked),
 367                           modest_ui);
 368
 369         view_attachments_item = glade_xml_get_widget (priv->glade_xml, "menu_view_attachments");
 370         if (!view_attachments_item)
 371         {
 372                 g_warning ("The view_attachments_item isn't available!");
 373                 return FALSE;
 374         }
 375
 376         gtk_check_menu_item_set_active(GTK_CHECK_MENU_ITEM(view_attachments_item),
 377                                                                    modest_conf_get_bool(priv->modest_conf,
 378                                                                                                                 MODEST_CONF_MSG_VIEW_SHOW_ATTACHMENTS_INLINE,
 379                                                                                                                 NULL)
 380                                                                    );
 381
 382         g_signal_connect (view_attachments_item,
 383                                           "toggled",
 384                                           G_CALLBACK(on_view_attachments_toggled),
 385                                           modest_ui);
 386
 387         register_toolbar_callbacks (modest_ui);
 388
 389         modest_window_mgr_register (priv->modest_window_mgr,
 390                                     G_OBJECT(win), MODEST_MAIN_WINDOW, 0);
 391         g_signal_connect (win, "destroy-event", G_CALLBACK(modest_ui_window_destroy),
 392                           modest_ui);
 393         g_signal_connect (win, "delete-event", G_CALLBACK(modest_ui_window_destroy),
 394                           modest_ui);
 395         gtk_widget_set_usize (GTK_WIDGET(win), width, height);
 396         gtk_window_set_title (GTK_WINDOW(win), PACKAGE_STRING);
 397
 398         gtk_widget_show_all (win);
 399         return TRUE;
 400 }
 401
 402
 403 static void
 404 register_toolbar_callbacks (ModestUI *modest_ui)
 405 {
 406         ModestUIPrivate *priv;
 407         GtkWidget *button;
 408
 409         g_return_if_fail (modest_ui);
 410
 411         priv = MODEST_UI_GET_PRIVATE (modest_ui);
 412
 413         button = glade_xml_get_widget (priv->glade_xml, "toolb_new_mail");
 414         if (button)
 415                 g_signal_connect (button, "clicked",
 416                                   G_CALLBACK(on_new_mail_clicked), modest_ui);
 417
 418         button = glade_xml_get_widget (priv->glade_xml, "toolb_reply");
 419         if (button) {
 420                 g_signal_connect (button, "clicked",
 421                                   G_CALLBACK(on_reply_clicked), modest_ui);
 422                 gtk_widget_set_sensitive(button, FALSE);
 423         }
 424
 425         button = glade_xml_get_widget (priv->glade_xml, "toolb_reply_all");
 426         if (button) {
 427                 //g_signal_connect (button, "clicked",
 428                 //                G_CALLBACK(on_reply_all_clicked), modest_ui);
 429                 gtk_widget_set_sensitive(button, FALSE);
 430         }
 431
 432         button = glade_xml_get_widget (priv->glade_xml, "toolb_forward");
 433         if (button) {
 434                 g_signal_connect (button, "clicked",
 435                                   G_CALLBACK(on_forward_clicked), modest_ui);
 436                 gtk_widget_set_sensitive(button, FALSE);
 437         }
 438
 439         button = glade_xml_get_widget (priv->glade_xml, "toolb_move_to");
 440         if (button) {
 441                 //g_signal_connect (button, "clicked",
 442                 //                G_CALLBACK(on_move_to_clicked), modest_ui);
 443                 gtk_widget_set_sensitive(button, FALSE);
 444         }
 445
 446         button = glade_xml_get_widget (priv->glade_xml, "toolb_delete");
 447         if (button) {
 448                 g_signal_connect (button, "clicked",
 449                                   G_CALLBACK(on_delete_clicked), modest_ui);
 450                 gtk_widget_set_sensitive(button, FALSE);
 451         }
 452
 453         button = glade_xml_get_widget (priv->glade_xml, "toolb_send_receive");
 454         if (button) {
 455                 g_signal_connect (button, "clicked",
 456                                   G_CALLBACK(on_sendreceive_button_clicked), modest_ui);
 457                 gtk_widget_set_sensitive(button, TRUE);
 458         }
 459 }
 460
 461 #if 0
 462 static void
 463 hide_edit_window (GtkWidget *win, GdkEvent *event, gpointer data)
 464 {
 465         ModestUIPrivate *priv;
 466
 467         priv = MODEST_UI_GET_PRIVATE(data);
 468         gtk_widget_hide (win);
 469         modest_window_mgr_unregister(priv->modest_window_mgr, G_OBJECT(win));
 470 }
 471 #endif
 472
 473
 474 static gboolean close_edit_confirm_dialog(ModestEditorWindow *edit_win)
 475 {
 476         GtkWidget *mdialog;
 477         gint res;
 478
 479         mdialog = gtk_message_dialog_new(GTK_WINDOW(edit_win),
 480                         GTK_DIALOG_MODAL | GTK_DIALOG_DESTROY_WITH_PARENT,
 481                         GTK_MESSAGE_QUESTION,
 482                         GTK_BUTTONS_YES_NO,
 483                         _("Message was modified.\nDiscard Changes?"));
 484         gtk_widget_show_all (mdialog);
 485
 486         res=gtk_dialog_run(GTK_DIALOG(mdialog));
 487         gtk_widget_destroy (mdialog);
 488         if (res == GTK_RESPONSE_YES)
 489                 return TRUE;
 490         else
 491                 return FALSE;
 492 }
 493
 494 static void
 495 close_edit_window (GtkWidget *win, GdkEvent *event, gpointer data)
 496 {
 497         ModestEditorWindow *edit_win;
 498         ModestUIPrivate *priv;
 499         EditWinData *win_data;
 500
 501         edit_win = (ModestEditorWindow *)data;
 502         win_data = modest_editor_window_get_data(edit_win);
 503         priv = MODEST_UI_GET_PRIVATE(win_data->modest_ui);
 504
 505         // g_message("window was %s modified", modest_editor_window_get_modified(edit_win) ? "" : "not");
 506
 507         if (modest_editor_window_get_modified(edit_win)) {
 508                 if (close_edit_confirm_dialog(edit_win)) {
 509                         gtk_widget_hide (GTK_WIDGET(edit_win));
 510                         modest_window_mgr_unregister(priv->modest_window_mgr, G_OBJECT(edit_win));
 511                         gtk_widget_destroy(GTK_WIDGET(edit_win));
 512                         g_message("closing window");
 513                 } else {
 514                         g_message("not closing window");
 515                 }
 516         }
 517 }
 518
 519
 520 GtkContainer
 521 *modest_ui_new_editor_window (ModestUI *modest_ui, gpointer *user_data)
 522 {
 523         GtkWidget       *top_container;
 524
 525         GladeXML                *glade_xml;
 526         EditWinData             *win_data;
 527
 528         glade_xml = glade_xml_new(MODEST_GLADE, "new_mail_top_container", NULL);
 529         if (!glade_xml)
 530                 return NULL;
 531
 532         win_data = g_malloc(sizeof(EditWinData));
 533         win_data->modest_ui = modest_ui;
 534         win_data->glade_xml = glade_xml;
 535         *user_data = win_data;
 536
 537         top_container = glade_xml_get_widget(glade_xml, "new_mail_top_container");
 538         if (!top_container) {
 539                 g_object_unref(G_OBJECT(glade_xml));
 540                 return NULL;
 541         }
 542
 543         return GTK_CONTAINER(top_container);
 544 }
 545
 546
 547 gboolean
 548 modest_ui_editor_window_set_to_header(const gchar *to, gpointer window_data)
 549 {
 550         GladeXML *glade_xml;
 551         GtkWidget *w;
 552         EditWinData *win_data;
 553
 554         win_data = (EditWinData *)window_data;
 555         glade_xml = win_data->glade_xml;
 556         w = glade_xml_get_widget(glade_xml, "to_entry");
 557         gtk_entry_set_text(GTK_ENTRY(w), to);
 558
 559         return TRUE;
 560 }
 561
 562
 563 gboolean
 564 modest_ui_editor_window_set_cc_header(const gchar *cc, gpointer window_data)
 565 {
 566         GladeXML *glade_xml;
 567         // GtkWidget *w;
 568         EditWinData *win_data;
 569
 570         win_data = (EditWinData *)window_data;
 571         glade_xml = win_data->glade_xml;
 572 /*
 573         w = glade_xml_get_widget(glade_xml, "cc_entry");
 574         gtk_entry_set_text(GTK_ENTRY(w), cc);
 575 */
 576         return TRUE;
 577 }
 578
 579
 580 gboolean
 581 modest_ui_editor_window_set_bcc_header(const gchar *bcc, gpointer window_data)
 582 {
 583         GladeXML *glade_xml;
 584         // GtkWidget *w;
 585         EditWinData *win_data;
 586
 587         win_data = (EditWinData *)window_data;
 588         glade_xml = win_data->glade_xml;
 589 /*
 590         w = glade_xml_get_widget(glade_xml, "bcc_entry");
 591         gtk_entry_set_text(GTK_ENTRY(w), bcc);
 592 */
 593         return TRUE;
 594 }
 595
 596
 597 gboolean
 598 modest_ui_editor_window_set_subject_header(const gchar *subject, gpointer window_data)
 599 {
 600         GladeXML *glade_xml;
 601         GtkWidget *w;
 602         EditWinData *win_data;
 603
 604         win_data = (EditWinData *)window_data;
 605         glade_xml = win_data->glade_xml;
 606
 607         w = glade_xml_get_widget(glade_xml, "subject_entry");
 608         gtk_entry_set_text(GTK_ENTRY(w), subject);
 609
 610         return TRUE;
 611 }
 612
 613
 614 gboolean
 615 modest_ui_editor_window_set_body(const gchar *body, gpointer window_data)
 616 {
 617         GladeXML *glade_xml;
 618         GtkWidget *body_view;
 619         GtkTextBuffer *buf;
 620         EditWinData *win_data;
 621
 622         win_data = (EditWinData *)window_data;
 623         glade_xml = win_data->glade_xml;
 624
 625         body_view = glade_xml_get_widget(glade_xml, "body_view");
 626         buf = gtk_text_view_get_buffer(GTK_TEXT_VIEW(body_view));
 627
 628         gtk_text_buffer_set_text(GTK_TEXT_BUFFER(buf), body, -1);
 629
 630         return TRUE;
 631 }
 632
 633 #if 0
 634 gboolean
 635 modest_ui_new_edit_window (ModestUI *modest_ui, const gchar* to,
 636                             const gchar* cc, const gchar* bcc,
 637                             const gchar* subject, const gchar *body,
 638                             const GSList* att)
 639 {
 640         GtkWidget       *win, *to_entry, *subject_entry, *body_view;
 641
 642         ModestUIPrivate *priv;
 643         GtkWidget       *btn;
 644         GtkTextBuffer   *buf;
 645
 646         priv = MODEST_UI_GET_PRIVATE(modest_ui);
 647         int height = modest_conf_get_int (priv->modest_conf,
 648                                           MODEST_CONF_EDIT_WINDOW_HEIGHT,NULL);
 649         int width  = modest_conf_get_int (priv->modest_conf,
 650                                           MODEST_CONF_EDIT_WINDOW_WIDTH,NULL);
 651
 652         win = glade_xml_get_widget (priv->glade_xml, "new_mail");
 653         if (!win) {
 654                 g_warning ("could not create new mail  window");
 655                 return FALSE;
 656         }
 657
 658         /* FIXME: this also assumes that there can be only one edit window! */
 659         if (!modest_window_mgr_find_by_type(priv->modest_window_mgr, MODEST_EDIT_WINDOW)) {
 660                 /* there already is one edit win, maybe we should preserver its contents */
 661                 modest_window_mgr_register (priv->modest_window_mgr,
 662                                                                         G_OBJECT(win), MODEST_EDIT_WINDOW, 0);
 663         }
 664
 665         to_entry      = glade_xml_get_widget (priv->glade_xml, "to_entry");
 666         subject_entry = glade_xml_get_widget (priv->glade_xml, "subject_entry");
 667         body_view     = glade_xml_get_widget (priv->glade_xml, "body_view");
 668
 669         gtk_entry_set_text(GTK_ENTRY(subject_entry), subject);
 670         gtk_entry_set_text(GTK_ENTRY(to_entry), to);
 671
 672         buf = gtk_text_view_get_buffer(GTK_TEXT_VIEW(body_view));
 673         if (body) {
 674                 gtk_text_buffer_set_text(buf, body, -1);
 675         } else {
 676                 gtk_text_buffer_set_text(buf, "", -1);
 677         }
 678         g_signal_connect (win, "destroy-event", G_CALLBACK(hide_edit_window),
 679                           modest_ui);
 680         g_signal_connect (win, "delete-event", G_CALLBACK(hide_edit_window),
 681                           modest_ui);
 682
 683         gtk_widget_set_usize (GTK_WIDGET(win), height, width);
 684         gtk_window_set_title (GTK_WINDOW(win),
 685                               subject ? subject : "Untitled");
 686
 687
 688         btn = glade_xml_get_widget (priv->glade_xml, "toolb_send");
 689         g_signal_connect (btn, "clicked", G_CALLBACK(on_send_button_clicked),
 690                           modest_ui);
 691
 692         gtk_widget_show_all (win);
 693
 694         return TRUE;
 695 }
 696 #endif
 697
 698 static void
 699 modest_ui_window_destroy (GtkWidget *win, GdkEvent *event, gpointer data)
 700 {
 701         ModestUIPrivate *priv;
 702
 703         g_return_if_fail (data);
 704         g_return_if_fail(MODEST_IS_UI(data));
 705         priv = MODEST_UI_GET_PRIVATE((ModestUI *)data);
 706         g_return_if_fail(priv);
 707         if (!modest_window_mgr_unregister (priv->modest_window_mgr, G_OBJECT(win)))
 708                 g_warning ("modest window mgr: failed to unregister %p",
 709                            G_OBJECT(win));
 710         else
 711                 gtk_widget_hide(win);
 712 }
 713
 714
 715 static void
 716 modest_ui_last_window_closed (GObject *obj, gpointer data)
 717 {
 718         /* FIXME: Other cleanups todo? Finalize Tinymail? */
 719         gtk_main_quit ();
 720 }
 721
 722
 723 void
 724 on_account_selector_selection_changed (GtkWidget *widget,
 725                                        gpointer user_data)
 726 {
 727         GtkTreeModel *model = gtk_combo_box_get_model(GTK_COMBO_BOX(widget));
 728         GtkTreeIter iter;
 729
 730         gchar *account_name;
 731
 732         if (gtk_combo_box_get_active_iter(GTK_COMBO_BOX(widget), &iter))
 733         {
 734                 gtk_tree_model_get(GTK_TREE_MODEL(model),
 735                                    &iter,
 736                                    0, &account_name,
 737                                    -1);
 738         }
 739         else
 740         {
 741                 account_name="empty";
 742         }
 743
 744         g_message("Value: '%s'\n", account_name);
 745
 746         free(account_name);
 747 }
 748
 749 #if 0
 750 static void
 751 on_account_settings1_activate (GtkMenuItem *menuitem,
 752                                gpointer user_data)
 753 {
 754         GladeXML *glade_xml;
 755         GtkWidget *advanced_account_setup;
 756         ModestUIPrivate *priv;
 757         gint retval;
 758         GSList *account_name_list;
 759         GSList *account_name_list_iter;
 760         GtkListStore *account_names;
 761         GtkTreeIter account_names_iter;
 762         GtkWidget *account_selector;
 763         GtkCellRenderer *renderer;
 764
 765
 766         g_return_if_fail(MODEST_IS_UI(user_data));
 767         priv = MODEST_UI_GET_PRIVATE(MODEST_UI(user_data));
 768
 769         glade_xml = glade_xml_new(MODEST_GLADE, "mailbox_setup_advanced", NULL);
 770         advanced_account_setup = glade_xml_get_widget(glade_xml, "mailbox_setup_advanced");
 771
 772         account_name_list=modest_account_mgr_account_names(priv->modest_acc_mgr, NULL);
 773         account_names = gtk_list_store_new(1, G_TYPE_STRING);
 774
 775         for (account_name_list_iter=account_name_list;
 776              account_name_list_iter!=NULL;
 777              account_name_list_iter=g_slist_next(account_name_list_iter))
 778         {
 779                 gtk_list_store_append(account_names, &account_names_iter);
 780                 gtk_list_store_set(account_names, &account_names_iter,
 781                                    0, account_name_list_iter->data,
 782                                    -1);
 783         }
 784
 785         g_slist_free(account_name_list);
 786
 787         account_selector = glade_xml_get_widget(glade_xml, "account_selector");
 788         gtk_combo_box_set_model(GTK_COMBO_BOX(account_selector), GTK_TREE_MODEL(account_names));
 789
 790         renderer = gtk_cell_renderer_text_new ();
 791         gtk_cell_layout_pack_start (GTK_CELL_LAYOUT (account_selector), renderer, TRUE);
 792         gtk_cell_layout_set_attributes (GTK_CELL_LAYOUT (account_selector), renderer,
 793                                         "text", 0,
 794                                         NULL);
 795
 796         g_signal_connect(GTK_WIDGET(account_selector), "changed",
 797                          G_CALLBACK(on_account_selector_selection_changed),
 798                          GTK_WIDGET(advanced_account_setup));
 799
 800         gtk_combo_box_set_active(GTK_COMBO_BOX(account_selector), 0);
 801
 802         gtk_widget_show_all(GTK_WIDGET(advanced_account_setup));
 803
 804         retval=gtk_dialog_run(GTK_DIALOG(advanced_account_setup));
 805
 806         g_object_unref(account_names);
 807
 808         gtk_widget_destroy(GTK_WIDGET(advanced_account_setup));
 809
 810         g_object_unref(glade_xml);
 811 }
 812 #endif
 813
 814
 815 static void
 816 on_folder_clicked (ModestTnyFolderTreeView *folder_tree,
 817                    TnyMsgFolderIface *folder,
 818                    gpointer data)
 819 {
 820         GtkWidget *win;
 821         GtkWidget *button;
 822         GtkWidget *paned;
 823         ModestTnyHeaderTreeView *tree_view;
 824         ModestTnyMsgView *msg_view;
 825         ModestUIPrivate *priv;
 826         GtkWidget *scrollview;
 827
 828         g_return_if_fail (folder);
 829         g_return_if_fail (data);
 830
 831         priv = MODEST_UI_GET_PRIVATE(data);
 832         scrollview = glade_xml_get_widget (priv->glade_xml,"mail_list");
 833
 834         tree_view = MODEST_TNY_HEADER_TREE_VIEW(
 835                 gtk_bin_get_child(GTK_BIN(scrollview)));
 836         win = glade_xml_get_widget (priv->glade_xml, "main");
 837         gtk_window_set_title (GTK_WINDOW(win),
 838                               tny_msg_folder_iface_get_name(folder));
 839
 840         modest_tny_header_tree_view_set_folder (tree_view,
 841                                                 folder);
 842
 843         button = glade_xml_get_widget (priv->glade_xml, "toolb_reply");
 844         if (button) {
 845                 gtk_widget_set_sensitive(button, FALSE);
 846         }
 847
 848         button = glade_xml_get_widget (priv->glade_xml, "toolb_forward");
 849         if (button) {
 850                 gtk_widget_set_sensitive(button, FALSE);
 851         }
 852
 853         button = glade_xml_get_widget (priv->glade_xml, "toolb_delete");
 854         if (button) {
 855                 gtk_widget_set_sensitive(button, FALSE);
 856         }
 857
 858         paned = glade_xml_get_widget (priv->glade_xml,"mail_paned");
 859         g_return_if_fail (paned);
 860
 861         msg_view = MODEST_TNY_MSG_VIEW(gtk_paned_get_child2 (GTK_PANED(paned)));
 862         g_return_if_fail (msg_view);
 863
 864         modest_tny_msg_view_set_message  (msg_view, NULL);
 865 }
 866
 867
 868 static void
 869 on_message_clicked (ModestTnyFolderTreeView *folder_tree,
 870                                 TnyMsgIface *message,
 871                                 gpointer data)
 872 {
 873         GtkWidget *paned;
 874         GtkWidget *button;
 875         ModestTnyMsgView *msg_view;
 876         ModestUIPrivate *priv;
 877
 878         g_return_if_fail (data);
 879
 880         priv = MODEST_UI_GET_PRIVATE(data);
 881         paned = glade_xml_get_widget (priv->glade_xml,"mail_paned");
 882         msg_view = MODEST_TNY_MSG_VIEW(gtk_paned_get_child2 (GTK_PANED(paned)));
 883
 884         modest_tny_msg_view_set_message (msg_view,
 885                                          message);
 886         button = glade_xml_get_widget (priv->glade_xml, "toolb_reply");
 887         if (button) {
 888                 gtk_widget_set_sensitive(button, TRUE);
 889         }
 890         button = glade_xml_get_widget (priv->glade_xml, "toolb_forward");
 891         if (button) {
 892                 gtk_widget_set_sensitive(button, TRUE);
 893         }
 894         button = glade_xml_get_widget (priv->glade_xml, "toolb_delete");
 895         if (button) {
 896                 gtk_widget_set_sensitive(button, TRUE);
 897         }
 898 }
 899
 900
 901 static void
 902 on_password_requested (ModestTnyAccountStore *account_store,
 903                        const gchar *account_name, gpointer user_data)
 904 {
 905
 906         GtkWidget *passdialog;
 907         GtkWidget *vbox;
 908         GtkWidget *infolabel;
 909         GtkWidget *passentry;
 910         gint retval;
 911         const gchar *infostring=g_strconcat("Please enter the password for ", account_name, ".", NULL);
 912
 913         passdialog = gtk_dialog_new_with_buttons("MyDialog",
 914                                                  NULL,
 915                                                  GTK_DIALOG_MODAL|GTK_DIALOG_DESTROY_WITH_PARENT,
 916                                                  GTK_STOCK_OK,
 917                                                  GTK_RESPONSE_ACCEPT,
 918                                                  GTK_STOCK_CANCEL,
 919                                                  GTK_RESPONSE_REJECT,
 920                                                  NULL);
 921
 922         vbox=gtk_vbox_new(FALSE, 0);
 923
 924         infolabel=gtk_label_new(infostring);
 925         passentry=gtk_entry_new();
 926
 927         gtk_box_pack_start(GTK_BOX(GTK_DIALOG(passdialog)->vbox), infolabel, FALSE, FALSE, 0);
 928         gtk_box_pack_start(GTK_BOX(GTK_DIALOG(passdialog)->vbox), passentry, FALSE, FALSE, 0);
 929         gtk_widget_show_all(passdialog);
 930
 931         retval = gtk_dialog_run (GTK_DIALOG(passdialog));
 932
 933         switch (retval)
 934         {
 935         case GTK_RESPONSE_ACCEPT:
 936                 modest_account_mgr_set_server_account_string(modest_tny_account_store_get_accout_mgr(account_store),
 937                                                              account_name,
 938                                                              "password",
 939                                                              gtk_entry_get_text(GTK_ENTRY(passentry)),
 940                                                              NULL);
 941                 break;
 942         case GTK_RESPONSE_CANCEL:
 943                 /* FIXME:
 944                  * What happens, if canceled?"
 945                  */
 946                 break;
 947         }
 948
 949         gtk_widget_destroy (passdialog);
 950 }
 951
 952
 953 static GtkWidget*
 954 modest_main_window_header_tree (TnyMsgFolderIface *folder)
 955 {
 956         int i;
 957         GSList *columns = NULL;
 958         GtkWidget *header_tree;
 959         ModestTnyHeaderTreeViewColumn cols[] = {
 960                 MODEST_TNY_HEADER_TREE_VIEW_COLUMN_MSGTYPE,
 961                 MODEST_TNY_HEADER_TREE_VIEW_COLUMN_ATTACH,
 962                 MODEST_TNY_HEADER_TREE_VIEW_COLUMN_COMPACT_HEADER
 963         };
 964
 965         for (i = 0 ; i != sizeof(cols)/sizeof(ModestTnyHeaderTreeViewColumn); ++i)
 966                 columns = g_slist_append (columns, GINT_TO_POINTER(cols[i]));
 967
 968         header_tree = GTK_WIDGET(modest_tny_header_tree_view_new(folder, columns,
 969                                                                  MODEST_TNY_HEADER_TREE_VIEW_STYLE_NORMAL));
 970         g_slist_free (columns);
 971
 972         if (!header_tree) {
 973                 g_warning ("could not create header tree");
 974                 return NULL;
 975         }
 976
 977         return GTK_WIDGET(header_tree);
 978 }
 979
 980
 981 static GtkWidget*
 982 modest_main_window_folder_tree (ModestAccountMgr *modest_acc_mgr,
 983                                 TnyAccountStoreIface *account_store)
 984 {
 985         GtkWidget *folder_tree;
 986
 987         folder_tree = GTK_WIDGET(modest_tny_folder_tree_view_new (account_store));
 988         if (!folder_tree) {
 989                 g_warning ("could not create folder list");
 990                 return NULL;
 991         }
 992
 993         return folder_tree;
 994 }
 995
 996 static void on_editor_entry_changed(GtkEditable *editable,
 997                                             gpointer     user_data)
 998 {
 999         GtkWidget *edit_win;
1000         EditWinData *windata;
1001
1002         edit_win = (GtkWidget *)user_data;
1003         windata = (EditWinData *)modest_editor_window_get_data(MODEST_EDITOR_WINDOW(edit_win));
1004
1005         modest_editor_window_set_modified(MODEST_EDITOR_WINDOW(edit_win), TRUE);
1006 }
1007
1008 static void on_editor_buffer_changed (GtkTextBuffer *textbuffer,
1009                                             gpointer       user_data)
1010 {
1011         GtkWidget *edit_win;
1012         EditWinData *windata;
1013
1014         edit_win = (GtkWidget *)user_data;
1015         windata = (EditWinData *)modest_editor_window_get_data(MODEST_EDITOR_WINDOW(edit_win));
1016
1017         modest_editor_window_set_modified(MODEST_EDITOR_WINDOW(edit_win), TRUE);
1018 }
1019
1020 static void
1021 on_new_mail_clicked (GtkWidget *widget, ModestUI *modest_ui)
1022 {
1023         GtkWidget *edit_win;
1024         GladeXML *glade_xml;
1025         GtkWidget *btn, *w;
1026         GtkTextBuffer *buf;
1027         EditWinData *windata;
1028         ModestUIPrivate *priv;
1029         gint height, width;
1030
1031         g_return_if_fail (modest_ui);
1032         //modest_ui_new_edit_window (modest_ui, "", "", "", "", "", NULL);
1033
1034         edit_win = modest_editor_window_new(modest_ui);
1035         windata = (EditWinData *)modest_editor_window_get_data(MODEST_EDITOR_WINDOW(edit_win));
1036         g_return_if_fail(windata);
1037
1038         windata->edit_win = MODEST_EDITOR_WINDOW(edit_win);
1039         glade_xml = windata->glade_xml;
1040         btn = glade_xml_get_widget (glade_xml, "toolb_send");
1041         g_signal_connect (btn, "clicked", G_CALLBACK(on_send_button_clicked),
1042                           edit_win);
1043
1044         w = glade_xml_get_widget (glade_xml, "to_entry");
1045         g_signal_connect(w, "changed", G_CALLBACK(on_editor_entry_changed), edit_win);
1046         w = glade_xml_get_widget (glade_xml, "subject_entry");
1047         g_signal_connect(w, "changed", G_CALLBACK(on_editor_entry_changed), edit_win);
1048         w = glade_xml_get_widget (glade_xml, "body_view");
1049         buf = gtk_text_view_get_buffer(GTK_TEXT_VIEW(w));
1050         gtk_text_buffer_set_text(buf, "", -1);
1051         g_signal_connect(buf, "changed", G_CALLBACK(on_editor_buffer_changed), edit_win);
1052
1053         g_signal_connect (edit_win, "destroy-event", G_CALLBACK(close_edit_window),
1054                           edit_win);
1055         g_signal_connect (edit_win, "delete-event", G_CALLBACK(close_edit_window),
1056                           edit_win);
1057
1058         priv = MODEST_UI_GET_PRIVATE(windata->modest_ui);
1059         height = modest_conf_get_int (priv->modest_conf,
1060                                           MODEST_CONF_EDIT_WINDOW_HEIGHT, NULL);
1061         width  = modest_conf_get_int (priv->modest_conf,
1062                                           MODEST_CONF_EDIT_WINDOW_WIDTH, NULL);
1063
1064         // g_message("new editor win@%dx%d", width, height);
1065
1066         gtk_widget_set_usize (GTK_WIDGET(edit_win), width, height);
1067         gtk_window_set_title (GTK_WINDOW(edit_win), _("Untitled"));
1068         modest_window_mgr_register(priv->modest_window_mgr, G_OBJECT(edit_win), MODEST_EDIT_WINDOW, 0);
1069         gtk_widget_show(edit_win);
1070 }
1071
1072
1073 static void
1074 new_editor_with_presets (ModestUI *modest_ui, const gchar *to_header,
1075                                                         const gchar *cc_header, const gchar *bcc_header,
1076                                                         const gchar *subject_header, const gchar *body)
1077 {
1078         GtkWidget *edit_win;
1079         GladeXML *glade_xml;
1080         GtkWidget *btn, *w;
1081         GtkTextBuffer *buf;
1082         EditWinData *windata;
1083         ModestUIPrivate *priv;
1084         gint height, width;
1085
1086         g_return_if_fail (modest_ui);
1087
1088         edit_win = modest_editor_window_new(modest_ui);
1089         windata = (EditWinData *)modest_editor_window_get_data(MODEST_EDITOR_WINDOW(edit_win));
1090         g_return_if_fail(windata);
1091
1092         glade_xml = windata->glade_xml;
1093         btn = glade_xml_get_widget (glade_xml, "toolb_send");
1094         g_signal_connect (btn, "clicked", G_CALLBACK(on_send_button_clicked),
1095                           edit_win);
1096
1097         w = glade_xml_get_widget (glade_xml, "to_entry");
1098         g_signal_connect(w, "changed", G_CALLBACK(on_editor_entry_changed), edit_win);
1099         w = glade_xml_get_widget (glade_xml, "subject_entry");
1100         g_signal_connect(w, "changed", G_CALLBACK(on_editor_entry_changed), edit_win);
1101         w = glade_xml_get_widget (glade_xml, "body_view");
1102         buf = gtk_text_view_get_buffer(GTK_TEXT_VIEW(w));
1103         g_signal_connect(buf, "changed", G_CALLBACK(on_editor_buffer_changed), edit_win);
1104
1105         g_signal_connect (edit_win, "destroy-event", G_CALLBACK(close_edit_window),
1106                           edit_win);
1107         g_signal_connect (edit_win, "delete-event", G_CALLBACK(close_edit_window),
1108                           edit_win);
1109
1110         priv = MODEST_UI_GET_PRIVATE(windata->modest_ui);
1111         height = modest_conf_get_int (priv->modest_conf,
1112                                           MODEST_CONF_EDIT_WINDOW_HEIGHT, NULL);
1113         width  = modest_conf_get_int (priv->modest_conf,
1114                                           MODEST_CONF_EDIT_WINDOW_WIDTH, NULL);
1115
1116         // g_message("new editor win@%dx%d", width, height);
1117
1118         gtk_widget_set_usize (GTK_WIDGET(edit_win), width, height);
1119         gtk_window_set_title (GTK_WINDOW(edit_win), _("Untitled"));
1120         modest_window_mgr_register(priv->modest_window_mgr, G_OBJECT(edit_win), MODEST_EDIT_WINDOW, 0);
1121
1122         modest_editor_window_set_to_header(MODEST_EDITOR_WINDOW(edit_win), to_header);
1123         modest_editor_window_set_cc_header(MODEST_EDITOR_WINDOW(edit_win), cc_header);
1124         modest_editor_window_set_bcc_header(MODEST_EDITOR_WINDOW(edit_win), bcc_header);
1125         modest_editor_window_set_subject_header(MODEST_EDITOR_WINDOW(edit_win), subject_header);
1126         modest_editor_window_set_body(MODEST_EDITOR_WINDOW(edit_win), body);
1127
1128         modest_editor_window_set_modified(MODEST_EDITOR_WINDOW(edit_win), FALSE);
1129
1130         gtk_widget_show(edit_win);
1131 }
1132
1133
1134 static void
1135 quoted_send_msg (ModestUI *modest_ui, quoted_send_type qstype) {
1136         GtkTreeSelection *sel;
1137         GtkWidget *paned;
1138         GtkTreeModel *model;
1139         GtkTreeIter iter;
1140         GtkScrolledWindow *scroll;
1141
1142         TnyMsgHeaderIface *header;
1143
1144         ModestTnyHeaderTreeView *header_view;
1145         ModestTnyMsgView *msg_view;
1146         ModestUIPrivate *priv;
1147
1148         const TnyMsgIface *msg;
1149         const TnyMsgFolderIface *folder;
1150         GString *re_sub;
1151         const gchar *subject, *from;
1152         gchar *unquoted, *quoted;
1153         time_t sent_date;
1154         gint line_limit = 76;
1155
1156         g_return_if_fail (modest_ui);
1157
1158         priv = MODEST_UI_GET_PRIVATE(modest_ui);
1159
1160         paned = glade_xml_get_widget (priv->glade_xml,"mail_paned");
1161         g_return_if_fail (paned);
1162
1163         scroll = GTK_SCROLLED_WINDOW(gtk_paned_get_child1 (GTK_PANED(paned)));
1164         g_return_if_fail (scroll);
1165
1166         msg_view = MODEST_TNY_MSG_VIEW(gtk_paned_get_child2 (GTK_PANED(paned)));
1167         g_return_if_fail (msg_view);
1168
1169         header_view = MODEST_TNY_HEADER_TREE_VIEW(gtk_bin_get_child (GTK_BIN(scroll)));
1170         g_return_if_fail (header_view);
1171
1172         sel = gtk_tree_view_get_selection (GTK_TREE_VIEW(header_view));
1173         g_return_if_fail (sel);
1174
1175         if (!gtk_tree_selection_get_selected (sel, &model, &iter)) {
1176                 g_warning("nothing to reply to");
1177                 return;
1178         }
1179
1180         gtk_tree_model_get (model, &iter,
1181                             TNY_MSG_HEADER_LIST_MODEL_INSTANCE_COLUMN,
1182                             &header, -1);
1183
1184         if (!header) {
1185                 g_warning("no header");
1186                 return;
1187         }
1188
1189         folder = tny_msg_header_iface_get_folder (TNY_MSG_HEADER_IFACE(header));
1190         if (!folder) {
1191                 g_warning ("cannot find folder");
1192                 return;
1193         }
1194
1195         msg = tny_msg_folder_iface_get_message (TNY_MSG_FOLDER_IFACE(folder), header);
1196         if (!msg) {
1197                 g_warning ("cannot find msg");
1198                 return;
1199         }
1200
1201         subject = tny_msg_header_iface_get_subject(header);
1202         re_sub = g_string_new(subject);
1203         /* FIXME: honor replyto, cc */
1204         from = tny_msg_header_iface_get_from(header);
1205         sent_date = tny_msg_header_iface_get_date_sent(header);
1206
1207         unquoted = modest_tny_msg_view_get_selected_text(msg_view);
1208         quoted = modest_tny_msg_actions_quote(msg, from, sent_date, line_limit, unquoted);
1209
1210         switch (qstype) {
1211                 case QUOTED_SEND_REPLY:
1212                         g_string_prepend(re_sub, _("Re: "));
1213                         new_editor_with_presets(modest_ui, from, /* cc */ "", /* bcc */ "", re_sub->str, quoted);
1214                         break;
1215                 case QUOTED_SEND_FORWARD:
1216                         g_string_prepend(re_sub, _("Fwd: "));
1217                         new_editor_with_presets(modest_ui, /* from */ "", /* cc */ "", /* bcc */ "", re_sub->str, quoted);
1218                         break;
1219                 default:
1220                         break;
1221         }
1222         g_free(quoted);
1223         g_free(unquoted);
1224         g_string_free(re_sub, TRUE);
1225 }
1226
1227
1228 static void
1229 on_reply_clicked (GtkWidget *widget, ModestUI *modest_ui)
1230 {
1231         quoted_send_msg (modest_ui, QUOTED_SEND_REPLY);
1232 }
1233
1234
1235 static void
1236 on_forward_clicked (GtkWidget *widget, ModestUI *modest_ui)
1237 {
1238         quoted_send_msg (modest_ui, QUOTED_SEND_FORWARD);
1239 }
1240
1241
1242 static void
1243 on_send_button_clicked (GtkWidget *widget, ModestEditorWindow *modest_editwin)
1244 {
1245         ModestTnyTransportActions *actions;
1246         ModestUI *modest_ui;
1247         ModestUIPrivate *priv;
1248         GtkWidget *to_entry, *subject_entry, *body_view;
1249         const gchar *to, *subject, *email_from;
1250         gchar *body;
1251         GtkTextIter start, end;
1252         GtkTextBuffer *buf;
1253         TnyAccountStoreIface *account_store;
1254         const GList *transport_accounts;
1255         TnyTransportAccountIface *transport_account;
1256         ModestConf       *conf;
1257         ModestIdentityMgr *id_mgr;
1258         EditWinData *win_data;
1259
1260
1261         win_data = modest_editor_window_get_data(modest_editwin);
1262         modest_ui = win_data->modest_ui;
1263
1264         g_return_if_fail (modest_ui);
1265
1266         actions = MODEST_TNY_TRANSPORT_ACTIONS
1267                 (modest_tny_transport_actions_new ());
1268
1269         priv = MODEST_UI_GET_PRIVATE(modest_ui);
1270
1271         account_store = priv->account_store;
1272         transport_accounts =
1273                 tny_account_store_iface_get_transport_accounts (account_store);
1274         if (!transport_accounts) {
1275                 g_message ("cannot send message: no transport account defined");
1276                 return;
1277         } else /* take the first one! */
1278                 transport_account =
1279                         TNY_TRANSPORT_ACCOUNT_IFACE(transport_accounts->data);
1280
1281         to_entry      = glade_xml_get_widget (win_data->glade_xml, "to_entry");
1282         subject_entry = glade_xml_get_widget (win_data->glade_xml, "subject_entry");
1283         body_view     = glade_xml_get_widget (win_data->glade_xml, "body_view");
1284
1285         to      = gtk_entry_get_text (GTK_ENTRY(to_entry));
1286         subject = gtk_entry_get_text (GTK_ENTRY(subject_entry));
1287
1288         buf = gtk_text_view_get_buffer(GTK_TEXT_VIEW(body_view));
1289         gtk_text_buffer_get_bounds (buf, &start, &end);
1290         body    = gtk_text_buffer_get_text (buf, &start, &end, FALSE);
1291
1292         id_mgr = priv->modest_id_mgr;
1293         email_from = modest_identity_mgr_get_identity_string(id_mgr,
1294                                                              MODEST_IDENTITY_DEFAULT_IDENTITY,
1295                                                              MODEST_IDENTITY_EMAIL, NULL);
1296
1297         if (!email_from)
1298                 email_from = "";
1299
1300         g_message("sending \"%s\" %s ==> %s", subject, email_from, to);
1301
1302         modest_tny_transport_actions_send_message (actions,
1303                                                    transport_account,
1304                                                    email_from,
1305                                                    to, "", "", subject,
1306                                                    body);
1307
1308         g_free (body);
1309         g_object_unref (G_OBJECT(actions));
1310
1311         gtk_widget_hide (GTK_WIDGET(modest_editwin));
1312         modest_window_mgr_unregister(priv->modest_window_mgr, G_OBJECT(modest_editwin));
1313         if (GTK_IS_WIDGET(modest_editwin)) {
1314                 gtk_widget_destroy(GTK_WIDGET(modest_editwin));
1315         } else
1316                 g_warning("editor window has vanished!");
1317 }
1318
1319 static void
1320 on_view_attachments_toggled(GtkWidget *widget, ModestUI *modest_ui)
1321 {
1322         GtkWidget *view_attachments_item, *paned;
1323         ModestTnyMsgView *msg_view;
1324         ModestUIPrivate *priv;
1325
1326         priv = MODEST_UI_GET_PRIVATE(modest_ui);
1327         view_attachments_item = glade_xml_get_widget (priv->glade_xml, "menu_view_attachments");
1328         g_return_if_fail(view_attachments_item);
1329
1330         modest_conf_set_bool(priv->modest_conf,
1331                                                          MODEST_CONF_MSG_VIEW_SHOW_ATTACHMENTS_INLINE,
1332                                                          gtk_check_menu_item_get_active(GTK_CHECK_MENU_ITEM(view_attachments_item)),
1333                                                          NULL);
1334
1335         /* refresh message view */
1336         paned = glade_xml_get_widget (priv->glade_xml,"mail_paned");
1337         msg_view = MODEST_TNY_MSG_VIEW(gtk_paned_get_child2 (GTK_PANED(paned)));
1338         modest_tny_msg_view_redraw(MODEST_TNY_MSG_VIEW(msg_view));
1339 }
1340 static void
1341 on_delete_clicked (GtkWidget *widget, ModestUI *modest_ui)
1342 {
1343         GtkTreeSelection *sel;
1344         GtkWidget *paned;
1345         GtkTreeModel *model;
1346         GtkTreeIter iter;
1347         GtkScrolledWindow *scroll;
1348         GtkTreeModel *mymodel;
1349
1350         ModestTnyHeaderTreeView *header_view;
1351         ModestTnyMsgView *msg_view;
1352         ModestUIPrivate *priv;
1353
1354         g_return_if_fail (modest_ui);
1355
1356         priv = MODEST_UI_GET_PRIVATE(modest_ui);
1357
1358         paned = glade_xml_get_widget (priv->glade_xml,"mail_paned");
1359         g_return_if_fail (paned);
1360
1361         scroll = GTK_SCROLLED_WINDOW(gtk_paned_get_child1 (GTK_PANED(paned)));
1362         g_return_if_fail (scroll);
1363
1364         msg_view = MODEST_TNY_MSG_VIEW(gtk_paned_get_child2 (GTK_PANED(paned)));
1365         g_return_if_fail (msg_view);
1366
1367         header_view = MODEST_TNY_HEADER_TREE_VIEW(gtk_bin_get_child (GTK_BIN(scroll)));
1368         g_return_if_fail (header_view);
1369
1370         sel = gtk_tree_view_get_selection (GTK_TREE_VIEW(header_view));
1371         g_return_if_fail (sel);
1372
1373         /* get all selected mails */
1374         if (G_LIKELY (gtk_tree_selection_get_selected (sel, &model, &iter)))
1375         {
1376                 TnyMsgHeaderIface *header;
1377
1378                 gtk_tree_model_get (model, &iter, TNY_MSG_HEADER_LIST_MODEL_INSTANCE_COLUMN,
1379                         &header, -1);
1380
1381                 if (G_LIKELY (header))
1382                 {
1383                         TnyMsgFolderIface *folder;
1384                         // const TnyMsgIface *msg;
1385
1386                         if (GTK_IS_TREE_MODEL_SORT (model))
1387                         {
1388                                 mymodel = gtk_tree_model_sort_get_model
1389                                         (GTK_TREE_MODEL_SORT (model));
1390                         } else
1391                                 mymodel = model;
1392
1393                         folder = (TnyMsgFolderIface*)tny_msg_header_iface_get_folder (header);
1394
1395                         /* this will make the message as deleted */
1396                         /*      tny_msg_folder_iface_expunge (folder); will finally delete messages */
1397                         if (TNY_IS_MSG_FOLDER (folder))
1398                                 tny_msg_folder_iface_remove_message (folder, header);
1399                         gtk_widget_queue_draw (GTK_WIDGET (header_view));
1400                 }
1401         }
1402 }
1403
1404 static void
1405 on_sendreceive_button_clicked (GtkWidget *widget, ModestUI *modest_ui)
1406 {
1407         ModestUIPrivate *priv;
1408         ModestTnyStoreActions *store_actions;
1409         TnyAccountStoreIface *account_store;
1410         const GList *store_accounts;
1411         const GList *iter;
1412
1413         g_return_if_fail (modest_ui);
1414
1415         store_actions = MODEST_TNY_STORE_ACTIONS (modest_tny_store_actions_new ());
1416         priv = MODEST_UI_GET_PRIVATE(modest_ui);
1417
1418         account_store = priv->account_store;
1419         store_accounts =
1420                 tny_account_store_iface_get_store_accounts (account_store);
1421
1422         for (iter = store_accounts; iter; iter = iter->next)
1423         {
1424                 modest_tny_store_actions_update_folders (store_actions,
1425                                                                                                  TNY_STORE_ACCOUNT_IFACE (iter->data));
1426
1427         }
1428         g_object_unref (store_actions);
1429
1430 }