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