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