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 "modest-platform.h"
  35 #include <modest-tny-msg.h>
  36 #include <modest-msg-view-window.h>
  37 #include <modest-main-window-ui.h>
  38 #include <modest-widget-memory.h>
  39 #include <modest-runtime.h>
  40 #include <modest-window-priv.h>
  41 #include <modest-tny-folder.h>
  42 #include <modest-text-utils.h>
  43 #include "modest-progress-bar-widget.h"
  44 #include "modest-defs.h"
  45 #include "modest-hildon-includes.h"
  46 #include <gtkhtml/gtkhtml-search.h>
  47 #include <gdk/gdkkeysyms.h>
  48
  49 static void  modest_msg_view_window_class_init   (ModestMsgViewWindowClass *klass);
  50 static void  modest_msg_view_window_init         (ModestMsgViewWindow *obj);
  51 static void  modest_msg_view_window_finalize     (GObject *obj);
  52 static void  modest_msg_view_window_toggle_find_toolbar (GtkToggleAction *obj,
  53                                                          gpointer data);
  54 static void  modest_msg_view_window_find_toolbar_close (GtkWidget *widget,
  55                                                         ModestMsgViewWindow *obj);
  56 static void  modest_msg_view_window_find_toolbar_search (GtkWidget *widget,
  57                                                         ModestMsgViewWindow *obj);
  58
  59 static void  modest_msg_view_window_set_zoom (ModestWindow *window,
  60                                               gdouble zoom);
  61 static gdouble modest_msg_view_window_get_zoom (ModestWindow *window);
  62 static gboolean modest_msg_view_window_zoom_minus (ModestWindow *window);
  63 static gboolean modest_msg_view_window_zoom_plus (ModestWindow *window);
  64 static gboolean modest_msg_view_window_key_release_event (GtkWidget *window,
  65                                                           GdkEventKey *event,
  66                                                           gpointer userdata);
  67 static gboolean modest_msg_view_window_window_state_event (GtkWidget *widget,
  68                                                            GdkEventWindowState *event,
  69                                                            gpointer userdata);
  70 static void modest_msg_view_window_scroll_up (ModestWindow *window);
  71 static void modest_msg_view_window_scroll_down (ModestWindow *window);
  72 static gboolean modest_msg_view_window_is_last_message (ModestMsgViewWindow *window);
  73 static gboolean modest_msg_view_window_is_first_message (ModestMsgViewWindow *window);
  74 static TnyFolderType modest_msg_view_window_get_folder_type (ModestMsgViewWindow *window);
  75 static void modest_msg_view_window_update_dimmed (ModestMsgViewWindow *window);
  76 static void modest_msg_view_window_update_priority (ModestMsgViewWindow *window);
  77
  78 static void modest_msg_view_window_show_toolbar   (ModestWindow *window,
  79                                                    gboolean show_toolbar);
  80
  81 static void modest_msg_view_window_clipboard_owner_change (GtkClipboard *clipboard,
  82                                                            GdkEvent *event,
  83                                                            ModestMsgViewWindow *window);
  84
  85 static void cancel_progressbar (GtkToolButton *toolbutton,
  86                                 ModestMsgViewWindow *self);
  87
  88 static void         on_queue_changed                     (ModestMailOperationQueue *queue,
  89                                                           ModestMailOperation *mail_op,
  90                                                           ModestMailOperationQueueNotification type,
  91                                                           ModestMsgViewWindow *self);
  92
  93 static void set_toolbar_mode (ModestMsgViewWindow *self,
  94                               ModestToolBarModes mode);
  95
  96
  97 /* list my signals */
  98 enum {
  99         /* MY_SIGNAL_1, */
 100         /* MY_SIGNAL_2, */
 101         LAST_SIGNAL
 102 };
 103
 104 static const GtkToggleActionEntry msg_view_toggle_action_entries [] = {
 105         { "FindInMessage",    GTK_STOCK_FIND,    N_("qgn_toolb_gene_find"), NULL, NULL, G_CALLBACK (modest_msg_view_window_toggle_find_toolbar), FALSE },
 106 };
 107
 108 static const GtkRadioActionEntry msg_view_zoom_action_entries [] = {
 109         { "Zoom50", NULL, N_("mcen_me_viewer_50"), NULL, NULL, 50 },
 110         { "Zoom80", NULL, N_("mcen_me_viewer_80"), NULL, NULL, 80 },
 111         { "Zoom100", NULL, N_("mcen_me_viewer_100"), NULL, NULL, 100 },
 112         { "Zoom120", NULL, N_("mcen_me_viewer_120"), NULL, NULL, 120 },
 113         { "Zoom150", NULL, N_("mcen_me_viewer_150"), NULL, NULL, 150 },
 114         { "Zoom200", NULL, N_("mcen_me_viewer_200"), NULL, NULL, 200 }
 115 };
 116
 117 typedef struct _ModestMsgViewWindowPrivate ModestMsgViewWindowPrivate;
 118 struct _ModestMsgViewWindowPrivate {
 119
 120         GtkWidget   *msg_view;
 121         GtkWidget   *main_scroll;
 122         GtkWidget   *find_toolbar;
 123         gchar       *last_search;
 124
 125         /* Progress observers */
 126         GtkWidget        *progress_bar;
 127         GSList           *progress_widgets;
 128
 129         /* Tollbar items */
 130         GtkWidget   *progress_toolitem;
 131         GtkWidget   *cancel_toolitem;
 132         GtkWidget   *prev_toolitem;
 133         GtkWidget   *next_toolitem;
 134
 135         GtkTreeModel *header_model;
 136         GtkTreeIter   iter;
 137
 138         guint clipboard_change_handler;
 139 };
 140
 141 #define MODEST_MSG_VIEW_WINDOW_GET_PRIVATE(o)      (G_TYPE_INSTANCE_GET_PRIVATE((o), \
 142                                                     MODEST_TYPE_MSG_VIEW_WINDOW, \
 143                                                     ModestMsgViewWindowPrivate))
 144 /* globals */
 145 static GtkWindowClass *parent_class = NULL;
 146
 147 /* uncomment the following if you have defined any signals */
 148 /* static guint signals[LAST_SIGNAL] = {0}; */
 149
 150 GType
 151 modest_msg_view_window_get_type (void)
 152 {
 153         static GType my_type = 0;
 154         if (!my_type) {
 155                 static const GTypeInfo my_info = {
 156                         sizeof(ModestMsgViewWindowClass),
 157                         NULL,           /* base init */
 158                         NULL,           /* base finalize */
 159                         (GClassInitFunc) modest_msg_view_window_class_init,
 160                         NULL,           /* class finalize */
 161                         NULL,           /* class data */
 162                         sizeof(ModestMsgViewWindow),
 163                         1,              /* n_preallocs */
 164                         (GInstanceInitFunc) modest_msg_view_window_init,
 165                         NULL
 166                 };
 167                 my_type = g_type_register_static (MODEST_TYPE_WINDOW,
 168                                                   "ModestMsgViewWindow",
 169                                                   &my_info, 0);
 170         }
 171         return my_type;
 172 }
 173
 174 static void
 175 modest_msg_view_window_class_init (ModestMsgViewWindowClass *klass)
 176 {
 177         GObjectClass *gobject_class;
 178         ModestWindowClass *modest_window_class;
 179         gobject_class = (GObjectClass*) klass;
 180         modest_window_class = (ModestWindowClass *) klass;
 181
 182         parent_class            = g_type_class_peek_parent (klass);
 183         gobject_class->finalize = modest_msg_view_window_finalize;
 184
 185         modest_window_class->set_zoom_func = modest_msg_view_window_set_zoom;
 186         modest_window_class->get_zoom_func = modest_msg_view_window_get_zoom;
 187         modest_window_class->zoom_minus_func = modest_msg_view_window_zoom_minus;
 188         modest_window_class->zoom_plus_func = modest_msg_view_window_zoom_plus;
 189         modest_window_class->show_toolbar_func = modest_msg_view_window_show_toolbar;
 190
 191         g_type_class_add_private (gobject_class, sizeof(ModestMsgViewWindowPrivate));
 192 }
 193
 194 static void
 195 modest_msg_view_window_init (ModestMsgViewWindow *obj)
 196 {
 197         ModestMsgViewWindowPrivate *priv;
 198         priv = MODEST_MSG_VIEW_WINDOW_GET_PRIVATE(obj);
 199
 200         priv->msg_view      = NULL;
 201         priv->header_model  = NULL;
 202         priv->clipboard_change_handler = 0;
 203 }
 204
 205 static void
 206 save_settings (ModestMsgViewWindow *self)
 207 {
 208         modest_widget_memory_save (modest_runtime_get_conf (),
 209                                    G_OBJECT(self),
 210                                    MODEST_CONF_MSG_VIEW_WINDOW_KEY);
 211 }
 212
 213
 214 static void
 215 restore_settings (ModestMsgViewWindow *self)
 216 {
 217         modest_widget_memory_restore (modest_runtime_get_conf (),
 218                                       G_OBJECT(self),
 219                                       MODEST_CONF_MSG_VIEW_WINDOW_KEY);
 220 }
 221
 222
 223 static void
 224 set_toolbar_mode (ModestMsgViewWindow *self,
 225                   ModestToolBarModes mode)
 226 {
 227         ModestWindowPrivate *parent_priv;
 228         ModestMsgViewWindowPrivate *priv;
 229         GtkAction *widget = NULL;
 230
 231         g_return_if_fail (MODEST_IS_MSG_VIEW_WINDOW (self));
 232
 233         parent_priv = MODEST_WINDOW_GET_PRIVATE(self);
 234         priv = MODEST_MSG_VIEW_WINDOW_GET_PRIVATE(self);
 235
 236         switch (mode) {
 237         case TOOLBAR_MODE_NORMAL:
 238                 widget = gtk_ui_manager_get_action (parent_priv->ui_manager, "/ToolBar/ToolbarMessageNew");
 239                 gtk_action_set_sensitive (widget, TRUE);
 240                 widget = gtk_ui_manager_get_action (parent_priv->ui_manager, "/ToolBar/ToolbarMessageReply");
 241                 gtk_action_set_sensitive (widget, TRUE);
 242                 widget = gtk_ui_manager_get_action (parent_priv->ui_manager, "/ToolBar/ToolbarDeleteMessage");
 243                 gtk_action_set_sensitive (widget, TRUE);
 244                 widget = gtk_ui_manager_get_action (parent_priv->ui_manager, "/ToolBar/ToolbarMessageMoveTo");
 245                 gtk_action_set_sensitive (widget, TRUE);
 246                 widget = gtk_ui_manager_get_action (parent_priv->ui_manager, "/ToolBar/FindInMessage");
 247                 gtk_action_set_sensitive (widget, TRUE);
 248
 249                 if (priv->prev_toolitem)
 250                         gtk_widget_show (priv->prev_toolitem);
 251
 252                 if (priv->next_toolitem)
 253                         gtk_widget_show (priv->next_toolitem);
 254
 255                 if (priv->progress_toolitem)
 256                         gtk_tool_item_set_expand (GTK_TOOL_ITEM (priv->progress_toolitem), FALSE);
 257                 if (priv->progress_bar)
 258                         gtk_widget_hide (priv->progress_bar);
 259
 260                 if (priv->cancel_toolitem)
 261                         gtk_widget_hide (priv->cancel_toolitem);
 262                 break;
 263         case TOOLBAR_MODE_TRANSFER:
 264                 widget = gtk_ui_manager_get_action (parent_priv->ui_manager, "/ToolBar/ToolbarMessageNew");
 265                 gtk_action_set_sensitive (widget, FALSE);
 266                 widget = gtk_ui_manager_get_action (parent_priv->ui_manager, "/ToolBar/ToolbarMessageReply");
 267                 gtk_action_set_sensitive (widget, FALSE);
 268                 widget = gtk_ui_manager_get_action (parent_priv->ui_manager, "/ToolBar/ToolbarDeleteMessage");
 269                 gtk_action_set_sensitive (widget, FALSE);
 270                 widget = gtk_ui_manager_get_action (parent_priv->ui_manager, "/ToolBar/ToolbarMessageMoveTo");
 271                 gtk_action_set_sensitive (widget, FALSE);
 272                 widget = gtk_ui_manager_get_action (parent_priv->ui_manager, "/ToolBar/FindInMessage");
 273                 gtk_action_set_sensitive (widget, FALSE);
 274
 275                 if (priv->prev_toolitem)
 276                         gtk_widget_hide (priv->prev_toolitem);
 277
 278                 if (priv->next_toolitem)
 279                         gtk_widget_hide (priv->next_toolitem);
 280
 281                 if (priv->progress_toolitem)
 282                         gtk_tool_item_set_expand (GTK_TOOL_ITEM (priv->progress_toolitem), TRUE);
 283                 if (priv->progress_bar)
 284                         gtk_widget_show (priv->progress_bar);
 285
 286                 if (priv->cancel_toolitem)
 287                         gtk_widget_show (priv->cancel_toolitem);
 288                 break;
 289         default:
 290                 widget = gtk_ui_manager_get_action (parent_priv->ui_manager, "/ToolBar/ToolbarMessageNew");
 291                 gtk_action_set_sensitive (widget, TRUE);
 292                 widget = gtk_ui_manager_get_action (parent_priv->ui_manager, "/ToolBar/ToolbarMessageReply");
 293                 gtk_action_set_sensitive (widget, TRUE);
 294                 widget = gtk_ui_manager_get_action (parent_priv->ui_manager, "/ToolBar/ToolbarDeleteMessage");
 295                 gtk_action_set_sensitive (widget, TRUE);
 296                 widget = gtk_ui_manager_get_action (parent_priv->ui_manager, "/ToolBar/ToolbarMessageMoveTo");
 297                 gtk_action_set_sensitive (widget, TRUE);
 298                 widget = gtk_ui_manager_get_action (parent_priv->ui_manager, "/ToolBar/FindInMessage");
 299                 gtk_action_set_sensitive (widget, TRUE);
 300
 301                 if (priv->cancel_toolitem)
 302                         gtk_widget_show (priv->prev_toolitem);
 303
 304                 if (priv->next_toolitem)
 305                         gtk_widget_show (priv->next_toolitem);
 306
 307                 if (priv->progress_bar)
 308                         gtk_widget_hide (priv->progress_bar);
 309                 if (priv->progress_bar)
 310                         gtk_widget_hide (priv->progress_bar);
 311
 312                 if (priv->cancel_toolitem)
 313                         gtk_widget_hide (priv->cancel_toolitem);
 314         }
 315
 316 }
 317
 318
 319 static GtkWidget *
 320 menubar_to_menu (GtkUIManager *ui_manager)
 321 {
 322         GtkWidget *main_menu;
 323         GtkWidget *menubar;
 324         GList *iter;
 325
 326         /* Create new main menu */
 327         main_menu = gtk_menu_new();
 328
 329         /* Get the menubar from the UI manager */
 330         menubar = gtk_ui_manager_get_widget (ui_manager, "/MenuBar");
 331
 332         iter = gtk_container_get_children (GTK_CONTAINER (menubar));
 333         while (iter) {
 334                 GtkWidget *menu;
 335
 336                 menu = GTK_WIDGET (iter->data);
 337                 gtk_widget_reparent(menu, main_menu);
 338
 339                 iter = g_list_next (iter);
 340         }
 341         return main_menu;
 342 }
 343
 344 static void
 345 init_window (ModestMsgViewWindow *obj, TnyMsg *msg)
 346 {
 347         GtkWidget *main_vbox;
 348         ModestMsgViewWindowPrivate *priv;
 349         ModestWindowPrivate *parent_priv;
 350
 351         priv = MODEST_MSG_VIEW_WINDOW_GET_PRIVATE(obj);
 352         parent_priv = MODEST_WINDOW_GET_PRIVATE(obj);
 353
 354         priv->msg_view = modest_msg_view_new (msg);
 355         modest_msg_view_set_shadow_type (MODEST_MSG_VIEW (priv->msg_view), GTK_SHADOW_NONE);
 356         main_vbox = gtk_vbox_new  (FALSE, 6);
 357
 358         /* Menubar */
 359         parent_priv->menubar = menubar_to_menu (parent_priv->ui_manager);
 360         gtk_widget_show_all (GTK_WIDGET(parent_priv->menubar));
 361         hildon_window_set_menu    (HILDON_WINDOW(obj), GTK_MENU(parent_priv->menubar));
 362
 363         priv->main_scroll = gtk_scrolled_window_new (NULL, NULL);
 364         gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (priv->main_scroll), GTK_POLICY_NEVER, GTK_POLICY_AUTOMATIC);
 365         gtk_scrolled_window_set_shadow_type (GTK_SCROLLED_WINDOW (priv->main_scroll), GTK_SHADOW_NONE);
 366
 367         gtk_container_add (GTK_CONTAINER (priv->main_scroll), priv->msg_view);
 368         gtk_box_pack_start (GTK_BOX(main_vbox), priv->main_scroll, TRUE, TRUE, 0);
 369         gtk_container_add   (GTK_CONTAINER(obj), main_vbox);
 370
 371         priv->find_toolbar = hildon_find_toolbar_new (NULL);
 372         gtk_widget_set_no_show_all (priv->find_toolbar, TRUE);
 373         g_signal_connect (G_OBJECT (priv->find_toolbar), "close", G_CALLBACK (modest_msg_view_window_find_toolbar_close), obj);
 374         g_signal_connect (G_OBJECT (priv->find_toolbar), "search", G_CALLBACK (modest_msg_view_window_find_toolbar_search), obj);
 375
 376         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);
 377         modest_msg_view_window_clipboard_owner_change (gtk_clipboard_get (GDK_SELECTION_PRIMARY), NULL, obj);
 378         gtk_widget_show_all (GTK_WIDGET(main_vbox));
 379         gtk_box_pack_end (GTK_BOX (main_vbox), priv->find_toolbar, FALSE, FALSE, 0);
 380 }
 381
 382
 383 static void
 384 modest_msg_view_window_finalize (GObject *obj)
 385 {
 386         ModestMsgViewWindowPrivate *priv;
 387
 388         priv = MODEST_MSG_VIEW_WINDOW_GET_PRIVATE (obj);
 389         if (priv->header_model != NULL) {
 390                 g_object_unref (priv->header_model);
 391                 priv->header_model = NULL;
 392         }
 393         if (priv->clipboard_change_handler > 0) {
 394                 g_signal_handler_disconnect (gtk_clipboard_get (GDK_SELECTION_PRIMARY), priv->clipboard_change_handler);
 395                 priv->clipboard_change_handler = 0;
 396         }
 397
 398         G_OBJECT_CLASS(parent_class)->finalize (obj);
 399 }
 400
 401
 402
 403 static gboolean
 404 on_delete_event (GtkWidget *widget, GdkEvent *event, ModestMsgViewWindow *self)
 405 {
 406         save_settings (self);
 407         return FALSE;
 408 }
 409
 410 ModestWindow *
 411 modest_msg_view_window_new_with_header_model (TnyMsg *msg, const gchar *account_name,
 412                                               GtkTreeModel *model, GtkTreeIter iter)
 413 {
 414         ModestMsgViewWindow *window = NULL;
 415         ModestMsgViewWindowPrivate *priv = NULL;
 416
 417         window = MODEST_MSG_VIEW_WINDOW(modest_msg_view_window_new (msg, account_name));
 418         g_return_val_if_fail (MODEST_IS_MSG_VIEW_WINDOW (window), NULL);
 419
 420         priv = MODEST_MSG_VIEW_WINDOW_GET_PRIVATE (window);
 421
 422         g_object_ref (model);
 423         priv->header_model = model;
 424         priv->iter = iter;
 425
 426         modest_msg_view_window_update_priority (window);
 427
 428         modest_msg_view_window_update_dimmed (window);
 429
 430         return MODEST_WINDOW(window);
 431 }
 432
 433
 434 ModestWindow *
 435 modest_msg_view_window_new (TnyMsg *msg, const gchar *account_name)
 436 {
 437         GObject *obj;
 438         ModestMsgViewWindowPrivate *priv;
 439         ModestWindowPrivate *parent_priv;
 440         GtkActionGroup *action_group;
 441         GError *error = NULL;
 442         GdkPixbuf *window_icon = NULL;
 443
 444         g_return_val_if_fail (msg, NULL);
 445
 446         obj = g_object_new(MODEST_TYPE_MSG_VIEW_WINDOW, NULL);
 447         priv = MODEST_MSG_VIEW_WINDOW_GET_PRIVATE(obj);
 448         parent_priv = MODEST_WINDOW_GET_PRIVATE(obj);
 449
 450         parent_priv->ui_manager = gtk_ui_manager_new();
 451         action_group = gtk_action_group_new ("ModestMsgViewWindowActions");
 452         gtk_action_group_set_translation_domain (action_group, GETTEXT_PACKAGE);
 453
 454         /* Add common actions */
 455         gtk_action_group_add_actions (action_group,
 456                                       modest_action_entries,
 457                                       G_N_ELEMENTS (modest_action_entries),
 458                                       obj);
 459         gtk_action_group_add_toggle_actions (action_group,
 460                                              modest_toggle_action_entries,
 461                                              G_N_ELEMENTS (modest_toggle_action_entries),
 462                                              obj);
 463         gtk_action_group_add_toggle_actions (action_group,
 464                                              msg_view_toggle_action_entries,
 465                                              G_N_ELEMENTS (msg_view_toggle_action_entries),
 466                                              obj);
 467         gtk_action_group_add_radio_actions (action_group,
 468                                             msg_view_zoom_action_entries,
 469                                             G_N_ELEMENTS (msg_view_zoom_action_entries),
 470                                             100,
 471                                             G_CALLBACK (modest_ui_actions_on_change_zoom),
 472                                             obj);
 473
 474         gtk_ui_manager_insert_action_group (parent_priv->ui_manager, action_group, 0);
 475         g_object_unref (action_group);
 476
 477         /* Load the UI definition */
 478         gtk_ui_manager_add_ui_from_file (parent_priv->ui_manager, MODEST_UIDIR "modest-msg-view-window-ui.xml",
 479                                          &error);
 480         if (error) {
 481                 g_printerr ("modest: could not merge modest-msg-view-window-ui.xml: %s\n", error->message);
 482                 g_error_free (error);
 483                 error = NULL;
 484         }
 485         /* ****** */
 486
 487         /* Add accelerators */
 488         gtk_window_add_accel_group (GTK_WINDOW (obj),
 489                                     gtk_ui_manager_get_accel_group (parent_priv->ui_manager));
 490
 491         /* Init window */
 492         init_window (MODEST_MSG_VIEW_WINDOW(obj), msg);
 493         restore_settings (MODEST_MSG_VIEW_WINDOW(obj));
 494
 495         g_signal_connect (G_OBJECT(obj), "delete-event", G_CALLBACK(on_delete_event), obj);
 496
 497         g_signal_connect (G_OBJECT(priv->msg_view), "link_clicked",
 498                           G_CALLBACK (modest_ui_actions_on_msg_link_clicked), obj);
 499         g_signal_connect (G_OBJECT(priv->msg_view), "link_hover",
 500                           G_CALLBACK (modest_ui_actions_on_msg_link_hover), obj);
 501         g_signal_connect (G_OBJECT(priv->msg_view), "attachment_clicked",
 502                           G_CALLBACK (modest_ui_actions_on_msg_attachment_clicked), obj);
 503         g_signal_connect (G_OBJECT(priv->msg_view), "recpt_activated",
 504                           G_CALLBACK (modest_ui_actions_on_msg_recpt_activated), obj);
 505         g_signal_connect (G_OBJECT(priv->msg_view), "link_contextual",
 506                           G_CALLBACK (modest_ui_actions_on_msg_link_contextual), obj);
 507
 508         g_signal_connect (G_OBJECT (obj), "key-release-event",
 509                           G_CALLBACK (modest_msg_view_window_key_release_event),
 510                           NULL);
 511
 512         g_signal_connect (G_OBJECT (obj), "window-state-event",
 513                           G_CALLBACK (modest_msg_view_window_window_state_event),
 514                           NULL);
 515
 516         /* Mail Operation Queue */
 517         g_signal_connect (G_OBJECT (modest_runtime_get_mail_operation_queue ()),
 518                           "queue-changed",
 519                           G_CALLBACK (on_queue_changed),
 520                           obj);
 521
 522         modest_window_set_active_account (MODEST_WINDOW(obj), account_name);
 523
 524         priv->last_search = NULL;
 525
 526         modest_msg_view_window_update_dimmed (MODEST_MSG_VIEW_WINDOW (obj));
 527
 528         /* Set window icon */
 529         window_icon = modest_platform_get_icon (MODEST_APP_MSG_VIEW_ICON);
 530         gtk_window_set_icon (GTK_WINDOW (obj), window_icon);
 531
 532         gtk_widget_grab_focus (priv->msg_view);
 533
 534         return MODEST_WINDOW(obj);
 535 }
 536
 537
 538
 539 TnyMsg*
 540 modest_msg_view_window_get_message (ModestMsgViewWindow *self)
 541 {
 542         ModestMsgView *msg_view;
 543         ModestMsgViewWindowPrivate *priv;
 544
 545         g_return_val_if_fail (self, NULL);
 546
 547         priv = MODEST_MSG_VIEW_WINDOW_GET_PRIVATE(self);
 548
 549         msg_view = MODEST_MSG_VIEW (priv->msg_view);
 550
 551         return modest_msg_view_get_message (msg_view);
 552 }
 553
 554 const gchar*
 555 modest_msg_view_window_get_message_uid (ModestMsgViewWindow *self)
 556 {
 557         TnyMsg *msg;
 558         TnyHeader *header;
 559         const gchar *retval = NULL;
 560
 561         msg = modest_msg_view_window_get_message (self);
 562
 563         if (!msg)
 564                 return NULL;
 565
 566         header = tny_msg_get_header (msg);
 567         if (header) {
 568                 retval = tny_header_get_uid (header);
 569                 g_object_unref (header);
 570         }
 571         return retval;
 572 }
 573
 574 static void
 575 modest_msg_view_window_toggle_find_toolbar (GtkToggleAction *toggle,
 576                                             gpointer data)
 577 {
 578         ModestMsgViewWindow *window = MODEST_MSG_VIEW_WINDOW (data);
 579         ModestMsgViewWindowPrivate *priv = MODEST_MSG_VIEW_WINDOW_GET_PRIVATE (window);
 580
 581         if (gtk_toggle_action_get_active (toggle)) {
 582                 gtk_widget_show (priv->find_toolbar);
 583         } else {
 584                 gtk_widget_hide (priv->find_toolbar);
 585         }
 586
 587
 588 }
 589
 590 static void
 591 modest_msg_view_window_find_toolbar_close (GtkWidget *widget,
 592                                            ModestMsgViewWindow *obj)
 593 {
 594         GtkToggleAction *toggle;
 595         ModestWindowPrivate *parent_priv;
 596         parent_priv = MODEST_WINDOW_GET_PRIVATE (obj);
 597
 598         toggle = GTK_TOGGLE_ACTION (gtk_ui_manager_get_action (parent_priv->ui_manager, "/ToolBar/FindInMessage"));
 599         gtk_toggle_action_set_active (toggle, FALSE);
 600 }
 601
 602 static void
 603 modest_msg_view_window_find_toolbar_search (GtkWidget *widget,
 604                                            ModestMsgViewWindow *obj)
 605 {
 606         gchar *current_search;
 607         ModestMsgViewWindowPrivate *priv = MODEST_MSG_VIEW_WINDOW_GET_PRIVATE (obj);
 608
 609         g_object_get (G_OBJECT (widget), "prefix", &current_search, NULL);
 610
 611         if ((current_search == NULL) && (strcmp (current_search, "") == 0)) {
 612                 g_free (current_search);
 613                 return;
 614         }
 615
 616         if ((priv->last_search == NULL) || (strcmp (priv->last_search, current_search) != 0)) {
 617                 gboolean result;
 618                 g_free (priv->last_search);
 619                 priv->last_search = g_strdup (current_search);
 620                 result = modest_msg_view_search (MODEST_MSG_VIEW (priv->msg_view),
 621                                                  priv->last_search);
 622         } else {
 623                 modest_msg_view_search_next (MODEST_MSG_VIEW (priv->msg_view));
 624         }
 625
 626         g_free (current_search);
 627
 628 }
 629
 630 static void
 631 modest_msg_view_window_set_zoom (ModestWindow *window,
 632                                  gdouble zoom)
 633 {
 634         ModestMsgViewWindowPrivate *priv;
 635
 636         g_return_if_fail (MODEST_IS_MSG_VIEW_WINDOW (window));
 637
 638         priv = MODEST_MSG_VIEW_WINDOW_GET_PRIVATE (window);
 639         modest_msg_view_set_zoom (MODEST_MSG_VIEW (priv->msg_view), zoom);
 640 }
 641
 642 static gdouble
 643 modest_msg_view_window_get_zoom (ModestWindow *window)
 644 {
 645         ModestMsgViewWindowPrivate *priv;
 646
 647         g_return_val_if_fail (MODEST_IS_MSG_VIEW_WINDOW (window), 1.0);
 648
 649         priv = MODEST_MSG_VIEW_WINDOW_GET_PRIVATE (window);
 650         return modest_msg_view_get_zoom (MODEST_MSG_VIEW (priv->msg_view));
 651 }
 652
 653 static gboolean
 654 modest_msg_view_window_zoom_plus (ModestWindow *window)
 655 {
 656         ModestWindowPrivate *parent_priv;
 657         GtkRadioAction *zoom_radio_action;
 658         GSList *group, *node;
 659
 660         parent_priv = MODEST_WINDOW_GET_PRIVATE (window);
 661         zoom_radio_action = GTK_RADIO_ACTION (gtk_ui_manager_get_action (parent_priv->ui_manager,
 662                                                                          "/MenuBar/ViewMenu/ZoomMenu/Zoom50Menu"));
 663
 664         group = gtk_radio_action_get_group (zoom_radio_action);
 665
 666         if (gtk_toggle_action_get_active (GTK_TOGGLE_ACTION (group->data))) {
 667                 hildon_banner_show_information (NULL, NULL, _("mcen_ib_max_zoom_level"));
 668                 return FALSE;
 669         }
 670
 671         for (node = group; node != NULL; node = g_slist_next (node)) {
 672                 if ((node->next != NULL) && gtk_toggle_action_get_active (GTK_TOGGLE_ACTION (node->next->data))) {
 673                         gtk_toggle_action_set_active (GTK_TOGGLE_ACTION (node->data), TRUE);
 674                         return TRUE;
 675                 }
 676         }
 677         return FALSE;
 678 }
 679
 680 static gboolean
 681 modest_msg_view_window_zoom_minus (ModestWindow *window)
 682 {
 683         ModestWindowPrivate *parent_priv;
 684         GtkRadioAction *zoom_radio_action;
 685         GSList *group, *node;
 686
 687         parent_priv = MODEST_WINDOW_GET_PRIVATE (window);
 688         zoom_radio_action = GTK_RADIO_ACTION (gtk_ui_manager_get_action (parent_priv->ui_manager,
 689                                                                          "/MenuBar/ViewMenu/ZoomMenu/Zoom50Menu"));
 690
 691         group = gtk_radio_action_get_group (zoom_radio_action);
 692
 693         for (node = group; node != NULL; node = g_slist_next (node)) {
 694                 if (gtk_toggle_action_get_active (GTK_TOGGLE_ACTION (node->data))) {
 695                         if (node->next != NULL) {
 696                                 gtk_toggle_action_set_active (GTK_TOGGLE_ACTION (node->next->data), TRUE);
 697                                 return TRUE;
 698                         } else {
 699                                 hildon_banner_show_information (NULL, NULL, _("mcen_ib_min_zoom_level"));
 700                                 return FALSE;
 701                         }
 702                         break;
 703                 }
 704         }
 705         return FALSE;
 706 }
 707
 708 static gboolean
 709 modest_msg_view_window_key_release_event (GtkWidget *window,
 710                                           GdkEventKey *event,
 711                                           gpointer userdata)
 712 {
 713         if (event->type == GDK_KEY_RELEASE) {
 714                 switch (event->keyval) {
 715                 case GDK_Up:
 716                         modest_msg_view_window_scroll_up (MODEST_WINDOW (window));
 717                         return TRUE;
 718                         break;
 719                 case GDK_Down:
 720                         modest_msg_view_window_scroll_down (MODEST_WINDOW (window));
 721                         return TRUE;
 722                         break;
 723                 default:
 724                         return FALSE;
 725                         break;
 726                 };
 727         } else {
 728                 return FALSE;
 729         }
 730 }
 731
 732 static void
 733 modest_msg_view_window_scroll_up (ModestWindow *window)
 734 {
 735         ModestMsgViewWindowPrivate *priv;
 736
 737         priv = MODEST_MSG_VIEW_WINDOW_GET_PRIVATE (window);
 738         g_signal_emit_by_name (G_OBJECT (priv->main_scroll), "scroll-child", GTK_SCROLL_STEP_UP, FALSE);
 739 }
 740
 741 static void
 742 modest_msg_view_window_scroll_down (ModestWindow *window)
 743 {
 744         ModestMsgViewWindowPrivate *priv;
 745
 746         priv = MODEST_MSG_VIEW_WINDOW_GET_PRIVATE (window);
 747         g_signal_emit_by_name (G_OBJECT (priv->main_scroll), "scroll-child", GTK_SCROLL_STEP_DOWN, FALSE);
 748 }
 749
 750 static gboolean
 751 modest_msg_view_window_is_last_message (ModestMsgViewWindow *window)
 752 {
 753         GtkTreePath *path;
 754         ModestMsgViewWindowPrivate *priv;
 755         GtkTreeIter tmp_iter;
 756         gboolean has_next = FALSE;
 757
 758         g_return_val_if_fail (MODEST_IS_MSG_VIEW_WINDOW (window), TRUE);
 759         priv = MODEST_MSG_VIEW_WINDOW_GET_PRIVATE (window);
 760
 761         if (priv->header_model) {
 762                 path = gtk_tree_model_get_path (priv->header_model, &priv->iter);
 763                 if (!path)
 764                         return TRUE;
 765                 while (!has_next) {
 766                         TnyHeader *header;
 767                         gtk_tree_path_next (path);
 768                         if (!gtk_tree_model_get_iter (priv->header_model, &tmp_iter, path))
 769                                 break;
 770                         gtk_tree_model_get (priv->header_model, &tmp_iter, TNY_GTK_HEADER_LIST_MODEL_INSTANCE_COLUMN,
 771                                             &header, -1);
 772                         if (!(tny_header_get_flags(header)&TNY_HEADER_FLAG_DELETED)) {
 773                                 has_next = TRUE;
 774                                 break;
 775                         }
 776
 777                 }
 778                 gtk_tree_path_free (path);
 779                 return !has_next;
 780         } else {
 781                 return TRUE;
 782         }
 783
 784 }
 785
 786 static gboolean
 787 modest_msg_view_window_is_first_message (ModestMsgViewWindow *window)
 788 {
 789         GtkTreePath *path;
 790         ModestMsgViewWindowPrivate *priv;
 791         gboolean result;
 792         GtkTreeIter tmp_iter;
 793
 794         g_return_val_if_fail (MODEST_IS_MSG_VIEW_WINDOW (window), TRUE);
 795         priv = MODEST_MSG_VIEW_WINDOW_GET_PRIVATE (window);
 796
 797         if (priv->header_model) {
 798                 gchar * path_string;
 799                 path = gtk_tree_model_get_path (priv->header_model, &priv->iter);
 800                 if (!path)
 801                         return TRUE;
 802
 803                 path_string = gtk_tree_path_to_string (path);
 804                 result = (strcmp (path_string, "0")==0);
 805                 if (result) {
 806                         g_free (path_string);
 807                         gtk_tree_path_free (path);
 808                         return result;
 809                 }
 810
 811                 while (result) {
 812                         TnyHeader *header;
 813
 814                         gtk_tree_path_prev (path);
 815
 816                         if (!gtk_tree_model_get_iter (priv->header_model, &tmp_iter, path))
 817                                 break;
 818                         gtk_tree_model_get (priv->header_model, &tmp_iter, TNY_GTK_HEADER_LIST_MODEL_INSTANCE_COLUMN,
 819                                             &header, -1);
 820                         if (!(tny_header_get_flags(header)&TNY_HEADER_FLAG_DELETED)) {
 821                                 result = FALSE;
 822                                 break;
 823                         }
 824
 825                         path_string = gtk_tree_path_to_string (path);
 826                         if (strcmp(path_string, "0")==0) {
 827                                 g_free (path_string);
 828                                 break;
 829                         }
 830                         g_free (path_string);
 831                 }
 832                 gtk_tree_path_free (path);
 833                 return result;
 834         } else {
 835                 return TRUE;
 836         }
 837
 838 }
 839
 840 gboolean
 841 modest_msg_view_window_select_next_message (ModestMsgViewWindow *window)
 842 {
 843         ModestMsgViewWindowPrivate *priv;
 844         GtkTreeIter tmp_iter;
 845         gboolean has_next = FALSE;
 846
 847         g_return_val_if_fail (MODEST_IS_MSG_VIEW_WINDOW (window), FALSE);
 848         priv = MODEST_MSG_VIEW_WINDOW_GET_PRIVATE (window);
 849
 850         if (priv->header_model) {
 851                 tmp_iter = priv->iter;
 852                 while (gtk_tree_model_iter_next (priv->header_model, &tmp_iter)) {
 853                         TnyHeader *header;
 854                         TnyFolder *folder;
 855                         TnyMsg *msg;
 856
 857                         priv->iter = tmp_iter;
 858                         gtk_tree_model_get (priv->header_model, &(priv->iter), TNY_GTK_HEADER_LIST_MODEL_INSTANCE_COLUMN,
 859                                             &header, -1);
 860                         if (!header)
 861                                 break;
 862                         if (tny_header_get_flags (header) & TNY_HEADER_FLAG_DELETED)
 863                                 continue;
 864
 865                         folder = tny_header_get_folder (header);
 866                         if (!folder)
 867                                 break;
 868                         msg = tny_folder_get_msg (folder, header, NULL);
 869                         if (!msg) {
 870                                 g_object_unref (folder);
 871                                 break;
 872                         }
 873                         has_next = TRUE;
 874                         modest_msg_view_set_message (MODEST_MSG_VIEW (priv->msg_view), msg);
 875                         modest_msg_view_window_update_dimmed (window);
 876                         modest_msg_view_window_update_priority (window);
 877                         gtk_widget_grab_focus (priv->msg_view);
 878
 879                         g_object_unref (msg);
 880                         break;
 881                 }
 882
 883                 return has_next;
 884         } else {
 885                 return FALSE;
 886         }
 887 }
 888
 889 gboolean
 890 modest_msg_view_window_select_previous_message (ModestMsgViewWindow *window)
 891 {
 892         ModestMsgViewWindowPrivate *priv;
 893
 894         g_return_val_if_fail (MODEST_IS_MSG_VIEW_WINDOW (window), FALSE);
 895         priv = MODEST_MSG_VIEW_WINDOW_GET_PRIVATE (window);
 896
 897         if (priv->header_model) {
 898                 GtkTreePath *path;
 899                 gboolean has_prev = FALSE;
 900
 901                 path = gtk_tree_model_get_path (priv->header_model, &(priv->iter));
 902                 while (gtk_tree_path_prev (path)) {
 903                         TnyHeader *header;
 904                         TnyFolder *folder;
 905                         TnyMsg *msg;
 906
 907                         gtk_tree_model_get_iter (priv->header_model, &(priv->iter), path);
 908                         gtk_tree_model_get (priv->header_model, &(priv->iter), TNY_GTK_HEADER_LIST_MODEL_INSTANCE_COLUMN,
 909                                             &header, -1);
 910                         if (!header)
 911                                 break;
 912                         if (tny_header_get_flags (header) & TNY_HEADER_FLAG_DELETED)
 913                                 continue;
 914                         folder = tny_header_get_folder (header);
 915                         if (!folder)
 916                                 break;
 917                         msg = tny_folder_get_msg (folder, header, NULL);
 918                         if (!msg) {
 919                                 g_object_unref (folder);
 920                                 break;
 921                         }
 922                         has_prev = TRUE;
 923                         modest_msg_view_set_message (MODEST_MSG_VIEW (priv->msg_view), msg);
 924                         modest_msg_view_window_update_dimmed (window);
 925                         modest_msg_view_window_update_priority (window);
 926                         gtk_widget_grab_focus (priv->msg_view);
 927
 928                         g_object_unref (msg);
 929                         break;
 930                 }
 931                 gtk_tree_path_free (path);
 932                 return has_prev;
 933         } else {
 934                 return FALSE;
 935         }
 936 }
 937
 938 static TnyFolderType
 939 modest_msg_view_window_get_folder_type (ModestMsgViewWindow *window)
 940 {
 941         ModestMsgViewWindowPrivate *priv;
 942         TnyMsg *msg;
 943         TnyFolderType folder_type;
 944
 945         priv = MODEST_MSG_VIEW_WINDOW_GET_PRIVATE (window);
 946
 947         folder_type = TNY_FOLDER_TYPE_UNKNOWN;
 948
 949         msg = modest_msg_view_get_message (MODEST_MSG_VIEW (priv->msg_view));
 950         if (msg) {
 951                 TnyFolder *folder;
 952
 953                 folder = tny_msg_get_folder (msg);
 954
 955                 if (folder) {
 956                         folder_type = tny_folder_get_folder_type (folder);
 957
 958                         if (folder_type == TNY_FOLDER_TYPE_NORMAL || folder_type == TNY_FOLDER_TYPE_UNKNOWN) {
 959                                 const gchar *fname = tny_folder_get_name (folder);
 960                                 folder_type = modest_tny_folder_guess_folder_type_from_name (fname);
 961                         }
 962
 963                         g_object_unref (folder);
 964                 }
 965         }
 966
 967         return folder_type;
 968 }
 969
 970 static void
 971 modest_msg_view_window_update_dimmed (ModestMsgViewWindow *window)
 972 {
 973         ModestWindowPrivate *parent_priv;
 974         GtkAction *widget;
 975         gboolean is_first, is_last;
 976         TnyFolderType folder_type;
 977         gboolean is_not_sent;
 978
 979         parent_priv = MODEST_WINDOW_GET_PRIVATE (window);
 980
 981         is_first = modest_msg_view_window_is_first_message (window);
 982         is_last = modest_msg_view_window_is_last_message (window);
 983
 984         widget = gtk_ui_manager_get_action (parent_priv->ui_manager, "/ToolBar/ToolbarMessageBack");
 985         gtk_action_set_sensitive (widget, !is_first);
 986         widget = gtk_ui_manager_get_action (parent_priv->ui_manager, "/MenuBar/ViewMenu/ViewPreviousMessageMenu");
 987         gtk_action_set_sensitive (widget, !is_first);
 988
 989         widget = gtk_ui_manager_get_action (parent_priv->ui_manager, "/ToolBar/ToolbarMessageNext");
 990         gtk_action_set_sensitive (widget, !is_last);
 991         widget = gtk_ui_manager_get_action (parent_priv->ui_manager, "/MenuBar/ViewMenu/ViewNextMessageMenu");
 992         gtk_action_set_sensitive (widget, !is_last);
 993
 994         folder_type = modest_msg_view_window_get_folder_type (MODEST_MSG_VIEW_WINDOW (window));
 995         is_not_sent = ((folder_type == TNY_FOLDER_TYPE_DRAFTS)||(folder_type == TNY_FOLDER_TYPE_OUTBOX));
 996         widget = gtk_ui_manager_get_action (parent_priv->ui_manager, "/ToolBar/ToolbarMessageReply");
 997         gtk_action_set_sensitive (widget, !is_not_sent);
 998         widget = gtk_ui_manager_get_action (parent_priv->ui_manager, "/MenuBar/MessageMenu/MessageReplyMenu");
 999         gtk_action_set_sensitive (widget, !is_not_sent);
1000         widget = gtk_ui_manager_get_action (parent_priv->ui_manager, "/MenuBar/MessageMenu/MessageReplyAllMenu");
1001         gtk_action_set_sensitive (widget, !is_not_sent);
1002         widget = gtk_ui_manager_get_action (parent_priv->ui_manager, "/MenuBar/MessageMenu/MessageForwardMenu");
1003         gtk_action_set_sensitive (widget, !is_not_sent);
1004
1005 }
1006
1007 static void
1008 modest_msg_view_window_update_priority (ModestMsgViewWindow *window)
1009 {
1010         ModestMsgViewWindowPrivate *priv;
1011         TnyHeaderFlags flags = 0;
1012
1013         priv = MODEST_MSG_VIEW_WINDOW_GET_PRIVATE (window);
1014
1015         if (priv->header_model) {
1016                 TnyHeader *header;
1017
1018                 gtk_tree_model_get (priv->header_model, &(priv->iter), TNY_GTK_HEADER_LIST_MODEL_INSTANCE_COLUMN,
1019                                     &header, -1);
1020                 flags = tny_header_get_flags (header);
1021         }
1022
1023         modest_msg_view_set_priority (MODEST_MSG_VIEW(priv->msg_view), flags);
1024
1025 }
1026
1027 static gboolean
1028 modest_msg_view_window_window_state_event (GtkWidget *widget, GdkEventWindowState *event, gpointer userdata)
1029 {
1030         if (event->changed_mask & GDK_WINDOW_STATE_FULLSCREEN) {
1031                 ModestWindowPrivate *parent_priv;
1032                 ModestWindowMgr *mgr;
1033                 gboolean is_fullscreen;
1034                 GtkAction *fs_toggle_action;
1035                 gboolean active;
1036
1037                 mgr = modest_runtime_get_window_mgr ();
1038                 is_fullscreen = (modest_window_mgr_get_fullscreen_mode (mgr))?1:0;
1039
1040                 parent_priv = MODEST_WINDOW_GET_PRIVATE (widget);
1041
1042                 fs_toggle_action = gtk_ui_manager_get_action (parent_priv->ui_manager, "/MenuBar/ViewMenu/ViewToggleFullscreenMenu");
1043                 active = (gtk_toggle_action_get_active (GTK_TOGGLE_ACTION (fs_toggle_action)))?1:0;
1044                 if (is_fullscreen != active) {
1045                         gtk_toggle_action_set_active (GTK_TOGGLE_ACTION (fs_toggle_action), is_fullscreen);
1046                 }
1047         }
1048
1049         return FALSE;
1050
1051 }
1052
1053 void
1054 modest_msg_view_window_toggle_fullscreen (ModestMsgViewWindow *window)
1055 {
1056                 ModestWindowPrivate *parent_priv;
1057                 GtkAction *fs_toggle_action;
1058                 parent_priv = MODEST_WINDOW_GET_PRIVATE (window);
1059
1060                 fs_toggle_action = gtk_ui_manager_get_action (parent_priv->ui_manager, "/MenuBar/ViewMenu/ViewToggleFullscreenMenu");
1061                 gtk_toggle_action_set_active (GTK_TOGGLE_ACTION (fs_toggle_action),
1062                                               !gtk_toggle_action_get_active (GTK_TOGGLE_ACTION (fs_toggle_action)));
1063 }
1064
1065 static void
1066 set_homogeneous (GtkWidget *widget,
1067                  gpointer data)
1068 {
1069         if (GTK_IS_TOOL_ITEM (widget)) {
1070                 gtk_tool_item_set_expand (GTK_TOOL_ITEM (widget), TRUE);
1071                 gtk_tool_item_set_homogeneous (GTK_TOOL_ITEM (widget), TRUE);
1072         }
1073 }
1074
1075 static void
1076 modest_msg_view_window_show_toolbar (ModestWindow *self,
1077                                      gboolean show_toolbar)
1078 {
1079         ModestMsgViewWindowPrivate *priv = NULL;
1080         ModestWindowPrivate *parent_priv;
1081         GtkWidget *reply_button = NULL, *menu = NULL;
1082         GtkWidget *placeholder = NULL;
1083         gint insert_index;
1084
1085         parent_priv = MODEST_WINDOW_GET_PRIVATE(self);
1086         priv = MODEST_MSG_VIEW_WINDOW_GET_PRIVATE(self);
1087
1088         if (!parent_priv->toolbar && show_toolbar) {
1089                 parent_priv->toolbar = gtk_ui_manager_get_widget (parent_priv->ui_manager,
1090                                                                   "/ToolBar");
1091
1092                 /* Set homogeneous toolbar */
1093                 gtk_container_foreach (GTK_CONTAINER (parent_priv->toolbar),
1094                                        set_homogeneous, NULL);
1095
1096                 priv->progress_toolitem = GTK_WIDGET (gtk_tool_item_new ());
1097                 priv->cancel_toolitem = gtk_ui_manager_get_widget (parent_priv->ui_manager, "/ToolBar/ToolbarCancel");
1098                 priv->next_toolitem = gtk_ui_manager_get_widget (parent_priv->ui_manager, "/ToolBar/ToolbarMessageNext");
1099                 priv->prev_toolitem = gtk_ui_manager_get_widget (parent_priv->ui_manager, "/ToolBar/ToolbarMessageBack");
1100                 gtk_tool_item_set_expand (GTK_TOOL_ITEM (priv->progress_toolitem), FALSE);
1101                 gtk_tool_item_set_homogeneous (GTK_TOOL_ITEM (priv->progress_toolitem), FALSE);
1102                 gtk_tool_item_set_homogeneous (GTK_TOOL_ITEM (priv->cancel_toolitem), FALSE);
1103                 gtk_tool_item_set_expand (GTK_TOOL_ITEM (priv->cancel_toolitem), FALSE);
1104
1105                 /* Add ProgressBar (Transfer toolbar) */
1106                 priv->progress_bar = modest_progress_bar_widget_new ();
1107                 gtk_widget_set_no_show_all (priv->progress_bar, TRUE);
1108                 placeholder = gtk_ui_manager_get_widget (parent_priv->ui_manager, "/ToolBar/ProgressbarView");
1109                 insert_index = gtk_toolbar_get_item_index(GTK_TOOLBAR (parent_priv->toolbar), GTK_TOOL_ITEM(placeholder));
1110                 gtk_container_add (GTK_CONTAINER (priv->progress_toolitem), priv->progress_bar);
1111                 gtk_toolbar_insert(GTK_TOOLBAR(parent_priv->toolbar), GTK_TOOL_ITEM (priv->progress_toolitem), insert_index);
1112
1113                 /* Connect cancel 'clicked' signal to abort progress mode */
1114                 g_signal_connect(priv->cancel_toolitem, "clicked",
1115                                  G_CALLBACK(cancel_progressbar),
1116                                  self);
1117
1118                 /* Add it to the observers list */
1119                 priv->progress_widgets = g_slist_prepend(priv->progress_widgets, priv->progress_bar);
1120
1121                 /* Add to window */
1122                 hildon_window_add_toolbar (HILDON_WINDOW (self),
1123                                            GTK_TOOLBAR (parent_priv->toolbar));
1124
1125
1126                 /* Set reply button tap and hold menu */
1127                 reply_button = gtk_ui_manager_get_widget (parent_priv->ui_manager,
1128                                                           "/ToolBar/ToolbarMessageReply");
1129                 menu = gtk_ui_manager_get_widget (parent_priv->ui_manager,
1130                                                   "/ToolbarReplyCSM");
1131                 gtk_widget_tap_and_hold_setup (GTK_WIDGET (reply_button), menu, NULL, 0);
1132         }
1133
1134         /* TODO: Why is this sometimes NULL? murrayc */
1135         if (parent_priv->toolbar) {
1136                 if (show_toolbar) {
1137                         gtk_widget_show (GTK_WIDGET (parent_priv->toolbar));
1138                         set_toolbar_mode (MODEST_MSG_VIEW_WINDOW(self), TOOLBAR_MODE_NORMAL);
1139                 } else
1140                         gtk_widget_hide (GTK_WIDGET (parent_priv->toolbar));
1141         }
1142 }
1143
1144 static void
1145 modest_msg_view_window_clipboard_owner_change (GtkClipboard *clipboard,
1146                                                GdkEvent *event,
1147                                                ModestMsgViewWindow *window)
1148 {
1149         ModestWindowPrivate *parent_priv;
1150         GtkAction *action;
1151         gboolean is_address;
1152         gchar *selection;
1153
1154         parent_priv = MODEST_WINDOW_GET_PRIVATE (window);
1155         selection = gtk_clipboard_wait_for_text (clipboard);
1156
1157         g_message ("SELECTION %s", selection);
1158         is_address = ((selection != NULL) && (modest_text_utils_validate_recipient (selection)));
1159         g_free (selection);
1160
1161         action = gtk_ui_manager_get_action (parent_priv->ui_manager, "/MenuBar/ToolsMenu/ToolsAddToContactsMenu");
1162         gtk_action_set_sensitive (action, is_address);
1163
1164 }
1165
1166 static void
1167 cancel_progressbar (GtkToolButton *toolbutton,
1168                     ModestMsgViewWindow *self)
1169 {
1170         GSList *tmp;
1171         ModestMsgViewWindowPrivate *priv;
1172
1173         priv = MODEST_MSG_VIEW_WINDOW_GET_PRIVATE(self);
1174
1175         /* Get operation observers and cancel its current operation */
1176         tmp = priv->progress_widgets;
1177         while (tmp) {
1178                 modest_progress_object_cancel_current_operation (MODEST_PROGRESS_OBJECT(tmp->data));
1179                 tmp=g_slist_next(tmp);
1180         }
1181 }
1182
1183 static void
1184 on_queue_changed (ModestMailOperationQueue *queue,
1185                   ModestMailOperation *mail_op,
1186                   ModestMailOperationQueueNotification type,
1187                   ModestMsgViewWindow *self)
1188 {
1189         GSList *tmp;
1190         ModestMsgViewWindowPrivate *priv;
1191         ModestMailOperationId op_id;
1192         ModestToolBarModes mode;
1193
1194         g_return_if_fail (MODEST_IS_MSG_VIEW_WINDOW (self));
1195         priv = MODEST_MSG_VIEW_WINDOW_GET_PRIVATE(self);
1196
1197         /* Get toolbar mode from operation id*/
1198         op_id = modest_mail_operation_get_id (mail_op);
1199         switch (op_id) {
1200         case MODEST_MAIL_OPERATION_ID_SEND:
1201         case MODEST_MAIL_OPERATION_ID_RECEIVE:
1202                 mode = TOOLBAR_MODE_TRANSFER;
1203                 break;
1204         default:
1205                 mode = TOOLBAR_MODE_NORMAL;
1206
1207         }
1208
1209         /* Add operation observers and change toolbar if neccessary*/
1210         tmp = priv->progress_widgets;
1211         switch (type) {
1212         case MODEST_MAIL_OPERATION_QUEUE_OPERATION_ADDED:
1213                 if (mode != TOOLBAR_MODE_NORMAL)
1214                         set_toolbar_mode (MODEST_MSG_VIEW_WINDOW(self), mode);
1215                 while (tmp) {
1216                         modest_progress_object_add_operation (MODEST_PROGRESS_OBJECT (tmp->data),
1217                                                               mail_op);
1218                         tmp = g_slist_next (tmp);
1219                 }
1220                 break;
1221         case MODEST_MAIL_OPERATION_QUEUE_OPERATION_REMOVED:
1222                 if (mode != TOOLBAR_MODE_NORMAL)
1223                         set_toolbar_mode (MODEST_MSG_VIEW_WINDOW(self), TOOLBAR_MODE_NORMAL);
1224                 while (tmp) {
1225                         modest_progress_object_remove_operation (MODEST_PROGRESS_OBJECT (tmp->data),
1226                                                                  mail_op);
1227                         tmp = g_slist_next (tmp);
1228                 }
1229                 break;
1230         }
1231 }