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