git.maemo.org Git - modest/blob - src/maemo/modest-msg-view-window.c

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