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

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