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