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