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