git.maemo.org Git - modest/blob - src/gnome/modest-msg-edit-window.c

   1 /* Copyright (c) 2006, Nokia Corporation
   2  * All rights reserved.
   3  *
   4  * Redistribution and use in source and binary forms, with or without
   5  * modification, are permitted provided that the following conditions are
   6  * met:
   7  *
   8  * * Redistributions of source code must retain the above copyright
   9  *   notice, this list of conditions and the following disclaimer.
  10  * * Redistributions in binary form must reproduce the above copyright
  11  *   notice, this list of conditions and the following disclaimer in the
  12  *   documentation and/or other materials provided with the distribution.
  13  * * Neither the name of the Nokia Corporation nor the names of its
  14  *   contributors may be used to endorse or promote products derived from
  15  *   this software without specific prior written permission.
  16  *
  17  * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS
  18  * IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
  19  * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A
  20  * PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER
  21  * OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
  22  * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
  23  * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
  24  * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
  25  * LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
  26  * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
  27  * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  28  */
  29 #include <glib/gi18n.h>
  30 #include <string.h>
  31 #include <tny-account-store.h>
  32 #include <tny-simple-list.h>
  33 #include <modest-conf.h>
  34 #include <modest-runtime.h>
  35 #include <modest-tny-msg.h>
  36
  37 #include <widgets/modest-window-priv.h>
  38 #include <widgets/modest-msg-edit-window.h>
  39 #include <widgets/modest-msg-edit-window-ui.h>
  40 #include <widgets/modest-combo-box.h>
  41 #include <widgets/modest-attachments-view.h>
  42
  43 #include <modest-widget-memory.h>
  44 #include <modest-account-mgr-helpers.h>
  45 #include <modest-tny-folder.h>
  46 #include <gtkhtml/gtkhtml.h>
  47 #include "modest-msg-edit-window-ui-dimming.h"
  48 #include <modest-platform.h>
  49 #include <libgnomevfs/gnome-vfs-mime-utils.h>
  50 #include <libgnomevfs/gnome-vfs.h>
  51 #include <tny-vfs-stream.h>
  52
  53 static void  modest_msg_edit_window_class_init   (ModestMsgEditWindowClass *klass);
  54 static void  modest_msg_edit_window_init         (ModestMsgEditWindow *obj);
  55 static void  modest_msg_edit_window_finalize     (GObject *obj);
  56
  57 static void  modest_msg_edit_window_add_attachment_clicked (GtkButton *button,
  58                                                             ModestMsgEditWindow *window);
  59 static void update_next_cid (ModestMsgEditWindow *self, TnyList *attachments);
  60
  61 /* list my signals */
  62 enum {
  63         /* MY_SIGNAL_1, */
  64         /* MY_SIGNAL_2, */
  65         LAST_SIGNAL
  66 };
  67
  68 typedef struct _ModestMsgEditWindowPrivate ModestMsgEditWindowPrivate;
  69 struct _ModestMsgEditWindowPrivate {
  70
  71         GtkWidget   *toolbar;
  72         GtkWidget   *menubar;
  73
  74         GtkWidget   *msg_body;
  75
  76         ModestPairList *from_field_protos;
  77         GtkWidget   *from_field;
  78
  79         GtkWidget   *to_field;
  80         GtkWidget   *cc_field;
  81         GtkWidget   *bcc_field;
  82         GtkWidget   *subject_field;
  83
  84         GtkWidget   *attachments_view;
  85         TnyList     *attachments;
  86         guint       next_cid;
  87
  88         TnyMsg      *draft_msg;
  89         TnyMsg      *outbox_msg;
  90         gchar       *msg_uid;
  91
  92         gchar       *references;
  93         gchar       *in_reply_to;
  94
  95         gboolean    sent;
  96 };
  97
  98 #define MODEST_MSG_EDIT_WINDOW_GET_PRIVATE(o)      (G_TYPE_INSTANCE_GET_PRIVATE((o), \
  99                                                     MODEST_TYPE_MSG_EDIT_WINDOW, \
 100                                                     ModestMsgEditWindowPrivate))
 101 /* globals */
 102 static GtkWindowClass *parent_class = NULL;
 103
 104 /* uncomment the following if you have defined any signals */
 105 /* static guint signals[LAST_SIGNAL] = {0}; */
 106
 107 GType
 108 modest_msg_edit_window_get_type (void)
 109 {
 110         static GType my_type = 0;
 111         if (!my_type) {
 112                 static const GTypeInfo my_info = {
 113                         sizeof(ModestMsgEditWindowClass),
 114                         NULL,           /* base init */
 115                         NULL,           /* base finalize */
 116                         (GClassInitFunc) modest_msg_edit_window_class_init,
 117                         NULL,           /* class finalize */
 118                         NULL,           /* class data */
 119                         sizeof(ModestMsgEditWindow),
 120                         1,              /* n_preallocs */
 121                         (GInstanceInitFunc) modest_msg_edit_window_init,
 122                         NULL
 123                 };
 124                 my_type = g_type_register_static (MODEST_TYPE_WINDOW,
 125                                                   "ModestMsgEditWindow",
 126                                                   &my_info, 0);
 127         }
 128         return my_type;
 129 }
 130
 131
 132 static void
 133 save_state (ModestWindow *self)
 134 {
 135         modest_widget_memory_save (modest_runtime_get_conf (),
 136                                     G_OBJECT(self), "modest-edit-msg-window");
 137 }
 138
 139
 140 static void
 141 restore_settings (ModestMsgEditWindow *self)
 142 {
 143         modest_widget_memory_restore (modest_runtime_get_conf (),
 144                                       G_OBJECT(self), "modest-edit-msg-window");
 145 }
 146
 147 static void
 148 modest_msg_edit_window_class_init (ModestMsgEditWindowClass *klass)
 149 {
 150         GObjectClass *gobject_class;
 151         ModestWindowClass *modest_window_class;
 152
 153         gobject_class = (GObjectClass*) klass;
 154         modest_window_class = (ModestWindowClass*) klass;
 155
 156         parent_class            = g_type_class_peek_parent (klass);
 157         gobject_class->finalize = modest_msg_edit_window_finalize;
 158
 159         g_type_class_add_private (gobject_class, sizeof(ModestMsgEditWindowPrivate));
 160
 161         modest_window_class->save_state_func = save_state;
 162 }
 163
 164 static void
 165 modest_msg_edit_window_init (ModestMsgEditWindow *obj)
 166 {
 167         ModestMsgEditWindowPrivate *priv;
 168         priv = MODEST_MSG_EDIT_WINDOW_GET_PRIVATE(obj);
 169
 170         priv->toolbar       = NULL;
 171         priv->menubar       = NULL;
 172         priv->msg_body      = NULL;
 173         priv->from_field    = NULL;
 174         priv->to_field      = NULL;
 175         priv->cc_field      = NULL;
 176         priv->bcc_field     = NULL;
 177         priv->subject_field = NULL;
 178         priv->attachments_view = NULL;
 179         priv->attachments = TNY_LIST (tny_simple_list_new ());
 180         priv->sent          = FALSE;
 181         priv->next_cid      = 0;
 182         priv->draft_msg = NULL;
 183         priv->outbox_msg = NULL;
 184         priv->msg_uid = NULL;
 185         priv->references = NULL;
 186         priv->in_reply_to = NULL;
 187 }
 188
 189 /**
 190  * @result: A ModestPairList, which must be freed with modest_pair_list_free().
 191  */
 192 static ModestPairList*
 193 get_transports (void)
 194 {
 195         ModestAccountMgr *account_mgr;
 196         GSList *transports = NULL;
 197         GSList *cursor, *accounts;
 198
 199         account_mgr = modest_runtime_get_account_mgr();
 200         cursor = accounts = modest_account_mgr_account_names (account_mgr, TRUE);
 201         while (cursor) {
 202                 gchar *account_name = cursor->data ? g_strdup((gchar*)cursor->data) : NULL;
 203                 gchar *from_string  = modest_account_mgr_get_from_string (account_mgr,
 204                                                                           account_name, NULL);
 205                 if (!from_string)  {
 206                         /* something went wrong: ignore this one */
 207                         g_free (account_name);
 208                         cursor->data = NULL;
 209                 } else {
 210                         ModestPair *pair;
 211                         pair = modest_pair_new ((gpointer) account_name,
 212                                                 (gpointer) from_string , TRUE);
 213                         transports = g_slist_prepend (transports, pair);
 214                 } /* don't free account name; it's freed when the transports list is freed */
 215                 cursor = cursor->next;
 216         }
 217         g_slist_free (accounts);
 218         return transports;
 219 }
 220
 221
 222 static void
 223 on_from_combo_changed (ModestComboBox *combo, ModestWindow *win)
 224 {
 225         modest_window_set_active_account (
 226                 win, modest_combo_box_get_active_id(combo));
 227 }
 228
 229
 230
 231 static void
 232 init_window (ModestMsgEditWindow *obj, const gchar* account)
 233 {
 234         GtkWidget *to_button, *cc_button, *bcc_button, *add_attachment_button;
 235         GtkWidget *header_table;
 236         GtkWidget *main_vbox;
 237         GtkWidget *msg_vbox;
 238         GtkWidget *scrolled_window;
 239         ModestMsgEditWindowPrivate *priv;
 240         ModestWindowPrivate *parent_priv;
 241
 242         priv = MODEST_MSG_EDIT_WINDOW_GET_PRIVATE(obj);
 243         parent_priv = MODEST_WINDOW_GET_PRIVATE(obj);
 244
 245         to_button     = gtk_button_new_with_label (_("To..."));
 246         cc_button     = gtk_button_new_with_label (_("Cc..."));
 247         bcc_button    = gtk_button_new_with_label (_("Bcc..."));
 248         add_attachment_button = gtk_button_new_with_label (_("Attach..."));
 249
 250         /* Note: This ModestPairList* must exist for as long as the combo
 251          * that uses it, because the ModestComboBox uses the ID opaquely,
 252          * so it can't know how to manage its memory. */
 253         priv->from_field_protos = get_transports ();
 254         priv->from_field    = modest_combo_box_new (priv->from_field_protos, g_str_equal);
 255
 256         if (account) {
 257                 modest_combo_box_set_active_id (MODEST_COMBO_BOX(priv->from_field),
 258                                                 (gpointer)account);
 259                 modest_window_set_active_account (MODEST_WINDOW(obj), account);
 260         }
 261         /* auto-update the active account */
 262         g_signal_connect (G_OBJECT(priv->from_field), "changed", G_CALLBACK(on_from_combo_changed), obj);
 263
 264         priv->to_field      = gtk_entry_new_with_max_length (80);
 265         priv->cc_field      = gtk_entry_new_with_max_length (80);
 266         priv->bcc_field     = gtk_entry_new_with_max_length (80);
 267         priv->subject_field = gtk_entry_new_with_max_length (80);
 268         priv->attachments_view = modest_attachments_view_new (NULL);
 269
 270         header_table = gtk_table_new (6,2, FALSE);
 271
 272         gtk_table_attach (GTK_TABLE(header_table), gtk_label_new (_("From:")),
 273                           0,1,0,1, GTK_FILL, 0, 0, 0);
 274         gtk_table_attach (GTK_TABLE(header_table), to_button,     0,1,1,2, GTK_FILL, 0, 0, 0);
 275         gtk_table_attach (GTK_TABLE(header_table), cc_button,     0,1,2,3, GTK_FILL, 0, 0, 0);
 276         gtk_table_attach (GTK_TABLE(header_table), bcc_button,    0,1,3,4, GTK_FILL, 0, 0, 0);
 277         gtk_table_attach (GTK_TABLE(header_table), gtk_label_new (_("Subject:")),
 278                           0,1,4,5, GTK_FILL, 0, 0, 0);
 279         gtk_table_attach (GTK_TABLE(header_table), add_attachment_button, 0, 1, 5, 6, GTK_FILL, 0, 0, 0);
 280
 281         gtk_table_attach_defaults (GTK_TABLE(header_table), priv->from_field,   1,2,0,1);
 282         gtk_table_attach_defaults (GTK_TABLE(header_table), priv->to_field,     1,2,1,2);
 283         gtk_table_attach_defaults (GTK_TABLE(header_table), priv->cc_field,     1,2,2,3);
 284         gtk_table_attach_defaults (GTK_TABLE(header_table), priv->bcc_field,    1,2,3,4);
 285         gtk_table_attach_defaults (GTK_TABLE(header_table), priv->subject_field,1,2,4,5);
 286         gtk_table_attach_defaults (GTK_TABLE(header_table), priv->attachments_view,1,2,5,6);
 287
 288         priv->msg_body = gtk_html_new ();
 289         gtk_html_load_empty (GTK_HTML (priv->msg_body));
 290         gtk_html_set_editable (GTK_HTML (priv->msg_body), TRUE);
 291
 292         main_vbox = gtk_vbox_new  (FALSE, 0);
 293
 294         scrolled_window = gtk_scrolled_window_new (NULL, NULL);
 295         gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (scrolled_window),
 296                                         GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC);
 297         gtk_scrolled_window_set_shadow_type (GTK_SCROLLED_WINDOW (scrolled_window), GTK_SHADOW_IN);
 298
 299         gtk_box_pack_start (GTK_BOX(main_vbox), priv->menubar, FALSE, FALSE, 0);
 300         gtk_box_pack_start (GTK_BOX(main_vbox), priv->toolbar, FALSE, FALSE, 0);
 301
 302         msg_vbox = gtk_vbox_new (FALSE, 0);
 303         gtk_box_pack_start (GTK_BOX (main_vbox), msg_vbox, TRUE, TRUE, 0);
 304
 305         gtk_box_pack_start (GTK_BOX(msg_vbox), header_table, FALSE, FALSE, 0);
 306         gtk_container_add (GTK_CONTAINER (scrolled_window), priv->msg_body);
 307
 308         gtk_box_pack_start (GTK_BOX(msg_vbox), scrolled_window, TRUE, TRUE, 0);
 309
 310         gtk_widget_show_all (GTK_WIDGET(main_vbox));
 311         gtk_container_add (GTK_CONTAINER(obj), main_vbox);
 312
 313         g_signal_connect_object (add_attachment_button, "clicked",
 314                                  G_CALLBACK (modest_msg_edit_window_add_attachment_clicked), G_OBJECT (obj), 0);
 315 }
 316
 317
 318 static void
 319 modest_msg_edit_window_finalize (GObject *obj)
 320 {
 321         ModestMsgEditWindowPrivate *priv = MODEST_MSG_EDIT_WINDOW_GET_PRIVATE(obj);
 322
 323         /* These had to stay alive for as long as the comboboxes that used them: */
 324         modest_pair_list_free (priv->from_field_protos);
 325         g_object_unref (priv->attachments);
 326         priv->attachments = NULL;
 327
 328         if (priv->draft_msg != NULL) {
 329                 TnyHeader *header = tny_msg_get_header (priv->draft_msg);
 330                 if (TNY_IS_HEADER (header)) {
 331                         ModestWindowMgr *mgr = modest_runtime_get_window_mgr ();
 332                         modest_window_mgr_unregister_header (mgr, header);
 333                 }
 334                 g_object_unref (priv->draft_msg);
 335                 priv->draft_msg = NULL;
 336         }
 337         if (priv->outbox_msg != NULL) {
 338                 TnyHeader *header = tny_msg_get_header (priv->outbox_msg);
 339                 if (TNY_IS_HEADER (header)) {
 340                         ModestWindowMgr *mgr = modest_runtime_get_window_mgr ();
 341                         modest_window_mgr_unregister_header (mgr, header);
 342                 }
 343                 g_object_unref (priv->outbox_msg);
 344                 priv->outbox_msg = NULL;
 345         }
 346         g_free (priv->msg_uid);
 347         g_free (priv->references);
 348         g_free (priv->in_reply_to);
 349
 350         G_OBJECT_CLASS(parent_class)->finalize (obj);
 351 }
 352
 353 static void
 354 update_next_cid (ModestMsgEditWindow *self, TnyList *attachments)
 355 {
 356         TnyIterator *iter;
 357         ModestMsgEditWindowPrivate *priv = MODEST_MSG_EDIT_WINDOW_GET_PRIVATE (self);
 358
 359         for (iter = tny_list_create_iterator (attachments) ;
 360              !tny_iterator_is_done (iter);
 361              tny_iterator_next (iter)) {
 362                 TnyMimePart *part = (TnyMimePart *) tny_iterator_get_current (iter);
 363                 const gchar *cid = tny_mime_part_get_content_id (part);
 364                 if (cid != NULL) {
 365                         char *invalid = NULL;
 366                         gint int_cid = strtol (cid, &invalid, 10);
 367                         if ((invalid != NULL) && (*invalid == '\0') && (int_cid >= priv->next_cid)) {
 368                                 priv->next_cid = int_cid + 1;
 369                         }
 370                 }
 371                 g_object_unref (part);
 372         }
 373         g_object_unref (iter);
 374 }
 375
 376
 377
 378 static gboolean
 379 on_delete_event (GtkWidget *widget, GdkEvent *event, ModestMsgEditWindow *self)
 380 {
 381         modest_window_save_state (MODEST_WINDOW(self));
 382         return FALSE;
 383 }
 384
 385
 386 static void
 387 set_msg (ModestMsgEditWindow *self, TnyMsg *msg)
 388 {
 389         TnyHeader *header;
 390         TnyFolder *msg_folder;
 391         gchar *to, *cc, *bcc, *subject;
 392         ModestMsgEditWindowPrivate *priv;
 393         gchar *body;
 394
 395         g_return_if_fail (MODEST_IS_MSG_EDIT_WINDOW (self));
 396         g_return_if_fail (TNY_IS_MSG (msg));
 397
 398         priv = MODEST_MSG_EDIT_WINDOW_GET_PRIVATE (self);
 399
 400         header  = tny_msg_get_header (msg);
 401         to      = tny_header_dup_to (header);
 402         cc      = tny_header_dup_cc (header);
 403         bcc     = tny_header_dup_bcc (header);
 404         subject = tny_header_dup_subject (header);
 405
 406         if (to)
 407                 gtk_entry_set_text (GTK_ENTRY(priv->to_field), to);
 408         if (cc)
 409                 gtk_entry_set_text (GTK_ENTRY(priv->cc_field), cc);
 410         if (bcc)
 411                 gtk_entry_set_text (GTK_ENTRY(priv->bcc_field),  bcc);
 412         if (subject)
 413                 gtk_entry_set_text (GTK_ENTRY(priv->subject_field), subject);
 414
 415         modest_tny_msg_get_references (TNY_MSG (msg), NULL, &(priv->references), &(priv->in_reply_to));
 416
 417         modest_attachments_view_set_message (MODEST_ATTACHMENTS_VIEW (priv->attachments_view), msg);
 418         priv->attachments = modest_attachments_view_get_attachments (MODEST_ATTACHMENTS_VIEW (priv->attachments_view));
 419         update_next_cid (self, priv->attachments);
 420
 421         body = modest_tny_msg_get_body (msg, FALSE, NULL);
 422         gtk_html_set_editable (GTK_HTML (priv->msg_body), FALSE);
 423         if (body) {
 424                 gtk_html_load_from_string (GTK_HTML (priv->msg_body), body, -1);
 425         }
 426         gtk_html_set_editable (GTK_HTML (priv->msg_body), TRUE);
 427         g_free (body);
 428
 429         modest_msg_edit_window_set_modified (self, FALSE);
 430
 431         if (priv->msg_uid) {
 432                 g_free (priv->msg_uid);
 433                 priv->msg_uid = NULL;
 434         }
 435
 436         /* we should set a reference to the incoming message if it is a draft */
 437         msg_folder = tny_msg_get_folder (msg);
 438         if (msg_folder) {
 439                 if (modest_tny_folder_is_local_folder (msg_folder)) {
 440                         TnyFolderType type = modest_tny_folder_get_local_or_mmc_folder_type (msg_folder);
 441                         if (type == TNY_FOLDER_TYPE_INVALID)
 442                                 g_warning ("%s: BUG: TNY_FOLDER_TYPE_INVALID", __FUNCTION__);
 443
 444                         if (type == TNY_FOLDER_TYPE_DRAFTS)
 445                                 priv->draft_msg = g_object_ref(msg);
 446                         if (type == TNY_FOLDER_TYPE_OUTBOX)
 447                                 priv->outbox_msg = g_object_ref(msg);
 448                         priv->msg_uid = modest_tny_folder_get_header_unique_id (header);
 449                 }
 450                 g_object_unref (msg_folder);
 451         }
 452
 453         g_free (subject);
 454         g_free (to);
 455         g_free (cc);
 456         g_free (bcc);
 457 }
 458
 459
 460 ModestWindow *
 461 modest_msg_edit_window_new (TnyMsg *msg, const gchar *account,
 462                             const gchar *mailbox,
 463                             gboolean preserve_is_rich)
 464 {
 465         ModestMsgEditWindow *self;
 466         ModestMsgEditWindowPrivate *priv;
 467         ModestWindowPrivate *parent_priv;
 468         GtkActionGroup *action_group;
 469         ModestDimmingRulesGroup *menu_rules_group = NULL;
 470         ModestDimmingRulesGroup *toolbar_rules_group = NULL;
 471         ModestDimmingRulesGroup *clipboard_rules_group = NULL;
 472         GError *error = NULL;
 473
 474         g_return_val_if_fail (msg, NULL);
 475
 476         self = MODEST_MSG_EDIT_WINDOW(g_object_new(MODEST_TYPE_MSG_EDIT_WINDOW, NULL));
 477         priv = MODEST_MSG_EDIT_WINDOW_GET_PRIVATE(self);
 478         parent_priv = MODEST_WINDOW_GET_PRIVATE(self);
 479
 480         parent_priv->ui_manager = gtk_ui_manager_new();
 481         action_group = gtk_action_group_new ("ModestMsgEditWindowActions");
 482         gtk_action_group_set_translation_domain (action_group, GETTEXT_PACKAGE);
 483
 484         /* Add common actions */
 485         gtk_action_group_add_actions (action_group,
 486                                       modest_msg_edit_action_entries,
 487                                       G_N_ELEMENTS (modest_msg_edit_action_entries),
 488                                       self);
 489         gtk_action_group_add_toggle_actions (action_group,
 490                                              modest_msg_edit_toggle_action_entries,
 491                                              G_N_ELEMENTS (modest_msg_edit_toggle_action_entries),
 492                                              self);
 493         gtk_ui_manager_insert_action_group (parent_priv->ui_manager, action_group, 0);
 494         g_object_unref (action_group);
 495
 496         /* Load the UI definition */
 497         gtk_ui_manager_add_ui_from_file (parent_priv->ui_manager,
 498                                          MODEST_UIDIR "modest-msg-edit-window-ui.xml",
 499                                          &error);
 500         if (error) {
 501                 g_printerr ("modest: could not merge modest-msg-edit-window-ui.xml: %s\n", error->message);
 502                 g_error_free (error);
 503                 error = NULL;
 504         }
 505         /* ****** */
 506
 507         /* Add accelerators */
 508         gtk_window_add_accel_group (GTK_WINDOW (self),
 509                                     gtk_ui_manager_get_accel_group (parent_priv->ui_manager));
 510
 511         /* Toolbar / Menubar */
 512         priv->toolbar = gtk_ui_manager_get_widget (parent_priv->ui_manager, "/ToolBar");
 513         priv->menubar = gtk_ui_manager_get_widget (parent_priv->ui_manager, "/MenuBar");
 514
 515         gtk_toolbar_set_tooltips (GTK_TOOLBAR (priv->toolbar), TRUE);
 516
 517         /* Init window */
 518         init_window (MODEST_MSG_EDIT_WINDOW(self), account);
 519
 520         restore_settings (MODEST_MSG_EDIT_WINDOW(self));
 521
 522         gtk_window_set_title (GTK_WINDOW(self), "Modest");
 523         gtk_window_set_icon_from_file (GTK_WINDOW(self), MODEST_APP_ICON, NULL);
 524
 525         g_signal_connect (G_OBJECT(self), "delete-event",
 526                           G_CALLBACK(on_delete_event), self);
 527
 528         parent_priv->ui_dimming_manager = modest_ui_dimming_manager_new ();
 529         menu_rules_group = modest_dimming_rules_group_new (MODEST_DIMMING_RULES_MENU, FALSE);
 530         toolbar_rules_group = modest_dimming_rules_group_new (MODEST_DIMMING_RULES_TOOLBAR, TRUE);
 531         clipboard_rules_group = modest_dimming_rules_group_new (MODEST_DIMMING_RULES_CLIPBOARD, FALSE);
 532
 533         /* Add common dimming rules */
 534         modest_dimming_rules_group_add_rules (menu_rules_group,
 535                                               modest_msg_edit_window_menu_dimming_entries,
 536                                               G_N_ELEMENTS (modest_msg_edit_window_menu_dimming_entries),
 537                                               MODEST_WINDOW (self));
 538         modest_dimming_rules_group_add_rules (toolbar_rules_group,
 539                                               modest_msg_edit_window_toolbar_dimming_entries,
 540                                               G_N_ELEMENTS (modest_msg_edit_window_toolbar_dimming_entries),
 541                                               MODEST_WINDOW (self));
 542 /*      modest_dimming_rules_group_add_widget_rule (toolbar_rules_group, priv->font_color_button, */
 543 /*                                                  G_CALLBACK (modest_ui_dimming_rules_on_set_style), */
 544 /*                                                  MODEST_WINDOW (self)); */
 545 /*      modest_dimming_rules_group_add_widget_rule (toolbar_rules_group, priv->font_size_toolitem, */
 546 /*                                                  G_CALLBACK (modest_ui_dimming_rules_on_set_style), */
 547 /*                                                  MODEST_WINDOW (self)); */
 548 /*      modest_dimming_rules_group_add_widget_rule (toolbar_rules_group, priv->font_face_toolitem, */
 549 /*                                                  G_CALLBACK (modest_ui_dimming_rules_on_set_style), */
 550 /*                                                  MODEST_WINDOW (self)); */
 551         modest_dimming_rules_group_add_rules (clipboard_rules_group,
 552                                               modest_msg_edit_window_clipboard_dimming_entries,
 553                                               G_N_ELEMENTS (modest_msg_edit_window_clipboard_dimming_entries),
 554                                               MODEST_WINDOW (self));
 555         /* Insert dimming rules group for this window */
 556         modest_ui_dimming_manager_insert_rules_group (parent_priv->ui_dimming_manager, menu_rules_group);
 557         modest_ui_dimming_manager_insert_rules_group (parent_priv->ui_dimming_manager, toolbar_rules_group);
 558         modest_ui_dimming_manager_insert_rules_group (parent_priv->ui_dimming_manager, clipboard_rules_group);
 559         /* Checks the dimming rules */
 560         g_object_unref (menu_rules_group);
 561         g_object_unref (toolbar_rules_group);
 562         g_object_unref (clipboard_rules_group);
 563
 564         set_msg (self, msg);
 565
 566         return MODEST_WINDOW(self);
 567 }
 568
 569 static gboolean
 570 html_export_save_buffer (gpointer engine,
 571                          const gchar *data,
 572                          size_t len,
 573                          GString **buffer)
 574 {
 575         *buffer = g_string_append (*buffer, data);
 576         return TRUE;
 577 }
 578
 579
 580 MsgData *
 581 modest_msg_edit_window_get_msg_data (ModestMsgEditWindow *edit_window)
 582 {
 583         MsgData *data;
 584
 585         const gchar *account_name;
 586         gchar *from_string = NULL;
 587         ModestMsgEditWindowPrivate *priv;
 588         GString *buffer;
 589         TnyIterator *att_iter;
 590
 591         g_return_val_if_fail (MODEST_IS_MSG_EDIT_WINDOW (edit_window), NULL);
 592
 593         priv = MODEST_MSG_EDIT_WINDOW_GET_PRIVATE (edit_window);
 594
 595         account_name = (gchar*)modest_combo_box_get_active_id (MODEST_COMBO_BOX (priv->from_field));
 596         if (account_name)
 597                 from_string = modest_account_mgr_get_from_string (modest_runtime_get_account_mgr(),
 598                                                                   account_name, NULL);
 599         if (!from_string) {
 600                 g_printerr ("modest: cannot get from string\n");
 601                 return NULL;
 602         }
 603
 604
 605
 606         data = g_slice_new0 (MsgData);
 607         data->from    =  from_string; /* will be freed when data is freed */
 608         data->to      =  g_strdup ( gtk_entry_get_text (GTK_ENTRY(priv->to_field)));
 609         data->cc      =  g_strdup ( gtk_entry_get_text (GTK_ENTRY(priv->cc_field)));
 610         data->bcc     =  g_strdup ( gtk_entry_get_text (GTK_ENTRY(priv->bcc_field)));
 611         data->subject =  g_strdup ( gtk_entry_get_text (GTK_ENTRY(priv->subject_field)));
 612         data->references = g_strdup (priv->references);
 613         data->in_reply_to = g_strdup (priv->in_reply_to);
 614
 615 /*      GtkTextBuffer *buf = gtk_text_view_get_buffer (GTK_TEXT_VIEW (priv->msg_body)); */
 616 /*      GtkTextIter b, e; */
 617 /*      gtk_text_buffer_get_bounds (buf, &b, &e); */
 618 /*      data->plain_body =  gtk_text_buffer_get_text (buf, &b, &e, FALSE); /\* Returns a copy. *\/ */
 619
 620         buffer = g_string_new ("");
 621         gtk_html_export (GTK_HTML (priv->msg_body), "text/html", (GtkHTMLSaveReceiverFn) html_export_save_buffer, &buffer);
 622         data->html_body = g_string_free (buffer, FALSE);
 623         buffer = g_string_new ("");
 624         gtk_html_export (GTK_HTML (priv->msg_body), "text/plain", (GtkHTMLSaveReceiverFn) html_export_save_buffer, &buffer);
 625         data->plain_body = g_string_free (buffer, FALSE);
 626
 627         /* deep-copy the attachment data */
 628         att_iter = tny_list_create_iterator (priv->attachments);
 629         data->attachments = NULL;
 630         while (!tny_iterator_is_done (att_iter)) {
 631                 TnyMimePart *part = (TnyMimePart *) tny_iterator_get_current (att_iter);
 632                 if (!(TNY_IS_MIME_PART(part))) {
 633                         g_warning ("strange data in attachment list");
 634                         g_object_unref (part);
 635                         tny_iterator_next (att_iter);
 636                         continue;
 637                 }
 638                 data->attachments = g_list_append (data->attachments,
 639                                                    part);
 640                 tny_iterator_next (att_iter);
 641         }
 642         g_object_unref (att_iter);
 643
 644
 645         if (priv->draft_msg) {
 646                 data->draft_msg = g_object_ref (priv->draft_msg);
 647         } else if (priv->outbox_msg) {
 648                 data->draft_msg = g_object_ref (priv->outbox_msg);
 649         } else {
 650                 data->draft_msg = NULL;
 651         }
 652         return data;
 653 }
 654
 655 static void
 656 unref_gobject (GObject *obj, gpointer data)
 657 {
 658         if (!G_IS_OBJECT(obj))
 659                 return;
 660         g_object_unref (obj);
 661 }
 662
 663 void
 664 modest_msg_edit_window_free_msg_data (ModestMsgEditWindow *edit_window,
 665                                       MsgData *data)
 666 {
 667         g_return_if_fail (MODEST_IS_MSG_EDIT_WINDOW (edit_window));
 668
 669         if (!data)
 670                 return;
 671
 672         g_free (data->to);
 673         g_free (data->cc);
 674         g_free (data->bcc);
 675         g_free (data->subject);
 676         g_free (data->plain_body);
 677         g_free (data->html_body);
 678         g_free (data->references);
 679         g_free (data->in_reply_to);
 680
 681         if (data->draft_msg != NULL) {
 682                 g_object_unref (data->draft_msg);
 683                 data->draft_msg = NULL;
 684         }
 685
 686         g_list_foreach (data->attachments, (GFunc)unref_gobject,  NULL);
 687         g_list_free (data->attachments);
 688
 689         g_slice_free (MsgData, data);
 690 }
 691
 692 /* Rich formatting API functions */
 693 ModestMsgEditFormat
 694 modest_msg_edit_window_get_format (ModestMsgEditWindow *self)
 695 {
 696         return MODEST_MSG_EDIT_FORMAT_TEXT;
 697 }
 698
 699 void
 700 modest_msg_edit_window_set_format (ModestMsgEditWindow *self,
 701                                    ModestMsgEditFormat format)
 702 {
 703         switch (format) {
 704         case MODEST_MSG_EDIT_FORMAT_TEXT:
 705                 break;
 706         case MODEST_MSG_EDIT_FORMAT_HTML:
 707                 g_message ("HTML format not supported in Gnome ModestMsgEditWindow");
 708                 break;
 709         default:
 710                 break;
 711         }
 712 }
 713
 714 ModestMsgEditFormatState *
 715 modest_msg_edit_window_get_format_state (ModestMsgEditWindow *self)
 716 {
 717         ModestMsgEditFormatState *format_state;
 718
 719         g_return_val_if_fail (MODEST_IS_MSG_EDIT_WINDOW (self), NULL);
 720
 721         format_state = g_new0 (ModestMsgEditFormatState, 1);
 722
 723         return format_state;
 724 }
 725
 726 void
 727 modest_msg_edit_window_set_format_state (ModestMsgEditWindow *self,
 728                                          const ModestMsgEditFormatState *format_state)
 729 {
 730         g_return_if_fail (MODEST_MSG_EDIT_WINDOW (self));
 731
 732         /* Ends silently as set_format_state should do nothing when edit window format
 733            is not HTML */
 734         return;
 735 }
 736
 737 void
 738 modest_msg_edit_window_select_color (ModestMsgEditWindow *window)
 739 {
 740         g_return_if_fail (MODEST_MSG_EDIT_WINDOW (window));
 741
 742         g_message ("Select color operation is not supported");
 743 }
 744
 745 void
 746 modest_msg_edit_window_select_file_format (ModestMsgEditWindow *window,
 747                                            gint file_format)
 748 {
 749         g_return_if_fail (MODEST_MSG_EDIT_WINDOW (window));
 750
 751         g_message ("Select file format operation is not supported");
 752 }
 753
 754 void
 755 modest_msg_edit_window_select_font (ModestMsgEditWindow *window)
 756 {
 757         g_return_if_fail (MODEST_MSG_EDIT_WINDOW (window));
 758
 759         g_message ("Select font operation is not supported");
 760 }
 761
 762 void
 763 modest_msg_edit_window_select_background_color (ModestMsgEditWindow *window)
 764 {
 765         g_return_if_fail (MODEST_MSG_EDIT_WINDOW (window));
 766
 767         g_message ("Select background color operation is not supported");
 768 }
 769
 770 void
 771 modest_msg_edit_window_insert_image (ModestMsgEditWindow *window)
 772 {
 773         g_return_if_fail (MODEST_MSG_EDIT_WINDOW (window));
 774
 775         g_message ("Insert image operation is not supported");
 776 }
 777
 778 void
 779 modest_msg_edit_window_attach_file (ModestMsgEditWindow *window)
 780 {
 781         g_return_if_fail (MODEST_MSG_EDIT_WINDOW (window));
 782
 783         g_message ("Attach file operation is not supported");
 784 }
 785
 786 void
 787 modest_msg_edit_window_remove_attachments (ModestMsgEditWindow *window,
 788                                            TnyList *att_list)
 789 {
 790         ModestMsgEditWindowPrivate *priv;
 791         TnyIterator *iter;
 792
 793         g_return_if_fail (MODEST_IS_MSG_EDIT_WINDOW (window));
 794         priv = MODEST_MSG_EDIT_WINDOW_GET_PRIVATE (window);
 795
 796         if (att_list == NULL) {
 797                 att_list = modest_attachments_view_get_selection (MODEST_ATTACHMENTS_VIEW (priv->attachments_view));
 798         } else {
 799                 g_object_ref (att_list);
 800         }
 801
 802         if (tny_list_get_length (att_list) == 0) {
 803                 modest_platform_information_banner (NULL, NULL, _("TODO: no attachments selected to remove"));
 804         } else {
 805                 GtkWidget *confirmation_dialog = NULL;
 806                 gboolean dialog_response;
 807                 gchar *message = NULL;
 808                 gchar *filename = NULL;
 809
 810                 if (tny_list_get_length (att_list) == 1) {
 811                         TnyMimePart *part;
 812                         iter = tny_list_create_iterator (att_list);
 813                         part = (TnyMimePart *) tny_iterator_get_current (iter);
 814                         g_object_unref (iter);
 815                         if (TNY_IS_MSG (part)) {
 816                                 TnyHeader *header = tny_msg_get_header (TNY_MSG (part));
 817                                 if (header) {
 818                                         filename = tny_header_dup_subject (header);
 819                                         g_object_unref (header);
 820                                 }
 821                                 if (filename == NULL) {
 822                                         filename = g_strdup (_("mail_va_no_subject"));
 823                                 }
 824                         } else {
 825                                 filename = g_strdup (tny_mime_part_get_filename (TNY_MIME_PART (part)));
 826                         }
 827                         g_object_unref (part);
 828                 } else {
 829                         filename = g_strdup ("");
 830                 }
 831                 message = g_strdup_printf (ngettext("emev_nc_delete_attachment", "emev_nc_delete_attachments",
 832                                                     (tny_list_get_length (att_list) == 1)), filename);
 833                 g_free (filename);
 834                 confirmation_dialog = gtk_message_dialog_new (GTK_WINDOW (window),
 835                                                               GTK_DIALOG_MODAL | GTK_DIALOG_DESTROY_WITH_PARENT,
 836                                                               GTK_MESSAGE_QUESTION,
 837                                                               GTK_BUTTONS_OK_CANCEL,
 838                                                               "%s", message);
 839                 g_free (message);
 840                 dialog_response = (gtk_dialog_run (GTK_DIALOG (confirmation_dialog))==GTK_RESPONSE_OK);
 841                 gtk_widget_destroy (confirmation_dialog);
 842                 if (!dialog_response) {
 843                         g_object_unref (att_list);
 844                         return;
 845                 }
 846                 modest_platform_information_banner (NULL, NULL, _("mcen_ib_removing_attachment"));
 847
 848                 for (iter = tny_list_create_iterator (att_list);
 849                      !tny_iterator_is_done (iter);
 850                      tny_iterator_next (iter)) {
 851                         TnyMimePart *mime_part = (TnyMimePart *) tny_iterator_get_current (iter);
 852                         tny_list_remove (priv->attachments, (GObject *) mime_part);
 853
 854                         modest_attachments_view_remove_attachment (MODEST_ATTACHMENTS_VIEW (priv->attachments_view),
 855                                                                    mime_part);
 856                         g_object_unref (mime_part);
 857                 }
 858                 g_object_unref (iter);
 859         }
 860
 861         g_object_unref (att_list);
 862
 863 }
 864
 865 static void
 866 modest_msg_edit_window_add_attachment_clicked (GtkButton *button,
 867                                                ModestMsgEditWindow *window)
 868 {
 869         modest_msg_edit_window_offer_attach_file (window);
 870 }
 871
 872 void
 873 modest_msg_edit_window_get_parts_size (ModestMsgEditWindow *window,
 874                                        gint *parts_count,
 875                                        guint64 *parts_size)
 876 {
 877         ModestMsgEditWindowPrivate *priv;
 878
 879         priv = MODEST_MSG_EDIT_WINDOW_GET_PRIVATE (window);
 880
 881         modest_attachments_view_get_sizes (MODEST_ATTACHMENTS_VIEW (priv->attachments_view), parts_count, parts_size);
 882
 883 }
 884
 885 void
 886 modest_msg_edit_window_show_cc (ModestMsgEditWindow *window,
 887                                 gboolean show)
 888 {
 889         g_return_if_fail (MODEST_IS_MSG_EDIT_WINDOW (window));
 890
 891         g_message ("not implemented yet %s", __FUNCTION__);
 892 }
 893 void
 894 modest_msg_edit_window_show_bcc (ModestMsgEditWindow *window,
 895                                 gboolean show)
 896 {
 897         g_return_if_fail (MODEST_IS_MSG_EDIT_WINDOW (window));
 898
 899         g_message ("not implemented yet %s", __FUNCTION__);
 900 }
 901 void
 902 modest_msg_edit_window_undo (ModestMsgEditWindow *window)
 903 {
 904         g_return_if_fail (MODEST_IS_MSG_EDIT_WINDOW (window));
 905
 906         g_message ("not implemented yet %s", __FUNCTION__);
 907 }
 908 void
 909 modest_msg_edit_window_toggle_fullscreen (ModestMsgEditWindow *window)
 910 {
 911         g_return_if_fail (MODEST_IS_MSG_EDIT_WINDOW (window));
 912
 913         g_message ("not implemented yet %s", __FUNCTION__);
 914 }
 915 void
 916 modest_msg_edit_window_set_priority_flags (ModestMsgEditWindow *window,
 917                                            TnyHeaderFlags priority_flags)
 918 {
 919         g_return_if_fail (MODEST_IS_MSG_EDIT_WINDOW (window));
 920
 921         g_message ("not implemented yet %s", __FUNCTION__);
 922 }
 923
 924
 925 void
 926 modest_msg_edit_window_select_contacts (ModestMsgEditWindow *window)
 927 {
 928         g_return_if_fail (MODEST_IS_MSG_EDIT_WINDOW (window));
 929
 930         g_message ("not implemented yet %s", __FUNCTION__);
 931 }
 932
 933 gboolean
 934 modest_msg_edit_window_check_names (ModestMsgEditWindow *window, gboolean add_to_addressbook)
 935 {
 936         g_return_val_if_fail (MODEST_IS_MSG_EDIT_WINDOW (window), FALSE);
 937
 938         g_message ("not implemented yet %s", __FUNCTION__);
 939         return TRUE;
 940 }
 941
 942 void
 943 modest_msg_edit_window_set_file_format (ModestMsgEditWindow *window,
 944                                         gint file_format)
 945 {
 946         g_return_if_fail (MODEST_IS_MSG_EDIT_WINDOW (window));
 947
 948         g_message ("not implemented yet %s", __FUNCTION__);
 949 }
 950
 951 gboolean
 952 modest_msg_edit_window_get_sent (ModestMsgEditWindow *window)
 953 {
 954         ModestMsgEditWindowPrivate *priv;
 955
 956         priv = MODEST_MSG_EDIT_WINDOW_GET_PRIVATE(window);
 957         return priv->sent;
 958 }
 959
 960 void
 961 modest_msg_edit_window_set_sent (ModestMsgEditWindow *window,
 962                                  gboolean sent)
 963 {
 964         ModestMsgEditWindowPrivate *priv;
 965
 966         priv = MODEST_MSG_EDIT_WINDOW_GET_PRIVATE(window);
 967         priv->sent = sent;
 968 }
 969
 970 GtkWidget *
 971 modest_msg_edit_window_get_child_widget (ModestMsgEditWindow *win,
 972                                          ModestMsgEditWindowWidgetType widget_type)
 973 {
 974         ModestMsgEditWindowPrivate *priv;
 975
 976         g_return_val_if_fail (MODEST_IS_MSG_EDIT_WINDOW (win), NULL);
 977         priv = MODEST_MSG_EDIT_WINDOW_GET_PRIVATE (win);
 978
 979         switch (widget_type) {
 980         case MODEST_MSG_EDIT_WINDOW_WIDGET_TYPE_BODY:
 981                 return priv->msg_body;
 982                 break;
 983         case MODEST_MSG_EDIT_WINDOW_WIDGET_TYPE_TO:
 984                 return priv->to_field;
 985                 break;
 986         case MODEST_MSG_EDIT_WINDOW_WIDGET_TYPE_CC:
 987                 return priv->cc_field;
 988                 break;
 989         case MODEST_MSG_EDIT_WINDOW_WIDGET_TYPE_BCC:
 990                 return priv->bcc_field;
 991                 break;
 992         case MODEST_MSG_EDIT_WINDOW_WIDGET_TYPE_SUBJECT:
 993                 return priv->subject_field;
 994                 break;
 995         case MODEST_MSG_EDIT_WINDOW_WIDGET_TYPE_ATTACHMENTS:
 996                 return priv->attachments_view;
 997                 break;
 998         default:
 999                 return NULL;
1000         }
1001         return NULL;
1002 }
1003
1004 /* FUNCTIONS NOT IMPLEMENTED YET */
1005
1006 void
1007 modest_msg_edit_window_set_modified      (ModestMsgEditWindow *window,
1008                                           gboolean modified)
1009 {
1010         g_message (__FUNCTION__);
1011 }
1012
1013 void
1014 modest_msg_edit_window_toggle_find_toolbar (ModestMsgEditWindow *window,
1015                                             gboolean show)
1016 {
1017         g_message ("NOT IMPLEMENTED %s", __FUNCTION__);
1018 }
1019
1020 void
1021 modest_msg_edit_window_add_part (ModestMsgEditWindow *window,
1022                                  TnyMimePart *part)
1023 {
1024         ModestMsgEditWindowPrivate *priv = MODEST_MSG_EDIT_WINDOW_GET_PRIVATE (window);
1025
1026         g_return_if_fail (TNY_IS_MIME_PART (part));
1027         tny_list_prepend (priv->attachments, (GObject *) part);
1028         modest_attachments_view_add_attachment (MODEST_ATTACHMENTS_VIEW (priv->attachments_view), part, TRUE, 0);
1029 }
1030
1031 void
1032 modest_msg_edit_window_redo               (ModestMsgEditWindow *window)
1033 {
1034         g_message ("NOT IMPLEMENTED %s", __FUNCTION__);
1035 }
1036
1037 void
1038 modest_msg_edit_window_offer_attach_file           (ModestMsgEditWindow *window)
1039 {
1040         GtkWidget *dialog = NULL;
1041         gint response = 0;
1042         GSList *uris = NULL;
1043         GSList *uri_node;
1044
1045         dialog = gtk_file_chooser_dialog_new (_("mcen_ti_select_attachment_title"),
1046                                               GTK_WINDOW (window),
1047                                               GTK_FILE_CHOOSER_ACTION_OPEN,
1048                                               GTK_STOCK_OPEN,
1049                                               GTK_RESPONSE_OK,
1050                                               GTK_STOCK_CANCEL,
1051                                               GTK_RESPONSE_CANCEL,
1052                                               NULL);
1053
1054         response = gtk_dialog_run (GTK_DIALOG (dialog));
1055         switch (response) {
1056         case GTK_RESPONSE_OK:
1057                 uris = gtk_file_chooser_get_uris (GTK_FILE_CHOOSER (dialog));
1058                 break;
1059         default:
1060                 break;
1061         }
1062         gtk_widget_destroy (dialog);
1063
1064         for (uri_node = uris; uri_node != NULL; uri_node = g_slist_next (uri_node)) {
1065                 const gchar *uri = (const gchar *) uri_node->data;
1066                 modest_msg_edit_window_attach_file_one (window, uri, MODEST_MAX_ATTACHMENT_SIZE);
1067         }
1068         g_slist_foreach (uris, (GFunc) g_free, NULL);
1069         g_slist_free (uris);
1070 }
1071
1072 GnomeVFSFileSize
1073 modest_msg_edit_window_attach_file_one (ModestMsgEditWindow *window,
1074                                         const gchar *uri,
1075                                         GnomeVFSFileSize allowed_size)
1076 {
1077         GnomeVFSHandle *handle = NULL;
1078         ModestMsgEditWindowPrivate *priv;
1079         GnomeVFSResult result;
1080
1081         g_return_val_if_fail (window, 0);
1082         g_return_val_if_fail (uri, 0);
1083
1084         priv = MODEST_MSG_EDIT_WINDOW_GET_PRIVATE (window);
1085
1086         result = gnome_vfs_open (&handle, uri, GNOME_VFS_OPEN_READ);
1087         if (result == GNOME_VFS_OK) {
1088                 TnyMimePart *mime_part;
1089                 TnyStream *stream;
1090                 const gchar *mime_type = NULL;
1091                 gchar *basename;
1092                 gchar *escaped_filename;
1093                 gchar *filename;
1094                 gchar *content_id;
1095                 GnomeVFSFileInfo *info;
1096                 GnomeVFSURI *vfs_uri;
1097
1098                 vfs_uri = gnome_vfs_uri_new (uri);
1099
1100                 escaped_filename = g_path_get_basename (gnome_vfs_uri_get_path (vfs_uri));
1101                 filename = gnome_vfs_unescape_string_for_display (escaped_filename);
1102                 g_free (escaped_filename);
1103                 gnome_vfs_uri_unref (vfs_uri);
1104
1105                 info = gnome_vfs_file_info_new ();
1106
1107                 if (gnome_vfs_get_file_info (uri,
1108                                              info,
1109                                              GNOME_VFS_FILE_INFO_GET_MIME_TYPE)
1110                     == GNOME_VFS_OK)
1111                         mime_type = gnome_vfs_file_info_get_mime_type (info);
1112                 mime_part = tny_platform_factory_new_mime_part
1113                         (modest_runtime_get_platform_factory ());
1114                 stream = TNY_STREAM (tny_vfs_stream_new (handle));
1115
1116                 tny_mime_part_construct (mime_part, stream, mime_type, "base64");
1117
1118                 g_object_unref (stream);
1119
1120                 content_id = g_strdup_printf ("%d", priv->next_cid);
1121                 tny_mime_part_set_content_id (mime_part, content_id);
1122                 g_free (content_id);
1123                 priv->next_cid++;
1124
1125                 basename = g_path_get_basename (filename);
1126                 tny_mime_part_set_filename (mime_part, basename);
1127                 g_free (basename);
1128
1129                 tny_list_prepend (priv->attachments, (GObject *) mime_part);
1130                 modest_attachments_view_add_attachment (MODEST_ATTACHMENTS_VIEW (priv->attachments_view),
1131                                                         mime_part,
1132                                                         info->size == 0, info->size);
1133                 g_free (filename);
1134                 g_object_unref (mime_part);
1135                 gnome_vfs_file_info_unref (info);
1136         }
1137         /* TODO: return proper file size */
1138         return 0;
1139 }
1140
1141 void
1142 modest_msg_edit_window_set_draft (ModestMsgEditWindow *window,
1143                                   TnyMsg *draft)
1144 {
1145         ModestMsgEditWindowPrivate *priv;
1146         TnyHeader *header = NULL;
1147
1148         g_return_if_fail (MODEST_IS_MSG_EDIT_WINDOW (window));
1149         g_return_if_fail ((draft == NULL)||(TNY_IS_MSG (draft)));
1150
1151         priv = MODEST_MSG_EDIT_WINDOW_GET_PRIVATE (window);
1152         ModestWindowMgr *mgr = modest_runtime_get_window_mgr ();
1153
1154         if (priv->draft_msg != NULL) {
1155                 g_object_unref (priv->draft_msg);
1156         }
1157
1158         if (draft != NULL) {
1159                 g_object_ref (draft);
1160                 header = tny_msg_get_header (draft);
1161                 if (priv->msg_uid) {
1162                         g_free (priv->msg_uid);
1163                         priv->msg_uid = NULL;
1164                 }
1165                 priv->msg_uid = modest_tny_folder_get_header_unique_id (header);
1166                 if (GTK_WIDGET_REALIZED (window))
1167                         modest_window_mgr_register_window (mgr, MODEST_WINDOW (window), NULL);
1168         }
1169
1170         priv->draft_msg = draft;
1171 }
1172
1173 gboolean
1174 modest_msg_edit_window_is_modified         (ModestMsgEditWindow *window)
1175 {
1176         g_message ("NOT IMPLEMENTED %s", __FUNCTION__);
1177         return TRUE;
1178 }
1179
1180 const gchar *
1181 modest_msg_edit_window_get_clipboard_text (ModestMsgEditWindow *win)
1182 {
1183         g_message ("NOT IMPLEMENTED %s", __FUNCTION__);
1184         return NULL;
1185 }
1186
1187 gboolean
1188 modest_msg_edit_window_can_redo               (ModestMsgEditWindow *window)
1189 {
1190         g_message ("NOT IMPLEMENTED %s", __FUNCTION__);
1191         return FALSE;
1192 }
1193 gboolean
1194 modest_msg_edit_window_can_undo               (ModestMsgEditWindow *window)
1195 {
1196         g_message ("NOT IMPLEMENTED %s", __FUNCTION__);
1197         return FALSE;
1198 }
1199
1200 const gchar*
1201 modest_msg_edit_window_get_message_uid (ModestMsgEditWindow *window)
1202 {
1203         ModestMsgEditWindowPrivate *priv;
1204
1205         g_return_val_if_fail (MODEST_IS_MSG_EDIT_WINDOW (window), NULL);
1206         priv = MODEST_MSG_EDIT_WINDOW_GET_PRIVATE (window);
1207
1208         return priv->msg_uid;
1209 }