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