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

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