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-msg.h>
  34 #include <tny-mime-part.h>
  35 #include <tny-vfs-stream.h>
  36 #include "modest-marshal.h"
  37 #include "modest-platform.h"
  38 #include <modest-utils.h>
  39 #include <modest-maemo-utils.h>
  40 #include <modest-tny-msg.h>
  41 #include <modest-msg-view-window.h>
  42 #include <modest-main-window-ui.h>
  43 #include "modest-msg-view-window-ui-dimming.h"
  44 #include <modest-widget-memory.h>
  45 #include <modest-runtime.h>
  46 #include <modest-window-priv.h>
  47 #include <modest-tny-folder.h>
  48 #include <modest-text-utils.h>
  49 #include <modest-account-mgr-helpers.h>
  50 #include "modest-progress-bar.h"
  51 #include "modest-defs.h"
  52 #include "modest-hildon-includes.h"
  53 #include "modest-ui-dimming-manager.h"
  54 #include <gdk/gdkkeysyms.h>
  55 #include <modest-tny-account.h>
  56 #include <modest-mime-part-view.h>
  57 #include <modest-isearch-view.h>
  58 #include <modest-tny-mime-part.h>
  59 #include <math.h>
  60 #include <errno.h>
  61 #include <glib/gstdio.h>
  62 #include <modest-debug.h>
  63
  64 #define DEFAULT_FOLDER "MyDocs/.documents"
  65
  66 static void  modest_msg_view_window_class_init   (ModestMsgViewWindowClass *klass);
  67 static void  modest_msg_view_window_init         (ModestMsgViewWindow *obj);
  68 static void  modest_header_view_observer_init(
  69                 ModestHeaderViewObserverIface *iface_class);
  70 static void  modest_msg_view_window_finalize     (GObject *obj);
  71 static void  modest_msg_view_window_toggle_find_toolbar (GtkToggleAction *obj,
  72                                                          gpointer data);
  73 static void  modest_msg_view_window_find_toolbar_close (GtkWidget *widget,
  74                                                         ModestMsgViewWindow *obj);
  75 static void  modest_msg_view_window_find_toolbar_search (GtkWidget *widget,
  76                                                         ModestMsgViewWindow *obj);
  77
  78 static void modest_msg_view_window_disconnect_signals (ModestWindow *self);
  79 static void modest_msg_view_window_set_zoom (ModestWindow *window,
  80                                              gdouble zoom);
  81 static gdouble modest_msg_view_window_get_zoom (ModestWindow *window);
  82 static gboolean modest_msg_view_window_zoom_minus (ModestWindow *window);
  83 static gboolean modest_msg_view_window_zoom_plus (ModestWindow *window);
  84 static gboolean modest_msg_view_window_key_event (GtkWidget *window,
  85                                                   GdkEventKey *event,
  86                                                   gpointer userdata);
  87 static gboolean modest_msg_view_window_window_state_event (GtkWidget *widget,
  88                                                            GdkEventWindowState *event,
  89                                                            gpointer userdata);
  90 static void modest_msg_view_window_update_priority (ModestMsgViewWindow *window);
  91
  92 static void modest_msg_view_window_show_toolbar   (ModestWindow *window,
  93                                                    gboolean show_toolbar);
  94
  95 static void modest_msg_view_window_clipboard_owner_change (GtkClipboard *clipboard,
  96                                                            GdkEvent *event,
  97                                                            ModestMsgViewWindow *window);
  98 void modest_msg_view_window_on_row_changed(
  99                 GtkTreeModel *header_model,
 100                 GtkTreePath *arg1,
 101                 GtkTreeIter *arg2,
 102                 ModestMsgViewWindow *window);
 103
 104 void modest_msg_view_window_on_row_deleted(
 105                 GtkTreeModel *header_model,
 106                 GtkTreePath *arg1,
 107                 ModestMsgViewWindow *window);
 108
 109 void modest_msg_view_window_on_row_inserted(
 110                 GtkTreeModel *header_model,
 111                 GtkTreePath *tree_path,
 112                 GtkTreeIter *tree_iter,
 113                 ModestMsgViewWindow *window);
 114
 115 void modest_msg_view_window_on_row_reordered(
 116                 GtkTreeModel *header_model,
 117                 GtkTreePath *arg1,
 118                 GtkTreeIter *arg2,
 119                 gpointer arg3,
 120                 ModestMsgViewWindow *window);
 121
 122 void modest_msg_view_window_update_model_replaced(
 123                 ModestHeaderViewObserver *window,
 124                 GtkTreeModel *model,
 125                 const gchar *tny_folder_id);
 126
 127 static void cancel_progressbar  (GtkToolButton *toolbutton,
 128                                  ModestMsgViewWindow *self);
 129
 130 static void on_queue_changed    (ModestMailOperationQueue *queue,
 131                                  ModestMailOperation *mail_op,
 132                                  ModestMailOperationQueueNotification type,
 133                                  ModestMsgViewWindow *self);
 134
 135 static void on_account_removed  (TnyAccountStore *account_store,
 136                                  TnyAccount *account,
 137                                  gpointer user_data);
 138
 139 static void on_move_focus (GtkWidget *widget,
 140                            GtkDirectionType direction,
 141                            gpointer userdata);
 142
 143 static void view_msg_cb         (ModestMailOperation *mail_op,
 144                                  TnyHeader *header,
 145                                  gboolean canceled,
 146                                  TnyMsg *msg,
 147                                  GError *error,
 148                                  gpointer user_data);
 149
 150 static void set_toolbar_mode    (ModestMsgViewWindow *self,
 151                                  ModestToolBarModes mode);
 152
 153 static void update_window_title (ModestMsgViewWindow *window);
 154
 155 static gboolean set_toolbar_transfer_mode     (ModestMsgViewWindow *self);
 156 static void init_window (ModestMsgViewWindow *obj);
 157
 158 static gboolean msg_is_visible (TnyHeader *header, gboolean check_outbox);
 159
 160
 161 /* list my signals */
 162 enum {
 163         MSG_CHANGED_SIGNAL,
 164         LAST_SIGNAL
 165 };
 166
 167 static const GtkToggleActionEntry msg_view_toggle_action_entries [] = {
 168         { "FindInMessage",    MODEST_TOOLBAR_ICON_FIND,    N_("qgn_toolb_gene_find"), NULL, NULL, G_CALLBACK (modest_msg_view_window_toggle_find_toolbar), FALSE },
 169         { "ToolsFindInMessage", NULL, N_("mcen_me_viewer_find"), "<CTRL>F", NULL, G_CALLBACK (modest_msg_view_window_toggle_find_toolbar), FALSE },
 170 };
 171
 172 static const GtkRadioActionEntry msg_view_zoom_action_entries [] = {
 173         { "Zoom50", NULL, N_("mcen_me_viewer_50"), NULL, NULL, 50 },
 174         { "Zoom80", NULL, N_("mcen_me_viewer_80"), NULL, NULL, 80 },
 175         { "Zoom100", NULL, N_("mcen_me_viewer_100"), NULL, NULL, 100 },
 176         { "Zoom120", NULL, N_("mcen_me_viewer_120"), NULL, NULL, 120 },
 177         { "Zoom150", NULL, N_("mcen_me_viewer_150"), NULL, NULL, 150 },
 178         { "Zoom200", NULL, N_("mcen_me_viewer_200"), NULL, NULL, 200 }
 179 };
 180
 181 typedef struct _ModestMsgViewWindowPrivate ModestMsgViewWindowPrivate;
 182 struct _ModestMsgViewWindowPrivate {
 183
 184         GtkWidget   *msg_view;
 185         GtkWidget   *main_scroll;
 186         GtkWidget   *find_toolbar;
 187         gchar       *last_search;
 188
 189         /* Progress observers */
 190         GtkWidget        *progress_bar;
 191         GSList           *progress_widgets;
 192
 193         /* Tollbar items */
 194         GtkWidget   *progress_toolitem;
 195         GtkWidget   *cancel_toolitem;
 196         GtkWidget   *prev_toolitem;
 197         GtkWidget   *next_toolitem;
 198         ModestToolBarModes current_toolbar_mode;
 199
 200         /* Optimized view enabled */
 201         gboolean optimized_view;
 202
 203         /* Whether this was created via the *_new_for_search_result() function. */
 204         gboolean is_search_result;
 205
 206         /* Whether the message is in outbox */
 207         gboolean is_outbox;
 208
 209         /* A reference to the @model of the header view
 210          * to allow selecting previous/next messages,
 211          * if the message is currently selected in the header view.
 212          */
 213         const gchar *header_folder_id;
 214         GtkTreeModel *header_model;
 215         GtkTreeRowReference *row_reference;
 216         GtkTreeRowReference *next_row_reference;
 217
 218         gulong clipboard_change_handler;
 219         gulong queue_change_handler;
 220         gulong account_removed_handler;
 221         gulong row_changed_handler;
 222         gulong row_deleted_handler;
 223         gulong row_inserted_handler;
 224         gulong rows_reordered_handler;
 225
 226         guint purge_timeout;
 227         GtkWidget *remove_attachment_banner;
 228
 229         guint progress_bar_timeout;
 230
 231         gchar *msg_uid;
 232
 233         GSList *sighandlers;
 234 };
 235
 236 #define MODEST_MSG_VIEW_WINDOW_GET_PRIVATE(o)      (G_TYPE_INSTANCE_GET_PRIVATE((o), \
 237                                                     MODEST_TYPE_MSG_VIEW_WINDOW, \
 238                                                     ModestMsgViewWindowPrivate))
 239 /* globals */
 240 static GtkWindowClass *parent_class = NULL;
 241
 242 /* uncomment the following if you have defined any signals */
 243 static guint signals[LAST_SIGNAL] = {0};
 244
 245 GType
 246 modest_msg_view_window_get_type (void)
 247 {
 248         static GType my_type = 0;
 249         if (!my_type) {
 250                 static const GTypeInfo my_info = {
 251                         sizeof(ModestMsgViewWindowClass),
 252                         NULL,           /* base init */
 253                         NULL,           /* base finalize */
 254                         (GClassInitFunc) modest_msg_view_window_class_init,
 255                         NULL,           /* class finalize */
 256                         NULL,           /* class data */
 257                         sizeof(ModestMsgViewWindow),
 258                         1,              /* n_preallocs */
 259                         (GInstanceInitFunc) modest_msg_view_window_init,
 260                         NULL
 261                 };
 262                 my_type = g_type_register_static (MODEST_TYPE_WINDOW,
 263                                                   "ModestMsgViewWindow",
 264                                                   &my_info, 0);
 265
 266                 static const GInterfaceInfo modest_header_view_observer_info =
 267                 {
 268                         (GInterfaceInitFunc) modest_header_view_observer_init,
 269                         NULL,         /* interface_finalize */
 270                         NULL          /* interface_data */
 271                 };
 272
 273                 g_type_add_interface_static (my_type,
 274                                 MODEST_TYPE_HEADER_VIEW_OBSERVER,
 275                                 &modest_header_view_observer_info);
 276         }
 277         return my_type;
 278 }
 279
 280 static void
 281 save_state (ModestWindow *self)
 282 {
 283         modest_widget_memory_save (modest_runtime_get_conf (),
 284                                    G_OBJECT(self),
 285                                    MODEST_CONF_MSG_VIEW_WINDOW_KEY);
 286 }
 287
 288
 289 static void
 290 restore_settings (ModestMsgViewWindow *self)
 291 {
 292         ModestConf *conf;
 293         ModestWindowPrivate *parent_priv = MODEST_WINDOW_GET_PRIVATE (self);
 294         GtkAction *action;
 295
 296         conf = modest_runtime_get_conf ();
 297         action = gtk_ui_manager_get_action (parent_priv->ui_manager,
 298                                             "/MenuBar/ViewMenu/ViewShowToolbarMenu/ViewShowToolbarNormalScreenMenu");
 299         gtk_toggle_action_set_active (GTK_TOGGLE_ACTION (action),
 300                                       modest_conf_get_bool (conf, MODEST_CONF_MSG_VIEW_WINDOW_SHOW_TOOLBAR, NULL));
 301         action = gtk_ui_manager_get_action (parent_priv->ui_manager,
 302                                             "/MenuBar/ViewMenu/ViewShowToolbarMenu/ViewShowToolbarFullScreenMenu");
 303         gtk_toggle_action_set_active (GTK_TOGGLE_ACTION (action),
 304                                       modest_conf_get_bool (conf, MODEST_CONF_MSG_VIEW_WINDOW_SHOW_TOOLBAR_FULLSCREEN, NULL));
 305         modest_widget_memory_restore (conf,
 306                                       G_OBJECT(self),
 307                                       MODEST_CONF_MSG_VIEW_WINDOW_KEY);
 308 }
 309
 310 static void
 311 modest_msg_view_window_class_init (ModestMsgViewWindowClass *klass)
 312 {
 313         GObjectClass *gobject_class;
 314         ModestWindowClass *modest_window_class;
 315         gobject_class = (GObjectClass*) klass;
 316         modest_window_class = (ModestWindowClass *) klass;
 317
 318         parent_class            = g_type_class_peek_parent (klass);
 319         gobject_class->finalize = modest_msg_view_window_finalize;
 320
 321         modest_window_class->set_zoom_func = modest_msg_view_window_set_zoom;
 322         modest_window_class->get_zoom_func = modest_msg_view_window_get_zoom;
 323         modest_window_class->zoom_minus_func = modest_msg_view_window_zoom_minus;
 324         modest_window_class->zoom_plus_func = modest_msg_view_window_zoom_plus;
 325         modest_window_class->show_toolbar_func = modest_msg_view_window_show_toolbar;
 326         modest_window_class->disconnect_signals_func = modest_msg_view_window_disconnect_signals;
 327
 328         g_type_class_add_private (gobject_class, sizeof(ModestMsgViewWindowPrivate));
 329
 330         modest_window_class->save_state_func = save_state;
 331
 332         signals[MSG_CHANGED_SIGNAL] =
 333                 g_signal_new ("msg-changed",
 334                               G_TYPE_FROM_CLASS (gobject_class),
 335                               G_SIGNAL_RUN_FIRST,
 336                               G_STRUCT_OFFSET (ModestMsgViewWindowClass, msg_changed),
 337                               NULL, NULL,
 338                               modest_marshal_VOID__POINTER_POINTER,
 339                               G_TYPE_NONE, 2, G_TYPE_POINTER, G_TYPE_POINTER);
 340 }
 341
 342 static void modest_header_view_observer_init(
 343                 ModestHeaderViewObserverIface *iface_class)
 344 {
 345         iface_class->update_func = modest_msg_view_window_update_model_replaced;
 346 }
 347
 348 static void
 349 modest_msg_view_window_init (ModestMsgViewWindow *obj)
 350 {
 351         ModestMsgViewWindowPrivate *priv;
 352         ModestWindowPrivate *parent_priv = NULL;
 353         GtkActionGroup *action_group = NULL;
 354         GError *error = NULL;
 355         GdkPixbuf *window_icon;
 356
 357         priv = MODEST_MSG_VIEW_WINDOW_GET_PRIVATE(obj);
 358         parent_priv = MODEST_WINDOW_GET_PRIVATE(obj);
 359         parent_priv->ui_manager = gtk_ui_manager_new();
 360
 361         action_group = gtk_action_group_new ("ModestMsgViewWindowActions");
 362         gtk_action_group_set_translation_domain (action_group, GETTEXT_PACKAGE);
 363
 364         /* Add common actions */
 365         gtk_action_group_add_actions (action_group,
 366                                       modest_action_entries,
 367                                       G_N_ELEMENTS (modest_action_entries),
 368                                       obj);
 369         gtk_action_group_add_toggle_actions (action_group,
 370                                              modest_toggle_action_entries,
 371                                              G_N_ELEMENTS (modest_toggle_action_entries),
 372                                              obj);
 373         gtk_action_group_add_toggle_actions (action_group,
 374                                              msg_view_toggle_action_entries,
 375                                              G_N_ELEMENTS (msg_view_toggle_action_entries),
 376                                              obj);
 377         gtk_action_group_add_radio_actions (action_group,
 378                                             msg_view_zoom_action_entries,
 379                                             G_N_ELEMENTS (msg_view_zoom_action_entries),
 380                                             100,
 381                                             G_CALLBACK (modest_ui_actions_on_change_zoom),
 382                                             obj);
 383
 384         gtk_ui_manager_insert_action_group (parent_priv->ui_manager, action_group, 0);
 385         g_object_unref (action_group);
 386
 387         /* Load the UI definition */
 388         gtk_ui_manager_add_ui_from_file (parent_priv->ui_manager, MODEST_UIDIR "modest-msg-view-window-ui.xml",
 389                                          &error);
 390         if (error) {
 391                 g_printerr ("modest: could not merge modest-msg-view-window-ui.xml: %s\n", error->message);
 392                 g_error_free (error);
 393                 error = NULL;
 394         }
 395         /* ****** */
 396
 397         /* Add accelerators */
 398         gtk_window_add_accel_group (GTK_WINDOW (obj),
 399                                     gtk_ui_manager_get_accel_group (parent_priv->ui_manager));
 400
 401         priv->is_search_result = FALSE;
 402         priv->is_outbox = FALSE;
 403
 404         priv->msg_view      = NULL;
 405         priv->header_model  = NULL;
 406         priv->header_folder_id  = NULL;
 407         priv->clipboard_change_handler = 0;
 408         priv->queue_change_handler = 0;
 409         priv->account_removed_handler = 0;
 410         priv->row_changed_handler = 0;
 411         priv->row_deleted_handler = 0;
 412         priv->row_inserted_handler = 0;
 413         priv->rows_reordered_handler = 0;
 414         priv->current_toolbar_mode = TOOLBAR_MODE_NORMAL;
 415
 416         priv->optimized_view  = FALSE;
 417         priv->progress_bar_timeout = 0;
 418         priv->purge_timeout = 0;
 419         priv->remove_attachment_banner = NULL;
 420         priv->msg_uid = NULL;
 421
 422         priv->sighandlers = NULL;
 423
 424         /* Init window */
 425         init_window (MODEST_MSG_VIEW_WINDOW(obj));
 426
 427         /* Set window icon */
 428         window_icon = modest_platform_get_icon (MODEST_APP_MSG_VIEW_ICON, MODEST_ICON_SIZE_BIG);
 429         if (window_icon) {
 430                 gtk_window_set_icon (GTK_WINDOW (obj), window_icon);
 431                 g_object_unref (window_icon);
 432         }
 433
 434         hildon_program_add_window (hildon_program_get_instance(),
 435                                    HILDON_WINDOW(obj));
 436
 437         modest_window_mgr_register_help_id (modest_runtime_get_window_mgr(),
 438                                             GTK_WINDOW(obj),"applications_email_viewer");
 439 }
 440
 441
 442 static gboolean
 443 set_toolbar_transfer_mode (ModestMsgViewWindow *self)
 444 {
 445         ModestMsgViewWindowPrivate *priv = NULL;
 446
 447         g_return_val_if_fail (MODEST_IS_MSG_VIEW_WINDOW (self), FALSE);
 448
 449         priv = MODEST_MSG_VIEW_WINDOW_GET_PRIVATE(self);
 450
 451         set_toolbar_mode (self, TOOLBAR_MODE_TRANSFER);
 452
 453         if (priv->progress_bar_timeout > 0) {
 454                 g_source_remove (priv->progress_bar_timeout);
 455                 priv->progress_bar_timeout = 0;
 456         }
 457
 458         return FALSE;
 459 }
 460
 461 static void
 462 set_toolbar_mode (ModestMsgViewWindow *self,
 463                   ModestToolBarModes mode)
 464 {
 465         ModestWindowPrivate *parent_priv;
 466         ModestMsgViewWindowPrivate *priv;
 467 /*      GtkWidget *widget = NULL; */
 468
 469         g_return_if_fail (MODEST_IS_MSG_VIEW_WINDOW (self));
 470
 471         parent_priv = MODEST_WINDOW_GET_PRIVATE(self);
 472         priv = MODEST_MSG_VIEW_WINDOW_GET_PRIVATE(self);
 473
 474         /* Sets current toolbar mode */
 475         priv->current_toolbar_mode = mode;
 476
 477         /* Update toolbar dimming state */
 478         modest_ui_actions_check_toolbar_dimming_rules (MODEST_WINDOW (self));
 479
 480         switch (mode) {
 481         case TOOLBAR_MODE_NORMAL:
 482                 if (priv->progress_toolitem) {
 483                         gtk_tool_item_set_expand (GTK_TOOL_ITEM (priv->progress_toolitem), FALSE);
 484                         gtk_widget_hide (priv->progress_toolitem);
 485                 }
 486
 487                 if (priv->progress_bar)
 488                         gtk_widget_hide (priv->progress_bar);
 489
 490                 if (priv->cancel_toolitem)
 491                         gtk_widget_hide (priv->cancel_toolitem);
 492
 493                 if (priv->prev_toolitem)
 494                         gtk_widget_show (priv->prev_toolitem);
 495
 496                 if (priv->next_toolitem)
 497                         gtk_widget_show (priv->next_toolitem);
 498
 499                 /* Hide toolbar if optimized view is enabled */
 500                 if (priv->optimized_view) {
 501                         gtk_widget_set_no_show_all (parent_priv->toolbar, TRUE);
 502                         gtk_widget_hide (GTK_WIDGET(parent_priv->toolbar));
 503                 }
 504
 505                 break;
 506         case TOOLBAR_MODE_TRANSFER:
 507                 if (priv->prev_toolitem)
 508                         gtk_widget_hide (priv->prev_toolitem);
 509
 510                 if (priv->next_toolitem)
 511                         gtk_widget_hide (priv->next_toolitem);
 512
 513                 if (priv->progress_bar)
 514                         gtk_widget_show (priv->progress_bar);
 515
 516                 if (priv->progress_toolitem) {
 517                         gtk_tool_item_set_expand (GTK_TOOL_ITEM (priv->progress_toolitem), TRUE);
 518                         gtk_widget_show (priv->progress_toolitem);
 519                 }
 520
 521                 if (priv->cancel_toolitem)
 522                         gtk_widget_show (priv->cancel_toolitem);
 523
 524                 /* Show toolbar if it's hiden (optimized view ) */
 525                 if (priv->optimized_view) {
 526                         gtk_widget_set_no_show_all (parent_priv->toolbar, FALSE);
 527                         gtk_widget_show (GTK_WIDGET (parent_priv->toolbar));
 528                 }
 529
 530                 break;
 531         default:
 532                 g_return_if_reached ();
 533         }
 534
 535 }
 536
 537
 538 static void
 539 init_window (ModestMsgViewWindow *obj)
 540 {
 541         GtkWidget *main_vbox;
 542         ModestMsgViewWindowPrivate *priv;
 543
 544         priv = MODEST_MSG_VIEW_WINDOW_GET_PRIVATE(obj);
 545
 546         priv->msg_view = GTK_WIDGET (tny_platform_factory_new_msg_view (modest_tny_platform_factory_get_instance ()));
 547         modest_msg_view_set_shadow_type (MODEST_MSG_VIEW (priv->msg_view), GTK_SHADOW_NONE);
 548         main_vbox = gtk_vbox_new  (FALSE, 6);
 549
 550 #ifdef MODEST_USE_MOZEMBED
 551         priv->main_scroll = priv->msg_view;
 552         gtk_widget_set_size_request (priv->msg_view, -1, 1600);
 553 #else
 554         priv->main_scroll = gtk_scrolled_window_new (NULL, NULL);
 555         gtk_container_add (GTK_CONTAINER (priv->main_scroll), priv->msg_view);
 556 #endif
 557         gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (priv->main_scroll), GTK_POLICY_NEVER, GTK_POLICY_AUTOMATIC);
 558         gtk_scrolled_window_set_shadow_type (GTK_SCROLLED_WINDOW (priv->main_scroll), GTK_SHADOW_NONE);
 559         modest_maemo_set_thumbable_scrollbar (GTK_SCROLLED_WINDOW(priv->main_scroll), TRUE);
 560
 561         gtk_box_pack_start (GTK_BOX(main_vbox), priv->main_scroll, TRUE, TRUE, 0);
 562         gtk_container_add   (GTK_CONTAINER(obj), main_vbox);
 563
 564         priv->find_toolbar = hildon_find_toolbar_new (NULL);
 565         hildon_window_add_toolbar (HILDON_WINDOW (obj), GTK_TOOLBAR (priv->find_toolbar));
 566         gtk_widget_set_no_show_all (priv->find_toolbar, TRUE);
 567
 568         gtk_widget_show_all (GTK_WIDGET(main_vbox));
 569 }
 570
 571 static void
 572 modest_msg_view_window_disconnect_signals (ModestWindow *self)
 573 {
 574         ModestMsgViewWindowPrivate *priv;
 575         ModestHeaderView *header_view = NULL;
 576         ModestWindow *main_window = NULL;
 577
 578         priv = MODEST_MSG_VIEW_WINDOW_GET_PRIVATE (self);
 579
 580         if (gtk_clipboard_get (GDK_SELECTION_PRIMARY) &&
 581             g_signal_handler_is_connected (gtk_clipboard_get (GDK_SELECTION_PRIMARY),
 582                                            priv->clipboard_change_handler))
 583                 g_signal_handler_disconnect (gtk_clipboard_get (GDK_SELECTION_PRIMARY),
 584                                              priv->clipboard_change_handler);
 585
 586         if (g_signal_handler_is_connected (G_OBJECT (modest_runtime_get_mail_operation_queue ()),
 587                                            priv->queue_change_handler))
 588                 g_signal_handler_disconnect (G_OBJECT (modest_runtime_get_mail_operation_queue ()),
 589                                              priv->queue_change_handler);
 590
 591         if (g_signal_handler_is_connected (G_OBJECT (modest_runtime_get_account_store ()),
 592                                            priv->account_removed_handler))
 593                 g_signal_handler_disconnect (G_OBJECT (modest_runtime_get_account_store ()),
 594                                              priv->account_removed_handler);
 595
 596         if (priv->header_model) {
 597                 if (g_signal_handler_is_connected(G_OBJECT (priv->header_model),
 598                                                   priv->row_changed_handler))
 599                         g_signal_handler_disconnect(G_OBJECT (priv->header_model),
 600                                                     priv->row_changed_handler);
 601
 602                 if (g_signal_handler_is_connected(G_OBJECT (priv->header_model),
 603                                                   priv->row_deleted_handler))
 604                         g_signal_handler_disconnect(G_OBJECT (priv->header_model),
 605                                              priv->row_deleted_handler);
 606
 607                 if (g_signal_handler_is_connected(G_OBJECT (priv->header_model),
 608                                                   priv->row_inserted_handler))
 609                         g_signal_handler_disconnect(G_OBJECT (priv->header_model),
 610                                                     priv->row_inserted_handler);
 611
 612                 if (g_signal_handler_is_connected(G_OBJECT (priv->header_model),
 613                                                   priv->rows_reordered_handler))
 614                         g_signal_handler_disconnect(G_OBJECT (priv->header_model),
 615                                                     priv->rows_reordered_handler);
 616         }
 617
 618         modest_signal_mgr_disconnect_all_and_destroy (priv->sighandlers);
 619         priv->sighandlers = NULL;
 620
 621         main_window = modest_window_mgr_get_main_window (modest_runtime_get_window_mgr(),
 622                                                          FALSE); /* don't create */
 623         if (!main_window)
 624                 return;
 625
 626         header_view = MODEST_HEADER_VIEW(
 627                         modest_main_window_get_child_widget(
 628                                 MODEST_MAIN_WINDOW(main_window),
 629                                 MODEST_MAIN_WINDOW_WIDGET_TYPE_HEADER_VIEW));
 630         if (header_view == NULL)
 631                 return;
 632
 633         modest_header_view_remove_observer(header_view,
 634                         MODEST_HEADER_VIEW_OBSERVER(self));
 635 }
 636
 637 static void
 638 modest_msg_view_window_finalize (GObject *obj)
 639 {
 640         ModestMsgViewWindowPrivate *priv;
 641
 642         priv = MODEST_MSG_VIEW_WINDOW_GET_PRIVATE (obj);
 643
 644         /* Sanity check: shouldn't be needed, the window mgr should
 645            call this function before */
 646         modest_msg_view_window_disconnect_signals (MODEST_WINDOW (obj));
 647
 648         if (priv->header_model != NULL) {
 649                 g_object_unref (priv->header_model);
 650                 priv->header_model = NULL;
 651         }
 652
 653         if (priv->progress_bar_timeout > 0) {
 654                 g_source_remove (priv->progress_bar_timeout);
 655                 priv->progress_bar_timeout = 0;
 656         }
 657
 658         if (priv->remove_attachment_banner) {
 659                 gtk_widget_destroy (priv->remove_attachment_banner);
 660                 g_object_unref (priv->remove_attachment_banner);
 661                 priv->remove_attachment_banner = NULL;
 662         }
 663
 664         if (priv->purge_timeout > 0) {
 665                 g_source_remove (priv->purge_timeout);
 666                 priv->purge_timeout = 0;
 667         }
 668
 669         if (priv->row_reference) {
 670                 gtk_tree_row_reference_free (priv->row_reference);
 671                 priv->row_reference = NULL;
 672         }
 673
 674         if (priv->next_row_reference) {
 675                 gtk_tree_row_reference_free (priv->next_row_reference);
 676                 priv->next_row_reference = NULL;
 677         }
 678
 679         if (priv->msg_uid) {
 680                 g_free (priv->msg_uid);
 681                 priv->msg_uid = NULL;
 682         }
 683
 684         G_OBJECT_CLASS(parent_class)->finalize (obj);
 685 }
 686
 687 static gboolean
 688 select_next_valid_row (GtkTreeModel *model,
 689                        GtkTreeRowReference **row_reference,
 690                        gboolean cycle)
 691 {
 692         GtkTreeIter tmp_iter;
 693         GtkTreePath *path;
 694         GtkTreePath *next = NULL;
 695         gboolean retval = FALSE;
 696
 697         g_return_val_if_fail (gtk_tree_row_reference_valid (*row_reference), FALSE);
 698
 699         path = gtk_tree_row_reference_get_path (*row_reference);
 700         gtk_tree_model_get_iter (model, &tmp_iter, path);
 701         gtk_tree_row_reference_free (*row_reference);
 702         *row_reference = NULL;
 703
 704         if (gtk_tree_model_iter_next (model, &tmp_iter)) {
 705                 next = gtk_tree_model_get_path (model, &tmp_iter);
 706                 *row_reference = gtk_tree_row_reference_new (model, next);
 707                 retval = TRUE;
 708         } else if (cycle && gtk_tree_model_get_iter_first (model, &tmp_iter)) {
 709                 next = gtk_tree_model_get_path (model, &tmp_iter);
 710
 711                 /* Ensure that we are not selecting the same */
 712                 if (gtk_tree_path_compare (path, next) != 0) {
 713                         *row_reference = gtk_tree_row_reference_new (model, next);
 714                         retval = TRUE;
 715                 }
 716         }
 717
 718         /* Free */
 719         gtk_tree_path_free (path);
 720         if (next)
 721                 gtk_tree_path_free (next);
 722
 723         return retval;
 724 }
 725
 726 /* TODO: This should be in _init(), with the parameters as properties. */
 727 static void
 728 modest_msg_view_window_construct (ModestMsgViewWindow *self,
 729                                   const gchar *modest_account_name,
 730                                   const gchar *msg_uid)
 731 {
 732         GObject *obj = NULL;
 733         ModestMsgViewWindowPrivate *priv = NULL;
 734         ModestWindowPrivate *parent_priv = NULL;
 735         ModestDimmingRulesGroup *menu_rules_group = NULL;
 736         ModestDimmingRulesGroup *toolbar_rules_group = NULL;
 737         ModestDimmingRulesGroup *clipboard_rules_group = NULL;
 738
 739         obj = G_OBJECT (self);
 740         priv = MODEST_MSG_VIEW_WINDOW_GET_PRIVATE(obj);
 741         parent_priv = MODEST_WINDOW_GET_PRIVATE(obj);
 742
 743         priv->msg_uid = g_strdup (msg_uid);
 744
 745         /* Menubar */
 746         parent_priv->menubar = modest_maemo_utils_get_manager_menubar_as_menu (parent_priv->ui_manager, "/MenuBar");
 747         hildon_window_set_menu    (HILDON_WINDOW(obj), GTK_MENU(parent_priv->menubar));
 748         gtk_widget_show (parent_priv->menubar);
 749         parent_priv->ui_dimming_manager = modest_ui_dimming_manager_new();
 750
 751         menu_rules_group = modest_dimming_rules_group_new (MODEST_DIMMING_RULES_MENU, FALSE);
 752         toolbar_rules_group = modest_dimming_rules_group_new (MODEST_DIMMING_RULES_TOOLBAR, TRUE);
 753         clipboard_rules_group = modest_dimming_rules_group_new (MODEST_DIMMING_RULES_CLIPBOARD, FALSE);
 754
 755         /* Add common dimming rules */
 756         modest_dimming_rules_group_add_rules (menu_rules_group,
 757                                               modest_msg_view_menu_dimming_entries,
 758                                               G_N_ELEMENTS (modest_msg_view_menu_dimming_entries),
 759                                               MODEST_WINDOW (self));
 760         modest_dimming_rules_group_add_rules (toolbar_rules_group,
 761                                               modest_msg_view_toolbar_dimming_entries,
 762                                               G_N_ELEMENTS (modest_msg_view_toolbar_dimming_entries),
 763                                               MODEST_WINDOW (self));
 764         modest_dimming_rules_group_add_rules (clipboard_rules_group,
 765                                               modest_msg_view_clipboard_dimming_entries,
 766                                               G_N_ELEMENTS (modest_msg_view_clipboard_dimming_entries),
 767                                               MODEST_WINDOW (self));
 768
 769         /* Insert dimming rules group for this window */
 770         modest_ui_dimming_manager_insert_rules_group (parent_priv->ui_dimming_manager, menu_rules_group);
 771         modest_ui_dimming_manager_insert_rules_group (parent_priv->ui_dimming_manager, toolbar_rules_group);
 772         modest_ui_dimming_manager_insert_rules_group (parent_priv->ui_dimming_manager, clipboard_rules_group);
 773         g_object_unref (menu_rules_group);
 774         g_object_unref (toolbar_rules_group);
 775         g_object_unref (clipboard_rules_group);
 776
 777         restore_settings (MODEST_MSG_VIEW_WINDOW(obj));
 778
 779         /* g_signal_connect (G_OBJECT(obj), "delete-event", G_CALLBACK(on_delete_event), obj); */
 780
 781         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);
 782         g_signal_connect (G_OBJECT(priv->msg_view), "activate_link",
 783                           G_CALLBACK (modest_ui_actions_on_msg_link_clicked), obj);
 784         g_signal_connect (G_OBJECT(priv->msg_view), "link_hover",
 785                           G_CALLBACK (modest_ui_actions_on_msg_link_hover), obj);
 786         g_signal_connect (G_OBJECT(priv->msg_view), "attachment_clicked",
 787                           G_CALLBACK (modest_ui_actions_on_msg_attachment_clicked), obj);
 788         g_signal_connect (G_OBJECT(priv->msg_view), "recpt_activated",
 789                           G_CALLBACK (modest_ui_actions_on_msg_recpt_activated), obj);
 790         g_signal_connect (G_OBJECT(priv->msg_view), "link_contextual",
 791                           G_CALLBACK (modest_ui_actions_on_msg_link_contextual), obj);
 792
 793         g_signal_connect (G_OBJECT (obj), "key-release-event",
 794                           G_CALLBACK (modest_msg_view_window_key_event),
 795                           NULL);
 796
 797         g_signal_connect (G_OBJECT (obj), "key-press-event",
 798                           G_CALLBACK (modest_msg_view_window_key_event),
 799                           NULL);
 800
 801         g_signal_connect (G_OBJECT (obj), "window-state-event",
 802                           G_CALLBACK (modest_msg_view_window_window_state_event),
 803                           NULL);
 804
 805         g_signal_connect (G_OBJECT (obj), "move-focus",
 806                           G_CALLBACK (on_move_focus), obj);
 807
 808         /* Mail Operation Queue */
 809         priv->queue_change_handler = g_signal_connect (G_OBJECT (modest_runtime_get_mail_operation_queue ()),
 810                                                        "queue-changed",
 811                                                        G_CALLBACK (on_queue_changed),
 812                                                        obj);
 813
 814         /* Account manager */
 815         priv->account_removed_handler = g_signal_connect (G_OBJECT (modest_runtime_get_account_store ()),
 816                                                           "account_removed",
 817                                                           G_CALLBACK(on_account_removed),
 818                                                           obj);
 819
 820         modest_window_set_active_account (MODEST_WINDOW(obj), modest_account_name);
 821
 822         g_signal_connect (G_OBJECT (priv->find_toolbar), "close", G_CALLBACK (modest_msg_view_window_find_toolbar_close), obj);
 823         g_signal_connect (G_OBJECT (priv->find_toolbar), "search", G_CALLBACK (modest_msg_view_window_find_toolbar_search), obj);
 824         priv->last_search = NULL;
 825
 826         /* Init the clipboard actions dim status */
 827         modest_msg_view_grab_focus(MODEST_MSG_VIEW (priv->msg_view));
 828
 829         update_window_title (MODEST_MSG_VIEW_WINDOW (obj));
 830
 831
 832 }
 833
 834 /* FIXME: parameter checks */
 835 ModestWindow *
 836 modest_msg_view_window_new_with_header_model (TnyMsg *msg,
 837                                               const gchar *modest_account_name,
 838                                               const gchar *msg_uid,
 839                                               GtkTreeModel *model,
 840                                               GtkTreeRowReference *row_reference)
 841 {
 842         ModestMsgViewWindow *window = NULL;
 843         ModestMsgViewWindowPrivate *priv = NULL;
 844         TnyFolder *header_folder = NULL;
 845         ModestHeaderView *header_view = NULL;
 846         ModestWindow *main_window = NULL;
 847         ModestWindowMgr *mgr = NULL;
 848
 849         MODEST_DEBUG_BLOCK (
 850                modest_tny_mime_part_to_string (TNY_MIME_PART (msg), 0);
 851         );
 852
 853         mgr = modest_runtime_get_window_mgr ();
 854         window = MODEST_MSG_VIEW_WINDOW (modest_window_mgr_get_msg_view_window (mgr));
 855         g_return_val_if_fail (MODEST_IS_MSG_VIEW_WINDOW (window), NULL);
 856
 857         modest_msg_view_window_construct (window, modest_account_name, msg_uid);
 858
 859         priv = MODEST_MSG_VIEW_WINDOW_GET_PRIVATE (window);
 860
 861         /* Remember the message list's TreeModel so we can detect changes
 862          * and change the list selection when necessary: */
 863
 864         main_window = modest_window_mgr_get_main_window(mgr, FALSE); /* don't create */
 865         if (main_window) {
 866                 header_view = MODEST_HEADER_VIEW(modest_main_window_get_child_widget(
 867                                                          MODEST_MAIN_WINDOW(main_window),
 868                                                          MODEST_MAIN_WINDOW_WIDGET_TYPE_HEADER_VIEW));
 869         }
 870
 871         if (header_view != NULL){
 872                 header_folder = modest_header_view_get_folder(header_view);
 873                 /* This could happen if the header folder was
 874                    unseleted before opening this msg window (for
 875                    example if the user selects an account in the
 876                    folder view of the main window */
 877                 if (header_folder) {
 878                         priv->is_outbox = (modest_tny_folder_guess_folder_type (header_folder) == TNY_FOLDER_TYPE_OUTBOX);
 879                         priv->header_folder_id = tny_folder_get_id(header_folder);
 880                         g_assert(priv->header_folder_id != NULL);
 881                         g_object_unref(header_folder);
 882                 }
 883         }
 884
 885         priv->header_model = g_object_ref(model);
 886         if (row_reference) {
 887                 priv->row_reference = gtk_tree_row_reference_copy (row_reference);
 888                 priv->next_row_reference = gtk_tree_row_reference_copy (row_reference);
 889                 select_next_valid_row (model, &(priv->next_row_reference), TRUE);
 890         } else {
 891                 priv->row_reference = NULL;
 892                 priv->next_row_reference = NULL;
 893         }
 894
 895         priv->row_changed_handler = g_signal_connect(
 896                         GTK_TREE_MODEL(model), "row-changed",
 897                         G_CALLBACK(modest_msg_view_window_on_row_changed),
 898                         window);
 899         priv->row_deleted_handler = g_signal_connect(
 900                         GTK_TREE_MODEL(model), "row-deleted",
 901                         G_CALLBACK(modest_msg_view_window_on_row_deleted),
 902                         window);
 903         priv->row_inserted_handler = g_signal_connect (
 904                         GTK_TREE_MODEL(model), "row-inserted",
 905                         G_CALLBACK(modest_msg_view_window_on_row_inserted),
 906                         window);
 907         priv->rows_reordered_handler = g_signal_connect(
 908                         GTK_TREE_MODEL(model), "rows-reordered",
 909                         G_CALLBACK(modest_msg_view_window_on_row_reordered),
 910                         window);
 911
 912         if (header_view != NULL){
 913                 modest_header_view_add_observer(header_view,
 914                                 MODEST_HEADER_VIEW_OBSERVER(window));
 915         }
 916
 917         tny_msg_view_set_msg (TNY_MSG_VIEW (priv->msg_view), msg);
 918         update_window_title (MODEST_MSG_VIEW_WINDOW (window));
 919         gtk_widget_show_all (GTK_WIDGET (window));
 920         modest_msg_view_window_update_priority (window);
 921
 922         /* Check dimming rules */
 923         modest_ui_actions_check_toolbar_dimming_rules (MODEST_WINDOW (window));
 924         modest_ui_actions_check_menu_dimming_rules (MODEST_WINDOW (window));
 925         modest_window_check_dimming_rules_group (MODEST_WINDOW (window), MODEST_DIMMING_RULES_CLIPBOARD);
 926
 927         return MODEST_WINDOW(window);
 928 }
 929
 930 ModestWindow *
 931 modest_msg_view_window_new_for_search_result (TnyMsg *msg,
 932                                               const gchar *modest_account_name,
 933                                               const gchar *msg_uid)
 934 {
 935         ModestMsgViewWindow *window = NULL;
 936         ModestMsgViewWindowPrivate *priv = NULL;
 937         ModestWindowMgr *mgr = NULL;
 938
 939         mgr = modest_runtime_get_window_mgr ();
 940         window = MODEST_MSG_VIEW_WINDOW (modest_window_mgr_get_msg_view_window (mgr));
 941         g_return_val_if_fail (MODEST_IS_MSG_VIEW_WINDOW (window), NULL);
 942         modest_msg_view_window_construct (window, modest_account_name, msg_uid);
 943
 944         priv = MODEST_MSG_VIEW_WINDOW_GET_PRIVATE (window);
 945
 946         /* Remember that this is a search result,
 947          * so we can disable some UI appropriately: */
 948         priv->is_search_result = TRUE;
 949
 950         tny_msg_view_set_msg (TNY_MSG_VIEW (priv->msg_view), msg);
 951
 952         update_window_title (window);
 953         modest_msg_view_window_update_priority (window);
 954
 955         gtk_widget_show_all (GTK_WIDGET (window));
 956
 957
 958         return MODEST_WINDOW(window);
 959 }
 960
 961 ModestWindow *
 962 modest_msg_view_window_new_for_attachment (TnyMsg *msg,
 963                             const gchar *modest_account_name,
 964                             const gchar *msg_uid)
 965 {
 966         GObject *obj = NULL;
 967         ModestMsgViewWindowPrivate *priv;
 968         ModestWindowMgr *mgr = NULL;
 969
 970         g_return_val_if_fail (msg, NULL);
 971         mgr = modest_runtime_get_window_mgr ();
 972         obj = G_OBJECT (modest_window_mgr_get_msg_view_window (mgr));
 973         priv = MODEST_MSG_VIEW_WINDOW_GET_PRIVATE (obj);
 974         modest_msg_view_window_construct (MODEST_MSG_VIEW_WINDOW (obj),
 975                 modest_account_name, msg_uid);
 976
 977         tny_msg_view_set_msg (TNY_MSG_VIEW (priv->msg_view), msg);
 978         update_window_title (MODEST_MSG_VIEW_WINDOW (obj));
 979
 980         gtk_widget_show_all (GTK_WIDGET (obj));
 981
 982         /* Check dimming rules */
 983         modest_ui_actions_check_toolbar_dimming_rules (MODEST_WINDOW (obj));
 984         modest_ui_actions_check_menu_dimming_rules (MODEST_WINDOW (obj));
 985         modest_window_check_dimming_rules_group (MODEST_WINDOW (obj), MODEST_DIMMING_RULES_CLIPBOARD);
 986
 987         return MODEST_WINDOW(obj);
 988 }
 989
 990 void modest_msg_view_window_on_row_changed(
 991                 GtkTreeModel *header_model,
 992                 GtkTreePath *arg1,
 993                 GtkTreeIter *arg2,
 994                 ModestMsgViewWindow *window){
 995         modest_ui_actions_check_toolbar_dimming_rules (MODEST_WINDOW (window));
 996 }
 997
 998 void modest_msg_view_window_on_row_deleted(
 999                 GtkTreeModel *header_model,
1000                 GtkTreePath *arg1,
1001                 ModestMsgViewWindow *window){
1002         modest_ui_actions_check_toolbar_dimming_rules (MODEST_WINDOW (window));
1003 }
1004
1005 /* On insertions we check if the folder still has the message we are
1006  * showing or do not. If do not, we do nothing. Which means we are still
1007  * not attached to any header folder and thus next/prev buttons are
1008  * still dimmed. Once the message that is shown by msg-view is found, the
1009  * new model of header-view will be attached and the references will be set.
1010  * On each further insertions dimming rules will be checked. However
1011  * this requires extra CPU time at least works.
1012  * (An message might be deleted from TnyFolder and thus will not be
1013  * inserted into the model again for example if it is removed by the
1014  * imap server and the header view is refreshed.)
1015  */
1016 void modest_msg_view_window_on_row_inserted(
1017                 GtkTreeModel *new_model,
1018                 GtkTreePath *tree_path,
1019                 GtkTreeIter *tree_iter,
1020                 ModestMsgViewWindow *window){
1021         ModestMsgViewWindowPrivate *priv = NULL;
1022         TnyHeader *header = NULL;
1023         gchar *uid = NULL;
1024
1025         g_return_if_fail (MODEST_IS_MSG_VIEW_WINDOW (window));
1026
1027         priv = MODEST_MSG_VIEW_WINDOW_GET_PRIVATE (window);
1028
1029         /* If we already has a model attached then the message shown by
1030          * msg-view is in it, and thus we do not need any actions but
1031          * to check the dimming rules.*/
1032         if(priv->header_model != NULL){
1033                 if (priv->row_reference) {
1034                         gtk_tree_row_reference_free(priv->next_row_reference);
1035                         priv->next_row_reference = gtk_tree_row_reference_copy(
1036                                 priv->row_reference);
1037                         select_next_valid_row (priv->header_model,
1038                                                &(priv->next_row_reference), FALSE);
1039                 }
1040                 modest_ui_actions_check_toolbar_dimming_rules (
1041                                 MODEST_WINDOW (window));
1042                 return;
1043         }
1044
1045         /* Check if the newly inserted message is the same we are actually
1046          * showing. IF not, we should remain detached from the header model
1047          * and thus prev and next toolbarbuttons should remain dimmed. */
1048         gtk_tree_model_get (new_model, tree_iter,
1049                         TNY_GTK_HEADER_LIST_MODEL_INSTANCE_COLUMN, &header, -1);
1050         uid = modest_tny_folder_get_header_unique_id(header);
1051         if(!g_str_equal(priv->msg_uid, uid)){
1052                 g_free(uid);
1053                 g_object_unref(G_OBJECT(header));
1054                 header = NULL;
1055                 return;
1056         }
1057         if (!(tny_header_get_flags (header) & TNY_HEADER_FLAG_SEEN))
1058                 tny_header_set_flag (header, TNY_HEADER_FLAG_SEEN);
1059         g_object_unref(G_OBJECT(header));
1060         header = NULL;
1061         g_free(uid);
1062
1063         /* Setup row_reference for the actual msg. */
1064         priv->row_reference = gtk_tree_row_reference_new(
1065                         new_model, tree_path);
1066         if(priv->row_reference == NULL){
1067                 g_warning("No reference for msg header item.");
1068                 return;
1069         }
1070
1071         /* Attach new_model and connect some callback to it to become able
1072          * to detect changes in header-view. */
1073         priv->header_model = g_object_ref(new_model);
1074         priv->row_changed_handler = g_signal_connect (new_model, "row-changed",
1075                                                       G_CALLBACK (modest_msg_view_window_on_row_changed),
1076                                                       window);
1077         priv->row_deleted_handler = g_signal_connect (new_model, "row-deleted",
1078                                                       G_CALLBACK (modest_msg_view_window_on_row_deleted),
1079                                                       window);
1080         priv->rows_reordered_handler = g_signal_connect (new_model, "rows-reordered",
1081                                                          G_CALLBACK (modest_msg_view_window_on_row_reordered),
1082                                                          window);
1083
1084         /* Now set up next_row_reference. */
1085         priv->next_row_reference = gtk_tree_row_reference_copy(
1086                         priv->row_reference);
1087         select_next_valid_row (priv->header_model,
1088                         &(priv->next_row_reference), FALSE);
1089
1090         modest_ui_actions_check_toolbar_dimming_rules (MODEST_WINDOW (window));
1091 }
1092
1093 void modest_msg_view_window_on_row_reordered(
1094                 GtkTreeModel *header_model,
1095                 GtkTreePath *arg1,
1096                 GtkTreeIter *arg2,
1097                 gpointer arg3,
1098                 ModestMsgViewWindow *window){
1099         modest_ui_actions_check_toolbar_dimming_rules (MODEST_WINDOW (window));
1100 }
1101
1102 /* The modest_msg_view_window_update_model_replaced implements update
1103  * function for ModestHeaderViewObserver. Checks whether the TnyFolder
1104  * actually belongs to the header-view is the same as the TnyFolder of
1105  * the message of msg-view or not. If they are different, there is
1106  * nothing to do. If they are the same, then the model has replaced and
1107  * the reference in msg-view shall be replaced from the old model to
1108  * the new model. In this case the view will be detached from it's
1109  * header folder. From this point the next/prev buttons are dimmed.
1110  */
1111 void
1112 modest_msg_view_window_update_model_replaced(ModestHeaderViewObserver *observer,
1113                                              GtkTreeModel *model,
1114                                              const gchar *tny_folder_id){
1115         ModestMsgViewWindowPrivate *priv = NULL;
1116         ModestMsgViewWindow *window = NULL;
1117
1118         g_assert(MODEST_IS_HEADER_VIEW_OBSERVER(observer));
1119         g_assert(MODEST_IS_MSG_VIEW_WINDOW(observer));
1120
1121         window = MODEST_MSG_VIEW_WINDOW(observer);
1122         priv = MODEST_MSG_VIEW_WINDOW_GET_PRIVATE(window);
1123
1124         /* If there is an other folder in the header-view then we do
1125          * not care about it's model (msg list). Else if the
1126          * header-view shows the folder the msg shown by us is in, we
1127          * shall replace our model reference and make some check. */
1128         if(tny_folder_id == NULL ||
1129            (priv->header_folder_id && !g_str_equal(tny_folder_id, priv->header_folder_id)))
1130                 return;
1131
1132         /* Model is changed(replaced), so we should forget the old
1133          * one. Because there might be other references and there
1134          * might be some change on the model even if we unreferenced
1135          * it, we need to disconnect our signals here. */
1136         if (g_signal_handler_is_connected(G_OBJECT (priv->header_model),
1137                                            priv->row_changed_handler))
1138                 g_signal_handler_disconnect(G_OBJECT (priv->header_model),
1139                                              priv->row_changed_handler);
1140         priv->row_changed_handler = 0;
1141         if (g_signal_handler_is_connected(G_OBJECT (priv->header_model),
1142                                            priv->row_deleted_handler))
1143                 g_signal_handler_disconnect(G_OBJECT (priv->header_model),
1144                                              priv->row_deleted_handler);
1145         priv->row_deleted_handler = 0;
1146         if (g_signal_handler_is_connected(G_OBJECT (priv->header_model),
1147                                            priv->row_inserted_handler))
1148                 g_signal_handler_disconnect(G_OBJECT (priv->header_model),
1149                                              priv->row_inserted_handler);
1150         priv->row_inserted_handler = 0;
1151         if (g_signal_handler_is_connected(G_OBJECT (priv->header_model),
1152                                            priv->rows_reordered_handler))
1153                 g_signal_handler_disconnect(G_OBJECT (priv->header_model),
1154                                              priv->rows_reordered_handler);
1155         priv->rows_reordered_handler = 0;
1156         g_object_unref(priv->header_model);
1157         priv->header_model = NULL;
1158         if (priv->row_reference)
1159                 gtk_tree_row_reference_free (priv->row_reference);
1160         priv->row_reference = NULL;
1161         if (priv->next_row_reference)
1162                 gtk_tree_row_reference_free (priv->next_row_reference);
1163         priv->next_row_reference = NULL;
1164
1165         modest_ui_actions_check_toolbar_dimming_rules(MODEST_WINDOW(window));
1166
1167         g_assert(model != NULL);
1168
1169         /* Also we must connect to the new model for row insertions.
1170          * Only for insertions now. We will need other ones only after
1171          * the msg is show by msg-view is added to the new model. */
1172         priv->row_inserted_handler = g_signal_connect (
1173                         model, "row-inserted",
1174                         G_CALLBACK(modest_msg_view_window_on_row_inserted),
1175                         window);
1176 }
1177
1178 gboolean
1179 modest_msg_view_window_toolbar_on_transfer_mode     (ModestMsgViewWindow *self)
1180 {
1181         ModestMsgViewWindowPrivate *priv= NULL;
1182
1183         g_return_val_if_fail (MODEST_IS_MSG_VIEW_WINDOW (self), FALSE);
1184         priv = MODEST_MSG_VIEW_WINDOW_GET_PRIVATE (self);
1185
1186         return priv->current_toolbar_mode == TOOLBAR_MODE_TRANSFER;
1187 }
1188
1189 TnyHeader*
1190 modest_msg_view_window_get_header (ModestMsgViewWindow *self)
1191 {
1192         ModestMsgViewWindowPrivate *priv= NULL;
1193         TnyMsg *msg = NULL;
1194         TnyHeader *header = NULL;
1195         GtkTreePath *path = NULL;
1196         GtkTreeIter iter;
1197
1198         g_return_val_if_fail (MODEST_IS_MSG_VIEW_WINDOW (self), NULL);
1199         priv = MODEST_MSG_VIEW_WINDOW_GET_PRIVATE (self);
1200
1201         /* If the message was not obtained from a treemodel,
1202          * for instance if it was opened directly by the search UI:
1203          */
1204         if (priv->header_model == NULL ||
1205             priv->row_reference == NULL ||
1206             !gtk_tree_row_reference_valid (priv->row_reference)) {
1207                 msg = modest_msg_view_window_get_message (self);
1208                 if (msg) {
1209                         header = tny_msg_get_header (msg);
1210                         g_object_unref (msg);
1211                 }
1212                 return header;
1213         }
1214
1215         /* Get iter of the currently selected message in the header view: */
1216         path = gtk_tree_row_reference_get_path (priv->row_reference);
1217         g_return_val_if_fail (path != NULL, NULL);
1218         gtk_tree_model_get_iter (priv->header_model,
1219                                  &iter,
1220                                  path);
1221
1222         /* Get current message header */
1223         gtk_tree_model_get (priv->header_model, &iter,
1224                             TNY_GTK_HEADER_LIST_MODEL_INSTANCE_COLUMN,
1225                             &header, -1);
1226
1227         gtk_tree_path_free (path);
1228         return header;
1229 }
1230
1231 TnyMsg*
1232 modest_msg_view_window_get_message (ModestMsgViewWindow *self)
1233 {
1234         ModestMsgViewWindowPrivate *priv;
1235
1236         g_return_val_if_fail (self, NULL);
1237
1238         priv = MODEST_MSG_VIEW_WINDOW_GET_PRIVATE(self);
1239
1240         return tny_msg_view_get_msg (TNY_MSG_VIEW (priv->msg_view));
1241 }
1242
1243 const gchar*
1244 modest_msg_view_window_get_message_uid (ModestMsgViewWindow *self)
1245 {
1246         ModestMsgViewWindowPrivate *priv;
1247
1248         g_return_val_if_fail (self, NULL);
1249
1250         priv  = MODEST_MSG_VIEW_WINDOW_GET_PRIVATE (self);
1251
1252         return (const gchar*) priv->msg_uid;
1253 }
1254
1255 static void
1256 modest_msg_view_window_toggle_find_toolbar (GtkToggleAction *toggle,
1257                                             gpointer data)
1258 {
1259         ModestMsgViewWindow *window = MODEST_MSG_VIEW_WINDOW (data);
1260         ModestMsgViewWindowPrivate *priv = MODEST_MSG_VIEW_WINDOW_GET_PRIVATE (window);
1261         ModestWindowPrivate *parent_priv = MODEST_WINDOW_GET_PRIVATE (window);
1262         gboolean is_active;
1263         GtkAction *action;
1264
1265         is_active = gtk_toggle_action_get_active (toggle);
1266
1267         if (is_active) {
1268                 gtk_widget_show (priv->find_toolbar);
1269                 hildon_find_toolbar_highlight_entry (HILDON_FIND_TOOLBAR (priv->find_toolbar), TRUE);
1270         } else {
1271                 gtk_widget_hide (priv->find_toolbar);
1272         }
1273
1274         /* update the toggle buttons status */
1275         action = gtk_ui_manager_get_action (parent_priv->ui_manager, "/ToolBar/FindInMessage");
1276         modest_utils_toggle_action_set_active_block_notify (GTK_TOGGLE_ACTION (action), is_active);
1277         action = gtk_ui_manager_get_action (parent_priv->ui_manager, "/MenuBar/ToolsMenu/ToolsFindInMessageMenu");
1278         modest_utils_toggle_action_set_active_block_notify (GTK_TOGGLE_ACTION (action), is_active);
1279
1280 }
1281
1282 static void
1283 modest_msg_view_window_find_toolbar_close (GtkWidget *widget,
1284                                            ModestMsgViewWindow *obj)
1285 {
1286         GtkToggleAction *toggle;
1287         ModestWindowPrivate *parent_priv;
1288         parent_priv = MODEST_WINDOW_GET_PRIVATE (obj);
1289
1290         toggle = GTK_TOGGLE_ACTION (gtk_ui_manager_get_action (parent_priv->ui_manager, "/ToolBar/FindInMessage"));
1291         gtk_toggle_action_set_active (toggle, FALSE);
1292 }
1293
1294 static void
1295 modest_msg_view_window_find_toolbar_search (GtkWidget *widget,
1296                                            ModestMsgViewWindow *obj)
1297 {
1298         gchar *current_search;
1299         ModestMsgViewWindowPrivate *priv = MODEST_MSG_VIEW_WINDOW_GET_PRIVATE (obj);
1300
1301         if (modest_mime_part_view_is_empty (MODEST_MIME_PART_VIEW (priv->msg_view))) {
1302                 hildon_banner_show_information (NULL, NULL, _("mail_ib_nothing_to_find"));
1303                 return;
1304         }
1305
1306         g_object_get (G_OBJECT (widget), "prefix", &current_search, NULL);
1307
1308         if ((current_search == NULL) || (strcmp (current_search, "") == 0)) {
1309                 g_free (current_search);
1310                 hildon_banner_show_information (NULL, NULL, dgettext("hildon-common-strings", "ecdg_ib_find_rep_enter_text"));
1311                 return;
1312         }
1313
1314         if ((priv->last_search == NULL) || (strcmp (priv->last_search, current_search) != 0)) {
1315                 gboolean result;
1316                 g_free (priv->last_search);
1317                 priv->last_search = g_strdup (current_search);
1318                 result = modest_isearch_view_search (MODEST_ISEARCH_VIEW (priv->msg_view),
1319                                                      priv->last_search);
1320                 if (!result) {
1321                         hildon_banner_show_information (NULL, NULL, dgettext("hildon-libs", "ckct_ib_find_no_matches"));
1322                         g_free (priv->last_search);
1323                         priv->last_search = NULL;
1324                 } else {
1325                         modest_msg_view_grab_focus (MODEST_MSG_VIEW (priv->msg_view));
1326                 }
1327         } else {
1328                 if (!modest_isearch_view_search_next (MODEST_ISEARCH_VIEW (priv->msg_view))) {
1329                         hildon_banner_show_information (NULL, NULL, dgettext("hildon-libs", "ckct_ib_find_search_complete"));
1330                         g_free (priv->last_search);
1331                         priv->last_search = NULL;
1332                 } else {
1333                         modest_msg_view_grab_focus (MODEST_MSG_VIEW (priv->msg_view));
1334                 }
1335         }
1336
1337         g_free (current_search);
1338
1339 }
1340
1341 static void
1342 modest_msg_view_window_set_zoom (ModestWindow *window,
1343                                  gdouble zoom)
1344 {
1345         ModestMsgViewWindowPrivate *priv;
1346         ModestWindowPrivate *parent_priv;
1347         GtkAction *action = NULL;
1348         gint int_zoom = (gint) rint (zoom*100.0+0.1);
1349
1350         g_return_if_fail (MODEST_IS_MSG_VIEW_WINDOW (window));
1351
1352         priv = MODEST_MSG_VIEW_WINDOW_GET_PRIVATE (window);
1353         parent_priv = MODEST_WINDOW_GET_PRIVATE (window);
1354         modest_zoomable_set_zoom (MODEST_ZOOMABLE (priv->msg_view), zoom);
1355
1356         action = gtk_ui_manager_get_action (parent_priv->ui_manager,
1357                                             "/MenuBar/ViewMenu/ZoomMenu/Zoom50Menu");
1358
1359         gtk_radio_action_set_current_value (GTK_RADIO_ACTION (action), int_zoom);
1360 }
1361
1362 static gdouble
1363 modest_msg_view_window_get_zoom (ModestWindow *window)
1364 {
1365         ModestMsgViewWindowPrivate *priv;
1366
1367         g_return_val_if_fail (MODEST_IS_MSG_VIEW_WINDOW (window), 1.0);
1368
1369         priv = MODEST_MSG_VIEW_WINDOW_GET_PRIVATE (window);
1370         return modest_zoomable_get_zoom (MODEST_ZOOMABLE (priv->msg_view));
1371 }
1372
1373 static gboolean
1374 modest_msg_view_window_zoom_plus (ModestWindow *window)
1375 {
1376         ModestWindowPrivate *parent_priv;
1377         GtkRadioAction *zoom_radio_action;
1378         GSList *group, *node;
1379
1380         parent_priv = MODEST_WINDOW_GET_PRIVATE (window);
1381         zoom_radio_action = GTK_RADIO_ACTION (gtk_ui_manager_get_action (parent_priv->ui_manager,
1382                                                                          "/MenuBar/ViewMenu/ZoomMenu/Zoom50Menu"));
1383
1384         group = gtk_radio_action_get_group (zoom_radio_action);
1385
1386         if (gtk_toggle_action_get_active (GTK_TOGGLE_ACTION (group->data))) {
1387                 hildon_banner_show_information (NULL, NULL, dgettext("hildon-common-strings", "ckct_ib_max_zoom_level_reached"));
1388                 return FALSE;
1389         }
1390
1391         for (node = group; node != NULL; node = g_slist_next (node)) {
1392                 if ((node->next != NULL) && gtk_toggle_action_get_active (GTK_TOGGLE_ACTION (node->next->data))) {
1393                         gtk_toggle_action_set_active (GTK_TOGGLE_ACTION (node->data), TRUE);
1394                         return TRUE;
1395                 }
1396         }
1397         return FALSE;
1398 }
1399
1400 static gboolean
1401 modest_msg_view_window_zoom_minus (ModestWindow *window)
1402 {
1403         ModestWindowPrivate *parent_priv;
1404         GtkRadioAction *zoom_radio_action;
1405         GSList *group, *node;
1406
1407         parent_priv = MODEST_WINDOW_GET_PRIVATE (window);
1408         zoom_radio_action = GTK_RADIO_ACTION (gtk_ui_manager_get_action (parent_priv->ui_manager,
1409                                                                          "/MenuBar/ViewMenu/ZoomMenu/Zoom50Menu"));
1410
1411         group = gtk_radio_action_get_group (zoom_radio_action);
1412
1413         for (node = group; node != NULL; node = g_slist_next (node)) {
1414                 if (gtk_toggle_action_get_active (GTK_TOGGLE_ACTION (node->data))) {
1415                         if (node->next != NULL) {
1416                                 gtk_toggle_action_set_active (GTK_TOGGLE_ACTION (node->next->data), TRUE);
1417                                 return TRUE;
1418                         } else {
1419                           hildon_banner_show_information (NULL, NULL, dgettext("hildon-common-strings", "ckct_ib_min_zoom_level_reached"));
1420                                 return FALSE;
1421                         }
1422                         break;
1423                 }
1424         }
1425         return FALSE;
1426 }
1427
1428 static gboolean
1429 modest_msg_view_window_key_event (GtkWidget *window,
1430                                   GdkEventKey *event,
1431                                   gpointer userdata)
1432 {
1433         GtkWidget *focus;
1434
1435         focus = gtk_window_get_focus (GTK_WINDOW (window));
1436
1437         /* for the find toolbar case */
1438         if (focus && GTK_IS_ENTRY (focus)) {
1439                 if (event->keyval == GDK_BackSpace) {
1440                         GdkEvent *copy;
1441                         copy = gdk_event_copy ((GdkEvent *) event);
1442                         gtk_widget_event (focus, copy);
1443                         gdk_event_free (copy);
1444                         return TRUE;
1445                 } else
1446                         return FALSE;
1447         }
1448         if (event->keyval == GDK_Up || event->keyval == GDK_KP_Up ||
1449             event->keyval == GDK_Down || event->keyval == GDK_KP_Down ||
1450             event->keyval == GDK_Page_Up || event->keyval == GDK_KP_Page_Up ||
1451             event->keyval == GDK_Page_Down || event->keyval == GDK_KP_Page_Down ||
1452             event->keyval == GDK_Home || event->keyval == GDK_KP_Home ||
1453             event->keyval == GDK_End || event->keyval == GDK_KP_End) {
1454                 ModestMsgViewWindowPrivate *priv = MODEST_MSG_VIEW_WINDOW_GET_PRIVATE (window);
1455                 gboolean return_value;
1456
1457                 if (event->type == GDK_KEY_RELEASE) {
1458                         GtkScrollType scroll_type;
1459
1460                         switch (event->keyval) {
1461                         case GDK_Up:
1462                         case GDK_KP_Up:
1463                                 scroll_type = GTK_SCROLL_STEP_UP; break;
1464                         case GDK_Down:
1465                         case GDK_KP_Down:
1466                                 scroll_type = GTK_SCROLL_STEP_DOWN; break;
1467                         case GDK_Page_Up:
1468                         case GDK_KP_Page_Up:
1469                                 scroll_type = GTK_SCROLL_PAGE_UP; break;
1470                         case GDK_Page_Down:
1471                         case GDK_KP_Page_Down:
1472                                 scroll_type = GTK_SCROLL_PAGE_DOWN; break;
1473                         case GDK_Home:
1474                         case GDK_KP_Home:
1475                                 scroll_type = GTK_SCROLL_START; break;
1476                         case GDK_End:
1477                         case GDK_KP_End:
1478                                 scroll_type = GTK_SCROLL_END; break;
1479                         default: scroll_type = GTK_SCROLL_NONE;
1480                         }
1481
1482                         g_signal_emit_by_name (G_OBJECT (priv->main_scroll), "scroll-child",
1483                                                scroll_type, FALSE, &return_value);
1484                         return TRUE;
1485                 } else {
1486                         return FALSE;
1487                 }
1488         } else {
1489                 return FALSE;
1490         }
1491 }
1492
1493 gboolean
1494 modest_msg_view_window_last_message_selected (ModestMsgViewWindow *window)
1495 {
1496         GtkTreePath *path;
1497         ModestMsgViewWindowPrivate *priv;
1498         GtkTreeIter tmp_iter;
1499         gboolean is_last_selected;
1500
1501         g_return_val_if_fail (MODEST_IS_MSG_VIEW_WINDOW (window), TRUE);
1502         priv = MODEST_MSG_VIEW_WINDOW_GET_PRIVATE (window);
1503
1504         /*if no model (so no rows at all), then virtually we are the last*/
1505         if (!priv->header_model || !priv->row_reference)
1506                 return TRUE;
1507
1508         path = gtk_tree_row_reference_get_path (priv->row_reference);
1509         if (path == NULL)
1510                 return TRUE;
1511
1512         is_last_selected = TRUE;
1513         while (is_last_selected) {
1514                 TnyHeader *header;
1515                 gtk_tree_path_next (path);
1516                 if (!gtk_tree_model_get_iter (priv->header_model, &tmp_iter, path))
1517                         break;
1518                 gtk_tree_model_get (priv->header_model, &tmp_iter,
1519                                 TNY_GTK_HEADER_LIST_MODEL_INSTANCE_COLUMN,
1520                                 &header, -1);
1521                 if (header) {
1522                         if (msg_is_visible (header, priv->is_outbox))
1523                                 is_last_selected = FALSE;
1524                         g_object_unref(G_OBJECT(header));
1525                 }
1526         }
1527         gtk_tree_path_free (path);
1528         return is_last_selected;
1529 }
1530
1531 gboolean
1532 modest_msg_view_window_has_headers_model (ModestMsgViewWindow *window)
1533 {
1534         ModestMsgViewWindowPrivate *priv;
1535
1536         g_return_val_if_fail (MODEST_IS_MSG_VIEW_WINDOW (window), TRUE);
1537         priv = MODEST_MSG_VIEW_WINDOW_GET_PRIVATE (window);
1538
1539         return priv->header_model != NULL;
1540 }
1541
1542 gboolean
1543 modest_msg_view_window_is_search_result (ModestMsgViewWindow *window)
1544 {
1545         ModestMsgViewWindowPrivate *priv;
1546
1547         g_return_val_if_fail (MODEST_IS_MSG_VIEW_WINDOW (window), TRUE);
1548         priv = MODEST_MSG_VIEW_WINDOW_GET_PRIVATE (window);
1549
1550         return priv->is_search_result;
1551 }
1552
1553 static gboolean
1554 msg_is_visible (TnyHeader *header, gboolean check_outbox)
1555 {
1556         return (!(tny_header_get_flags(header) & TNY_HEADER_FLAG_DELETED)) &&
1557                 ( (!check_outbox) || (modest_tny_all_send_queues_get_msg_status (header) != MODEST_TNY_SEND_QUEUE_FAILED)) ;
1558
1559 }
1560
1561 gboolean
1562 modest_msg_view_window_first_message_selected (ModestMsgViewWindow *window)
1563 {
1564         GtkTreePath *path;
1565         ModestMsgViewWindowPrivate *priv;
1566         gboolean is_first_selected;
1567         GtkTreeIter tmp_iter;
1568 /*      gchar * path_string;*/
1569
1570         g_return_val_if_fail (MODEST_IS_MSG_VIEW_WINDOW (window), TRUE);
1571         priv = MODEST_MSG_VIEW_WINDOW_GET_PRIVATE (window);
1572
1573         /*if no model (so no rows at all), then virtually we are the first*/
1574         if (!priv->header_model || !priv->row_reference)
1575                 return TRUE;
1576
1577         path = gtk_tree_row_reference_get_path (priv->row_reference);
1578         if (!path)
1579                 return TRUE;
1580
1581 /*      path_string = gtk_tree_path_to_string (path);
1582         is_first_selected = strcmp (path_string, "0");
1583
1584         g_free (path_string);
1585         gtk_tree_path_free (path);
1586
1587         return is_first_selected;*/
1588
1589         is_first_selected = TRUE;
1590         while (is_first_selected) {
1591                 TnyHeader *header;
1592                 if(!gtk_tree_path_prev (path))
1593                         break;
1594                 /* Here the 'if' is needless for logic, but let make sure
1595                  * iter is valid for gtk_tree_model_get. */
1596                 if (!gtk_tree_model_get_iter (priv->header_model, &tmp_iter, path))
1597                         break;
1598                 gtk_tree_model_get (priv->header_model, &tmp_iter,
1599                                 TNY_GTK_HEADER_LIST_MODEL_INSTANCE_COLUMN,
1600                                 &header, -1);
1601                 if (header) {
1602                         if (msg_is_visible (header, priv->is_outbox))
1603                                 is_first_selected = FALSE;
1604                         g_object_unref(G_OBJECT(header));
1605                 }
1606         }
1607         gtk_tree_path_free (path);
1608         return is_first_selected;
1609 }
1610
1611 typedef struct {
1612         TnyHeader *header;
1613         GtkTreeRowReference *row_reference;
1614 } MsgReaderInfo;
1615
1616 static void
1617 message_reader_performer (gboolean canceled,
1618                           GError *err,
1619                           GtkWindow *parent_window,
1620                           TnyAccount *account,
1621                           gpointer user_data)
1622 {
1623         ModestMailOperation *mail_op = NULL;
1624         MsgReaderInfo *info;
1625
1626         info = (MsgReaderInfo *) user_data;
1627         if (canceled || err) {
1628                 goto frees;
1629         }
1630
1631         /* Register the header - it'll be unregistered in the callback */
1632         modest_window_mgr_register_header (modest_runtime_get_window_mgr (), info->header, NULL);
1633
1634         /* New mail operation */
1635         mail_op = modest_mail_operation_new_with_error_handling (G_OBJECT(parent_window),
1636                                                                  modest_ui_actions_disk_operations_error_handler,
1637                                                                  NULL, NULL);
1638
1639         modest_mail_operation_queue_add (modest_runtime_get_mail_operation_queue (), mail_op);
1640         modest_mail_operation_get_msg (mail_op, info->header, view_msg_cb, info->row_reference);
1641         g_object_unref (mail_op);
1642
1643  frees:
1644         /* Frees. The row_reference will be freed by the view_msg_cb callback */
1645         g_object_unref (info->header);
1646         g_slice_free (MsgReaderInfo, info);
1647 }
1648
1649
1650 /**
1651  * Reads the message whose summary item is @header. It takes care of
1652  * several things, among others:
1653  *
1654  * If the message was not previously downloaded then ask the user
1655  * before downloading. If there is no connection launch the connection
1656  * dialog. Update toolbar dimming rules.
1657  *
1658  * Returns: TRUE if the mail operation was started, otherwise if the
1659  * user do not want to download the message, or if the user do not
1660  * want to connect, then the operation is not issued
1661  **/
1662 static gboolean
1663 message_reader (ModestMsgViewWindow *window,
1664                 ModestMsgViewWindowPrivate *priv,
1665                 TnyHeader *header,
1666                 GtkTreeRowReference *row_reference)
1667 {
1668         gboolean already_showing = FALSE;
1669         ModestWindow *msg_window = NULL;
1670         ModestWindowMgr *mgr;
1671         TnyAccount *account;
1672         TnyFolder *folder;
1673         MsgReaderInfo *info;
1674
1675         g_return_val_if_fail (row_reference != NULL, FALSE);
1676
1677         mgr = modest_runtime_get_window_mgr ();
1678         already_showing = modest_window_mgr_find_registered_header (mgr, header, &msg_window);
1679         if (already_showing && (msg_window != MODEST_WINDOW (window))) {
1680                 gboolean retval;
1681                 if (msg_window)
1682                         gtk_window_present (GTK_WINDOW (msg_window));
1683                 g_signal_emit_by_name (G_OBJECT (window), "delete-event", NULL, &retval);
1684                 return TRUE;
1685         }
1686
1687         /* Msg download completed */
1688         if (!(tny_header_get_flags (header) & TNY_HEADER_FLAG_CACHED)) {
1689                 /* Ask the user if he wants to download the message if
1690                    we're not online */
1691                 if (!tny_device_is_online (modest_runtime_get_device())) {
1692                         GtkResponseType response;
1693
1694                         response = modest_platform_run_confirmation_dialog (GTK_WINDOW (window),
1695                                                                             _("mcen_nc_get_msg"));
1696                         if (response == GTK_RESPONSE_CANCEL)
1697                                 return FALSE;
1698
1699                         folder = tny_header_get_folder (header);
1700                         info = g_slice_new (MsgReaderInfo);
1701                         info->header = g_object_ref (header);
1702                         info->row_reference = gtk_tree_row_reference_copy (row_reference);
1703
1704                         /* Offer the connection dialog if necessary */
1705                         modest_platform_connect_if_remote_and_perform ((GtkWindow *) window,
1706                                                                        TRUE,
1707                                                                        TNY_FOLDER_STORE (folder),
1708                                                                        message_reader_performer,
1709                                                                        info);
1710                         g_object_unref (folder);
1711                         return TRUE;
1712                 }
1713         }
1714
1715         folder = tny_header_get_folder (header);
1716         account = tny_folder_get_account (folder);
1717         info = g_slice_new (MsgReaderInfo);
1718         info->header = g_object_ref (header);
1719         info->row_reference = gtk_tree_row_reference_copy (row_reference);
1720
1721         message_reader_performer (FALSE, NULL, (GtkWindow *) window, account, info);
1722         g_object_unref (account);
1723         g_object_unref (folder);
1724
1725         return TRUE;
1726 }
1727
1728 gboolean
1729 modest_msg_view_window_select_next_message (ModestMsgViewWindow *window)
1730 {
1731         ModestMsgViewWindowPrivate *priv;
1732         GtkTreePath *path= NULL;
1733         GtkTreeIter tmp_iter;
1734         TnyHeader *header;
1735         gboolean retval = TRUE;
1736         GtkTreeRowReference *row_reference = NULL;
1737
1738         g_return_val_if_fail (MODEST_IS_MSG_VIEW_WINDOW (window), FALSE);
1739         priv = MODEST_MSG_VIEW_WINDOW_GET_PRIVATE (window);
1740
1741         if (!priv->row_reference)
1742                 return FALSE;
1743
1744         /* Update the next row reference if it's not valid. This could
1745            happen if for example the header which it was pointing to,
1746            was deleted. The best place to do it is in the row-deleted
1747            handler but the tinymail model do not work like the glib
1748            tree models and reports the deletion when the row is still
1749            there */
1750         if (!gtk_tree_row_reference_valid (priv->next_row_reference)) {
1751                 if (gtk_tree_row_reference_valid (priv->row_reference)) {
1752                         priv->next_row_reference = gtk_tree_row_reference_copy (priv->row_reference);
1753                         select_next_valid_row (priv->header_model, &(priv->next_row_reference), FALSE);
1754                 }
1755         }
1756         if (priv->next_row_reference)
1757                 path = gtk_tree_row_reference_get_path (priv->next_row_reference);
1758         if (path == NULL)
1759                 return FALSE;
1760
1761         row_reference = gtk_tree_row_reference_copy (priv->next_row_reference);
1762
1763         gtk_tree_model_get_iter (priv->header_model,
1764                                  &tmp_iter,
1765                                  path);
1766         gtk_tree_path_free (path);
1767
1768         gtk_tree_model_get (priv->header_model, &tmp_iter,
1769                             TNY_GTK_HEADER_LIST_MODEL_INSTANCE_COLUMN,
1770                             &header, -1);
1771
1772         /* Read the message & show it */
1773         if (!message_reader (window, priv, header, row_reference)) {
1774                 retval = FALSE;
1775         }
1776         gtk_tree_row_reference_free (row_reference);
1777
1778         /* Free */
1779         g_object_unref (header);
1780
1781         return retval;
1782 }
1783
1784 gboolean
1785 modest_msg_view_window_select_previous_message (ModestMsgViewWindow *window)
1786 {
1787         ModestMsgViewWindowPrivate *priv = NULL;
1788         GtkTreePath *path;
1789         gboolean finished = FALSE;
1790         gboolean retval = FALSE;
1791
1792         g_return_val_if_fail (MODEST_IS_MSG_VIEW_WINDOW (window), FALSE);
1793         priv = MODEST_MSG_VIEW_WINDOW_GET_PRIVATE (window);
1794
1795         /* Return inmediatly if there is no header model */
1796         if (!priv->header_model || !priv->row_reference)
1797                 return FALSE;
1798
1799         path = gtk_tree_row_reference_get_path (priv->row_reference);
1800         while (!finished && gtk_tree_path_prev (path)) {
1801                 TnyHeader *header;
1802                 GtkTreeIter iter;
1803
1804                 gtk_tree_model_get_iter (priv->header_model, &iter, path);
1805                 gtk_tree_model_get (priv->header_model, &iter,
1806                                     TNY_GTK_HEADER_LIST_MODEL_INSTANCE_COLUMN,
1807                                     &header, -1);
1808                 finished = TRUE;
1809                 if (header) {
1810                         if (msg_is_visible (header, priv->is_outbox)) {
1811                                 GtkTreeRowReference *row_reference;
1812                                 row_reference = gtk_tree_row_reference_new (priv->header_model, path);
1813                                 /* Read the message & show it */
1814                                 retval = message_reader (window, priv, header, row_reference);
1815                                 gtk_tree_row_reference_free (row_reference);
1816                         } else {
1817                                 finished = FALSE;
1818                         }
1819                         g_object_unref (header);
1820                 }
1821         }
1822
1823         gtk_tree_path_free (path);
1824         return retval;
1825 }
1826
1827 static void
1828 view_msg_cb (ModestMailOperation *mail_op,
1829              TnyHeader *header,
1830              gboolean canceled,
1831              TnyMsg *msg,
1832              GError *error,
1833              gpointer user_data)
1834 {
1835         ModestMsgViewWindow *self = NULL;
1836         ModestMsgViewWindowPrivate *priv = NULL;
1837         GtkTreeRowReference *row_reference = NULL;
1838
1839         /* Unregister the header (it was registered before creating the mail operation) */
1840         modest_window_mgr_unregister_header (modest_runtime_get_window_mgr (), header);
1841
1842         row_reference = (GtkTreeRowReference *) user_data;
1843         if (canceled) {
1844                 gtk_tree_row_reference_free (row_reference);
1845                 return;
1846         }
1847
1848         /* If there was any error */
1849         if (!modest_ui_actions_msg_retrieval_check (mail_op, header, msg)) {
1850                 gtk_tree_row_reference_free (row_reference);
1851                 return;
1852         }
1853
1854         /* Get the window */
1855         self = (ModestMsgViewWindow *) modest_mail_operation_get_source (mail_op);
1856         g_return_if_fail (MODEST_IS_MSG_VIEW_WINDOW (self));
1857         priv = MODEST_MSG_VIEW_WINDOW_GET_PRIVATE (self);
1858
1859         /* Update the row reference */
1860         if (priv->row_reference != NULL) {
1861                 gtk_tree_row_reference_free (priv->row_reference);
1862                 priv->row_reference = gtk_tree_row_reference_copy (row_reference);
1863                 if (priv->next_row_reference != NULL) {
1864                         gtk_tree_row_reference_free (priv->next_row_reference);
1865                 }
1866                 priv->next_row_reference = gtk_tree_row_reference_copy (priv->row_reference);
1867                 select_next_valid_row (priv->header_model, &(priv->next_row_reference), TRUE);
1868         }
1869
1870         /* Mark header as read */
1871         if (!(tny_header_get_flags (header) & TNY_HEADER_FLAG_SEEN))
1872                 tny_header_set_flag (header, TNY_HEADER_FLAG_SEEN);
1873
1874         /* Set new message */
1875         if (priv->msg_view != NULL && TNY_IS_MSG_VIEW (priv->msg_view)) {
1876                 tny_msg_view_set_msg (TNY_MSG_VIEW (priv->msg_view), msg);
1877                 modest_msg_view_window_update_priority (self);
1878                 update_window_title (MODEST_MSG_VIEW_WINDOW (self));
1879                 modest_msg_view_grab_focus (MODEST_MSG_VIEW (priv->msg_view));
1880         }
1881
1882         /* Set the new message uid of the window  */
1883         if (priv->msg_uid) {
1884                 g_free (priv->msg_uid);
1885                 priv->msg_uid = modest_tny_folder_get_header_unique_id (header);
1886         }
1887
1888         /* Notify the observers */
1889         g_signal_emit (G_OBJECT (self), signals[MSG_CHANGED_SIGNAL],
1890                        0, priv->header_model, priv->row_reference);
1891
1892         /* Frees */
1893         g_object_unref (self);
1894         gtk_tree_row_reference_free (row_reference);
1895 }
1896
1897 TnyFolderType
1898 modest_msg_view_window_get_folder_type (ModestMsgViewWindow *window)
1899 {
1900         ModestMsgViewWindowPrivate *priv;
1901         TnyMsg *msg;
1902         TnyFolderType folder_type;
1903
1904         priv = MODEST_MSG_VIEW_WINDOW_GET_PRIVATE (window);
1905
1906         folder_type = TNY_FOLDER_TYPE_UNKNOWN;
1907
1908         msg = tny_msg_view_get_msg (TNY_MSG_VIEW (priv->msg_view));
1909         if (msg) {
1910                 TnyFolder *folder;
1911
1912                 folder = tny_msg_get_folder (msg);
1913                 if (folder) {
1914                         folder_type = modest_tny_folder_guess_folder_type (folder);
1915                         g_object_unref (folder);
1916                 }
1917                 g_object_unref (msg);
1918         }
1919
1920         return folder_type;
1921 }
1922
1923
1924 static void
1925 modest_msg_view_window_update_priority (ModestMsgViewWindow *window)
1926 {
1927         ModestMsgViewWindowPrivate *priv;
1928         TnyHeader *header = NULL;
1929         TnyHeaderFlags flags = 0;
1930
1931         priv = MODEST_MSG_VIEW_WINDOW_GET_PRIVATE (window);
1932
1933         if (priv->header_model && priv->row_reference) {
1934                 GtkTreeIter iter;
1935                 GtkTreePath *path = NULL;
1936
1937                 path = gtk_tree_row_reference_get_path (priv->row_reference);
1938                 g_return_if_fail (path != NULL);
1939                 gtk_tree_model_get_iter (priv->header_model,
1940                                          &iter,
1941                                          gtk_tree_row_reference_get_path (priv->row_reference));
1942
1943                 gtk_tree_model_get (priv->header_model, &iter, TNY_GTK_HEADER_LIST_MODEL_INSTANCE_COLUMN,
1944                                     &header, -1);
1945                 gtk_tree_path_free (path);
1946         } else {
1947                 TnyMsg *msg;
1948                 msg = tny_msg_view_get_msg (TNY_MSG_VIEW (priv->msg_view));
1949                 if (msg) {
1950                         header = tny_msg_get_header (msg);
1951                         g_object_unref (msg);
1952                 }
1953         }
1954
1955         if (header) {
1956                 flags = tny_header_get_flags (header);
1957                 g_object_unref(G_OBJECT(header));
1958         }
1959
1960         modest_msg_view_set_priority (MODEST_MSG_VIEW(priv->msg_view), flags);
1961
1962 }
1963
1964 static void
1965 toolbar_resize (ModestMsgViewWindow *self)
1966 {
1967         ModestMsgViewWindowPrivate *priv = NULL;
1968         ModestWindowPrivate *parent_priv = NULL;
1969         GtkWidget *widget;
1970         gint static_button_size;
1971         ModestWindowMgr *mgr;
1972
1973         g_return_if_fail (MODEST_IS_MSG_VIEW_WINDOW (self));
1974         priv = MODEST_MSG_VIEW_WINDOW_GET_PRIVATE (self);
1975         parent_priv = MODEST_WINDOW_GET_PRIVATE(self);
1976
1977         mgr = modest_runtime_get_window_mgr ();
1978         static_button_size = modest_window_mgr_get_fullscreen_mode (mgr)?118:108;
1979
1980         if (parent_priv->toolbar) {
1981                 /* left size buttons */
1982                 widget = gtk_ui_manager_get_widget (parent_priv->ui_manager, "/ToolBar/ToolbarMessageReply");
1983                 gtk_tool_item_set_expand (GTK_TOOL_ITEM (widget), FALSE);
1984                 gtk_tool_item_set_homogeneous (GTK_TOOL_ITEM (widget), FALSE);
1985                 gtk_widget_set_size_request (GTK_WIDGET (widget), static_button_size, -1);
1986                 widget = gtk_ui_manager_get_widget (parent_priv->ui_manager, "/ToolBar/ToolbarMessageMoveTo");
1987                 gtk_tool_item_set_expand (GTK_TOOL_ITEM (widget), FALSE);
1988                 gtk_tool_item_set_homogeneous (GTK_TOOL_ITEM (widget), FALSE);
1989                 gtk_widget_set_size_request (GTK_WIDGET (widget), static_button_size, -1);
1990                 widget = gtk_ui_manager_get_widget (parent_priv->ui_manager, "/ToolBar/ToolbarDeleteMessage");
1991                 gtk_tool_item_set_expand (GTK_TOOL_ITEM (widget), FALSE);
1992                 gtk_tool_item_set_homogeneous (GTK_TOOL_ITEM (widget), FALSE);
1993                 gtk_widget_set_size_request (GTK_WIDGET (widget), static_button_size, -1);
1994                 widget = gtk_ui_manager_get_widget (parent_priv->ui_manager, "/ToolBar/FindInMessage");
1995                 gtk_tool_item_set_expand (GTK_TOOL_ITEM (widget), FALSE);
1996                 gtk_tool_item_set_homogeneous (GTK_TOOL_ITEM (widget), FALSE);
1997                 gtk_widget_set_size_request (GTK_WIDGET (widget), static_button_size, -1);
1998
1999                 gtk_tool_item_set_homogeneous (GTK_TOOL_ITEM (priv->progress_toolitem), FALSE);
2000                 gtk_tool_item_set_expand (GTK_TOOL_ITEM (priv->progress_toolitem), TRUE);
2001                 gtk_tool_item_set_homogeneous (GTK_TOOL_ITEM (priv->cancel_toolitem), FALSE);
2002                 gtk_tool_item_set_expand (GTK_TOOL_ITEM (priv->cancel_toolitem), FALSE);
2003                 gtk_tool_item_set_homogeneous (GTK_TOOL_ITEM (priv->next_toolitem), TRUE);
2004                 gtk_tool_item_set_expand (GTK_TOOL_ITEM (priv->next_toolitem), TRUE);
2005                 gtk_tool_item_set_homogeneous (GTK_TOOL_ITEM (priv->prev_toolitem), TRUE);
2006                 gtk_tool_item_set_expand (GTK_TOOL_ITEM (priv->prev_toolitem), TRUE);
2007         }
2008
2009 }
2010
2011 static gboolean
2012 modest_msg_view_window_window_state_event (GtkWidget *widget, GdkEventWindowState *event, gpointer userdata)
2013 {
2014         if (event->changed_mask & GDK_WINDOW_STATE_FULLSCREEN) {
2015                 ModestWindowPrivate *parent_priv;
2016                 ModestWindowMgr *mgr;
2017                 gboolean is_fullscreen;
2018                 GtkAction *fs_toggle_action;
2019                 gboolean active;
2020
2021                 mgr = modest_runtime_get_window_mgr ();
2022                 is_fullscreen = (modest_window_mgr_get_fullscreen_mode (mgr))?1:0;
2023
2024                 parent_priv = MODEST_WINDOW_GET_PRIVATE (widget);
2025
2026                 fs_toggle_action = gtk_ui_manager_get_action (parent_priv->ui_manager, "/MenuBar/ViewMenu/ViewToggleFullscreenMenu");
2027                 active = (gtk_toggle_action_get_active (GTK_TOGGLE_ACTION (fs_toggle_action)))?1:0;
2028                 if (is_fullscreen != active) {
2029                         gtk_toggle_action_set_active (GTK_TOGGLE_ACTION (fs_toggle_action), is_fullscreen);
2030                 }
2031                 toolbar_resize (MODEST_MSG_VIEW_WINDOW (widget));
2032         }
2033
2034         return FALSE;
2035
2036 }
2037
2038 static void
2039 modest_msg_view_window_show_toolbar (ModestWindow *self,
2040                                      gboolean show_toolbar)
2041 {
2042         ModestMsgViewWindowPrivate *priv = NULL;
2043         ModestWindowPrivate *parent_priv;
2044         GtkWidget *reply_button = NULL, *menu = NULL;
2045         GtkWidget *placeholder = NULL;
2046         gint insert_index;
2047         const gchar *action_name;
2048         GtkAction *action;
2049
2050         parent_priv = MODEST_WINDOW_GET_PRIVATE(self);
2051         priv = MODEST_MSG_VIEW_WINDOW_GET_PRIVATE(self);
2052
2053         /* Set optimized view status */
2054         priv->optimized_view = !show_toolbar;
2055
2056         if (!parent_priv->toolbar) {
2057                 parent_priv->toolbar = gtk_ui_manager_get_widget (parent_priv->ui_manager,
2058                                                                   "/ToolBar");
2059                 gtk_widget_set_no_show_all (parent_priv->toolbar, TRUE);
2060
2061                 priv->progress_toolitem = GTK_WIDGET (gtk_tool_item_new ());
2062                 priv->cancel_toolitem = gtk_ui_manager_get_widget (parent_priv->ui_manager, "/ToolBar/ToolbarCancel");
2063                 priv->next_toolitem = gtk_ui_manager_get_widget (parent_priv->ui_manager, "/ToolBar/ToolbarMessageNext");
2064                 priv->prev_toolitem = gtk_ui_manager_get_widget (parent_priv->ui_manager, "/ToolBar/ToolbarMessageBack");
2065                 toolbar_resize (MODEST_MSG_VIEW_WINDOW (self));
2066
2067                 /* Add ProgressBar (Transfer toolbar) */
2068                 priv->progress_bar = modest_progress_bar_new ();
2069                 gtk_widget_set_no_show_all (priv->progress_bar, TRUE);
2070                 placeholder = gtk_ui_manager_get_widget (parent_priv->ui_manager, "/ToolBar/ProgressbarView");
2071                 insert_index = gtk_toolbar_get_item_index(GTK_TOOLBAR (parent_priv->toolbar), GTK_TOOL_ITEM(placeholder));
2072                 gtk_container_add (GTK_CONTAINER (priv->progress_toolitem), priv->progress_bar);
2073                 gtk_toolbar_insert(GTK_TOOLBAR(parent_priv->toolbar), GTK_TOOL_ITEM (priv->progress_toolitem), insert_index);
2074
2075                 /* Connect cancel 'clicked' signal to abort progress mode */
2076                 g_signal_connect(priv->cancel_toolitem, "clicked",
2077                                  G_CALLBACK(cancel_progressbar),
2078                                  self);
2079
2080                 /* Add it to the observers list */
2081                 priv->progress_widgets = g_slist_prepend(priv->progress_widgets, priv->progress_bar);
2082
2083                 /* Add to window */
2084                 hildon_window_add_toolbar (HILDON_WINDOW (self),
2085                                            GTK_TOOLBAR (parent_priv->toolbar));
2086
2087                 /* Set reply button tap and hold menu */
2088                 reply_button = gtk_ui_manager_get_widget (parent_priv->ui_manager,
2089                                                           "/ToolBar/ToolbarMessageReply");
2090                 menu = gtk_ui_manager_get_widget (parent_priv->ui_manager,
2091                                                   "/ToolbarReplyCSM");
2092                 gtk_widget_tap_and_hold_setup (GTK_WIDGET (reply_button), menu, NULL, 0);
2093         }
2094
2095         if (show_toolbar) {
2096                 /* Quick hack: this prevents toolbar icons "dance" when progress bar show status is changed */
2097                 /* TODO: resize mode migth be GTK_RESIZE_QUEUE, in order to avoid unneccesary shows */
2098                 gtk_container_set_resize_mode (GTK_CONTAINER(parent_priv->toolbar), GTK_RESIZE_IMMEDIATE);
2099
2100                 gtk_widget_show (GTK_WIDGET (parent_priv->toolbar));
2101                 if (modest_msg_view_window_transfer_mode_enabled (MODEST_MSG_VIEW_WINDOW (self)))
2102                         set_toolbar_mode (MODEST_MSG_VIEW_WINDOW (self), TOOLBAR_MODE_TRANSFER);
2103                 else
2104                         set_toolbar_mode (MODEST_MSG_VIEW_WINDOW (self), TOOLBAR_MODE_NORMAL);
2105
2106         } else {
2107                 gtk_widget_set_no_show_all (parent_priv->toolbar, TRUE);
2108                 gtk_widget_hide (GTK_WIDGET (parent_priv->toolbar));
2109         }
2110
2111         /* Update also the actions (to update the toggles in the
2112            menus), we have to do it manually because some other window
2113            of the same time could have changed it (remember that the
2114            toolbar fullscreen mode is shared by all the windows of the
2115            same type */
2116         if (modest_window_mgr_get_fullscreen_mode (modest_runtime_get_window_mgr ()))
2117                 action_name = "/MenuBar/ViewMenu/ViewShowToolbarMenu/ViewShowToolbarFullScreenMenu";
2118         else
2119                 action_name = "/MenuBar/ViewMenu/ViewShowToolbarMenu/ViewShowToolbarNormalScreenMenu";
2120
2121         action = gtk_ui_manager_get_action (parent_priv->ui_manager, action_name);
2122         modest_utils_toggle_action_set_active_block_notify (GTK_TOGGLE_ACTION (action),
2123                                                             show_toolbar);
2124 }
2125
2126 static void
2127 modest_msg_view_window_clipboard_owner_change (GtkClipboard *clipboard,
2128                                                GdkEvent *event,
2129                                                ModestMsgViewWindow *window)
2130 {
2131         if (!GTK_WIDGET_VISIBLE (window))
2132                 return;
2133
2134         modest_window_check_dimming_rules_group (MODEST_WINDOW (window), MODEST_DIMMING_RULES_CLIPBOARD);
2135 }
2136
2137 gboolean
2138 modest_msg_view_window_transfer_mode_enabled (ModestMsgViewWindow *self)
2139 {
2140         ModestMsgViewWindowPrivate *priv;
2141
2142         g_return_val_if_fail (MODEST_IS_MSG_VIEW_WINDOW (self), FALSE);
2143         priv = MODEST_MSG_VIEW_WINDOW_GET_PRIVATE(self);
2144
2145         return priv->current_toolbar_mode == TOOLBAR_MODE_TRANSFER;
2146 }
2147
2148 static void
2149 cancel_progressbar (GtkToolButton *toolbutton,
2150                     ModestMsgViewWindow *self)
2151 {
2152         GSList *tmp;
2153         ModestMsgViewWindowPrivate *priv;
2154
2155         priv = MODEST_MSG_VIEW_WINDOW_GET_PRIVATE(self);
2156
2157         /* Get operation observers and cancel its current operation */
2158         tmp = priv->progress_widgets;
2159         while (tmp) {
2160                 modest_progress_object_cancel_current_operation (MODEST_PROGRESS_OBJECT(tmp->data));
2161                 tmp=g_slist_next(tmp);
2162         }
2163 }
2164 static gboolean
2165 observers_empty (ModestMsgViewWindow *self)
2166 {
2167         GSList *tmp = NULL;
2168         ModestMsgViewWindowPrivate *priv;
2169         gboolean is_empty = TRUE;
2170         guint pending_ops = 0;
2171
2172         priv = MODEST_MSG_VIEW_WINDOW_GET_PRIVATE(self);
2173         tmp = priv->progress_widgets;
2174
2175         /* Check all observers */
2176         while (tmp && is_empty)  {
2177                 pending_ops = modest_progress_object_num_pending_operations (MODEST_PROGRESS_OBJECT(tmp->data));
2178                 is_empty = pending_ops == 0;
2179
2180                 tmp = g_slist_next(tmp);
2181         }
2182
2183         return is_empty;
2184 }
2185
2186 static void
2187 on_account_removed (TnyAccountStore *account_store,
2188                     TnyAccount *account,
2189                     gpointer user_data)
2190 {
2191         /* Do nothing if it's a transport account, because we only
2192            show the messages of a store account */
2193         if (tny_account_get_account_type(account) == TNY_ACCOUNT_TYPE_STORE) {
2194                 const gchar *parent_acc = NULL;
2195                 const gchar *our_acc = NULL;
2196
2197                 our_acc = modest_window_get_active_account (MODEST_WINDOW (user_data));
2198                 parent_acc = modest_tny_account_get_parent_modest_account_name_for_server_account (account);
2199
2200                 /* Close this window if I'm showing a message of the removed account */
2201                 if (strcmp (parent_acc, our_acc) == 0)
2202                         modest_ui_actions_on_close_window (NULL, MODEST_WINDOW (user_data));
2203         }
2204 }
2205
2206 static void
2207 on_mail_operation_started (ModestMailOperation *mail_op,
2208                            gpointer user_data)
2209 {
2210         ModestMsgViewWindow *self;
2211         ModestMailOperationTypeOperation op_type;
2212         GSList *tmp;
2213         ModestMsgViewWindowPrivate *priv;
2214         GObject *source = NULL;
2215
2216         self = MODEST_MSG_VIEW_WINDOW (user_data);
2217         priv = MODEST_MSG_VIEW_WINDOW_GET_PRIVATE (self);
2218         op_type = modest_mail_operation_get_type_operation (mail_op);
2219         tmp = priv->progress_widgets;
2220         source = modest_mail_operation_get_source(mail_op);
2221         if (G_OBJECT (self) == source) {
2222                 if (op_type == MODEST_MAIL_OPERATION_TYPE_RECEIVE || op_type == MODEST_MAIL_OPERATION_TYPE_OPEN ) {
2223                         set_toolbar_transfer_mode(self);
2224                         while (tmp) {
2225                                 modest_progress_object_add_operation (
2226                                                 MODEST_PROGRESS_OBJECT (tmp->data),
2227                                                 mail_op);
2228                                 tmp = g_slist_next (tmp);
2229                         }
2230                 }
2231         }
2232         g_object_unref (source);
2233 }
2234
2235 static void
2236 on_mail_operation_finished (ModestMailOperation *mail_op,
2237                             gpointer user_data)
2238 {
2239         ModestMsgViewWindow *self;
2240         ModestMailOperationTypeOperation op_type;
2241         GSList *tmp;
2242         ModestMsgViewWindowPrivate *priv;
2243
2244         self = MODEST_MSG_VIEW_WINDOW (user_data);
2245         priv = MODEST_MSG_VIEW_WINDOW_GET_PRIVATE (self);
2246         op_type = modest_mail_operation_get_type_operation (mail_op);
2247         tmp = priv->progress_widgets;
2248
2249         if (op_type == MODEST_MAIL_OPERATION_TYPE_RECEIVE || op_type == MODEST_MAIL_OPERATION_TYPE_OPEN ) {
2250                 while (tmp) {
2251                         modest_progress_object_remove_operation (MODEST_PROGRESS_OBJECT (tmp->data),
2252                                                                  mail_op);
2253                         tmp = g_slist_next (tmp);
2254                 }
2255
2256                 /* If no more operations are being observed, NORMAL mode is enabled again */
2257                 if (observers_empty (self)) {
2258                         set_toolbar_mode (self, TOOLBAR_MODE_NORMAL);
2259                 }
2260
2261                 /* Update dimming rules. We have to do this right here
2262                    and not in view_msg_cb because at that point the
2263                    transfer mode is still enabled so the dimming rule
2264                    won't let the user delete the message that has been
2265                    readed for example */
2266                 modest_ui_actions_check_toolbar_dimming_rules (MODEST_WINDOW (self));
2267                 modest_ui_actions_check_menu_dimming_rules (MODEST_WINDOW (self));
2268         }
2269 }
2270
2271 static void
2272 on_queue_changed (ModestMailOperationQueue *queue,
2273                   ModestMailOperation *mail_op,
2274                   ModestMailOperationQueueNotification type,
2275                   ModestMsgViewWindow *self)
2276 {
2277         ModestMsgViewWindowPrivate *priv;
2278
2279         priv = MODEST_MSG_VIEW_WINDOW_GET_PRIVATE (self);
2280
2281         /* If this operations was created by another window, do nothing */
2282         if (!modest_mail_operation_is_mine (mail_op, G_OBJECT(self)))
2283             return;
2284
2285         if (type == MODEST_MAIL_OPERATION_QUEUE_OPERATION_ADDED) {
2286                 priv->sighandlers = modest_signal_mgr_connect (priv->sighandlers,
2287                                                                G_OBJECT (mail_op),
2288                                                                "operation-started",
2289                                                                G_CALLBACK (on_mail_operation_started),
2290                                                                self);
2291                 priv->sighandlers = modest_signal_mgr_connect (priv->sighandlers,
2292                                                                G_OBJECT (mail_op),
2293                                                                "operation-finished",
2294                                                                G_CALLBACK (on_mail_operation_finished),
2295                                                                self);
2296         } else if (type == MODEST_MAIL_OPERATION_QUEUE_OPERATION_REMOVED) {
2297                 priv->sighandlers = modest_signal_mgr_disconnect (priv->sighandlers,
2298                                                                   G_OBJECT (mail_op),
2299                                                                   "operation-started");
2300                 priv->sighandlers = modest_signal_mgr_disconnect (priv->sighandlers,
2301                                                                   G_OBJECT (mail_op),
2302                                                                   "operation-finished");
2303         }
2304 }
2305
2306 TnyList *
2307 modest_msg_view_window_get_attachments (ModestMsgViewWindow *win)
2308 {
2309         ModestMsgViewWindowPrivate *priv;
2310         TnyList *selected_attachments = NULL;
2311
2312         g_return_val_if_fail (MODEST_IS_MSG_VIEW_WINDOW (win), NULL);
2313         priv = MODEST_MSG_VIEW_WINDOW_GET_PRIVATE (win);
2314
2315         selected_attachments = modest_msg_view_get_selected_attachments (MODEST_MSG_VIEW (priv->msg_view));
2316
2317         return selected_attachments;
2318 }
2319
2320 void
2321 modest_msg_view_window_view_attachment (ModestMsgViewWindow *window, TnyMimePart *mime_part)
2322 {
2323         ModestMsgViewWindowPrivate *priv;
2324         const gchar *msg_uid;
2325         gchar *attachment_uid = NULL;
2326         gint attachment_index = 0;
2327         TnyList *attachments;
2328
2329         g_return_if_fail (MODEST_IS_MSG_VIEW_WINDOW (window));
2330         g_return_if_fail (TNY_IS_MIME_PART (mime_part) || (mime_part == NULL));
2331         priv = MODEST_MSG_VIEW_WINDOW_GET_PRIVATE (window);
2332
2333         msg_uid = modest_msg_view_window_get_message_uid (MODEST_MSG_VIEW_WINDOW (window));
2334         attachments = modest_msg_view_get_attachments (MODEST_MSG_VIEW (priv->msg_view));
2335         attachment_index = modest_list_index (attachments, (GObject *) mime_part);
2336         g_object_unref (attachments);
2337
2338         if (msg_uid && attachment_index >= 0) {
2339                 attachment_uid = g_strdup_printf ("%s/%d", msg_uid, attachment_index);
2340         }
2341
2342         if (mime_part == NULL) {
2343                 gboolean error = FALSE;
2344                 TnyList *selected_attachments = modest_msg_view_get_selected_attachments (MODEST_MSG_VIEW (priv->msg_view));
2345                 if (selected_attachments == NULL || tny_list_get_length (selected_attachments) == 0) {
2346                         error = TRUE;
2347                 } else if (tny_list_get_length (selected_attachments) > 1) {
2348                         hildon_banner_show_information (NULL, NULL, _("mcen_ib_unable_to_display_more"));
2349                         error = TRUE;
2350                 } else {
2351                         TnyIterator *iter;
2352                         iter = tny_list_create_iterator (selected_attachments);
2353                         mime_part = (TnyMimePart *) tny_iterator_get_current (iter);
2354                         g_object_unref (iter);
2355                 }
2356                 g_object_unref (selected_attachments);
2357
2358                 if (error)
2359                         return;
2360         } else {
2361                 g_object_ref (mime_part);
2362         }
2363
2364         if (tny_mime_part_is_purged (mime_part)) {
2365                 g_object_unref (mime_part);
2366                 return;
2367         }
2368
2369         if (!modest_tny_mime_part_is_msg (mime_part)) {
2370                 gchar *filepath = NULL;
2371                 const gchar *att_filename = tny_mime_part_get_filename (mime_part);
2372                 const gchar *content_type;
2373                 gboolean show_error_banner = FALSE;
2374                 GError *err;
2375                 TnyFsStream *temp_stream = NULL;
2376                 temp_stream = modest_utils_create_temp_stream (att_filename, attachment_uid,
2377                                                                &filepath);
2378
2379                 if (temp_stream != NULL) {
2380                         content_type = tny_mime_part_get_content_type (mime_part);
2381                         if (tny_mime_part_decode_to_stream (mime_part, TNY_STREAM (temp_stream), &err) >= 0) {
2382                                 /* make the file read-only */
2383                                 if (g_chmod(filepath, 0444) != 0)
2384                                         g_warning ("%s: failed to set file '%s' to read-only: %s",
2385                                                         __FUNCTION__, filepath, strerror(errno));
2386
2387                                 modest_platform_activate_file (filepath, content_type);
2388                         } else {
2389                                 /* error while saving attachment, maybe cerm_device_memory_full */
2390                                 show_error_banner = TRUE;
2391                                 if (err != NULL) {
2392                                         g_warning ("%s: tny_mime_part_decode_to_stream failed (%s)", __FUNCTION__, err->message);
2393                                         g_error_free (err);
2394                                 }
2395                         }
2396                         g_object_unref (temp_stream);
2397                         g_free (filepath);
2398                         /* NOTE: files in the temporary area will be automatically
2399                          * cleaned after some time if they are no longer in use */
2400                 } else {
2401                         if (filepath != NULL) {
2402                                 /* the file may already exist but it isn't writable,
2403                                  * let's try to open it anyway */
2404                                 content_type = tny_mime_part_get_content_type (mime_part);
2405                                 modest_platform_activate_file (filepath, content_type);
2406                                 g_free (filepath);
2407                         } else {
2408                                 g_warning ("%s: modest_utils_create_temp_stream failed", __FUNCTION__);
2409                                 show_error_banner = TRUE;
2410                         }
2411                 }
2412                 if (show_error_banner)
2413                         modest_platform_information_banner (NULL, NULL, _("mail_ib_file_operation_failed"));
2414         } else {
2415                 /* message attachment */
2416                 TnyHeader *header = NULL;
2417                 ModestWindowMgr *mgr;
2418                 ModestWindow *msg_win = NULL;
2419                 gboolean found;
2420
2421                 header = tny_msg_get_header (TNY_MSG (mime_part));
2422                 mgr = modest_runtime_get_window_mgr ();
2423                 found = modest_window_mgr_find_registered_header (mgr, header, &msg_win);
2424
2425                 if (found) {
2426                         if (msg_win)                            /* there is already a window for this uid; top it */
2427                                 gtk_window_present (GTK_WINDOW(msg_win));
2428                         else
2429                                 /* if it's found, but there is no msg_win, it's probably in the process of being created;
2430                                  * thus, we don't do anything */
2431                                 g_warning ("window for is already being created");
2432                 } else {
2433                         /* it's not found, so create a new window for it */
2434                         modest_window_mgr_register_header (mgr, header, attachment_uid); /* register the uid before building the window */
2435                         gchar *account = g_strdup (modest_window_get_active_account (MODEST_WINDOW (window)));
2436                         if (!account)
2437                                 account = modest_account_mgr_get_default_account (modest_runtime_get_account_mgr ());
2438                         msg_win = modest_msg_view_window_new_for_attachment (TNY_MSG (mime_part), account, attachment_uid);
2439                         modest_window_set_zoom (MODEST_WINDOW (msg_win),
2440                                                 modest_window_get_zoom (MODEST_WINDOW (window)));
2441                         modest_window_mgr_register_window (mgr, msg_win);
2442                         gtk_widget_show_all (GTK_WIDGET (msg_win));
2443                 }
2444         }
2445         g_object_unref (mime_part);
2446 }
2447
2448 typedef struct
2449 {
2450         gchar *filename;
2451         TnyMimePart *part;
2452 } SaveMimePartPair;
2453
2454 typedef struct
2455 {
2456         GList *pairs;
2457         GtkWidget *banner;
2458         GnomeVFSResult result;
2459 } SaveMimePartInfo;
2460
2461 static void save_mime_part_info_free (SaveMimePartInfo *info, gboolean with_struct);
2462 static gboolean idle_save_mime_part_show_result (SaveMimePartInfo *info);
2463 static gpointer save_mime_part_to_file (SaveMimePartInfo *info);
2464 static void save_mime_parts_to_file_with_checks (SaveMimePartInfo *info);
2465
2466 static void
2467 save_mime_part_info_free (SaveMimePartInfo *info, gboolean with_struct)
2468 {
2469
2470         GList *node;
2471         for (node = info->pairs; node != NULL; node = g_list_next (node)) {
2472                 SaveMimePartPair *pair = (SaveMimePartPair *) node->data;
2473                 g_free (pair->filename);
2474                 g_object_unref (pair->part);
2475                 g_slice_free (SaveMimePartPair, pair);
2476         }
2477         g_list_free (info->pairs);
2478         info->pairs = NULL;
2479         if (with_struct) {
2480                 gtk_widget_destroy (info->banner);
2481                 g_slice_free (SaveMimePartInfo, info);
2482         }
2483 }
2484
2485 static gboolean
2486 idle_save_mime_part_show_result (SaveMimePartInfo *info)
2487 {
2488         if (info->pairs != NULL) {
2489                 save_mime_part_to_file (info);
2490         } else {
2491                 /* This is a GDK lock because we are an idle callback and
2492                  * hildon_banner_show_information is or does Gtk+ code */
2493
2494                 gdk_threads_enter (); /* CHECKED */
2495                 save_mime_part_info_free (info, TRUE);
2496                 if (info->result == GNOME_VFS_OK) {
2497                         hildon_banner_show_information (NULL, NULL, _CS("sfil_ib_saved"));
2498                 } else if (info->result == GNOME_VFS_ERROR_NO_SPACE) {
2499                         hildon_banner_show_information (NULL, NULL, dgettext("ke-recv",
2500                                                                              "cerm_device_memory_full"));
2501                 } else {
2502                         hildon_banner_show_information (NULL, NULL, _("mail_ib_file_operation_failed"));
2503                 }
2504                 gdk_threads_leave (); /* CHECKED */
2505         }
2506
2507         return FALSE;
2508 }
2509
2510 static gpointer
2511 save_mime_part_to_file (SaveMimePartInfo *info)
2512 {
2513         GnomeVFSHandle *handle;
2514         TnyStream *stream;
2515         SaveMimePartPair *pair = (SaveMimePartPair *) info->pairs->data;
2516
2517         info->result = gnome_vfs_create (&handle, pair->filename, GNOME_VFS_OPEN_WRITE, FALSE, 0644);
2518         if (info->result == GNOME_VFS_OK) {
2519                 stream = tny_vfs_stream_new (handle);
2520                 if (tny_mime_part_decode_to_stream (pair->part, stream, NULL) < 0) {
2521                         info->result = GNOME_VFS_ERROR_IO;
2522                 }
2523                 g_object_unref (G_OBJECT (stream));
2524                 g_object_unref (pair->part);
2525                 g_slice_free (SaveMimePartPair, pair);
2526                 info->pairs = g_list_delete_link (info->pairs, info->pairs);
2527         } else {
2528                 save_mime_part_info_free (info, FALSE);
2529         }
2530
2531         g_idle_add ((GSourceFunc) idle_save_mime_part_show_result, info);
2532         return NULL;
2533 }
2534
2535 static void
2536 save_mime_parts_to_file_with_checks (SaveMimePartInfo *info)
2537 {
2538         gboolean is_ok = TRUE;
2539         gint replaced_files = 0;
2540         const GList *files = info->pairs;
2541         const GList *iter;
2542
2543         for (iter = files; (iter != NULL) && (replaced_files < 2); iter = g_list_next(iter)) {
2544                 SaveMimePartPair *pair = iter->data;
2545                 if (modest_utils_file_exists (pair->filename)) {
2546                         replaced_files++;
2547                 }
2548         }
2549         if (replaced_files) {
2550                 GtkWidget *confirm_overwrite_dialog;
2551                 const gchar *message = (replaced_files == 1) ?
2552                         _FM("docm_nc_replace_file") : _FM("docm_nc_replace_multiple");
2553                 confirm_overwrite_dialog = hildon_note_new_confirmation (NULL, message);
2554                 if (gtk_dialog_run (GTK_DIALOG (confirm_overwrite_dialog)) != GTK_RESPONSE_OK) {
2555                         is_ok = FALSE;
2556                 }
2557                 gtk_widget_destroy (confirm_overwrite_dialog);
2558         }
2559
2560         if (!is_ok) {
2561                 save_mime_part_info_free (info, TRUE);
2562         } else {
2563                 GtkWidget *banner = hildon_banner_show_animation (NULL, NULL,
2564                                                                   _CS("sfil_ib_saving"));
2565                 info->banner = banner;
2566                 g_thread_create ((GThreadFunc)save_mime_part_to_file, info, FALSE, NULL);
2567         }
2568
2569 }
2570
2571
2572 void
2573 modest_msg_view_window_save_attachments (ModestMsgViewWindow *window, TnyList *mime_parts)
2574 {
2575         ModestMsgViewWindowPrivate *priv;
2576         GList *files_to_save = NULL;
2577         GtkWidget *save_dialog = NULL;
2578         gchar *folder = NULL;
2579         const gchar *filename = NULL;
2580         gchar *save_multiple_str = NULL;
2581
2582         g_return_if_fail (MODEST_IS_MSG_VIEW_WINDOW (window));
2583         priv = MODEST_MSG_VIEW_WINDOW_GET_PRIVATE (window);
2584
2585         if (mime_parts == NULL) {
2586                 mime_parts = modest_msg_view_get_selected_attachments (MODEST_MSG_VIEW (priv->msg_view));
2587                 if (mime_parts == NULL || tny_list_get_length (mime_parts) == 0)
2588                         return;
2589         } else {
2590                 g_object_ref (mime_parts);
2591         }
2592
2593         /* prepare dialog */
2594         if (tny_list_get_length (mime_parts) == 1) {
2595                 TnyIterator *iter;
2596                 /* only one attachment selected */
2597                 iter = tny_list_create_iterator (mime_parts);
2598                 TnyMimePart *mime_part = (TnyMimePart *) tny_iterator_get_current (iter);
2599                 g_object_unref (iter);
2600                 if (!modest_tny_mime_part_is_msg (mime_part) &&
2601                     modest_tny_mime_part_is_attachment_for_modest (mime_part) &&
2602                     !tny_mime_part_is_purged (mime_part)) {
2603                         filename = tny_mime_part_get_filename (mime_part);
2604                 } else {
2605                         /* TODO: show any error? */
2606                         g_warning ("Tried to save a non-file attachment");
2607                         g_object_unref (mime_parts);
2608                         return;
2609                 }
2610                 g_object_unref (mime_part);
2611         } else {
2612                 save_multiple_str = g_strdup_printf (_FM("sfil_va_number_of_objects_attachments"),
2613                                                      tny_list_get_length (mime_parts));
2614         }
2615
2616         save_dialog = hildon_file_chooser_dialog_new (GTK_WINDOW (window),
2617                                                       GTK_FILE_CHOOSER_ACTION_SAVE);
2618
2619         /* set folder */
2620         folder = g_build_filename (g_get_home_dir (), DEFAULT_FOLDER, NULL);
2621         gtk_file_chooser_set_current_folder (GTK_FILE_CHOOSER (save_dialog), folder);
2622         g_free (folder);
2623
2624         /* set filename */
2625         if (filename != NULL)
2626                 gtk_file_chooser_set_current_name (GTK_FILE_CHOOSER (save_dialog),
2627                                                    filename);
2628
2629         /* if multiple, set multiple string */
2630         if (save_multiple_str) {
2631                 g_object_set (G_OBJECT (save_dialog), "save-multiple", save_multiple_str, NULL);
2632                 gtk_window_set_title (GTK_WINDOW (save_dialog), _FM("sfil_ti_save_objects_files"));
2633         }
2634
2635         /* show dialog */
2636         if (gtk_dialog_run (GTK_DIALOG (save_dialog)) == GTK_RESPONSE_OK) {
2637                 gchar *chooser_uri = gtk_file_chooser_get_uri (GTK_FILE_CHOOSER (save_dialog));
2638
2639                 if (!modest_utils_folder_writable (chooser_uri)) {
2640                         hildon_banner_show_information
2641                                 (NULL, NULL, dgettext("hildon-fm", "sfil_ib_readonly_location"));
2642                 } else {
2643                         TnyIterator *iter;
2644
2645                         iter = tny_list_create_iterator (mime_parts);
2646                         while (!tny_iterator_is_done (iter)) {
2647                                 TnyMimePart *mime_part = (TnyMimePart *) tny_iterator_get_current (iter);
2648
2649                                 if ((modest_tny_mime_part_is_attachment_for_modest (mime_part)) &&
2650                                     !tny_mime_part_is_purged (mime_part) &&
2651                                     (tny_mime_part_get_filename (mime_part) != NULL)) {
2652                                         SaveMimePartPair *pair;
2653
2654                                         pair = g_slice_new0 (SaveMimePartPair);
2655                                         if (save_multiple_str) {
2656                                                 gchar *escaped = gnome_vfs_escape_slashes (
2657                                                         tny_mime_part_get_filename (mime_part));
2658                                                 pair->filename = g_build_filename (chooser_uri, escaped, NULL);
2659                                                 g_free (escaped);
2660                                         } else {
2661                                                 pair->filename = g_strdup (chooser_uri);
2662                                         }
2663                                         pair->part = mime_part;
2664                                         files_to_save = g_list_prepend (files_to_save, pair);
2665                                 }
2666                                 tny_iterator_next (iter);
2667                         }
2668                         g_object_unref (iter);
2669                 }
2670                 g_free (chooser_uri);
2671         }
2672
2673         gtk_widget_destroy (save_dialog);
2674
2675         g_object_unref (mime_parts);
2676
2677         if (files_to_save != NULL) {
2678                 SaveMimePartInfo *info = g_slice_new0 (SaveMimePartInfo);
2679                 info->pairs = files_to_save;
2680                 info->result = TRUE;
2681                 save_mime_parts_to_file_with_checks (info);
2682         }
2683 }
2684
2685 static gboolean
2686 show_remove_attachment_information (gpointer userdata)
2687 {
2688         ModestMsgViewWindow *window = (ModestMsgViewWindow *) userdata;
2689         ModestMsgViewWindowPrivate *priv = MODEST_MSG_VIEW_WINDOW_GET_PRIVATE (window);
2690
2691         /* We're outside the main lock */
2692         gdk_threads_enter ();
2693
2694         if (priv->remove_attachment_banner != NULL) {
2695                 gtk_widget_destroy (priv->remove_attachment_banner);
2696                 g_object_unref (priv->remove_attachment_banner);
2697         }
2698
2699         priv->remove_attachment_banner = g_object_ref (
2700                 hildon_banner_show_animation (NULL, NULL, _("mcen_ib_removing_attachment")));
2701
2702         gdk_threads_leave ();
2703
2704         return FALSE;
2705 }
2706
2707 void
2708 modest_msg_view_window_remove_attachments (ModestMsgViewWindow *window, gboolean get_all)
2709 {
2710         ModestMsgViewWindowPrivate *priv;
2711         TnyList *mime_parts = NULL;
2712         gchar *confirmation_message;
2713         gint response;
2714         gint n_attachments;
2715         TnyMsg *msg;
2716         TnyIterator *iter;
2717 /*      TnyFolder *folder; */
2718
2719         g_return_if_fail (MODEST_IS_MSG_VIEW_WINDOW (window));
2720         priv = MODEST_MSG_VIEW_WINDOW_GET_PRIVATE (window);
2721
2722         if (get_all)
2723                 mime_parts = modest_msg_view_get_attachments (MODEST_MSG_VIEW (priv->msg_view));
2724         else
2725                 mime_parts = modest_msg_view_get_selected_attachments (MODEST_MSG_VIEW (priv->msg_view));
2726
2727         /* Remove already purged messages from mime parts list */
2728         iter = tny_list_create_iterator (mime_parts);
2729         while (!tny_iterator_is_done (iter)) {
2730                 TnyMimePart *part = TNY_MIME_PART (tny_iterator_get_current (iter));
2731                 tny_iterator_next (iter);
2732                 if (tny_mime_part_is_purged (part)) {
2733                         tny_list_remove (mime_parts, (GObject *) part);
2734                 }
2735                 g_object_unref (part);
2736         }
2737         g_object_unref (iter);
2738
2739         if (tny_list_get_length (mime_parts) == 0) {
2740                 g_object_unref (mime_parts);
2741                 return;
2742         }
2743
2744         n_attachments = tny_list_get_length (mime_parts);
2745         if (n_attachments == 1) {
2746                 const gchar *filename;
2747                 TnyMimePart *part;
2748
2749                 iter = tny_list_create_iterator (mime_parts);
2750                 part = (TnyMimePart *) tny_iterator_get_current (iter);
2751                 g_object_unref (iter);
2752                 if (modest_tny_mime_part_is_msg (part)) {
2753                         TnyHeader *header;
2754                         header = tny_msg_get_header (TNY_MSG (part));
2755                         filename = tny_header_get_subject (header);
2756                         g_object_unref (header);
2757                         if (filename == NULL)
2758                                 filename = _("mail_va_no_subject");
2759                 } else {
2760                         filename = tny_mime_part_get_filename (TNY_MIME_PART (part));
2761                 }
2762                 confirmation_message = g_strdup_printf (_("mcen_nc_purge_file_text"), filename);
2763                 g_object_unref (part);
2764         } else {
2765                 confirmation_message = g_strdup_printf (ngettext("mcen_nc_purge_file_text",
2766                                                                  "mcen_nc_purge_files_text",
2767                                                                  n_attachments), n_attachments);
2768         }
2769         response = modest_platform_run_confirmation_dialog (GTK_WINDOW (window),
2770                                                             confirmation_message);
2771         g_free (confirmation_message);
2772
2773         if (response != GTK_RESPONSE_OK) {
2774                 g_object_unref (mime_parts);
2775                 return;
2776         }
2777
2778         priv->purge_timeout = g_timeout_add (2000, show_remove_attachment_information, window);
2779 /*      folder = tny_msg_get_folder (msg); */
2780 /*      tny_msg_uncache_attachments (msg); */
2781 /*      tny_folder_refresh (folder, NULL); */
2782 /*      g_object_unref (folder); */
2783
2784         iter = tny_list_create_iterator (mime_parts);
2785         while (!tny_iterator_is_done (iter)) {
2786                 TnyMimePart *part;
2787
2788                 part = (TnyMimePart *) tny_iterator_get_current (iter);
2789                 tny_mime_part_set_purged (TNY_MIME_PART (part));
2790 /*              modest_msg_view_remove_attachment (MODEST_MSG_VIEW (priv->msg_view), node->data); */
2791                 g_object_unref (part);
2792                 tny_iterator_next (iter);
2793         }
2794         g_object_unref (iter);
2795
2796         msg = tny_msg_view_get_msg (TNY_MSG_VIEW (priv->msg_view));
2797         tny_msg_view_clear (TNY_MSG_VIEW (priv->msg_view));
2798         tny_msg_rewrite_cache (msg);
2799         tny_msg_view_set_msg (TNY_MSG_VIEW (priv->msg_view), msg);
2800         g_object_unref (msg);
2801
2802         g_object_unref (mime_parts);
2803
2804         if (priv->purge_timeout > 0) {
2805                 g_source_remove (priv->purge_timeout);
2806                 priv->purge_timeout = 0;
2807         }
2808
2809         if (priv->remove_attachment_banner) {
2810                 gtk_widget_destroy (priv->remove_attachment_banner);
2811                 g_object_unref (priv->remove_attachment_banner);
2812                 priv->remove_attachment_banner = NULL;
2813         }
2814
2815
2816 }
2817
2818
2819 static void
2820 update_window_title (ModestMsgViewWindow *window)
2821 {
2822         ModestMsgViewWindowPrivate *priv = MODEST_MSG_VIEW_WINDOW_GET_PRIVATE (window);
2823         TnyMsg *msg = NULL;
2824         TnyHeader *header = NULL;
2825         const gchar *subject = NULL;
2826
2827         msg = tny_msg_view_get_msg (TNY_MSG_VIEW (priv->msg_view));
2828
2829         if (msg != NULL) {
2830                 header = tny_msg_get_header (msg);
2831                 subject = tny_header_get_subject (header);
2832                 g_object_unref (msg);
2833         }
2834
2835         if ((subject == NULL)||(subject[0] == '\0'))
2836                 subject = _("mail_va_no_subject");
2837
2838         gtk_window_set_title (GTK_WINDOW (window), subject);
2839 }
2840
2841
2842 static void on_move_focus (GtkWidget *widget,
2843                            GtkDirectionType direction,
2844                            gpointer userdata)
2845 {
2846         g_signal_stop_emission_by_name (G_OBJECT (widget), "move-focus");
2847 }
2848