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);
 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                             gboolean preserve_is_rich)
 463 {
 464         ModestMsgEditWindow *self;
 465         ModestMsgEditWindowPrivate *priv;
 466         ModestWindowPrivate *parent_priv;
 467         GtkActionGroup *action_group;
 468         ModestDimmingRulesGroup *menu_rules_group = NULL;
 469         ModestDimmingRulesGroup *toolbar_rules_group = NULL;
 470         ModestDimmingRulesGroup *clipboard_rules_group = NULL;
 471         GError *error = NULL;
 472
 473         g_return_val_if_fail (msg, NULL);
 474
 475         self = MODEST_MSG_EDIT_WINDOW(g_object_new(MODEST_TYPE_MSG_EDIT_WINDOW, NULL));
 476         priv = MODEST_MSG_EDIT_WINDOW_GET_PRIVATE(self);
 477         parent_priv = MODEST_WINDOW_GET_PRIVATE(self);
 478
 479         parent_priv->ui_manager = gtk_ui_manager_new();
 480         action_group = gtk_action_group_new ("ModestMsgEditWindowActions");
 481         gtk_action_group_set_translation_domain (action_group, GETTEXT_PACKAGE);
 482
 483         /* Add common actions */
 484         gtk_action_group_add_actions (action_group,
 485                                       modest_msg_edit_action_entries,
 486                                       G_N_ELEMENTS (modest_msg_edit_action_entries),
 487                                       self);
 488         gtk_action_group_add_toggle_actions (action_group,
 489                                              modest_msg_edit_toggle_action_entries,
 490                                              G_N_ELEMENTS (modest_msg_edit_toggle_action_entries),
 491                                              self);
 492         gtk_ui_manager_insert_action_group (parent_priv->ui_manager, action_group, 0);
 493         g_object_unref (action_group);
 494
 495         /* Load the UI definition */
 496         gtk_ui_manager_add_ui_from_file (parent_priv->ui_manager,
 497                                          MODEST_UIDIR "modest-msg-edit-window-ui.xml",
 498                                          &error);
 499         if (error) {
 500                 g_printerr ("modest: could not merge modest-msg-edit-window-ui.xml: %s\n", error->message);
 501                 g_error_free (error);
 502                 error = NULL;
 503         }
 504         /* ****** */
 505
 506         /* Add accelerators */
 507         gtk_window_add_accel_group (GTK_WINDOW (self),
 508                                     gtk_ui_manager_get_accel_group (parent_priv->ui_manager));
 509
 510         /* Toolbar / Menubar */
 511         priv->toolbar = gtk_ui_manager_get_widget (parent_priv->ui_manager, "/ToolBar");
 512         priv->menubar = gtk_ui_manager_get_widget (parent_priv->ui_manager, "/MenuBar");
 513
 514         gtk_toolbar_set_tooltips (GTK_TOOLBAR (priv->toolbar), TRUE);
 515
 516         /* Init window */
 517         init_window (MODEST_MSG_EDIT_WINDOW(self), account);
 518
 519         restore_settings (MODEST_MSG_EDIT_WINDOW(self));
 520
 521         gtk_window_set_title (GTK_WINDOW(self), "Modest");
 522         gtk_window_set_icon_from_file (GTK_WINDOW(self), MODEST_APP_ICON, NULL);
 523
 524         g_signal_connect (G_OBJECT(self), "delete-event",
 525                           G_CALLBACK(on_delete_event), self);
 526
 527         parent_priv->ui_dimming_manager = modest_ui_dimming_manager_new ();
 528         menu_rules_group = modest_dimming_rules_group_new (MODEST_DIMMING_RULES_MENU, FALSE);
 529         toolbar_rules_group = modest_dimming_rules_group_new (MODEST_DIMMING_RULES_TOOLBAR, TRUE);
 530         clipboard_rules_group = modest_dimming_rules_group_new (MODEST_DIMMING_RULES_CLIPBOARD, FALSE);
 531
 532         /* Add common dimming rules */
 533         modest_dimming_rules_group_add_rules (menu_rules_group,
 534                                               modest_msg_edit_window_menu_dimming_entries,
 535                                               G_N_ELEMENTS (modest_msg_edit_window_menu_dimming_entries),
 536                                               MODEST_WINDOW (self));
 537         modest_dimming_rules_group_add_rules (toolbar_rules_group,
 538                                               modest_msg_edit_window_toolbar_dimming_entries,
 539                                               G_N_ELEMENTS (modest_msg_edit_window_toolbar_dimming_entries),
 540                                               MODEST_WINDOW (self));
 541 /*      modest_dimming_rules_group_add_widget_rule (toolbar_rules_group, priv->font_color_button, */
 542 /*                                                  G_CALLBACK (modest_ui_dimming_rules_on_set_style), */
 543 /*                                                  MODEST_WINDOW (self)); */
 544 /*      modest_dimming_rules_group_add_widget_rule (toolbar_rules_group, priv->font_size_toolitem, */
 545 /*                                                  G_CALLBACK (modest_ui_dimming_rules_on_set_style), */
 546 /*                                                  MODEST_WINDOW (self)); */
 547 /*      modest_dimming_rules_group_add_widget_rule (toolbar_rules_group, priv->font_face_toolitem, */
 548 /*                                                  G_CALLBACK (modest_ui_dimming_rules_on_set_style), */
 549 /*                                                  MODEST_WINDOW (self)); */
 550         modest_dimming_rules_group_add_rules (clipboard_rules_group,
 551                                               modest_msg_edit_window_clipboard_dimming_entries,
 552                                               G_N_ELEMENTS (modest_msg_edit_window_clipboard_dimming_entries),
 553                                               MODEST_WINDOW (self));
 554         /* Insert dimming rules group for this window */
 555         modest_ui_dimming_manager_insert_rules_group (parent_priv->ui_dimming_manager, menu_rules_group);
 556         modest_ui_dimming_manager_insert_rules_group (parent_priv->ui_dimming_manager, toolbar_rules_group);
 557         modest_ui_dimming_manager_insert_rules_group (parent_priv->ui_dimming_manager, clipboard_rules_group);
 558         /* Checks the dimming rules */
 559         g_object_unref (menu_rules_group);
 560         g_object_unref (toolbar_rules_group);
 561         g_object_unref (clipboard_rules_group);
 562
 563         set_msg (self, msg);
 564
 565         return MODEST_WINDOW(self);
 566 }
 567
 568 static gboolean
 569 html_export_save_buffer (gpointer engine,
 570                          const gchar *data,
 571                          size_t len,
 572                          GString **buffer)
 573 {
 574         *buffer = g_string_append (*buffer, data);
 575         return TRUE;
 576 }
 577
 578
 579 MsgData *
 580 modest_msg_edit_window_get_msg_data (ModestMsgEditWindow *edit_window)
 581 {
 582         MsgData *data;
 583
 584         const gchar *account_name;
 585         gchar *from_string = NULL;
 586         ModestMsgEditWindowPrivate *priv;
 587         GString *buffer;
 588         TnyIterator *att_iter;
 589
 590         g_return_val_if_fail (MODEST_IS_MSG_EDIT_WINDOW (edit_window), NULL);
 591
 592         priv = MODEST_MSG_EDIT_WINDOW_GET_PRIVATE (edit_window);
 593
 594         account_name = (gchar*)modest_combo_box_get_active_id (MODEST_COMBO_BOX (priv->from_field));
 595         if (account_name)
 596                 from_string = modest_account_mgr_get_from_string (
 597                         modest_runtime_get_account_mgr(), account_name);
 598         if (!from_string) {
 599                 g_printerr ("modest: cannot get from string\n");
 600                 return NULL;
 601         }
 602
 603
 604
 605         data = g_slice_new0 (MsgData);
 606         data->from    =  from_string; /* will be freed when data is freed */
 607         data->to      =  g_strdup ( gtk_entry_get_text (GTK_ENTRY(priv->to_field)));
 608         data->cc      =  g_strdup ( gtk_entry_get_text (GTK_ENTRY(priv->cc_field)));
 609         data->bcc     =  g_strdup ( gtk_entry_get_text (GTK_ENTRY(priv->bcc_field)));
 610         data->subject =  g_strdup ( gtk_entry_get_text (GTK_ENTRY(priv->subject_field)));
 611         data->references = g_strdup (priv->references);
 612         data->in_reply_to = g_strdup (priv->in_reply_to);
 613
 614 /*      GtkTextBuffer *buf = gtk_text_view_get_buffer (GTK_TEXT_VIEW (priv->msg_body)); */
 615 /*      GtkTextIter b, e; */
 616 /*      gtk_text_buffer_get_bounds (buf, &b, &e); */
 617 /*      data->plain_body =  gtk_text_buffer_get_text (buf, &b, &e, FALSE); /\* Returns a copy. *\/ */
 618
 619         buffer = g_string_new ("");
 620         gtk_html_export (GTK_HTML (priv->msg_body), "text/html", (GtkHTMLSaveReceiverFn) html_export_save_buffer, &buffer);
 621         data->html_body = g_string_free (buffer, FALSE);
 622         buffer = g_string_new ("");
 623         gtk_html_export (GTK_HTML (priv->msg_body), "text/plain", (GtkHTMLSaveReceiverFn) html_export_save_buffer, &buffer);
 624         data->plain_body = g_string_free (buffer, FALSE);
 625
 626         /* deep-copy the attachment data */
 627         att_iter = tny_list_create_iterator (priv->attachments);
 628         data->attachments = NULL;
 629         while (!tny_iterator_is_done (att_iter)) {
 630                 TnyMimePart *part = (TnyMimePart *) tny_iterator_get_current (att_iter);
 631                 if (!(TNY_IS_MIME_PART(part))) {
 632                         g_warning ("strange data in attachment list");
 633                         g_object_unref (part);
 634                         tny_iterator_next (att_iter);
 635                         continue;
 636                 }
 637                 data->attachments = g_list_append (data->attachments,
 638                                                    part);
 639                 tny_iterator_next (att_iter);
 640         }
 641         g_object_unref (att_iter);
 642
 643
 644         if (priv->draft_msg) {
 645                 data->draft_msg = g_object_ref (priv->draft_msg);
 646         } else if (priv->outbox_msg) {
 647                 data->draft_msg = g_object_ref (priv->outbox_msg);
 648         } else {
 649                 data->draft_msg = NULL;
 650         }
 651         return data;
 652 }
 653
 654 static void
 655 unref_gobject (GObject *obj, gpointer data)
 656 {
 657         if (!G_IS_OBJECT(obj))
 658                 return;
 659         g_object_unref (obj);
 660 }
 661
 662 void
 663 modest_msg_edit_window_free_msg_data (ModestMsgEditWindow *edit_window,
 664                                       MsgData *data)
 665 {
 666         g_return_if_fail (MODEST_IS_MSG_EDIT_WINDOW (edit_window));
 667
 668         if (!data)
 669                 return;
 670
 671         g_free (data->to);
 672         g_free (data->cc);
 673         g_free (data->bcc);
 674         g_free (data->subject);
 675         g_free (data->plain_body);
 676         g_free (data->html_body);
 677         g_free (data->references);
 678         g_free (data->in_reply_to);
 679
 680         if (data->draft_msg != NULL) {
 681                 g_object_unref (data->draft_msg);
 682                 data->draft_msg = NULL;
 683         }
 684
 685         g_list_foreach (data->attachments, (GFunc)unref_gobject,  NULL);
 686         g_list_free (data->attachments);
 687
 688         g_slice_free (MsgData, data);
 689 }
 690
 691 /* Rich formatting API functions */
 692 ModestMsgEditFormat
 693 modest_msg_edit_window_get_format (ModestMsgEditWindow *self)
 694 {
 695         return MODEST_MSG_EDIT_FORMAT_TEXT;
 696 }
 697
 698 void
 699 modest_msg_edit_window_set_format (ModestMsgEditWindow *self,
 700                                    ModestMsgEditFormat format)
 701 {
 702         switch (format) {
 703         case MODEST_MSG_EDIT_FORMAT_TEXT:
 704                 break;
 705         case MODEST_MSG_EDIT_FORMAT_HTML:
 706                 g_message ("HTML format not supported in Gnome ModestMsgEditWindow");
 707                 break;
 708         default:
 709                 break;
 710         }
 711 }
 712
 713 ModestMsgEditFormatState *
 714 modest_msg_edit_window_get_format_state (ModestMsgEditWindow *self)
 715 {
 716         ModestMsgEditFormatState *format_state;
 717
 718         g_return_val_if_fail (MODEST_IS_MSG_EDIT_WINDOW (self), NULL);
 719
 720         format_state = g_new0 (ModestMsgEditFormatState, 1);
 721
 722         return format_state;
 723 }
 724
 725 void
 726 modest_msg_edit_window_set_format_state (ModestMsgEditWindow *self,
 727                                          const ModestMsgEditFormatState *format_state)
 728 {
 729         g_return_if_fail (MODEST_MSG_EDIT_WINDOW (self));
 730
 731         /* Ends silently as set_format_state should do nothing when edit window format
 732            is not HTML */
 733         return;
 734 }
 735
 736 void
 737 modest_msg_edit_window_select_color (ModestMsgEditWindow *window)
 738 {
 739         g_return_if_fail (MODEST_MSG_EDIT_WINDOW (window));
 740
 741         g_message ("Select color operation is not supported");
 742 }
 743
 744 void
 745 modest_msg_edit_window_select_file_format (ModestMsgEditWindow *window,
 746                                            gint file_format)
 747 {
 748         g_return_if_fail (MODEST_MSG_EDIT_WINDOW (window));
 749
 750         g_message ("Select file format operation is not supported");
 751 }
 752
 753 void
 754 modest_msg_edit_window_select_font (ModestMsgEditWindow *window)
 755 {
 756         g_return_if_fail (MODEST_MSG_EDIT_WINDOW (window));
 757
 758         g_message ("Select font operation is not supported");
 759 }
 760
 761 void
 762 modest_msg_edit_window_select_background_color (ModestMsgEditWindow *window)
 763 {
 764         g_return_if_fail (MODEST_MSG_EDIT_WINDOW (window));
 765
 766         g_message ("Select background color operation is not supported");
 767 }
 768
 769 void
 770 modest_msg_edit_window_insert_image (ModestMsgEditWindow *window)
 771 {
 772         g_return_if_fail (MODEST_MSG_EDIT_WINDOW (window));
 773
 774         g_message ("Insert image operation is not supported");
 775 }
 776
 777 void
 778 modest_msg_edit_window_attach_file (ModestMsgEditWindow *window)
 779 {
 780         g_return_if_fail (MODEST_MSG_EDIT_WINDOW (window));
 781
 782         g_message ("Attach file operation is not supported");
 783 }
 784
 785 void
 786 modest_msg_edit_window_remove_attachments (ModestMsgEditWindow *window,
 787                                            TnyList *att_list)
 788 {
 789         ModestMsgEditWindowPrivate *priv;
 790         TnyIterator *iter;
 791
 792         g_return_if_fail (MODEST_IS_MSG_EDIT_WINDOW (window));
 793         priv = MODEST_MSG_EDIT_WINDOW_GET_PRIVATE (window);
 794
 795         if (att_list == NULL) {
 796                 att_list = modest_attachments_view_get_selection (MODEST_ATTACHMENTS_VIEW (priv->attachments_view));
 797         } else {
 798                 g_object_ref (att_list);
 799         }
 800
 801         if (tny_list_get_length (att_list) == 0) {
 802                 modest_platform_information_banner (NULL, NULL, _("TODO: no attachments selected to remove"));
 803         } else {
 804                 GtkWidget *confirmation_dialog = NULL;
 805                 gboolean dialog_response;
 806                 gchar *message = NULL;
 807                 gchar *filename = NULL;
 808
 809                 if (tny_list_get_length (att_list) == 1) {
 810                         TnyMimePart *part;
 811                         iter = tny_list_create_iterator (att_list);
 812                         part = (TnyMimePart *) tny_iterator_get_current (iter);
 813                         g_object_unref (iter);
 814                         if (TNY_IS_MSG (part)) {
 815                                 TnyHeader *header = tny_msg_get_header (TNY_MSG (part));
 816                                 if (header) {
 817                                         filename = tny_header_dup_subject (header);
 818                                         g_object_unref (header);
 819                                 }
 820                                 if (filename == NULL) {
 821                                         filename = g_strdup (_("mail_va_no_subject"));
 822                                 }
 823                         } else {
 824                                 filename = g_strdup (tny_mime_part_get_filename (TNY_MIME_PART (part)));
 825                         }
 826                         g_object_unref (part);
 827                 } else {
 828                         filename = g_strdup ("");
 829                 }
 830                 message = g_strdup_printf (ngettext("emev_nc_delete_attachment", "emev_nc_delete_attachments",
 831                                                     (tny_list_get_length (att_list) == 1)), filename);
 832                 g_free (filename);
 833                 confirmation_dialog = gtk_message_dialog_new (GTK_WINDOW (window),
 834                                                               GTK_DIALOG_MODAL | GTK_DIALOG_DESTROY_WITH_PARENT,
 835                                                               GTK_MESSAGE_QUESTION,
 836                                                               GTK_BUTTONS_OK_CANCEL,
 837                                                               message);
 838                 g_free (message);
 839                 dialog_response = (gtk_dialog_run (GTK_DIALOG (confirmation_dialog))==GTK_RESPONSE_OK);
 840                 gtk_widget_destroy (confirmation_dialog);
 841                 if (!dialog_response) {
 842                         g_object_unref (att_list);
 843                         return;
 844                 }
 845                 modest_platform_information_banner (NULL, NULL, _("mcen_ib_removing_attachment"));
 846
 847                 for (iter = tny_list_create_iterator (att_list);
 848                      !tny_iterator_is_done (iter);
 849                      tny_iterator_next (iter)) {
 850                         TnyMimePart *mime_part = (TnyMimePart *) tny_iterator_get_current (iter);
 851                         tny_list_remove (priv->attachments, (GObject *) mime_part);
 852
 853                         modest_attachments_view_remove_attachment (MODEST_ATTACHMENTS_VIEW (priv->attachments_view),
 854                                                                    mime_part);
 855                         g_object_unref (mime_part);
 856                 }
 857                 g_object_unref (iter);
 858         }
 859
 860         g_object_unref (att_list);
 861
 862 }
 863
 864 static void
 865 modest_msg_edit_window_add_attachment_clicked (GtkButton *button,
 866                                                ModestMsgEditWindow *window)
 867 {
 868         modest_msg_edit_window_offer_attach_file (window);
 869 }
 870
 871 void
 872 modest_msg_edit_window_get_parts_size (ModestMsgEditWindow *window,
 873                                        gint *parts_count,
 874                                        guint64 *parts_size)
 875 {
 876         ModestMsgEditWindowPrivate *priv;
 877
 878         priv = MODEST_MSG_EDIT_WINDOW_GET_PRIVATE (window);
 879
 880         modest_attachments_view_get_sizes (MODEST_ATTACHMENTS_VIEW (priv->attachments_view), parts_count, parts_size);
 881
 882 }
 883
 884 void
 885 modest_msg_edit_window_show_cc (ModestMsgEditWindow *window,
 886                                 gboolean show)
 887 {
 888         g_return_if_fail (MODEST_IS_MSG_EDIT_WINDOW (window));
 889
 890         g_message ("not implemented yet %s", __FUNCTION__);
 891 }
 892 void
 893 modest_msg_edit_window_show_bcc (ModestMsgEditWindow *window,
 894                                 gboolean show)
 895 {
 896         g_return_if_fail (MODEST_IS_MSG_EDIT_WINDOW (window));
 897
 898         g_message ("not implemented yet %s", __FUNCTION__);
 899 }
 900 void
 901 modest_msg_edit_window_undo (ModestMsgEditWindow *window)
 902 {
 903         g_return_if_fail (MODEST_IS_MSG_EDIT_WINDOW (window));
 904
 905         g_message ("not implemented yet %s", __FUNCTION__);
 906 }
 907 void
 908 modest_msg_edit_window_toggle_fullscreen (ModestMsgEditWindow *window)
 909 {
 910         g_return_if_fail (MODEST_IS_MSG_EDIT_WINDOW (window));
 911
 912         g_message ("not implemented yet %s", __FUNCTION__);
 913 }
 914 void
 915 modest_msg_edit_window_set_priority_flags (ModestMsgEditWindow *window,
 916                                            TnyHeaderFlags priority_flags)
 917 {
 918         g_return_if_fail (MODEST_IS_MSG_EDIT_WINDOW (window));
 919
 920         g_message ("not implemented yet %s", __FUNCTION__);
 921 }
 922
 923
 924 void
 925 modest_msg_edit_window_select_contacts (ModestMsgEditWindow *window)
 926 {
 927         g_return_if_fail (MODEST_IS_MSG_EDIT_WINDOW (window));
 928
 929         g_message ("not implemented yet %s", __FUNCTION__);
 930 }
 931
 932 gboolean
 933 modest_msg_edit_window_check_names (ModestMsgEditWindow *window, gboolean add_to_addressbook)
 934 {
 935         g_return_val_if_fail (MODEST_IS_MSG_EDIT_WINDOW (window), FALSE);
 936
 937         g_message ("not implemented yet %s", __FUNCTION__);
 938         return TRUE;
 939 }
 940
 941 void
 942 modest_msg_edit_window_set_file_format (ModestMsgEditWindow *window,
 943                                         gint file_format)
 944 {
 945         g_return_if_fail (MODEST_IS_MSG_EDIT_WINDOW (window));
 946
 947         g_message ("not implemented yet %s", __FUNCTION__);
 948 }
 949
 950 gboolean
 951 modest_msg_edit_window_get_sent (ModestMsgEditWindow *window)
 952 {
 953         ModestMsgEditWindowPrivate *priv;
 954
 955         priv = MODEST_MSG_EDIT_WINDOW_GET_PRIVATE(window);
 956         return priv->sent;
 957 }
 958
 959 void
 960 modest_msg_edit_window_set_sent (ModestMsgEditWindow *window,
 961                                  gboolean sent)
 962 {
 963         ModestMsgEditWindowPrivate *priv;
 964
 965         priv = MODEST_MSG_EDIT_WINDOW_GET_PRIVATE(window);
 966         priv->sent = sent;
 967 }
 968
 969 GtkWidget *
 970 modest_msg_edit_window_get_child_widget (ModestMsgEditWindow *win,
 971                                          ModestMsgEditWindowWidgetType widget_type)
 972 {
 973         ModestMsgEditWindowPrivate *priv;
 974
 975         g_return_val_if_fail (MODEST_IS_MSG_EDIT_WINDOW (win), NULL);
 976         priv = MODEST_MSG_EDIT_WINDOW_GET_PRIVATE (win);
 977
 978         switch (widget_type) {
 979         case MODEST_MSG_EDIT_WINDOW_WIDGET_TYPE_BODY:
 980                 return priv->msg_body;
 981                 break;
 982         case MODEST_MSG_EDIT_WINDOW_WIDGET_TYPE_TO:
 983                 return priv->to_field;
 984                 break;
 985         case MODEST_MSG_EDIT_WINDOW_WIDGET_TYPE_CC:
 986                 return priv->cc_field;
 987                 break;
 988         case MODEST_MSG_EDIT_WINDOW_WIDGET_TYPE_BCC:
 989                 return priv->bcc_field;
 990                 break;
 991         case MODEST_MSG_EDIT_WINDOW_WIDGET_TYPE_SUBJECT:
 992                 return priv->subject_field;
 993                 break;
 994         case MODEST_MSG_EDIT_WINDOW_WIDGET_TYPE_ATTACHMENTS:
 995                 return priv->attachments_view;
 996                 break;
 997         default:
 998                 return NULL;
 999         }
1000         return NULL;
1001 }
1002
1003 /* FUNCTIONS NOT IMPLEMENTED YET */
1004
1005 void
1006 modest_msg_edit_window_set_modified      (ModestMsgEditWindow *window,
1007                                           gboolean modified)
1008 {
1009         g_message (__FUNCTION__);
1010 }
1011
1012 void
1013 modest_msg_edit_window_toggle_find_toolbar (ModestMsgEditWindow *window,
1014                                             gboolean show)
1015 {
1016         g_message ("NOT IMPLEMENTED %s", __FUNCTION__);
1017 }
1018
1019 void
1020 modest_msg_edit_window_add_part (ModestMsgEditWindow *window,
1021                                  TnyMimePart *part)
1022 {
1023         ModestMsgEditWindowPrivate *priv = MODEST_MSG_EDIT_WINDOW_GET_PRIVATE (window);
1024
1025         g_return_if_fail (TNY_IS_MIME_PART (part));
1026         tny_list_prepend (priv->attachments, (GObject *) part);
1027         modest_attachments_view_add_attachment (MODEST_ATTACHMENTS_VIEW (priv->attachments_view), part, TRUE, 0);
1028 }
1029
1030 void
1031 modest_msg_edit_window_redo               (ModestMsgEditWindow *window)
1032 {
1033         g_message ("NOT IMPLEMENTED %s", __FUNCTION__);
1034 }
1035
1036 void
1037 modest_msg_edit_window_offer_attach_file           (ModestMsgEditWindow *window)
1038 {
1039         GtkWidget *dialog = NULL;
1040         gint response = 0;
1041         GSList *uris = NULL;
1042         GSList *uri_node;
1043
1044         dialog = gtk_file_chooser_dialog_new (_("mcen_ti_select_attachment_title"),
1045                                               GTK_WINDOW (window),
1046                                               GTK_FILE_CHOOSER_ACTION_OPEN,
1047                                               GTK_STOCK_OPEN,
1048                                               GTK_RESPONSE_OK,
1049                                               GTK_STOCK_CANCEL,
1050                                               GTK_RESPONSE_CANCEL,
1051                                               NULL);
1052
1053         response = gtk_dialog_run (GTK_DIALOG (dialog));
1054         switch (response) {
1055         case GTK_RESPONSE_OK:
1056                 uris = gtk_file_chooser_get_uris (GTK_FILE_CHOOSER (dialog));
1057                 break;
1058         default:
1059                 break;
1060         }
1061         gtk_widget_destroy (dialog);
1062
1063         for (uri_node = uris; uri_node != NULL; uri_node = g_slist_next (uri_node)) {
1064                 const gchar *uri = (const gchar *) uri_node->data;
1065                 modest_msg_edit_window_attach_file_one (window, uri, MODEST_MAX_ATTACHMENT_SIZE);
1066         }
1067         g_slist_foreach (uris, (GFunc) g_free, NULL);
1068         g_slist_free (uris);
1069 }
1070
1071 GnomeVFSFileSize
1072 modest_msg_edit_window_attach_file_one (ModestMsgEditWindow *window,
1073                                         const gchar *uri,
1074                                         GnomeVFSFileSize allowed_size)
1075 {
1076         GnomeVFSHandle *handle = NULL;
1077         ModestMsgEditWindowPrivate *priv;
1078         GnomeVFSResult result;
1079
1080         g_return_val_if_fail (window, 0);
1081         g_return_val_if_fail (uri, 0);
1082
1083         priv = MODEST_MSG_EDIT_WINDOW_GET_PRIVATE (window);
1084
1085         result = gnome_vfs_open (&handle, uri, GNOME_VFS_OPEN_READ);
1086         if (result == GNOME_VFS_OK) {
1087                 TnyMimePart *mime_part;
1088                 TnyStream *stream;
1089                 const gchar *mime_type = NULL;
1090                 gchar *basename;
1091                 gchar *escaped_filename;
1092                 gchar *filename;
1093                 gchar *content_id;
1094                 GnomeVFSFileInfo *info;
1095                 GnomeVFSURI *vfs_uri;
1096
1097                 vfs_uri = gnome_vfs_uri_new (uri);
1098
1099                 escaped_filename = g_path_get_basename (gnome_vfs_uri_get_path (vfs_uri));
1100                 filename = gnome_vfs_unescape_string_for_display (escaped_filename);
1101                 g_free (escaped_filename);
1102                 gnome_vfs_uri_unref (vfs_uri);
1103
1104                 info = gnome_vfs_file_info_new ();
1105
1106                 if (gnome_vfs_get_file_info (uri,
1107                                              info,
1108                                              GNOME_VFS_FILE_INFO_GET_MIME_TYPE)
1109                     == GNOME_VFS_OK)
1110                         mime_type = gnome_vfs_file_info_get_mime_type (info);
1111                 mime_part = tny_platform_factory_new_mime_part
1112                         (modest_runtime_get_platform_factory ());
1113                 stream = TNY_STREAM (tny_vfs_stream_new (handle));
1114
1115                 tny_mime_part_construct (mime_part, stream, mime_type, "base64");
1116
1117                 g_object_unref (stream);
1118
1119                 content_id = g_strdup_printf ("%d", priv->next_cid);
1120                 tny_mime_part_set_content_id (mime_part, content_id);
1121                 g_free (content_id);
1122                 priv->next_cid++;
1123
1124                 basename = g_path_get_basename (filename);
1125                 tny_mime_part_set_filename (mime_part, basename);
1126                 g_free (basename);
1127
1128                 tny_list_prepend (priv->attachments, (GObject *) mime_part);
1129                 modest_attachments_view_add_attachment (MODEST_ATTACHMENTS_VIEW (priv->attachments_view),
1130                                                         mime_part,
1131                                                         info->size == 0, info->size);
1132                 g_free (filename);
1133                 g_object_unref (mime_part);
1134                 gnome_vfs_file_info_unref (info);
1135         }
1136         /* TODO: return proper file size */
1137         return 0;
1138 }
1139
1140 void
1141 modest_msg_edit_window_set_draft (ModestMsgEditWindow *window,
1142                                   TnyMsg *draft)
1143 {
1144         ModestMsgEditWindowPrivate *priv;
1145         TnyHeader *header = NULL;
1146
1147         g_return_if_fail (MODEST_IS_MSG_EDIT_WINDOW (window));
1148         g_return_if_fail ((draft == NULL)||(TNY_IS_MSG (draft)));
1149
1150         priv = MODEST_MSG_EDIT_WINDOW_GET_PRIVATE (window);
1151         ModestWindowMgr *mgr = modest_runtime_get_window_mgr ();
1152
1153         if (priv->draft_msg != NULL) {
1154                 g_object_unref (priv->draft_msg);
1155         }
1156
1157         if (draft != NULL) {
1158                 g_object_ref (draft);
1159                 header = tny_msg_get_header (draft);
1160                 if (priv->msg_uid) {
1161                         g_free (priv->msg_uid);
1162                         priv->msg_uid = NULL;
1163                 }
1164                 priv->msg_uid = modest_tny_folder_get_header_unique_id (header);
1165                 if (GTK_WIDGET_REALIZED (window))
1166                         modest_window_mgr_register_window (mgr, MODEST_WINDOW (window), NULL);
1167         }
1168
1169         priv->draft_msg = draft;
1170 }
1171
1172 gboolean
1173 modest_msg_edit_window_is_modified         (ModestMsgEditWindow *window)
1174 {
1175         g_message ("NOT IMPLEMENTED %s", __FUNCTION__);
1176         return TRUE;
1177 }
1178
1179 const gchar *
1180 modest_msg_edit_window_get_clipboard_text (ModestMsgEditWindow *win)
1181 {
1182         g_message ("NOT IMPLEMENTED %s", __FUNCTION__);
1183         return NULL;
1184 }
1185
1186 gboolean
1187 modest_msg_edit_window_can_redo               (ModestMsgEditWindow *window)
1188 {
1189         g_message ("NOT IMPLEMENTED %s", __FUNCTION__);
1190         return FALSE;
1191 }
1192 gboolean
1193 modest_msg_edit_window_can_undo               (ModestMsgEditWindow *window)
1194 {
1195         g_message ("NOT IMPLEMENTED %s", __FUNCTION__);
1196         return FALSE;
1197 }
1198
1199 const gchar*
1200 modest_msg_edit_window_get_message_uid (ModestMsgEditWindow *window)
1201 {
1202         ModestMsgEditWindowPrivate *priv;
1203
1204         g_return_val_if_fail (MODEST_IS_MSG_EDIT_WINDOW (window), NULL);
1205         priv = MODEST_MSG_EDIT_WINDOW_GET_PRIVATE (window);
1206
1207         return priv->msg_uid;
1208 }