git.maemo.org Git - modest/blob - src/maemo/modest-msg-view-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 <tny-header.h>
  34 #include <tny-vfs-stream.h>
  35 #include "modest-platform.h"
  36 #include <modest-maemo-utils.h>
  37 #include <modest-tny-msg.h>
  38 #include <modest-msg-view-window.h>
  39 #include <modest-attachments-view.h>
  40 #include <modest-main-window-ui.h>
  41 #include "modest-msg-view-window-ui-dimming.h"
  42 #include <modest-widget-memory.h>
  43 #include <modest-runtime.h>
  44 #include <modest-window-priv.h>
  45 #include <modest-tny-folder.h>
  46 #include <modest-text-utils.h>
  47 #include <modest-account-mgr-helpers.h>
  48 #include "modest-progress-bar-widget.h"
  49 #include "modest-defs.h"
  50 #include "modest-hildon-includes.h"
  51 #include <gtkhtml/gtkhtml-search.h>
  52 #include "modest-ui-dimming-manager.h"
  53 #include <gdk/gdkkeysyms.h>
  54
  55 #define DEFAULT_FOLDER "MyDocs/.documents"
  56
  57 static void  modest_msg_view_window_class_init   (ModestMsgViewWindowClass *klass);
  58 static void  modest_msg_view_window_init         (ModestMsgViewWindow *obj);
  59 static void  modest_msg_view_window_finalize     (GObject *obj);
  60 static void  modest_msg_view_window_toggle_find_toolbar (GtkToggleAction *obj,
  61                                                          gpointer data);
  62 static void  modest_msg_view_window_find_toolbar_close (GtkWidget *widget,
  63                                                         ModestMsgViewWindow *obj);
  64 static void  modest_msg_view_window_find_toolbar_search (GtkWidget *widget,
  65                                                         ModestMsgViewWindow *obj);
  66
  67 static void  modest_msg_view_window_set_zoom (ModestWindow *window,
  68                                               gdouble zoom);
  69 static gdouble modest_msg_view_window_get_zoom (ModestWindow *window);
  70 static gboolean modest_msg_view_window_zoom_minus (ModestWindow *window);
  71 static gboolean modest_msg_view_window_zoom_plus (ModestWindow *window);
  72 static gboolean modest_msg_view_window_key_release_event (GtkWidget *window,
  73                                                           GdkEventKey *event,
  74                                                           gpointer userdata);
  75 static gboolean modest_msg_view_window_window_state_event (GtkWidget *widget,
  76                                                            GdkEventWindowState *event,
  77                                                            gpointer userdata);
  78 static void modest_msg_view_window_scroll_up (ModestWindow *window);
  79 static void modest_msg_view_window_scroll_down (ModestWindow *window);
  80 static gboolean modest_msg_view_window_is_last_message (ModestMsgViewWindow *window);
  81 static gboolean modest_msg_view_window_is_first_message (ModestMsgViewWindow *window);
  82 static TnyFolderType modest_msg_view_window_get_folder_type (ModestMsgViewWindow *window);
  83 static void modest_msg_view_window_update_dimmed (ModestMsgViewWindow *window);
  84 static void modest_msg_view_window_update_priority (ModestMsgViewWindow *window);
  85
  86 static void modest_msg_view_window_show_toolbar   (ModestWindow *window,
  87                                                    gboolean show_toolbar);
  88
  89 static void modest_msg_view_window_clipboard_owner_change (GtkClipboard *clipboard,
  90                                                            GdkEvent *event,
  91                                                            ModestMsgViewWindow *window);
  92
  93 static void cancel_progressbar (GtkToolButton *toolbutton,
  94                                 ModestMsgViewWindow *self);
  95
  96 static void         on_queue_changed                     (ModestMailOperationQueue *queue,
  97                                                           ModestMailOperation *mail_op,
  98                                                           ModestMailOperationQueueNotification type,
  99                                                           ModestMsgViewWindow *self);
 100
 101 static void view_msg_cb (ModestMailOperation *mail_op, TnyHeader *header, TnyMsg *msg, gpointer user_data);
 102
 103 static void set_toolbar_mode (ModestMsgViewWindow *self,
 104                               ModestToolBarModes mode);
 105
 106 static gboolean set_toolbar_transfer_mode     (ModestMsgViewWindow *self);
 107
 108 /* list my signals */
 109 enum {
 110         /* MY_SIGNAL_1, */
 111         /* MY_SIGNAL_2, */
 112         LAST_SIGNAL
 113 };
 114
 115 static const GtkToggleActionEntry msg_view_toggle_action_entries [] = {
 116         { "FindInMessage",    GTK_STOCK_FIND,    N_("qgn_toolb_gene_find"), NULL, NULL, G_CALLBACK (modest_msg_view_window_toggle_find_toolbar), FALSE },
 117 };
 118
 119 static const GtkRadioActionEntry msg_view_zoom_action_entries [] = {
 120         { "Zoom50", NULL, N_("mcen_me_viewer_50"), NULL, NULL, 50 },
 121         { "Zoom80", NULL, N_("mcen_me_viewer_80"), NULL, NULL, 80 },
 122         { "Zoom100", NULL, N_("mcen_me_viewer_100"), NULL, NULL, 100 },
 123         { "Zoom120", NULL, N_("mcen_me_viewer_120"), NULL, NULL, 120 },
 124         { "Zoom150", NULL, N_("mcen_me_viewer_150"), NULL, NULL, 150 },
 125         { "Zoom200", NULL, N_("mcen_me_viewer_200"), NULL, NULL, 200 }
 126 };
 127
 128 typedef struct _ModestMsgViewWindowPrivate ModestMsgViewWindowPrivate;
 129 struct _ModestMsgViewWindowPrivate {
 130
 131         GtkWidget   *msg_view;
 132         GtkWidget   *main_scroll;
 133         GtkWidget   *find_toolbar;
 134         gchar       *last_search;
 135
 136         /* Progress observers */
 137         GtkWidget        *progress_bar;
 138         GSList           *progress_widgets;
 139
 140         /* Tollbar items */
 141         GtkWidget   *progress_toolitem;
 142         GtkWidget   *cancel_toolitem;
 143         GtkWidget   *prev_toolitem;
 144         GtkWidget   *next_toolitem;
 145
 146         /* Optimized view enabled */
 147         gboolean optimized_view;
 148
 149         GtkTreeModel *header_model;
 150         GtkTreeRowReference *row_reference;
 151
 152         guint clipboard_change_handler;
 153         guint queue_change_handler;
 154
 155         guint progress_bar_timeout;
 156
 157         gchar *msg_uid;
 158 };
 159
 160 #define MODEST_MSG_VIEW_WINDOW_GET_PRIVATE(o)      (G_TYPE_INSTANCE_GET_PRIVATE((o), \
 161                                                     MODEST_TYPE_MSG_VIEW_WINDOW, \
 162                                                     ModestMsgViewWindowPrivate))
 163 /* globals */
 164 static GtkWindowClass *parent_class = NULL;
 165
 166 /* uncomment the following if you have defined any signals */
 167 /* static guint signals[LAST_SIGNAL] = {0}; */
 168
 169 GType
 170 modest_msg_view_window_get_type (void)
 171 {
 172         static GType my_type = 0;
 173         if (!my_type) {
 174                 static const GTypeInfo my_info = {
 175                         sizeof(ModestMsgViewWindowClass),
 176                         NULL,           /* base init */
 177                         NULL,           /* base finalize */
 178                         (GClassInitFunc) modest_msg_view_window_class_init,
 179                         NULL,           /* class finalize */
 180                         NULL,           /* class data */
 181                         sizeof(ModestMsgViewWindow),
 182                         1,              /* n_preallocs */
 183                         (GInstanceInitFunc) modest_msg_view_window_init,
 184                         NULL
 185                 };
 186                 my_type = g_type_register_static (MODEST_TYPE_WINDOW,
 187                                                   "ModestMsgViewWindow",
 188                                                   &my_info, 0);
 189         }
 190         return my_type;
 191 }
 192
 193 static void
 194 save_state (ModestWindow *self)
 195 {
 196         modest_widget_memory_save (modest_runtime_get_conf (),
 197                                    G_OBJECT(self),
 198                                    MODEST_CONF_MSG_VIEW_WINDOW_KEY);
 199 }
 200
 201
 202 static void
 203 restore_settings (ModestMsgViewWindow *self)
 204 {
 205         modest_widget_memory_restore (modest_runtime_get_conf (),
 206                                       G_OBJECT(self),
 207                                       MODEST_CONF_MSG_VIEW_WINDOW_KEY);
 208 }
 209
 210 static void
 211 modest_msg_view_window_class_init (ModestMsgViewWindowClass *klass)
 212 {
 213         GObjectClass *gobject_class;
 214         ModestWindowClass *modest_window_class;
 215         gobject_class = (GObjectClass*) klass;
 216         modest_window_class = (ModestWindowClass *) klass;
 217
 218         parent_class            = g_type_class_peek_parent (klass);
 219         gobject_class->finalize = modest_msg_view_window_finalize;
 220
 221         modest_window_class->set_zoom_func = modest_msg_view_window_set_zoom;
 222         modest_window_class->get_zoom_func = modest_msg_view_window_get_zoom;
 223         modest_window_class->zoom_minus_func = modest_msg_view_window_zoom_minus;
 224         modest_window_class->zoom_plus_func = modest_msg_view_window_zoom_plus;
 225         modest_window_class->show_toolbar_func = modest_msg_view_window_show_toolbar;
 226
 227         g_type_class_add_private (gobject_class, sizeof(ModestMsgViewWindowPrivate));
 228
 229         modest_window_class->save_state_func = save_state;
 230 }
 231
 232 static void
 233 modest_msg_view_window_init (ModestMsgViewWindow *obj)
 234 {
 235         ModestMsgViewWindowPrivate *priv;
 236         priv = MODEST_MSG_VIEW_WINDOW_GET_PRIVATE(obj);
 237
 238         priv->msg_view      = NULL;
 239         priv->header_model  = NULL;
 240         priv->clipboard_change_handler = 0;
 241
 242         priv->optimized_view  = FALSE;
 243         priv->progress_bar_timeout = 0;
 244         priv->msg_uid = NULL;
 245 }
 246
 247
 248 static gboolean
 249 set_toolbar_transfer_mode (ModestMsgViewWindow *self)
 250 {
 251         ModestMsgViewWindowPrivate *priv = NULL;
 252
 253         g_return_val_if_fail (MODEST_IS_MSG_VIEW_WINDOW (self), FALSE);
 254
 255         priv = MODEST_MSG_VIEW_WINDOW_GET_PRIVATE(self);
 256
 257         set_toolbar_mode (self, TOOLBAR_MODE_TRANSFER);
 258
 259         if (priv->progress_bar_timeout > 0) {
 260                 g_source_remove (priv->progress_bar_timeout);
 261                 priv->progress_bar_timeout = 0;
 262         }
 263
 264         return FALSE;
 265 }
 266
 267 static void
 268 set_toolbar_mode (ModestMsgViewWindow *self,
 269                   ModestToolBarModes mode)
 270 {
 271         ModestWindowPrivate *parent_priv;
 272         ModestMsgViewWindowPrivate *priv;
 273         GtkAction *widget = NULL;
 274
 275         g_return_if_fail (MODEST_IS_MSG_VIEW_WINDOW (self));
 276
 277         parent_priv = MODEST_WINDOW_GET_PRIVATE(self);
 278         priv = MODEST_MSG_VIEW_WINDOW_GET_PRIVATE(self);
 279
 280         switch (mode) {
 281         case TOOLBAR_MODE_NORMAL:
 282                 widget = gtk_ui_manager_get_action (parent_priv->ui_manager, "/ToolBar/ToolbarMessageNew");
 283                 gtk_action_set_sensitive (widget, TRUE);
 284                 widget = gtk_ui_manager_get_action (parent_priv->ui_manager, "/ToolBar/ToolbarMessageReply");
 285                 gtk_action_set_sensitive (widget, TRUE);
 286                 widget = gtk_ui_manager_get_action (parent_priv->ui_manager, "/ToolBar/ToolbarDeleteMessage");
 287                 gtk_action_set_sensitive (widget, TRUE);
 288                 widget = gtk_ui_manager_get_action (parent_priv->ui_manager, "/ToolBar/ToolbarMessageMoveTo");
 289                 gtk_action_set_sensitive (widget, TRUE);
 290                 widget = gtk_ui_manager_get_action (parent_priv->ui_manager, "/ToolBar/FindInMessage");
 291                 gtk_action_set_sensitive (widget, TRUE);
 292
 293                 if (priv->prev_toolitem)
 294                         gtk_widget_show (priv->prev_toolitem);
 295
 296                 if (priv->next_toolitem)
 297                         gtk_widget_show (priv->next_toolitem);
 298
 299                 if (priv->progress_toolitem)
 300                         gtk_tool_item_set_expand (GTK_TOOL_ITEM (priv->progress_toolitem), FALSE);
 301                 if (priv->progress_bar)
 302                         gtk_widget_hide (priv->progress_bar);
 303
 304                 if (priv->cancel_toolitem)
 305                         gtk_widget_hide (priv->cancel_toolitem);
 306
 307                 /* Hide toolbar if optimized view is enabled */
 308                 if (priv->optimized_view) {
 309                         gtk_widget_set_no_show_all (parent_priv->toolbar, TRUE);
 310                         gtk_widget_hide (GTK_WIDGET(parent_priv->toolbar));
 311                 }
 312
 313                 break;
 314         case TOOLBAR_MODE_TRANSFER:
 315                 widget = gtk_ui_manager_get_action (parent_priv->ui_manager, "/ToolBar/ToolbarMessageNew");
 316                 gtk_action_set_sensitive (widget, FALSE);
 317                 widget = gtk_ui_manager_get_action (parent_priv->ui_manager, "/ToolBar/ToolbarMessageReply");
 318                 gtk_action_set_sensitive (widget, FALSE);
 319                 widget = gtk_ui_manager_get_action (parent_priv->ui_manager, "/ToolBar/ToolbarDeleteMessage");
 320                 gtk_action_set_sensitive (widget, FALSE);
 321                 widget = gtk_ui_manager_get_action (parent_priv->ui_manager, "/ToolBar/ToolbarMessageMoveTo");
 322                 gtk_action_set_sensitive (widget, FALSE);
 323                 widget = gtk_ui_manager_get_action (parent_priv->ui_manager, "/ToolBar/FindInMessage");
 324                 gtk_action_set_sensitive (widget, FALSE);
 325
 326                 if (priv->prev_toolitem)
 327                         gtk_widget_hide (priv->prev_toolitem);
 328
 329                 if (priv->next_toolitem)
 330                         gtk_widget_hide (priv->next_toolitem);
 331
 332                 if (priv->progress_toolitem)
 333                         gtk_tool_item_set_expand (GTK_TOOL_ITEM (priv->progress_toolitem), TRUE);
 334                 if (priv->progress_bar)
 335                         gtk_widget_show (priv->progress_bar);
 336
 337                 if (priv->cancel_toolitem)
 338                         gtk_widget_show (priv->cancel_toolitem);
 339
 340                 /* Show toolbar if it's hiden (optimized view ) */
 341                 if (priv->optimized_view) {
 342                         gtk_widget_set_no_show_all (parent_priv->toolbar, FALSE);
 343                         gtk_widget_show (GTK_WIDGET (parent_priv->toolbar));
 344                 }
 345
 346                 break;
 347         default:
 348                 g_return_if_reached ();
 349         }
 350
 351 }
 352
 353
 354 static GtkWidget *
 355 menubar_to_menu (GtkUIManager *ui_manager)
 356 {
 357         GtkWidget *main_menu;
 358         GtkWidget *menubar;
 359         GList *iter;
 360
 361         /* Create new main menu */
 362         main_menu = gtk_menu_new();
 363
 364         /* Get the menubar from the UI manager */
 365         menubar = gtk_ui_manager_get_widget (ui_manager, "/MenuBar");
 366
 367         iter = gtk_container_get_children (GTK_CONTAINER (menubar));
 368         while (iter) {
 369                 GtkWidget *menu;
 370
 371                 menu = GTK_WIDGET (iter->data);
 372                 gtk_widget_reparent(menu, main_menu);
 373
 374                 iter = g_list_next (iter);
 375         }
 376         return main_menu;
 377 }
 378
 379 static void
 380 init_window (ModestMsgViewWindow *obj, TnyMsg *msg)
 381 {
 382         GtkWidget *main_vbox;
 383         ModestMsgViewWindowPrivate *priv;
 384         ModestWindowPrivate *parent_priv;
 385
 386         priv = MODEST_MSG_VIEW_WINDOW_GET_PRIVATE(obj);
 387         parent_priv = MODEST_WINDOW_GET_PRIVATE(obj);
 388
 389         priv->msg_view = modest_msg_view_new (msg);
 390         modest_msg_view_set_shadow_type (MODEST_MSG_VIEW (priv->msg_view), GTK_SHADOW_NONE);
 391         main_vbox = gtk_vbox_new  (FALSE, 6);
 392
 393         /* Menubar */
 394         parent_priv->menubar = menubar_to_menu (parent_priv->ui_manager);
 395         gtk_widget_show_all (GTK_WIDGET(parent_priv->menubar));
 396         hildon_window_set_menu    (HILDON_WINDOW(obj), GTK_MENU(parent_priv->menubar));
 397
 398         priv->main_scroll = gtk_scrolled_window_new (NULL, NULL);
 399         gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (priv->main_scroll), GTK_POLICY_NEVER, GTK_POLICY_AUTOMATIC);
 400         gtk_scrolled_window_set_shadow_type (GTK_SCROLLED_WINDOW (priv->main_scroll), GTK_SHADOW_NONE);
 401
 402         gtk_container_add (GTK_CONTAINER (priv->main_scroll), priv->msg_view);
 403         gtk_box_pack_start (GTK_BOX(main_vbox), priv->main_scroll, TRUE, TRUE, 0);
 404         gtk_container_add   (GTK_CONTAINER(obj), main_vbox);
 405
 406         priv->find_toolbar = hildon_find_toolbar_new (NULL);
 407         gtk_widget_set_no_show_all (priv->find_toolbar, TRUE);
 408         g_signal_connect (G_OBJECT (priv->find_toolbar), "close", G_CALLBACK (modest_msg_view_window_find_toolbar_close), obj);
 409         g_signal_connect (G_OBJECT (priv->find_toolbar), "search", G_CALLBACK (modest_msg_view_window_find_toolbar_search), obj);
 410
 411         priv->clipboard_change_handler = g_signal_connect (G_OBJECT (gtk_clipboard_get (GDK_SELECTION_PRIMARY)), "owner-change", G_CALLBACK (modest_msg_view_window_clipboard_owner_change), obj);
 412         gtk_widget_show_all (GTK_WIDGET(main_vbox));
 413         gtk_box_pack_end (GTK_BOX (main_vbox), priv->find_toolbar, FALSE, FALSE, 0);
 414
 415 }
 416
 417
 418 static void
 419 modest_msg_view_window_finalize (GObject *obj)
 420 {
 421         ModestMsgViewWindowPrivate *priv;
 422
 423         priv = MODEST_MSG_VIEW_WINDOW_GET_PRIVATE (obj);
 424         if (priv->clipboard_change_handler > 0) {
 425                 g_signal_handler_disconnect (gtk_clipboard_get (GDK_SELECTION_PRIMARY), priv->clipboard_change_handler);
 426                 priv->clipboard_change_handler = 0;
 427         }
 428         if (priv->queue_change_handler > 0) {
 429                 g_signal_handler_disconnect (G_OBJECT (modest_runtime_get_mail_operation_queue ()), priv->queue_change_handler);
 430                 priv->queue_change_handler = 0;
 431         }
 432         if (priv->header_model != NULL) {
 433                 g_object_unref (priv->header_model);
 434                 priv->header_model = NULL;
 435         }
 436
 437         /* disconnet operations queue observer */
 438
 439         if (priv->progress_bar_timeout > 0) {
 440                 g_source_remove (priv->progress_bar_timeout);
 441                 priv->progress_bar_timeout = 0;
 442         }
 443
 444         if (priv->row_reference) {
 445                 gtk_tree_row_reference_free (priv->row_reference);
 446                 priv->row_reference = NULL;
 447         }
 448
 449         if (priv->msg_uid) {
 450                 g_free (priv->msg_uid);
 451                 priv->msg_uid = NULL;
 452         }
 453
 454         G_OBJECT_CLASS(parent_class)->finalize (obj);
 455 }
 456
 457
 458
 459 static gboolean
 460 on_delete_event (GtkWidget *widget, GdkEvent *event, ModestMsgViewWindow *self)
 461 {
 462         modest_window_save_state (MODEST_WINDOW (self));
 463         return FALSE;
 464 }
 465
 466 ModestWindow *
 467 modest_msg_view_window_new_with_header_model (TnyMsg *msg,
 468                                               const gchar *account_name,
 469                                               const gchar *msg_uid,
 470                                               GtkTreeModel *model,
 471                                               GtkTreeRowReference *row_reference)
 472 {
 473         ModestMsgViewWindow *window = NULL;
 474         ModestMsgViewWindowPrivate *priv = NULL;
 475
 476         window = MODEST_MSG_VIEW_WINDOW(modest_msg_view_window_new (msg, account_name, msg_uid));
 477         g_return_val_if_fail (MODEST_IS_MSG_VIEW_WINDOW (window), NULL);
 478
 479         priv = MODEST_MSG_VIEW_WINDOW_GET_PRIVATE (window);
 480
 481         g_object_ref (model);
 482         priv->header_model = model;
 483         priv->row_reference = gtk_tree_row_reference_copy (row_reference);
 484
 485         modest_msg_view_window_update_priority (window);
 486
 487         modest_msg_view_window_update_dimmed (window);
 488
 489         return MODEST_WINDOW(window);
 490 }
 491
 492
 493 ModestWindow *
 494 modest_msg_view_window_new (TnyMsg *msg,
 495                             const gchar *account_name,
 496                             const gchar *msg_uid)
 497 {
 498         ModestMsgViewWindow *self = NULL;
 499         GObject *obj = NULL;
 500         ModestMsgViewWindowPrivate *priv = NULL;
 501         ModestWindowPrivate *parent_priv = NULL;
 502         ModestDimmingRulesGroup *rules_group = NULL;
 503         GtkActionGroup *action_group = NULL;
 504         GError *error = NULL;
 505         GdkPixbuf *window_icon = NULL;
 506         GtkAction *action = NULL;
 507
 508         g_return_val_if_fail (msg, NULL);
 509
 510         obj = g_object_new(MODEST_TYPE_MSG_VIEW_WINDOW, NULL);
 511         priv = MODEST_MSG_VIEW_WINDOW_GET_PRIVATE(obj);
 512         parent_priv = MODEST_WINDOW_GET_PRIVATE(obj);
 513         self = MODEST_MSG_VIEW_WINDOW (obj);
 514
 515         priv->msg_uid = g_strdup (msg_uid);
 516
 517         parent_priv->ui_manager = gtk_ui_manager_new();
 518         parent_priv->ui_dimming_manager = modest_ui_dimming_manager_new();
 519
 520         action_group = gtk_action_group_new ("ModestMsgViewWindowActions");
 521         gtk_action_group_set_translation_domain (action_group, GETTEXT_PACKAGE);
 522
 523         rules_group = modest_dimming_rules_group_new ("ModestCommonDimmingRules");
 524
 525         /* Add common actions */
 526         gtk_action_group_add_actions (action_group,
 527                                       modest_action_entries,
 528                                       G_N_ELEMENTS (modest_action_entries),
 529                                       obj);
 530         gtk_action_group_add_toggle_actions (action_group,
 531                                              modest_toggle_action_entries,
 532                                              G_N_ELEMENTS (modest_toggle_action_entries),
 533                                              obj);
 534         gtk_action_group_add_toggle_actions (action_group,
 535                                              msg_view_toggle_action_entries,
 536                                              G_N_ELEMENTS (msg_view_toggle_action_entries),
 537                                              obj);
 538         gtk_action_group_add_radio_actions (action_group,
 539                                             msg_view_zoom_action_entries,
 540                                             G_N_ELEMENTS (msg_view_zoom_action_entries),
 541                                             100,
 542                                             G_CALLBACK (modest_ui_actions_on_change_zoom),
 543                                             obj);
 544
 545         gtk_ui_manager_insert_action_group (parent_priv->ui_manager, action_group, 0);
 546         g_object_unref (action_group);
 547
 548         /* Load the UI definition */
 549         gtk_ui_manager_add_ui_from_file (parent_priv->ui_manager, MODEST_UIDIR "modest-msg-view-window-ui.xml",
 550                                          &error);
 551         if (error) {
 552                 g_printerr ("modest: could not merge modest-msg-view-window-ui.xml: %s\n", error->message);
 553                 g_error_free (error);
 554                 error = NULL;
 555         }
 556         /* ****** */
 557
 558         /* Add common dimming rules */
 559         modest_dimming_rules_group_add_rules (rules_group,
 560                                               modest_msg_view_dimming_entries,
 561                                               G_N_ELEMENTS (modest_msg_view_dimming_entries),
 562                                               self);
 563
 564         /* Insert dimming rules group for this window */
 565         modest_ui_dimming_manager_insert_rules_group (parent_priv->ui_dimming_manager, rules_group);
 566         g_object_unref (rules_group);
 567
 568         /* Add accelerators */
 569         gtk_window_add_accel_group (GTK_WINDOW (obj),
 570                                     gtk_ui_manager_get_accel_group (parent_priv->ui_manager));
 571
 572         /* Init window */
 573         init_window (MODEST_MSG_VIEW_WINDOW(obj), msg);
 574         restore_settings (MODEST_MSG_VIEW_WINDOW(obj));
 575
 576         g_signal_connect (G_OBJECT(obj), "delete-event", G_CALLBACK(on_delete_event), obj);
 577
 578         g_signal_connect (G_OBJECT(priv->msg_view), "link_clicked",
 579                           G_CALLBACK (modest_ui_actions_on_msg_link_clicked), obj);
 580         g_signal_connect (G_OBJECT(priv->msg_view), "link_hover",
 581                           G_CALLBACK (modest_ui_actions_on_msg_link_hover), obj);
 582         g_signal_connect (G_OBJECT(priv->msg_view), "attachment_clicked",
 583                           G_CALLBACK (modest_ui_actions_on_msg_attachment_clicked), obj);
 584         g_signal_connect (G_OBJECT(priv->msg_view), "recpt_activated",
 585                           G_CALLBACK (modest_ui_actions_on_msg_recpt_activated), obj);
 586         g_signal_connect (G_OBJECT(priv->msg_view), "link_contextual",
 587                           G_CALLBACK (modest_ui_actions_on_msg_link_contextual), obj);
 588
 589         g_signal_connect (G_OBJECT (obj), "key-release-event",
 590                           G_CALLBACK (modest_msg_view_window_key_release_event),
 591                           NULL);
 592
 593         g_signal_connect (G_OBJECT (obj), "window-state-event",
 594                           G_CALLBACK (modest_msg_view_window_window_state_event),
 595                           NULL);
 596
 597         /* Mail Operation Queue */
 598         priv->queue_change_handler = g_signal_connect (G_OBJECT (modest_runtime_get_mail_operation_queue ()),
 599                                                        "queue-changed",
 600                                                        G_CALLBACK (on_queue_changed),
 601                                                        obj);
 602
 603         modest_window_set_active_account (MODEST_WINDOW(obj), account_name);
 604
 605         priv->last_search = NULL;
 606
 607         modest_msg_view_window_update_dimmed (MODEST_MSG_VIEW_WINDOW (obj));
 608
 609         /* Set window icon */
 610         window_icon = modest_platform_get_icon (MODEST_APP_MSG_VIEW_ICON);
 611         gtk_window_set_icon (GTK_WINDOW (obj), window_icon);
 612
 613         /* Init the clipboard actions dim status */
 614         action = gtk_ui_manager_get_action (parent_priv->ui_manager, "/MenuBar/EditMenu/EditCopyMenu");
 615         gtk_action_set_sensitive (action, FALSE);
 616
 617         action = gtk_ui_manager_get_action (parent_priv->ui_manager, "/MenuBar/EditMenu/EditCutMenu");
 618         gtk_action_set_sensitive (action, FALSE);
 619
 620         /* also set the add to contacts status to false as it depends on clipboard status */
 621         action = gtk_ui_manager_get_action (parent_priv->ui_manager, "/MenuBar/ToolsMenu/ToolsAddToContactsMenu");
 622         gtk_action_set_sensitive (action, FALSE);
 623
 624         gtk_widget_grab_focus (priv->msg_view);
 625
 626         return MODEST_WINDOW(obj);
 627 }
 628
 629
 630
 631 TnyHeader*
 632 modest_msg_view_window_get_header (ModestMsgViewWindow *self)
 633 {
 634         ModestMsgViewWindowPrivate *priv= NULL;
 635         TnyHeader *header = NULL;
 636         GtkTreeIter iter;
 637
 638         g_return_val_if_fail (MODEST_IS_MSG_VIEW_WINDOW (self), NULL);
 639         priv = MODEST_MSG_VIEW_WINDOW_GET_PRIVATE (self);
 640
 641         /* Get current message iter */
 642         gtk_tree_model_get_iter (priv->header_model,
 643                                  &iter,
 644                                  gtk_tree_row_reference_get_path (priv->row_reference));
 645
 646         /* Get current message header */
 647         gtk_tree_model_get (priv->header_model, &iter,
 648                             TNY_GTK_HEADER_LIST_MODEL_INSTANCE_COLUMN,
 649                             &header, -1);
 650
 651         return header;
 652 }
 653
 654 TnyMsg*
 655 modest_msg_view_window_get_message (ModestMsgViewWindow *self)
 656 {
 657         ModestMsgView *msg_view;
 658         ModestMsgViewWindowPrivate *priv;
 659
 660         g_return_val_if_fail (self, NULL);
 661
 662         priv = MODEST_MSG_VIEW_WINDOW_GET_PRIVATE(self);
 663
 664         msg_view = MODEST_MSG_VIEW (priv->msg_view);
 665
 666         return modest_msg_view_get_message (msg_view);
 667 }
 668
 669 const gchar*
 670 modest_msg_view_window_get_message_uid (ModestMsgViewWindow *self)
 671 {
 672         ModestMsgViewWindowPrivate *priv = MODEST_MSG_VIEW_WINDOW_GET_PRIVATE (self);
 673         return (const gchar*) priv->msg_uid;
 674 }
 675
 676 static void
 677 modest_msg_view_window_toggle_find_toolbar (GtkToggleAction *toggle,
 678                                             gpointer data)
 679 {
 680         ModestMsgViewWindow *window = MODEST_MSG_VIEW_WINDOW (data);
 681         ModestMsgViewWindowPrivate *priv = MODEST_MSG_VIEW_WINDOW_GET_PRIVATE (window);
 682
 683         if (gtk_toggle_action_get_active (toggle)) {
 684                 gtk_widget_show (priv->find_toolbar);
 685         } else {
 686                 gtk_widget_hide (priv->find_toolbar);
 687         }
 688
 689
 690 }
 691
 692 static void
 693 modest_msg_view_window_find_toolbar_close (GtkWidget *widget,
 694                                            ModestMsgViewWindow *obj)
 695 {
 696         GtkToggleAction *toggle;
 697         ModestWindowPrivate *parent_priv;
 698         parent_priv = MODEST_WINDOW_GET_PRIVATE (obj);
 699
 700         toggle = GTK_TOGGLE_ACTION (gtk_ui_manager_get_action (parent_priv->ui_manager, "/ToolBar/FindInMessage"));
 701         gtk_toggle_action_set_active (toggle, FALSE);
 702 }
 703
 704 static void
 705 modest_msg_view_window_find_toolbar_search (GtkWidget *widget,
 706                                            ModestMsgViewWindow *obj)
 707 {
 708         gchar *current_search;
 709         ModestMsgViewWindowPrivate *priv = MODEST_MSG_VIEW_WINDOW_GET_PRIVATE (obj);
 710
 711         g_object_get (G_OBJECT (widget), "prefix", &current_search, NULL);
 712
 713         if ((current_search == NULL) && (strcmp (current_search, "") == 0)) {
 714                 g_free (current_search);
 715                 return;
 716         }
 717
 718         if ((priv->last_search == NULL) || (strcmp (priv->last_search, current_search) != 0)) {
 719                 gboolean result;
 720                 g_free (priv->last_search);
 721                 priv->last_search = g_strdup (current_search);
 722                 result = modest_msg_view_search (MODEST_MSG_VIEW (priv->msg_view),
 723                                                  priv->last_search);
 724         } else {
 725                 modest_msg_view_search_next (MODEST_MSG_VIEW (priv->msg_view));
 726         }
 727
 728         g_free (current_search);
 729
 730 }
 731
 732 static void
 733 modest_msg_view_window_set_zoom (ModestWindow *window,
 734                                  gdouble zoom)
 735 {
 736         ModestMsgViewWindowPrivate *priv;
 737
 738         g_return_if_fail (MODEST_IS_MSG_VIEW_WINDOW (window));
 739
 740         priv = MODEST_MSG_VIEW_WINDOW_GET_PRIVATE (window);
 741         modest_msg_view_set_zoom (MODEST_MSG_VIEW (priv->msg_view), zoom);
 742 }
 743
 744 static gdouble
 745 modest_msg_view_window_get_zoom (ModestWindow *window)
 746 {
 747         ModestMsgViewWindowPrivate *priv;
 748
 749         g_return_val_if_fail (MODEST_IS_MSG_VIEW_WINDOW (window), 1.0);
 750
 751         priv = MODEST_MSG_VIEW_WINDOW_GET_PRIVATE (window);
 752         return modest_msg_view_get_zoom (MODEST_MSG_VIEW (priv->msg_view));
 753 }
 754
 755 static gboolean
 756 modest_msg_view_window_zoom_plus (ModestWindow *window)
 757 {
 758         ModestWindowPrivate *parent_priv;
 759         GtkRadioAction *zoom_radio_action;
 760         GSList *group, *node;
 761
 762         parent_priv = MODEST_WINDOW_GET_PRIVATE (window);
 763         zoom_radio_action = GTK_RADIO_ACTION (gtk_ui_manager_get_action (parent_priv->ui_manager,
 764                                                                          "/MenuBar/ViewMenu/ZoomMenu/Zoom50Menu"));
 765
 766         group = gtk_radio_action_get_group (zoom_radio_action);
 767
 768         if (gtk_toggle_action_get_active (GTK_TOGGLE_ACTION (group->data))) {
 769                 hildon_banner_show_information (NULL, NULL, _("mcen_ib_max_zoom_level"));
 770                 return FALSE;
 771         }
 772
 773         for (node = group; node != NULL; node = g_slist_next (node)) {
 774                 if ((node->next != NULL) && gtk_toggle_action_get_active (GTK_TOGGLE_ACTION (node->next->data))) {
 775                         gtk_toggle_action_set_active (GTK_TOGGLE_ACTION (node->data), TRUE);
 776                         return TRUE;
 777                 }
 778         }
 779         return FALSE;
 780 }
 781
 782 static gboolean
 783 modest_msg_view_window_zoom_minus (ModestWindow *window)
 784 {
 785         ModestWindowPrivate *parent_priv;
 786         GtkRadioAction *zoom_radio_action;
 787         GSList *group, *node;
 788
 789         parent_priv = MODEST_WINDOW_GET_PRIVATE (window);
 790         zoom_radio_action = GTK_RADIO_ACTION (gtk_ui_manager_get_action (parent_priv->ui_manager,
 791                                                                          "/MenuBar/ViewMenu/ZoomMenu/Zoom50Menu"));
 792
 793         group = gtk_radio_action_get_group (zoom_radio_action);
 794
 795         for (node = group; node != NULL; node = g_slist_next (node)) {
 796                 if (gtk_toggle_action_get_active (GTK_TOGGLE_ACTION (node->data))) {
 797                         if (node->next != NULL) {
 798                                 gtk_toggle_action_set_active (GTK_TOGGLE_ACTION (node->next->data), TRUE);
 799                                 return TRUE;
 800                         } else {
 801                                 hildon_banner_show_information (NULL, NULL, _("mcen_ib_min_zoom_level"));
 802                                 return FALSE;
 803                         }
 804                         break;
 805                 }
 806         }
 807         return FALSE;
 808 }
 809
 810 static gboolean
 811 modest_msg_view_window_key_release_event (GtkWidget *window,
 812                                           GdkEventKey *event,
 813                                           gpointer userdata)
 814 {
 815         if (event->type == GDK_KEY_RELEASE) {
 816                 switch (event->keyval) {
 817                 case GDK_Up:
 818                         modest_msg_view_window_scroll_up (MODEST_WINDOW (window));
 819                         return TRUE;
 820                         break;
 821                 case GDK_Down:
 822                         modest_msg_view_window_scroll_down (MODEST_WINDOW (window));
 823                         return TRUE;
 824                         break;
 825                 default:
 826                         return FALSE;
 827                         break;
 828                 };
 829         } else {
 830                 return FALSE;
 831         }
 832 }
 833
 834 static void
 835 modest_msg_view_window_scroll_up (ModestWindow *window)
 836 {
 837         ModestMsgViewWindowPrivate *priv;
 838
 839         priv = MODEST_MSG_VIEW_WINDOW_GET_PRIVATE (window);
 840         g_signal_emit_by_name (G_OBJECT (priv->main_scroll), "scroll-child", GTK_SCROLL_STEP_UP, FALSE);
 841 }
 842
 843 static void
 844 modest_msg_view_window_scroll_down (ModestWindow *window)
 845 {
 846         ModestMsgViewWindowPrivate *priv;
 847
 848         priv = MODEST_MSG_VIEW_WINDOW_GET_PRIVATE (window);
 849         g_signal_emit_by_name (G_OBJECT (priv->main_scroll), "scroll-child", GTK_SCROLL_STEP_DOWN, FALSE);
 850 }
 851
 852 static gboolean
 853 modest_msg_view_window_is_last_message (ModestMsgViewWindow *window)
 854 {
 855         GtkTreePath *path;
 856         ModestMsgViewWindowPrivate *priv;
 857         GtkTreeIter tmp_iter;
 858         gboolean has_next = FALSE;
 859
 860         g_return_val_if_fail (MODEST_IS_MSG_VIEW_WINDOW (window), TRUE);
 861         priv = MODEST_MSG_VIEW_WINDOW_GET_PRIVATE (window);
 862
 863         if (priv->header_model) {
 864                 path = gtk_tree_row_reference_get_path (priv->row_reference);
 865                 if (!path)
 866                         return TRUE;
 867                 while (!has_next) {
 868                         TnyHeader *header;
 869                         gtk_tree_path_next (path);
 870                         if (!gtk_tree_model_get_iter (priv->header_model, &tmp_iter, path))
 871                                 break;
 872                         gtk_tree_model_get (priv->header_model, &tmp_iter, TNY_GTK_HEADER_LIST_MODEL_INSTANCE_COLUMN,
 873                                             &header, -1);
 874                         if (!(tny_header_get_flags(header)&TNY_HEADER_FLAG_DELETED)) {
 875                                 has_next = TRUE;
 876                                 break;
 877                         }
 878
 879                 }
 880                 return !has_next;
 881         } else {
 882                 return TRUE;
 883         }
 884
 885 }
 886
 887 static gboolean
 888 modest_msg_view_window_is_first_message (ModestMsgViewWindow *window)
 889 {
 890         GtkTreePath *path;
 891         ModestMsgViewWindowPrivate *priv;
 892         gboolean result;
 893         GtkTreeIter tmp_iter;
 894
 895         g_return_val_if_fail (MODEST_IS_MSG_VIEW_WINDOW (window), TRUE);
 896         priv = MODEST_MSG_VIEW_WINDOW_GET_PRIVATE (window);
 897
 898         if (priv->header_model) {
 899                 gchar * path_string;
 900                 path = gtk_tree_row_reference_get_path (priv->row_reference);
 901                 if (!path)
 902                         return TRUE;
 903
 904                 path_string = gtk_tree_path_to_string (path);
 905                 result = (strcmp (path_string, "0")==0);
 906                 if (result) {
 907                         g_free (path_string);
 908                         gtk_tree_path_free (path);
 909                         return result;
 910                 }
 911
 912                 while (result) {
 913                         TnyHeader *header;
 914
 915                         gtk_tree_path_prev (path);
 916
 917                         if (!gtk_tree_model_get_iter (priv->header_model, &tmp_iter, path))
 918                                 break;
 919                         gtk_tree_model_get (priv->header_model, &tmp_iter, TNY_GTK_HEADER_LIST_MODEL_INSTANCE_COLUMN,
 920                                             &header, -1);
 921                         if (!(tny_header_get_flags(header)&TNY_HEADER_FLAG_DELETED)) {
 922                                 result = FALSE;
 923                                 break;
 924                         }
 925
 926                         path_string = gtk_tree_path_to_string (path);
 927                         if (strcmp(path_string, "0")==0) {
 928                                 g_free (path_string);
 929                                 break;
 930                         }
 931                         g_free (path_string);
 932                 }
 933                 return result;
 934         } else {
 935                 return TRUE;
 936         }
 937
 938 }
 939
 940 gboolean
 941 modest_msg_view_window_select_next_message (ModestMsgViewWindow *window)
 942 {
 943         TnyHeaderFlags flags;
 944         ModestMailOperation *mail_op = NULL;
 945         ModestMsgViewWindowPrivate *priv;
 946         GtkTreeIter tmp_iter;
 947
 948         g_return_val_if_fail (MODEST_IS_MSG_VIEW_WINDOW (window), FALSE);
 949         priv = MODEST_MSG_VIEW_WINDOW_GET_PRIVATE (window);
 950
 951         if (priv->header_model) {
 952                 gtk_tree_model_get_iter (priv->header_model,
 953                                          &tmp_iter,
 954                                          gtk_tree_row_reference_get_path (priv->row_reference));
 955                 while (gtk_tree_model_iter_next (priv->header_model, &tmp_iter)) {
 956                         TnyHeader *header;
 957                         GtkTreePath *path;
 958
 959                         gtk_tree_model_get (priv->header_model, &tmp_iter, TNY_GTK_HEADER_LIST_MODEL_INSTANCE_COLUMN,
 960                                             &header, -1);
 961                         if (!header)
 962                                 break;
 963                         if (tny_header_get_flags (header) & TNY_HEADER_FLAG_DELETED)
 964                                 continue;
 965
 966                         /* Update the row reference */
 967                         gtk_tree_row_reference_free (priv->row_reference);
 968                         path = gtk_tree_model_get_path (priv->header_model, &tmp_iter);
 969                         priv->row_reference = gtk_tree_row_reference_new (priv->header_model, path);
 970                         gtk_tree_path_free (path);
 971
 972                         /* Mark as read */
 973                         flags = tny_header_get_flags (header);
 974                         if (!(flags & TNY_HEADER_FLAG_SEEN))
 975                                 tny_header_set_flags (header, flags | TNY_HEADER_FLAG_SEEN);
 976
 977                         /* New mail operation */
 978                         mail_op = modest_mail_operation_new (MODEST_MAIL_OPERATION_TYPE_RECEIVE, G_OBJECT(window));
 979                         modest_mail_operation_queue_add (modest_runtime_get_mail_operation_queue (), mail_op);
 980                         modest_mail_operation_get_msg (mail_op, header, view_msg_cb, NULL);
 981                         g_object_unref (mail_op);
 982
 983                         return TRUE;
 984                 }
 985         }
 986         return FALSE;
 987 }
 988
 989 gboolean
 990 modest_msg_view_window_select_first_message (ModestMsgViewWindow *self)
 991 {
 992         ModestMsgViewWindowPrivate *priv = NULL;
 993         ModestMailOperation *mail_op = NULL;
 994         TnyHeader *header = NULL;
 995         TnyHeaderFlags flags;
 996         GtkTreePath *path = NULL;
 997         GtkTreeIter iter;
 998
 999         g_return_val_if_fail (MODEST_IS_MSG_VIEW_WINDOW (self), FALSE);
1000         priv = MODEST_MSG_VIEW_WINDOW_GET_PRIVATE (self);
1001
1002         path = gtk_tree_path_new_from_string ("0");
1003
1004         /* Update the row reference */
1005         /* Get first message */
1006         gtk_tree_model_get_iter (priv->header_model, &iter, path);
1007         gtk_tree_model_get (priv->header_model, &iter, TNY_GTK_HEADER_LIST_MODEL_INSTANCE_COLUMN,
1008                             &header, -1);
1009
1010         g_return_val_if_fail (TNY_IS_HEADER (header), FALSE);
1011         if (tny_header_get_flags (header) & TNY_HEADER_FLAG_DELETED)
1012                 return modest_msg_view_window_select_next_message (self);
1013
1014         /* Update the row reference */
1015         gtk_tree_row_reference_free (priv->row_reference);
1016         priv->row_reference = gtk_tree_row_reference_new (priv->header_model, path);
1017         gtk_tree_path_free (path);
1018
1019         /* Mark as read */
1020         flags = tny_header_get_flags (header);
1021         if (!(flags & TNY_HEADER_FLAG_SEEN))
1022                 tny_header_set_flags (header, flags | TNY_HEADER_FLAG_SEEN);
1023
1024         /* New mail operation */
1025         mail_op = modest_mail_operation_new (MODEST_MAIL_OPERATION_TYPE_RECEIVE, G_OBJECT(self));
1026         modest_mail_operation_queue_add (modest_runtime_get_mail_operation_queue (), mail_op);
1027         modest_mail_operation_get_msg (mail_op, header, view_msg_cb, NULL);
1028         g_object_unref (mail_op);
1029
1030         /* Free */
1031 /*      g_object_unref (header); */
1032
1033         return TRUE;
1034 }
1035
1036 gboolean
1037 modest_msg_view_window_select_previous_message (ModestMsgViewWindow *window)
1038 {
1039         TnyHeaderFlags flags;
1040         ModestMsgViewWindowPrivate *priv = NULL;
1041         ModestMailOperation *mail_op = NULL;
1042
1043         g_return_val_if_fail (MODEST_IS_MSG_VIEW_WINDOW (window), FALSE);
1044         priv = MODEST_MSG_VIEW_WINDOW_GET_PRIVATE (window);
1045
1046         if (priv->header_model) {
1047                 GtkTreePath *path;
1048
1049                 path = gtk_tree_row_reference_get_path (priv->row_reference);
1050                 while (gtk_tree_path_prev (path)) {
1051                         TnyHeader *header;
1052                         GtkTreeIter iter;
1053
1054                         gtk_tree_model_get_iter (priv->header_model, &iter, path);
1055                         gtk_tree_model_get (priv->header_model, &iter, TNY_GTK_HEADER_LIST_MODEL_INSTANCE_COLUMN,
1056                                             &header, -1);
1057                         if (!header)
1058                                 break;
1059                         if (tny_header_get_flags (header) & TNY_HEADER_FLAG_DELETED)
1060                                 continue;
1061
1062                         /* Update the row reference */
1063                         gtk_tree_row_reference_free (priv->row_reference);
1064                         priv->row_reference = gtk_tree_row_reference_new (priv->header_model, path);
1065
1066                         /* Mark as read */
1067                         flags = tny_header_get_flags (header);
1068                         if (!(flags & TNY_HEADER_FLAG_SEEN))
1069                                 tny_header_set_flags (header, flags | TNY_HEADER_FLAG_SEEN);
1070
1071                         /* New mail operation */
1072                         mail_op = modest_mail_operation_new (MODEST_MAIL_OPERATION_TYPE_RECEIVE, G_OBJECT(window));
1073                         modest_mail_operation_queue_add (modest_runtime_get_mail_operation_queue (), mail_op);
1074                         modest_mail_operation_get_msg (mail_op, header, view_msg_cb, NULL);
1075
1076                         return TRUE;
1077                 }
1078         }
1079
1080         return FALSE;
1081 }
1082
1083 static void
1084 view_msg_cb (ModestMailOperation *mail_op,
1085              TnyHeader *header,
1086              TnyMsg *msg,
1087              gpointer user_data)
1088 {
1089         ModestMsgViewWindow *self = NULL;
1090         ModestMsgViewWindowPrivate *priv = NULL;
1091
1092         g_return_if_fail (TNY_IS_MSG (msg));
1093
1094         /* Get the window */
1095         self = (ModestMsgViewWindow *) modest_mail_operation_get_source (mail_op);
1096         g_return_if_fail (MODEST_IS_MSG_VIEW_WINDOW (self));
1097
1098         priv = MODEST_MSG_VIEW_WINDOW_GET_PRIVATE (self);
1099
1100         /* Set new message */
1101         modest_msg_view_set_message (MODEST_MSG_VIEW (priv->msg_view), msg);
1102         modest_msg_view_window_update_dimmed (self);
1103         modest_msg_view_window_update_priority (self);
1104         gtk_widget_grab_focus (priv->msg_view);
1105 }
1106
1107 static TnyFolderType
1108 modest_msg_view_window_get_folder_type (ModestMsgViewWindow *window)
1109 {
1110         ModestMsgViewWindowPrivate *priv;
1111         TnyMsg *msg;
1112         TnyFolderType folder_type;
1113
1114         priv = MODEST_MSG_VIEW_WINDOW_GET_PRIVATE (window);
1115
1116         folder_type = TNY_FOLDER_TYPE_UNKNOWN;
1117
1118         msg = modest_msg_view_get_message (MODEST_MSG_VIEW (priv->msg_view));
1119         if (msg) {
1120                 TnyFolder *folder;
1121
1122                 folder = tny_msg_get_folder (msg);
1123
1124                 if (folder) {
1125                         folder_type = tny_folder_get_folder_type (folder);
1126
1127                         if (folder_type == TNY_FOLDER_TYPE_NORMAL || folder_type == TNY_FOLDER_TYPE_UNKNOWN) {
1128                                 const gchar *fname = tny_folder_get_name (folder);
1129                                 folder_type = modest_tny_folder_guess_folder_type_from_name (fname);
1130                         }
1131
1132                         g_object_unref (folder);
1133                 }
1134                 g_object_unref (msg);
1135         }
1136
1137         return folder_type;
1138 }
1139
1140 static void
1141 modest_msg_view_window_update_dimmed (ModestMsgViewWindow *window)
1142 {
1143         ModestWindowPrivate *parent_priv;
1144         ModestMsgViewWindowPrivate *priv;
1145         GtkAction *widget;
1146         gboolean is_first, is_last;
1147         TnyFolderType folder_type;
1148         gboolean is_not_sent;
1149         GList *attachments, *node;
1150         gint n_selected;
1151         gboolean selected_messages = FALSE;
1152         gboolean nested_attachments = FALSE;
1153
1154         parent_priv = MODEST_WINDOW_GET_PRIVATE (window);
1155         priv = MODEST_MSG_VIEW_WINDOW_GET_PRIVATE (window);
1156
1157         is_first = modest_msg_view_window_is_first_message (window);
1158         is_last = modest_msg_view_window_is_last_message (window);
1159
1160         widget = gtk_ui_manager_get_action (parent_priv->ui_manager, "/ToolBar/ToolbarMessageBack");
1161         gtk_action_set_sensitive (widget, !is_first);
1162         widget = gtk_ui_manager_get_action (parent_priv->ui_manager, "/MenuBar/ViewMenu/ViewPreviousMessageMenu");
1163         gtk_action_set_sensitive (widget, !is_first);
1164
1165         widget = gtk_ui_manager_get_action (parent_priv->ui_manager, "/ToolBar/ToolbarMessageNext");
1166         gtk_action_set_sensitive (widget, !is_last);
1167         widget = gtk_ui_manager_get_action (parent_priv->ui_manager, "/MenuBar/ViewMenu/ViewNextMessageMenu");
1168         gtk_action_set_sensitive (widget, !is_last);
1169
1170         folder_type = modest_msg_view_window_get_folder_type (MODEST_MSG_VIEW_WINDOW (window));
1171         is_not_sent = ((folder_type == TNY_FOLDER_TYPE_DRAFTS)||(folder_type == TNY_FOLDER_TYPE_OUTBOX));
1172         widget = gtk_ui_manager_get_action (parent_priv->ui_manager, "/ToolBar/ToolbarMessageReply");
1173         gtk_action_set_sensitive (widget, !is_not_sent);
1174         widget = gtk_ui_manager_get_action (parent_priv->ui_manager, "/MenuBar/MessageMenu/MessageReplyMenu");
1175         gtk_action_set_sensitive (widget, !is_not_sent);
1176         widget = gtk_ui_manager_get_action (parent_priv->ui_manager, "/MenuBar/MessageMenu/MessageReplyAllMenu");
1177         gtk_action_set_sensitive (widget, !is_not_sent);
1178         widget = gtk_ui_manager_get_action (parent_priv->ui_manager, "/MenuBar/MessageMenu/MessageForwardMenu");
1179         gtk_action_set_sensitive (widget, !is_not_sent);
1180
1181         /* Attachment actions dimming */
1182         attachments = modest_msg_view_get_selected_attachments (MODEST_MSG_VIEW (priv->msg_view));
1183         n_selected = g_list_length (attachments);
1184         for (node = attachments; node != NULL; node = g_list_next (node)) {
1185                 TnyMimePart *mime_part = TNY_MIME_PART (node->data);
1186                 TnyList *nested_list = tny_simple_list_new ();
1187                 if (!tny_mime_part_is_attachment (mime_part)) {
1188                         selected_messages = TRUE;
1189                         break;
1190                 }
1191                 tny_mime_part_get_parts (mime_part, nested_list);
1192                 if (tny_list_get_length (nested_list) > 0)
1193                         nested_attachments = TRUE;
1194                 g_object_unref (nested_list);
1195         }
1196         g_list_free (attachments);
1197
1198         widget = gtk_ui_manager_get_action (parent_priv->ui_manager, "/MenuBar/AttachmentsMenu/ViewAttachmentMenu");
1199         gtk_action_set_sensitive (widget, n_selected == 1);
1200         widget = gtk_ui_manager_get_action (parent_priv->ui_manager, "/MenuBar/AttachmentsMenu/SaveAttachmentMenu");
1201         gtk_action_set_sensitive (widget, (n_selected > 0) && (!selected_messages) &&  (!nested_attachments));
1202
1203         /* Dimming depending of message being an attachment or not. It's not an attachment if
1204          * we opened it outside a folder view */
1205         widget = gtk_ui_manager_get_action (parent_priv->ui_manager, "/MenuBar/MessageMenu/MessageDeleteMenu");
1206         gtk_action_set_sensitive (widget, priv->header_model != NULL);
1207         widget = gtk_ui_manager_get_action (parent_priv->ui_manager, "/MenuBar/EditMenu/EditMoveToMenu");
1208         gtk_action_set_sensitive (widget, priv->header_model != NULL);
1209
1210 }
1211
1212 static void
1213 modest_msg_view_window_update_priority (ModestMsgViewWindow *window)
1214 {
1215         ModestMsgViewWindowPrivate *priv;
1216         TnyHeaderFlags flags = 0;
1217
1218         priv = MODEST_MSG_VIEW_WINDOW_GET_PRIVATE (window);
1219
1220         if (priv->header_model) {
1221                 TnyHeader *header;
1222                 GtkTreeIter iter;
1223
1224                 gtk_tree_model_get_iter (priv->header_model,
1225                                          &iter,
1226                                          gtk_tree_row_reference_get_path (priv->row_reference));
1227
1228                 gtk_tree_model_get (priv->header_model, &iter, TNY_GTK_HEADER_LIST_MODEL_INSTANCE_COLUMN,
1229                                     &header, -1);
1230                 flags = tny_header_get_flags (header);
1231         }
1232
1233         modest_msg_view_set_priority (MODEST_MSG_VIEW(priv->msg_view), flags);
1234
1235 }
1236
1237 static gboolean
1238 modest_msg_view_window_window_state_event (GtkWidget *widget, GdkEventWindowState *event, gpointer userdata)
1239 {
1240         if (event->changed_mask & GDK_WINDOW_STATE_FULLSCREEN) {
1241                 ModestWindowPrivate *parent_priv;
1242                 ModestWindowMgr *mgr;
1243                 gboolean is_fullscreen;
1244                 GtkAction *fs_toggle_action;
1245                 gboolean active;
1246
1247                 mgr = modest_runtime_get_window_mgr ();
1248                 is_fullscreen = (modest_window_mgr_get_fullscreen_mode (mgr))?1:0;
1249
1250                 parent_priv = MODEST_WINDOW_GET_PRIVATE (widget);
1251
1252                 fs_toggle_action = gtk_ui_manager_get_action (parent_priv->ui_manager, "/MenuBar/ViewMenu/ViewToggleFullscreenMenu");
1253                 active = (gtk_toggle_action_get_active (GTK_TOGGLE_ACTION (fs_toggle_action)))?1:0;
1254                 if (is_fullscreen != active) {
1255                         gtk_toggle_action_set_active (GTK_TOGGLE_ACTION (fs_toggle_action), is_fullscreen);
1256                 }
1257         }
1258
1259         return FALSE;
1260
1261 }
1262
1263 void
1264 modest_msg_view_window_toggle_fullscreen (ModestMsgViewWindow *window)
1265 {
1266                 ModestWindowPrivate *parent_priv;
1267                 GtkAction *fs_toggle_action;
1268                 parent_priv = MODEST_WINDOW_GET_PRIVATE (window);
1269
1270                 fs_toggle_action = gtk_ui_manager_get_action (parent_priv->ui_manager, "/MenuBar/ViewMenu/ViewToggleFullscreenMenu");
1271                 gtk_toggle_action_set_active (GTK_TOGGLE_ACTION (fs_toggle_action),
1272                                               !gtk_toggle_action_get_active (GTK_TOGGLE_ACTION (fs_toggle_action)));
1273 }
1274
1275 static void
1276 set_homogeneous (GtkWidget *widget,
1277                  gpointer data)
1278 {
1279         if (GTK_IS_TOOL_ITEM (widget)) {
1280                 gtk_tool_item_set_expand (GTK_TOOL_ITEM (widget), TRUE);
1281                 gtk_tool_item_set_homogeneous (GTK_TOOL_ITEM (widget), TRUE);
1282         }
1283 }
1284
1285 static void
1286 modest_msg_view_window_show_toolbar (ModestWindow *self,
1287                                      gboolean show_toolbar)
1288 {
1289         ModestMsgViewWindowPrivate *priv = NULL;
1290         ModestWindowPrivate *parent_priv;
1291         GtkWidget *reply_button = NULL, *menu = NULL;
1292         GtkWidget *placeholder = NULL;
1293         gint insert_index;
1294
1295         parent_priv = MODEST_WINDOW_GET_PRIVATE(self);
1296         priv = MODEST_MSG_VIEW_WINDOW_GET_PRIVATE(self);
1297
1298         /* Set optimized view status */
1299         priv->optimized_view = !show_toolbar;
1300
1301         if (!parent_priv->toolbar) {
1302                 parent_priv->toolbar = gtk_ui_manager_get_widget (parent_priv->ui_manager,
1303                                                                   "/ToolBar");
1304
1305                 /* Set homogeneous toolbar */
1306                 gtk_container_foreach (GTK_CONTAINER (parent_priv->toolbar),
1307                                        set_homogeneous, NULL);
1308
1309                 priv->progress_toolitem = GTK_WIDGET (gtk_tool_item_new ());
1310                 priv->cancel_toolitem = gtk_ui_manager_get_widget (parent_priv->ui_manager, "/ToolBar/ToolbarCancel");
1311                 priv->next_toolitem = gtk_ui_manager_get_widget (parent_priv->ui_manager, "/ToolBar/ToolbarMessageNext");
1312                 priv->prev_toolitem = gtk_ui_manager_get_widget (parent_priv->ui_manager, "/ToolBar/ToolbarMessageBack");
1313                 gtk_tool_item_set_expand (GTK_TOOL_ITEM (priv->progress_toolitem), TRUE);
1314                 gtk_tool_item_set_homogeneous (GTK_TOOL_ITEM (priv->progress_toolitem), TRUE);
1315                 gtk_tool_item_set_homogeneous (GTK_TOOL_ITEM (priv->cancel_toolitem), FALSE);
1316                 gtk_tool_item_set_expand (GTK_TOOL_ITEM (priv->cancel_toolitem), FALSE);
1317
1318                 /* Add ProgressBar (Transfer toolbar) */
1319                 priv->progress_bar = modest_progress_bar_widget_new ();
1320                 gtk_widget_set_no_show_all (priv->progress_bar, TRUE);
1321                 placeholder = gtk_ui_manager_get_widget (parent_priv->ui_manager, "/ToolBar/ProgressbarView");
1322                 insert_index = gtk_toolbar_get_item_index(GTK_TOOLBAR (parent_priv->toolbar), GTK_TOOL_ITEM(placeholder));
1323                 gtk_container_add (GTK_CONTAINER (priv->progress_toolitem), priv->progress_bar);
1324                 gtk_toolbar_insert(GTK_TOOLBAR(parent_priv->toolbar), GTK_TOOL_ITEM (priv->progress_toolitem), insert_index);
1325
1326                 /* Connect cancel 'clicked' signal to abort progress mode */
1327                 g_signal_connect(priv->cancel_toolitem, "clicked",
1328                                  G_CALLBACK(cancel_progressbar),
1329                                  self);
1330
1331                 /* Add it to the observers list */
1332                 priv->progress_widgets = g_slist_prepend(priv->progress_widgets, priv->progress_bar);
1333
1334                 /* Add to window */
1335                 hildon_window_add_toolbar (HILDON_WINDOW (self),
1336                                            GTK_TOOLBAR (parent_priv->toolbar));
1337
1338
1339                 /* Set reply button tap and hold menu */
1340                 reply_button = gtk_ui_manager_get_widget (parent_priv->ui_manager,
1341                                                           "/ToolBar/ToolbarMessageReply");
1342                 menu = gtk_ui_manager_get_widget (parent_priv->ui_manager,
1343                                                   "/ToolbarReplyCSM");
1344                 gtk_widget_tap_and_hold_setup (GTK_WIDGET (reply_button), menu, NULL, 0);
1345         }
1346
1347         if (show_toolbar) {
1348                 /* Quick hack: this prevents toolbar icons "dance" when progress bar show status is changed */
1349                 /* TODO: resize mode migth be GTK_RESIZE_QUEUE, in order to avoid unneccesary shows */
1350                 gtk_container_set_resize_mode (GTK_CONTAINER(parent_priv->toolbar), GTK_RESIZE_IMMEDIATE);
1351
1352                 gtk_widget_show (GTK_WIDGET (parent_priv->toolbar));
1353                 set_toolbar_mode (MODEST_MSG_VIEW_WINDOW(self), TOOLBAR_MODE_NORMAL);
1354         } else {
1355                 gtk_widget_set_no_show_all (parent_priv->toolbar, TRUE);
1356                 gtk_widget_hide (GTK_WIDGET (parent_priv->toolbar));
1357         }
1358 }
1359
1360 static void
1361 modest_msg_view_window_clipboard_owner_change (GtkClipboard *clipboard,
1362                                                GdkEvent *event,
1363                                                ModestMsgViewWindow *window)
1364 {
1365         ModestWindowPrivate *parent_priv;
1366         GtkAction *action;
1367         gboolean is_address;
1368         gchar *selection;
1369         GtkWidget *focused;
1370
1371         parent_priv = MODEST_WINDOW_GET_PRIVATE (window);
1372         selection = gtk_clipboard_wait_for_text (clipboard);
1373
1374         is_address = ((selection != NULL) && (modest_text_utils_validate_recipient (selection)));
1375
1376         action = gtk_ui_manager_get_action (parent_priv->ui_manager, "/MenuBar/ToolsMenu/ToolsAddToContactsMenu");
1377         gtk_action_set_sensitive (action, is_address);
1378
1379         focused = gtk_window_get_focus (GTK_WINDOW (window));
1380
1381         action = gtk_ui_manager_get_action (parent_priv->ui_manager, "/MenuBar/EditMenu/EditCopyMenu");
1382         gtk_action_set_sensitive (action, (selection != NULL) && (!MODEST_IS_ATTACHMENTS_VIEW (focused)));
1383
1384         action = gtk_ui_manager_get_action (parent_priv->ui_manager, "/MenuBar/EditMenu/EditCutMenu");
1385         gtk_action_set_sensitive (action, (selection != NULL) && (!MODEST_IS_ATTACHMENTS_VIEW (focused)));
1386
1387         g_free (selection);
1388         modest_msg_view_window_update_dimmed (window);
1389
1390 }
1391
1392 static void
1393 cancel_progressbar (GtkToolButton *toolbutton,
1394                     ModestMsgViewWindow *self)
1395 {
1396         GSList *tmp;
1397         ModestMsgViewWindowPrivate *priv;
1398
1399         priv = MODEST_MSG_VIEW_WINDOW_GET_PRIVATE(self);
1400
1401         /* Get operation observers and cancel its current operation */
1402         tmp = priv->progress_widgets;
1403         while (tmp) {
1404                 modest_progress_object_cancel_current_operation (MODEST_PROGRESS_OBJECT(tmp->data));
1405                 tmp=g_slist_next(tmp);
1406         }
1407 }
1408 static gboolean
1409 observers_empty (ModestMsgViewWindow *self)
1410 {
1411         GSList *tmp = NULL;
1412         ModestMsgViewWindowPrivate *priv;
1413         gboolean is_empty = TRUE;
1414         guint pending_ops = 0;
1415
1416         priv = MODEST_MSG_VIEW_WINDOW_GET_PRIVATE(self);
1417         tmp = priv->progress_widgets;
1418
1419         /* Check all observers */
1420         while (tmp && is_empty)  {
1421                 pending_ops = modest_progress_object_num_pending_operations (MODEST_PROGRESS_OBJECT(tmp->data));
1422                 is_empty = pending_ops == 0;
1423
1424                 tmp = g_slist_next(tmp);
1425         }
1426
1427         return is_empty;
1428 }
1429
1430
1431 static void
1432 on_queue_changed (ModestMailOperationQueue *queue,
1433                   ModestMailOperation *mail_op,
1434                   ModestMailOperationQueueNotification type,
1435                   ModestMsgViewWindow *self)
1436 {
1437         GSList *tmp;
1438         ModestMsgViewWindowPrivate *priv;
1439         ModestMailOperationTypeOperation op_type;
1440         ModestToolBarModes mode;
1441
1442         g_return_if_fail (MODEST_IS_MSG_VIEW_WINDOW (self));
1443         priv = MODEST_MSG_VIEW_WINDOW_GET_PRIVATE(self);
1444
1445         /* If this operations was created by another window, do nothing */
1446         if (!modest_mail_operation_is_mine (mail_op, G_OBJECT(self)))
1447             return;
1448
1449         /* Get toolbar mode from operation id*/
1450         op_type = modest_mail_operation_get_type_operation (mail_op);
1451         switch (op_type) {
1452         case MODEST_MAIL_OPERATION_TYPE_SEND:
1453         case MODEST_MAIL_OPERATION_TYPE_RECEIVE:
1454                 mode = TOOLBAR_MODE_TRANSFER;
1455                 break;
1456         default:
1457                 mode = TOOLBAR_MODE_NORMAL;
1458
1459         }
1460
1461         /* Add operation observers and change toolbar if neccessary*/
1462         tmp = priv->progress_widgets;
1463         switch (type) {
1464         case MODEST_MAIL_OPERATION_QUEUE_OPERATION_ADDED:
1465                 if (mode == TOOLBAR_MODE_TRANSFER) {
1466                         /* Enable transfer toolbar mode */
1467                         set_toolbar_transfer_mode(self);
1468                         while (tmp) {
1469                                 modest_progress_object_add_operation (MODEST_PROGRESS_OBJECT (tmp->data),
1470                                                                       mail_op);
1471                                 tmp = g_slist_next (tmp);
1472                         }
1473
1474                 }
1475                 break;
1476         case MODEST_MAIL_OPERATION_QUEUE_OPERATION_REMOVED:
1477                 if (mode == TOOLBAR_MODE_TRANSFER) {
1478                         while (tmp) {
1479                                 modest_progress_object_remove_operation (MODEST_PROGRESS_OBJECT (tmp->data),
1480                                                                  mail_op);
1481                                 tmp = g_slist_next (tmp);
1482
1483                         }
1484
1485                         /* If no more operations are being observed, NORMAL mode is enabled again */
1486                         if (observers_empty (self)) {
1487                                 set_toolbar_mode (self, TOOLBAR_MODE_NORMAL);
1488                         }
1489                 }
1490                 break;
1491         }
1492 }
1493
1494 void
1495 modest_msg_view_window_view_attachment (ModestMsgViewWindow *window, TnyMimePart *mime_part)
1496 {
1497         ModestMsgViewWindowPrivate *priv;
1498         g_return_if_fail (MODEST_IS_MSG_VIEW_WINDOW (window));
1499         g_return_if_fail (TNY_IS_MIME_PART (mime_part) || (mime_part == NULL));
1500
1501         priv = MODEST_MSG_VIEW_WINDOW_GET_PRIVATE (window);
1502
1503         if (mime_part == NULL) {
1504                 gboolean error = FALSE;
1505                 GList *selected_attachments = modest_msg_view_get_selected_attachments (MODEST_MSG_VIEW (priv->msg_view));
1506                 if (selected_attachments == NULL) {
1507                         error = TRUE;
1508                 } else if (g_list_length (selected_attachments) > 1) {
1509                         hildon_banner_show_information (NULL, NULL, _("TODO: more than one attachment is selected"));
1510                         error = TRUE;
1511                 } else {
1512                         mime_part = (TnyMimePart *) selected_attachments->data;
1513                         g_object_ref (mime_part);
1514                 }
1515                 g_list_foreach (selected_attachments, (GFunc) g_object_unref, NULL);
1516                 g_list_free (selected_attachments);
1517
1518                 if (error)
1519                         return;
1520         } else {
1521                 g_object_ref (mime_part);
1522         }
1523
1524         if (!TNY_IS_MSG (mime_part)) {
1525                 gchar *filepath = NULL;
1526                 TnyFsStream *temp_stream = modest_maemo_utils_create_temp_stream (&filepath);
1527
1528                 if (temp_stream) {
1529                         tny_mime_part_decode_to_stream (mime_part, TNY_STREAM (temp_stream));
1530                         modest_platform_activate_file (filepath);
1531                         g_object_unref (temp_stream);
1532                         g_free (filepath);
1533                         /* TODO: delete temporary file */
1534                 }
1535         } else {
1536                 /* message attachment */
1537                 TnyHeader *header = NULL;
1538                 ModestWindowMgr *mgr;
1539                 ModestWindow *msg_win = NULL;
1540
1541                 header = tny_msg_get_header (TNY_MSG (mime_part));
1542                 mgr = modest_runtime_get_window_mgr ();
1543                 msg_win = modest_window_mgr_find_window_by_header (mgr, header);
1544
1545                 if (!msg_win) {
1546                         gchar *account = g_strdup (modest_window_get_active_account (MODEST_WINDOW (window)));
1547                         if (!account)
1548                                 account = modest_account_mgr_get_default_account (modest_runtime_get_account_mgr ());
1549                         msg_win = modest_msg_view_window_new (TNY_MSG (mime_part), account, NULL);
1550                         modest_window_mgr_register_window (mgr, msg_win);
1551                         gtk_window_set_transient_for (GTK_WINDOW (msg_win), GTK_WINDOW (window));
1552                 }
1553
1554                 gtk_widget_show_all (GTK_WIDGET (msg_win));
1555         }
1556         g_object_unref (mime_part);
1557 }
1558
1559 static gboolean
1560 save_mime_part_to_file (const gchar *filename, TnyMimePart *mime_part)
1561 {
1562         GnomeVFSResult result;
1563         GnomeVFSHandle *handle;
1564         TnyStream *stream;
1565
1566         result = gnome_vfs_create (&handle, filename, GNOME_VFS_OPEN_WRITE, FALSE, 0777);
1567         if (result != GNOME_VFS_OK) {
1568                 hildon_banner_show_information (NULL, NULL, _("mail_ib_file_operation_failed"));
1569                 return FALSE;
1570         }
1571         stream = tny_vfs_stream_new (handle);
1572         tny_mime_part_decode_to_stream (mime_part, stream);
1573         g_object_unref (G_OBJECT (stream));
1574         return TRUE;
1575 }
1576
1577 static gboolean
1578 save_mime_part_to_file_with_checks (GtkWindow *parent, const gchar *filename, TnyMimePart *mime_part)
1579 {
1580         if (modest_maemo_utils_file_exists (filename)) {
1581                 GtkWidget *confirm_overwrite_dialog;
1582                 confirm_overwrite_dialog = hildon_note_new_confirmation (GTK_WINDOW (parent),
1583                                                                          _("TODO: confirm overwrite"));
1584                 if (gtk_dialog_run (GTK_DIALOG (confirm_overwrite_dialog)) != GTK_RESPONSE_OK) {
1585                         gtk_widget_destroy (confirm_overwrite_dialog);
1586                         return FALSE;
1587                 }
1588                 gtk_widget_destroy (confirm_overwrite_dialog);
1589         }
1590
1591         return save_mime_part_to_file (filename, mime_part);
1592 }
1593
1594 void
1595 modest_msg_view_window_save_attachments (ModestMsgViewWindow *window, GList *mime_parts)
1596 {
1597         gboolean clean_list = FALSE;
1598         ModestMsgViewWindowPrivate *priv;
1599         g_return_if_fail (MODEST_IS_MSG_VIEW_WINDOW (window));
1600
1601         priv = MODEST_MSG_VIEW_WINDOW_GET_PRIVATE (window);
1602
1603         if (mime_parts == NULL) {
1604                 mime_parts = modest_msg_view_get_selected_attachments (MODEST_MSG_VIEW (priv->msg_view));
1605                 if (mime_parts == NULL)
1606                         return;
1607                 clean_list = TRUE;
1608         }
1609
1610         if (mime_parts->next == NULL) {
1611                 /* only one attachment selected */
1612                 GtkWidget *save_dialog = NULL;
1613                 TnyMimePart *mime_part = (TnyMimePart *) mime_parts->data;
1614                 if (!TNY_IS_MSG (mime_part) && tny_mime_part_is_attachment (mime_part)) {
1615                         const gchar *filename;
1616                         gchar *folder;
1617                         save_dialog = hildon_file_chooser_dialog_new (GTK_WINDOW (window), GTK_FILE_CHOOSER_ACTION_SAVE);
1618                         folder = g_build_filename (g_get_home_dir (), DEFAULT_FOLDER, NULL);
1619                         gtk_file_chooser_set_current_folder (GTK_FILE_CHOOSER (save_dialog), folder);
1620                         g_free (folder);
1621                         filename = tny_mime_part_get_filename (mime_part);
1622                         if (filename != NULL)
1623                                 gtk_file_chooser_set_current_name (GTK_FILE_CHOOSER (save_dialog), filename);
1624                         while (gtk_dialog_run (GTK_DIALOG (save_dialog)) == GTK_RESPONSE_OK) {
1625                                 gchar *filename_tmp = gtk_file_chooser_get_uri (GTK_FILE_CHOOSER (save_dialog));
1626                                 gboolean save_result;
1627                                 if (!modest_maemo_utils_folder_writable (filename_tmp)) {
1628                                         g_free (filename_tmp);
1629                                         hildon_banner_show_information (NULL, NULL, _("TODO: read only location"));
1630                                         continue;
1631                                 }
1632                                 save_result = save_mime_part_to_file_with_checks (GTK_WINDOW (save_dialog),
1633                                                                                   filename_tmp, mime_part);
1634                                 g_free (filename_tmp);
1635                                 if (save_result)
1636                                         break;
1637                                 else
1638                                         continue;
1639                         }
1640                         gtk_widget_destroy (save_dialog);
1641                 } else {
1642                         g_warning ("Tried to save a non-file attachment");
1643                 }
1644         } else {
1645                 GtkWidget *save_dialog = NULL;
1646                 gchar *folder;
1647                 save_dialog = hildon_file_chooser_dialog_new (GTK_WINDOW (window), GTK_FILE_CHOOSER_ACTION_SELECT_FOLDER);
1648                 folder = g_build_filename (g_get_home_dir (), DEFAULT_FOLDER, NULL);
1649                 gtk_file_chooser_set_current_folder (GTK_FILE_CHOOSER (save_dialog), folder);
1650                 g_free (folder);
1651                 if (gtk_dialog_run (GTK_DIALOG (save_dialog)) == GTK_RESPONSE_OK) {
1652                         gchar *foldername = gtk_file_chooser_get_uri (GTK_FILE_CHOOSER (save_dialog));
1653                         GList *node = NULL;
1654                         gboolean attachment_found = FALSE;
1655                         if (!modest_maemo_utils_folder_writable (foldername)) {
1656                                 g_free (foldername);
1657                                 hildon_banner_show_information (NULL, NULL, _("TODO: read only location"));
1658                         }
1659                         for (node = mime_parts; node != NULL; node = g_list_next (node)) {
1660                                 TnyMimePart *mime_part = (TnyMimePart *) node->data;
1661                                 if (tny_mime_part_is_attachment (mime_part)) {
1662                                         const gchar *att_filename = tny_mime_part_get_filename (mime_part);
1663                                         if (att_filename != NULL) {
1664                                                 gchar *full_filename;
1665                                                 gboolean save_result;
1666                                                 full_filename = g_build_filename (foldername, att_filename, NULL);
1667                                                 attachment_found = TRUE;
1668
1669                                                 save_result = save_mime_part_to_file_with_checks (GTK_WINDOW (save_dialog),
1670                                                                                                   full_filename, mime_part);
1671                                                 g_free (full_filename);
1672                                                 if (!save_result)
1673                                                         break;
1674                                         }
1675                                 }
1676                         }
1677                         gtk_widget_destroy (save_dialog);
1678                 } else {
1679                         g_warning ("Tried to save a non-file attachment");
1680                 }
1681                 /* more than one attachment selected */
1682         }
1683         if (clean_list) {
1684                 g_list_foreach (mime_parts, (GFunc) g_object_unref, NULL);
1685                 g_list_free (mime_parts);
1686         }
1687 }
1688
1689 void
1690 modest_msg_view_window_remove_attachments (ModestMsgViewWindow *window, GList *mime_parts)
1691 {
1692 /*      g_message ("not implemented %s", __FUNCTION__); */
1693 }