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

   1 /* Copyright (c) 2006, 2007, 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
  30 #include <config.h>
  31 #include <tny-gtk-text-buffer-stream.h>
  32 #include <string.h>
  33 #include <regex.h>
  34 #include <ctype.h>
  35 #include <stdlib.h>
  36 #include <glib/gi18n.h>
  37 #include <tny-list.h>
  38 #include <tny-simple-list.h>
  39 #include <tny-vfs-stream.h>
  40
  41 #include <modest-tny-msg.h>
  42 #include <modest-text-utils.h>
  43 #include <widgets/modest-msg-view.h>
  44 #ifdef MODEST_TOOLKIT_HILDON2
  45 #include <widgets/modest-compact-mail-header-view.h>
  46 #else
  47 #include <widgets/modest-mail-header-view.h>
  48 #endif
  49 #include <widgets/modest-attachments-view.h>
  50 #include <modest-marshal.h>
  51 #include <widgets/modest-gtkhtml-mime-part-view.h>
  52 #include <widgets/modest-gtkhtml-msg-view.h>
  53 #include <widgets/modest-isearch-view.h>
  54 #include <widgets/modest-ui-constants.h>
  55
  56 /* FIXNE: we should have no maemo-deps in widgets/ */
  57 #ifndef MODEST_TOOLKIT_GTK
  58 #include "maemo/modest-hildon-includes.h"
  59 #endif /*!MODEST_TOOLKIT_GTK*/
  60
  61
  62 /* 'private'/'protected' functions */
  63 static void     modest_gtkhtml_msg_view_class_init   (ModestGtkhtmlMsgViewClass *klass);
  64 static void     tny_msg_view_init (gpointer g, gpointer iface_data);
  65 static void     tny_mime_part_view_init (gpointer g, gpointer iface_data);
  66 static void     modest_mime_part_view_init (gpointer g, gpointer iface_data);
  67 static void     modest_zoomable_init (gpointer g, gpointer iface_data);
  68 static void     modest_isearch_view_init (gpointer g, gpointer iface_data);
  69 static void     modest_msg_view_init (gpointer g, gpointer iface_data);
  70 static void     modest_gtkhtml_msg_view_init         (ModestGtkhtmlMsgView *obj);
  71 static void     modest_gtkhtml_msg_view_finalize     (GObject *obj);
  72 static void     modest_gtkhtml_msg_view_destroy     (GtkObject *obj);
  73 static void     set_property (GObject *object, guint prop_id, const GValue *value, GParamSpec *pspec);
  74 static void     get_property (GObject *object, guint prop_id, GValue *value, GParamSpec *pspec);
  75
  76 /* headers signals */
  77 static void on_recpt_activated (ModestMailHeaderView *header_view, const gchar *address, ModestGtkhtmlMsgView *msg_view);
  78 static void on_show_details (ModestMailHeaderView *header_view, ModestGtkhtmlMsgView *msg_view);
  79 static void on_attachment_activated (ModestAttachmentsView * att_view, TnyMimePart *mime_part, gpointer userdata);
  80 static void on_view_images_clicked (GtkButton * button, gpointer self);
  81
  82 /* body view signals */
  83 static gboolean on_activate_link (GtkWidget *widget, const gchar *uri, ModestGtkhtmlMsgView *msg_view);
  84 static gboolean on_fetch_url (GtkWidget *widget, const gchar *uri, TnyStream *stream,
  85                               ModestGtkhtmlMsgView *msg_view);
  86 static gboolean on_link_hover (GtkWidget *widget, const gchar *uri, ModestGtkhtmlMsgView *msg_view);
  87
  88 #ifdef MAEMO_CHANGES
  89 static void     on_tap_and_hold (GtkWidget *widget, gpointer userdata);
  90 static gboolean on_tap_and_hold_query (GtkWidget *widget, GdkEvent *event, gpointer userdata);
  91 #endif /*MAEMO_CHANGES*/
  92
  93
  94 /* size allocation and drawing handlers */
  95 static void get_view_allocation (ModestGtkhtmlMsgView *msg_view, GtkAllocation *allocation);
  96 static void size_request (GtkWidget *widget, GtkRequisition *req);
  97 static void size_allocate (GtkWidget *widget, GtkAllocation *alloc);
  98 static void realize (GtkWidget *widget);
  99 static void unrealize (GtkWidget *widget);
 100 static gint expose (GtkWidget *widget, GdkEventExpose *event);
 101 static void reclamp_adjustment (GtkAdjustment *adj, gboolean *value_changed);
 102 static void set_hadjustment_values (ModestGtkhtmlMsgView *msg_view, gboolean *value_changed);
 103 static void set_scroll_adjustments (ModestGtkhtmlMsgView *msg_view, GtkAdjustment *hadj, GtkAdjustment *vadj);
 104 static void adjustment_value_changed (GtkAdjustment *adj, gpointer data);
 105 static void html_adjustment_changed (GtkAdjustment *adj, gpointer data);
 106 static void disconnect_vadjustment (ModestGtkhtmlMsgView *obj);
 107 static void disconnect_hadjustment (ModestGtkhtmlMsgView *obj);
 108 static gboolean idle_readjust_scroll (ModestGtkhtmlMsgView *obj);
 109
 110 /* vertical panning implementation */
 111 #ifdef MAEMO_CHANGES
 112 static gboolean motion_notify_event (GtkWidget *widget,
 113                                      GdkEventMotion *event,
 114                                      gpointer userdata);
 115 #endif
 116
 117 static gboolean
 118 button_press_event (GtkWidget *widget,
 119                     GdkEventButton *event,
 120                     gpointer userdata);
 121 static gboolean
 122 button_release_event (GtkWidget *widget,
 123                       GdkEventButton *event,
 124                       gpointer userdata);
 125
 126 /* GtkContainer methods */
 127 static void forall (GtkContainer *container, gboolean include_internals,
 128                     GtkCallback callback, gpointer userdata);
 129 static void container_remove (GtkContainer *container, GtkWidget *widget);
 130
 131 /* TnyMimePartView implementation */
 132 static void modest_msg_view_mp_clear (TnyMimePartView *self);
 133 static void modest_msg_view_mp_set_part (TnyMimePartView *self, TnyMimePart *part);
 134 static void modest_msg_view_mp_set_part_default (TnyMimePartView *self, TnyMimePart *part);
 135 static TnyMimePart* modest_msg_view_mp_get_part (TnyMimePartView *self);
 136 static TnyMimePart* modest_msg_view_mp_get_part_default (TnyMimePartView *self);
 137 /* ModestMimePartView implementation */
 138 static gboolean modest_msg_view_mp_is_empty (ModestMimePartView *self);
 139 static gboolean modest_msg_view_mp_is_empty_default (ModestMimePartView *self);
 140 /* TnyMsgView implementation */
 141 static TnyMsg *modest_msg_view_get_msg (TnyMsgView *self);
 142 static TnyMsg *modest_msg_view_get_msg_default (TnyMsgView *self);
 143 static void modest_msg_view_set_msg (TnyMsgView *self, TnyMsg *msg);
 144 static void modest_msg_view_set_msg_default (TnyMsgView *self, TnyMsg *msg);
 145 static void modest_msg_view_clear (TnyMsgView *self);
 146 static void modest_msg_view_clear_default (TnyMsgView *self);
 147 static void modest_msg_view_set_unavailable (TnyMsgView *self);
 148 static void modest_msg_view_set_unavailable_default (TnyMsgView *self);
 149 static TnyMimePartView *modest_msg_view_create_mime_part_view_for (TnyMsgView *self, TnyMimePart *part);
 150 static TnyMimePartView *modest_msg_view_create_mime_part_view_for_default (TnyMsgView *self, TnyMimePart *part);
 151 static TnyMsgView *modest_msg_view_create_new_inline_viewer (TnyMsgView *self);
 152 static TnyMsgView *modest_msg_view_create_new_inline_viewer_default (TnyMsgView *self);
 153 /* ModestZoomable implementation */
 154 static gdouble modest_msg_view_get_zoom (ModestZoomable *self);
 155 static void modest_msg_view_set_zoom (ModestZoomable *self, gdouble value);
 156 static gboolean modest_msg_view_zoom_minus (ModestZoomable *self);
 157 static gboolean modest_msg_view_zoom_plus (ModestZoomable *self);
 158 static gdouble modest_msg_view_get_zoom_default (ModestZoomable *self);
 159 static void modest_msg_view_set_zoom_default (ModestZoomable *self, gdouble value);
 160 static gboolean modest_msg_view_zoom_minus_default (ModestZoomable *self);
 161 static gboolean modest_msg_view_zoom_plus_default (ModestZoomable *self);
 162 /* ModestISearchView implementation */
 163 static gboolean modest_msg_view_search (ModestISearchView *self, const gchar *string);
 164 static gboolean modest_msg_view_search_default (ModestISearchView *self, const gchar *string);
 165 static gboolean modest_msg_view_search_next (ModestISearchView *self);
 166 static gboolean modest_msg_view_search_next_default (ModestISearchView *self);
 167 /* ModestMsgView implementation */
 168 static GtkAdjustment *modest_gtkhtml_msg_view_get_vadjustment (ModestMsgView *self);
 169 static GtkAdjustment *modest_gtkhtml_msg_view_get_hadjustment (ModestMsgView *self);
 170 static void modest_gtkhtml_msg_view_set_vadjustment (ModestMsgView *self, GtkAdjustment *vadj);
 171 static void modest_gtkhtml_msg_view_set_hadjustment (ModestMsgView *self, GtkAdjustment *hadj);
 172 static void modest_gtkhtml_msg_view_set_shadow_type (ModestMsgView *self, GtkShadowType type);
 173 static GtkShadowType modest_gtkhtml_msg_view_get_shadow_type (ModestMsgView *self);
 174 static TnyHeaderFlags modest_gtkhtml_msg_view_get_priority (ModestMsgView *self);
 175 static void modest_gtkhtml_msg_view_set_priority (ModestMsgView *self, TnyHeaderFlags flags);
 176 static TnyList *modest_gtkhtml_msg_view_get_selected_attachments (ModestMsgView *self);
 177 static TnyList *modest_gtkhtml_msg_view_get_attachments (ModestMsgView *self);
 178 static void modest_gtkhtml_msg_view_grab_focus (ModestMsgView *self);
 179 static void modest_gtkhtml_msg_view_remove_attachment (ModestMsgView *view, TnyMimePart *attachment);
 180 static GtkAdjustment *modest_gtkhtml_msg_view_get_vadjustment_default (ModestMsgView *self);
 181 static GtkAdjustment *modest_gtkhtml_msg_view_get_hadjustment_default (ModestMsgView *self);
 182 static void modest_gtkhtml_msg_view_set_vadjustment_default (ModestMsgView *self, GtkAdjustment *vadj);
 183 static void modest_gtkhtml_msg_view_set_hadjustment_default (ModestMsgView *self, GtkAdjustment *hadj);
 184 static void modest_gtkhtml_msg_view_set_shadow_type_default (ModestMsgView *self, GtkShadowType type);
 185 static GtkShadowType modest_gtkhtml_msg_view_get_shadow_type_default (ModestMsgView *self);
 186 static TnyHeaderFlags modest_gtkhtml_msg_view_get_priority_default (ModestMsgView *self);
 187 static void modest_gtkhtml_msg_view_set_priority_default (ModestMsgView *self, TnyHeaderFlags flags);
 188 static TnyList *modest_gtkhtml_msg_view_get_selected_attachments_default (ModestMsgView *self);
 189 static TnyList *modest_gtkhtml_msg_view_get_attachments_default (ModestMsgView *self);
 190 static void modest_gtkhtml_msg_view_grab_focus_default (ModestMsgView *self);
 191 static void modest_gtkhtml_msg_view_remove_attachment_default (ModestMsgView *view, TnyMimePart *attachment);
 192
 193 /* internal api */
 194 static TnyMsg   *get_message   (ModestGtkhtmlMsgView *self);
 195 static void     set_message    (ModestGtkhtmlMsgView *self, TnyMsg *tny_msg);
 196 static gboolean is_empty       (ModestGtkhtmlMsgView *self);
 197 static void     set_zoom       (ModestGtkhtmlMsgView *self, gdouble zoom);
 198 static gdouble  get_zoom       (ModestGtkhtmlMsgView *self);
 199 static gboolean search         (ModestGtkhtmlMsgView *self, const gchar *search);
 200 static gboolean search_next    (ModestGtkhtmlMsgView *self);
 201 static GtkAdjustment *get_vadjustment (ModestGtkhtmlMsgView *self);
 202 static GtkAdjustment *get_hadjustment (ModestGtkhtmlMsgView *self);
 203 static void set_vadjustment (ModestGtkhtmlMsgView *self, GtkAdjustment *vadj);
 204 static void set_hadjustment (ModestGtkhtmlMsgView *self, GtkAdjustment *hadj);
 205 static void set_shadow_type (ModestGtkhtmlMsgView *self, GtkShadowType type);
 206 static GtkShadowType get_shadow_type (ModestGtkhtmlMsgView *self);
 207 static TnyHeaderFlags get_priority (ModestGtkhtmlMsgView *self);
 208 static void set_priority (ModestGtkhtmlMsgView *self, TnyHeaderFlags flags);
 209 static TnyList *get_selected_attachments (ModestGtkhtmlMsgView *self);
 210 static TnyList *get_attachments (ModestGtkhtmlMsgView *self);
 211 static void grab_focus (ModestGtkhtmlMsgView *self);
 212 static void remove_attachment (ModestGtkhtmlMsgView *view, TnyMimePart *attachment);
 213
 214 /* list properties */
 215 enum {
 216         PROP_0,
 217         PROP_HADJUSTMENT,
 218         PROP_VADJUSTMENT,
 219         PROP_SHADOW_TYPE
 220 };
 221
 222 typedef struct _ModestGtkhtmlMsgViewPrivate ModestGtkhtmlMsgViewPrivate;
 223 struct _ModestGtkhtmlMsgViewPrivate {
 224         GtkWidget   *body_view;
 225         GtkWidget   *mail_header_view;
 226         GtkWidget   *attachments_view;
 227
 228         TnyMsg      *msg;
 229
 230         /* embedded elements */
 231         GtkWidget   *headers_box;
 232         GtkWidget   *html_scroll;
 233         GtkWidget   *attachments_box;
 234         GtkWidget   *view_images_button;
 235
 236         /* internal adjustments for set_scroll_adjustments */
 237         GtkAdjustment *hadj;
 238         GtkAdjustment *vadj;
 239         GtkShadowType shadow_type;
 240
 241         /* gdk windows for drawing */
 242         GdkWindow *view_window;
 243         GdkWindow *headers_window;
 244         GdkWindow *html_window;
 245
 246         /* id handler for dragged scroll */
 247         guint idle_motion_id;
 248
 249         /* zoom */
 250         gdouble current_zoom;
 251
 252         /* link click management */
 253         gchar *last_url;
 254 };
 255
 256 #define MODEST_GTKHTML_MSG_VIEW_GET_PRIVATE(o)      (G_TYPE_INSTANCE_GET_PRIVATE((o), \
 257                                                                                  MODEST_TYPE_GTKHTML_MSG_VIEW, \
 258                                                                                  ModestGtkhtmlMsgViewPrivate))
 259
 260 /* globals */
 261 static GtkContainerClass *parent_class = NULL;
 262
 263 GType
 264 modest_gtkhtml_msg_view_get_type (void)
 265 {
 266         static GType my_type = 0;
 267         if (!my_type) {
 268                 static const GTypeInfo my_info = {
 269                         sizeof(ModestGtkhtmlMsgViewClass),
 270                         NULL,           /* base init */
 271                         NULL,           /* base finalize */
 272                         (GClassInitFunc) modest_gtkhtml_msg_view_class_init,
 273                         NULL,           /* class finalize */
 274                         NULL,           /* class data */
 275                         sizeof(ModestGtkhtmlMsgView),
 276                         1,              /* n_preallocs */
 277                         (GInstanceInitFunc) modest_gtkhtml_msg_view_init,
 278                         NULL
 279                 };
 280                 static const GInterfaceInfo tny_msg_view_info =
 281                 {
 282                   (GInterfaceInitFunc) tny_msg_view_init, /* interface_init */
 283                   NULL,         /* interface_finalize */
 284                   NULL          /* interface_data */
 285                 };
 286
 287                 static const GInterfaceInfo tny_mime_part_view_info =
 288                 {
 289                   (GInterfaceInitFunc) tny_mime_part_view_init, /* interface_init */
 290                   NULL,         /* interface_finalize */
 291                   NULL          /* interface_data */
 292                 };
 293
 294                 static const GInterfaceInfo modest_mime_part_view_info =
 295                 {
 296                   (GInterfaceInitFunc) modest_mime_part_view_init, /* interface_init */
 297                   NULL,         /* interface_finalize */
 298                   NULL          /* interface_data */
 299                 };
 300
 301                 static const GInterfaceInfo modest_zoomable_info =
 302                 {
 303                   (GInterfaceInitFunc) modest_zoomable_init, /* interface_init */
 304                   NULL,         /* interface_finalize */
 305                   NULL          /* interface_data */
 306                 };
 307
 308                 static const GInterfaceInfo modest_isearch_view_info =
 309                 {
 310                   (GInterfaceInitFunc) modest_isearch_view_init, /* interface_init */
 311                   NULL,         /* interface_finalize */
 312                   NULL          /* interface_data */
 313                 };
 314
 315                 static const GInterfaceInfo modest_msg_view_info =
 316                 {
 317                   (GInterfaceInitFunc) modest_msg_view_init, /* interface_init */
 318                   NULL,         /* interface_finalize */
 319                   NULL          /* interface_data */
 320                 };
 321
 322                 my_type = g_type_register_static (GTK_TYPE_CONTAINER,
 323                                                   "ModestGtkhtmlMsgView",
 324                                                   &my_info, 0);
 325
 326                 g_type_add_interface_static (my_type, TNY_TYPE_MIME_PART_VIEW,
 327                         &tny_mime_part_view_info);
 328
 329                 g_type_add_interface_static (my_type, MODEST_TYPE_MIME_PART_VIEW,
 330                         &modest_mime_part_view_info);
 331
 332                 g_type_add_interface_static (my_type, TNY_TYPE_MSG_VIEW,
 333                         &tny_msg_view_info);
 334
 335                 g_type_add_interface_static (my_type, MODEST_TYPE_ZOOMABLE,
 336                         &modest_zoomable_info);
 337
 338                 g_type_add_interface_static (my_type, MODEST_TYPE_ISEARCH_VIEW,
 339                         &modest_isearch_view_info);
 340
 341                 g_type_add_interface_static (my_type, MODEST_TYPE_MSG_VIEW,
 342                         &modest_msg_view_info);
 343         }
 344         return my_type;
 345 }
 346
 347 static void
 348 modest_gtkhtml_msg_view_class_init (ModestGtkhtmlMsgViewClass *klass)
 349 {
 350         GObjectClass *gobject_class;
 351         GtkWidgetClass *widget_class;
 352         GtkObjectClass *gtkobject_class;
 353         GtkContainerClass *container_class;
 354         gobject_class = (GObjectClass*) klass;
 355         widget_class = (GtkWidgetClass *) klass;
 356         gtkobject_class = (GtkObjectClass *) klass;
 357         container_class = (GtkContainerClass *) klass;
 358
 359         parent_class            = g_type_class_peek_parent (klass);
 360         gobject_class->finalize = modest_gtkhtml_msg_view_finalize;
 361         gobject_class->set_property = set_property;
 362         gobject_class->get_property = get_property;
 363         gtkobject_class->destroy = modest_gtkhtml_msg_view_destroy;
 364
 365         widget_class->realize = realize;
 366         widget_class->unrealize = unrealize;
 367         widget_class->expose_event = expose;
 368         widget_class->size_request = size_request;
 369         widget_class->size_allocate = size_allocate;
 370
 371         container_class->forall = forall;
 372         container_class->remove = container_remove;
 373
 374         klass->set_scroll_adjustments = set_scroll_adjustments;
 375         klass->get_part_func = modest_msg_view_mp_get_part_default;
 376         klass->set_part_func = modest_msg_view_mp_set_part_default;
 377         klass->is_empty_func = modest_msg_view_mp_is_empty_default;
 378         klass->get_msg_func = modest_msg_view_get_msg_default;
 379         klass->set_msg_func = modest_msg_view_set_msg_default;
 380         klass->set_unavailable_func = modest_msg_view_set_unavailable_default;
 381         klass->clear_func = modest_msg_view_clear_default;
 382         klass->create_mime_part_view_for_func = modest_msg_view_create_mime_part_view_for_default;
 383         klass->create_new_inline_viewer_func = modest_msg_view_create_new_inline_viewer_default;
 384         klass->get_zoom_func = modest_msg_view_get_zoom_default;
 385         klass->set_zoom_func = modest_msg_view_set_zoom_default;
 386         klass->zoom_minus_func = modest_msg_view_zoom_minus_default;
 387         klass->zoom_plus_func = modest_msg_view_zoom_plus_default;
 388         klass->search_func = modest_msg_view_search_default;
 389         klass->search_next_func = modest_msg_view_search_next_default;
 390         klass->get_vadjustment_func = modest_gtkhtml_msg_view_get_vadjustment_default;
 391         klass->get_hadjustment_func = modest_gtkhtml_msg_view_get_hadjustment_default;
 392         klass->set_vadjustment_func = modest_gtkhtml_msg_view_set_vadjustment_default;
 393         klass->set_hadjustment_func = modest_gtkhtml_msg_view_set_hadjustment_default;
 394         klass->get_shadow_type_func = modest_gtkhtml_msg_view_get_shadow_type_default;
 395         klass->set_shadow_type_func = modest_gtkhtml_msg_view_set_shadow_type_default;
 396         klass->get_priority_func = modest_gtkhtml_msg_view_get_priority_default;
 397         klass->set_priority_func = modest_gtkhtml_msg_view_set_priority_default;
 398         klass->get_selected_attachments_func = modest_gtkhtml_msg_view_get_selected_attachments_default;
 399         klass->get_attachments_func = modest_gtkhtml_msg_view_get_attachments_default;
 400         klass->grab_focus_func = modest_gtkhtml_msg_view_grab_focus_default;
 401         klass->remove_attachment_func = modest_gtkhtml_msg_view_remove_attachment_default;
 402
 403         g_type_class_add_private (gobject_class, sizeof(ModestGtkhtmlMsgViewPrivate));
 404
 405         g_object_class_install_property (gobject_class,
 406                                          PROP_HADJUSTMENT,
 407                                          g_param_spec_object ("hadjustment",
 408                                                               _("Horizontal adjustment"),
 409                                                               _("GtkAdjustment with information of the horizontal visible position"),
 410                                                               GTK_TYPE_ADJUSTMENT,
 411                                                               G_PARAM_READABLE | G_PARAM_WRITABLE | G_PARAM_CONSTRUCT));
 412
 413         g_object_class_install_property (gobject_class,
 414                                          PROP_VADJUSTMENT,
 415                                          g_param_spec_object ("vadjustment",
 416                                                               _("Vertical adjustment"),
 417                                                               _("GtkAdjustment with information of the vertical visible position"),
 418                                                               GTK_TYPE_ADJUSTMENT,
 419                                                               G_PARAM_READABLE | G_PARAM_WRITABLE | G_PARAM_CONSTRUCT));
 420
 421         g_object_class_install_property (gobject_class,
 422                                          PROP_SHADOW_TYPE,
 423                                          g_param_spec_enum ("shadow_type",
 424                                                             _("Shadow type"),
 425                                                             _("Kind of shadow that's shown around the view"),
 426                                                             GTK_TYPE_SHADOW_TYPE,
 427                                                             GTK_SHADOW_IN,
 428                                                             G_PARAM_READABLE | G_PARAM_WRITABLE ));
 429
 430         widget_class->set_scroll_adjustments_signal =
 431                 g_signal_new ("set_scroll_adjustments",
 432                               G_OBJECT_CLASS_TYPE (gobject_class),
 433                               G_SIGNAL_RUN_LAST|G_SIGNAL_ACTION,
 434                               G_STRUCT_OFFSET (ModestGtkhtmlMsgViewClass, set_scroll_adjustments),
 435                               NULL, NULL,
 436                               modest_marshal_VOID__POINTER_POINTER,
 437                               G_TYPE_NONE, 2,
 438                               GTK_TYPE_ADJUSTMENT,
 439                               GTK_TYPE_ADJUSTMENT);
 440 }
 441
 442 static void
 443 set_property (GObject *object,
 444               guint prop_id,
 445               const GValue *value,
 446               GParamSpec *pspec)
 447 {
 448         ModestGtkhtmlMsgView *self = MODEST_GTKHTML_MSG_VIEW (object);
 449
 450         switch (prop_id) {
 451         case PROP_HADJUSTMENT:
 452                 set_hadjustment (self, g_value_get_object (value));
 453                 break;
 454         case PROP_VADJUSTMENT:
 455                 set_vadjustment (self, g_value_get_object (value));
 456                 break;
 457         case PROP_SHADOW_TYPE:
 458                 set_shadow_type (self, g_value_get_enum (value));
 459                 break;
 460         default:
 461                 G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
 462                 break;
 463         }
 464 }
 465
 466 static void
 467 get_property (GObject *object,
 468               guint prop_id,
 469               GValue *value,
 470               GParamSpec *pspec)
 471 {
 472         ModestGtkhtmlMsgView *self = MODEST_GTKHTML_MSG_VIEW (object);
 473         ModestGtkhtmlMsgViewPrivate *priv = MODEST_GTKHTML_MSG_VIEW_GET_PRIVATE (self);
 474
 475         switch (prop_id) {
 476         case PROP_HADJUSTMENT:
 477                 g_value_set_object (value, priv->hadj);
 478                 break;
 479         case PROP_VADJUSTMENT:
 480                 g_value_set_object (value, priv->vadj);
 481                 break;
 482         case PROP_SHADOW_TYPE:
 483                 g_value_set_enum (value, priv->shadow_type);
 484                 break;
 485         default:
 486                 G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
 487                 break;
 488         }
 489 }
 490
 491 static void
 492 disconnect_hadjustment (ModestGtkhtmlMsgView *self)
 493 {
 494         ModestGtkhtmlMsgViewPrivate *priv = MODEST_GTKHTML_MSG_VIEW_GET_PRIVATE (self);
 495
 496         if (priv->hadj) {
 497                 g_signal_handlers_disconnect_by_func(priv->hadj, adjustment_value_changed, self);
 498                 g_object_unref (priv->hadj);
 499                 priv->hadj = NULL;
 500         }
 501 }
 502
 503 static void
 504 disconnect_vadjustment (ModestGtkhtmlMsgView *self)
 505 {
 506         ModestGtkhtmlMsgViewPrivate *priv = MODEST_GTKHTML_MSG_VIEW_GET_PRIVATE (self);
 507
 508         if (priv->vadj) {
 509                 g_signal_handlers_disconnect_by_func(priv->vadj, adjustment_value_changed, self);
 510                 g_object_unref (priv->vadj);
 511                 priv->vadj = NULL;
 512         }
 513 }
 514
 515 static void
 516 get_view_allocation (ModestGtkhtmlMsgView *self, GtkAllocation *allocation)
 517 {
 518         /* This method gets the allocation of the widget in parent widget. It's the
 519            real position and size of the widget */
 520         ModestGtkhtmlMsgViewPrivate *priv = MODEST_GTKHTML_MSG_VIEW_GET_PRIVATE (self);
 521
 522         allocation->x = 0;
 523         allocation->y = 0;
 524
 525         if (priv->shadow_type != GTK_SHADOW_NONE) {
 526                 allocation->x = GTK_WIDGET (self)->style->xthickness;
 527                 allocation->y = GTK_WIDGET (self)->style->ythickness;
 528         }
 529
 530         allocation->width = MAX (1, (GTK_WIDGET (self)->allocation.width) - allocation->x * 2);
 531         allocation->height = MAX (1, (GTK_WIDGET (self)->allocation.height) - allocation->y * 2);
 532
 533 }
 534
 535 static void
 536 reclamp_adjustment (GtkAdjustment *adj,
 537                     gboolean *value_changed)
 538 {
 539         gdouble value = adj->value;
 540
 541         /* Correct value to be inside the expected values of a scroll */
 542
 543         value = CLAMP (value, 0, adj->upper - adj->page_size);
 544
 545         if (value != adj->value) {
 546                 adj->value = value;
 547                 if (value_changed)
 548                         *value_changed = TRUE;
 549         } else if (value_changed) {
 550                 *value_changed = FALSE;
 551         }
 552 }
 553
 554 static void
 555 set_hadjustment_values (ModestGtkhtmlMsgView *self,
 556                         gboolean *value_changed)
 557 {
 558         GtkAllocation view_allocation;
 559         GtkAdjustment *hadj = get_hadjustment (self);
 560
 561         get_view_allocation (self, &view_allocation);
 562         hadj->page_size = view_allocation.width;
 563         hadj->step_increment = view_allocation.width * 0.1;
 564         hadj->page_increment = view_allocation.width * 0.9;
 565
 566         hadj->lower = 0;
 567         hadj->upper = view_allocation.width;
 568
 569         reclamp_adjustment (hadj, value_changed);
 570
 571 }
 572
 573 static void
 574 set_vadjustment_values (ModestGtkhtmlMsgView *self,
 575                         gboolean *value_changed)
 576 {
 577         GtkAllocation view_allocation;
 578         GtkAdjustment *vadj = get_vadjustment (self);
 579         ModestGtkhtmlMsgViewPrivate *priv = MODEST_GTKHTML_MSG_VIEW_GET_PRIVATE (self);
 580         gint full_height = 0;
 581         GtkAdjustment *html_vadj;
 582
 583         get_view_allocation (self, &view_allocation);
 584         vadj->page_size = view_allocation.height;
 585         vadj->step_increment = view_allocation.height * 0.1;
 586         vadj->page_increment = view_allocation.height * 0.9;
 587
 588         vadj->lower = 0;
 589
 590         if (priv->headers_box && GTK_WIDGET_VISIBLE(priv->headers_box)) {
 591                 GtkRequisition child_requisition;
 592
 593                 gtk_widget_get_child_requisition (priv->headers_box, &child_requisition);
 594                 full_height = child_requisition.height;
 595         } else {
 596                 full_height = 0;
 597         }
 598
 599         /* Get the real height of the embedded html */
 600         if (priv->html_scroll && GTK_WIDGET_VISIBLE(priv->html_scroll)) {
 601                 html_vadj = gtk_scrolled_window_get_vadjustment (GTK_SCROLLED_WINDOW (priv->html_scroll));
 602                 full_height += html_vadj->upper;
 603         }
 604
 605         vadj->upper = MAX (view_allocation.height, full_height);
 606
 607         reclamp_adjustment (vadj, value_changed);
 608
 609 }
 610
 611 static void
 612 set_scroll_adjustments (ModestGtkhtmlMsgView *self,
 613                         GtkAdjustment *hadj,
 614                         GtkAdjustment *vadj)
 615 {
 616         ModestGtkhtmlMsgViewPrivate *priv = MODEST_GTKHTML_MSG_VIEW_GET_PRIVATE (self);
 617         set_hadjustment (self, hadj);
 618         set_vadjustment (self, vadj);
 619
 620         gtk_container_set_focus_vadjustment (GTK_CONTAINER (priv->body_view), vadj);
 621 }
 622
 623 static void
 624 realize (GtkWidget *widget)
 625 {
 626         ModestGtkhtmlMsgView *self = MODEST_GTKHTML_MSG_VIEW (widget);
 627         ModestGtkhtmlMsgViewPrivate *priv = MODEST_GTKHTML_MSG_VIEW_GET_PRIVATE (self);
 628         GtkAdjustment *hadj = get_hadjustment (self);
 629         GtkAdjustment *vadj = get_vadjustment (self);
 630         GdkWindowAttr attributes;
 631         gint event_mask;
 632         gint attributes_mask;
 633         GtkAllocation view_allocation;
 634
 635         GTK_WIDGET_SET_FLAGS (widget, GTK_REALIZED);
 636
 637         /* The structure of the GdkWindow's is:
 638          *    * widget->window: the shown gdkwindow embedding all the stuff inside
 639          *    * view_window: a backing store gdkwindow containing the headers and contents
 640          *      being scrolled. This window should have all the visible and non visible
 641          *      widgets inside.
 642          *    * headers_window: gdk window for headers_box.
 643          *    * html_window: gdk window for html_scroll (the scrolled window containing the
 644          *      body view showing the contents of the mail).
 645          */
 646
 647         attributes.x = widget->allocation.x;
 648         attributes.y = widget->allocation.y;
 649         attributes.width = widget->allocation.width;
 650         attributes.height = widget->allocation.height;
 651         attributes.window_type = GDK_WINDOW_CHILD;
 652         attributes.wclass = GDK_INPUT_OUTPUT;
 653         attributes.visual = gtk_widget_get_visual (widget);
 654         attributes.colormap = gtk_widget_get_colormap (widget);
 655
 656         event_mask = gtk_widget_get_events (widget) | GDK_EXPOSURE_MASK;
 657         attributes.event_mask = event_mask | GDK_BUTTON_PRESS_MASK;
 658         attributes_mask = GDK_WA_X | GDK_WA_Y | GDK_WA_VISUAL | GDK_WA_COLORMAP;
 659
 660         widget->window = gdk_window_new (gtk_widget_get_parent_window (widget),
 661                                          &attributes, attributes_mask);
 662         gdk_window_set_user_data (widget->window, self);
 663
 664         get_view_allocation (self, &view_allocation);
 665
 666         attributes.x = view_allocation.x;
 667         attributes.y = view_allocation.y;
 668         attributes.width = view_allocation.width;
 669         attributes.height = view_allocation.height;
 670         attributes.event_mask = 0;
 671         priv->view_window = gdk_window_new (widget->window, &attributes, attributes_mask);
 672         gdk_window_set_user_data (priv->view_window, self);
 673         gdk_window_set_back_pixmap (priv->view_window, NULL, FALSE);
 674
 675         attributes.x = -hadj->value;
 676         attributes.y = -vadj->value;
 677         attributes.width = hadj->upper;
 678         if (priv->headers_box)
 679                 attributes.height = GTK_WIDGET (priv->headers_box)->allocation.height;
 680         else
 681                 attributes.height = 1;
 682         attributes.event_mask = event_mask;
 683
 684         priv->headers_window = gdk_window_new (priv->view_window, &attributes, attributes_mask);
 685         gdk_window_set_user_data (priv->headers_window, self);
 686
 687         if (priv->headers_box)
 688                 gtk_widget_set_parent_window (priv->headers_box, priv->headers_window);
 689
 690         attributes.x = -hadj->value;
 691         if (priv->headers_box)
 692                 attributes.y = GTK_WIDGET (priv->headers_box)->allocation.height - vadj->value;
 693         else
 694                 attributes.y = -vadj->value;
 695         attributes.width = hadj->upper;
 696         if (priv->headers_box)
 697                 attributes.height = vadj->upper - GTK_WIDGET (priv->headers_box)->allocation.height;
 698         else
 699                 attributes.height = vadj->upper;
 700         attributes.event_mask = event_mask;
 701
 702         priv->html_window = gdk_window_new (priv->view_window, &attributes, attributes_mask);
 703         gdk_window_set_user_data (priv->html_window, self);
 704
 705         if (priv->html_scroll)
 706                 gtk_widget_set_parent_window (priv->html_scroll, priv->html_window);
 707
 708         widget->style = gtk_style_attach (widget->style, widget->window);
 709         gtk_style_set_background (widget->style, widget->window, GTK_STATE_NORMAL);
 710         gtk_style_set_background (widget->style, priv->headers_window, GTK_STATE_NORMAL);
 711         gtk_style_set_background (widget->style, priv->html_window, GTK_STATE_NORMAL);
 712
 713         gtk_paint_flat_box(widget->style, priv->headers_window, GTK_STATE_NORMAL,
 714                            GTK_SHADOW_NONE,
 715                            NULL, widget, "msgviewheaders",
 716                            0,0,-1,-1);
 717         gtk_paint_flat_box(widget->style, priv->html_window, GTK_STATE_NORMAL,
 718                            GTK_SHADOW_NONE,
 719                            NULL, widget, "msgviewcontents",
 720                            0,0,-1,-1);
 721
 722         gdk_window_show (priv->view_window);
 723         gdk_window_show (priv->headers_window);
 724         gdk_window_show (priv->html_window);
 725
 726 }
 727
 728 static void
 729 unrealize (GtkWidget *widget)
 730 {
 731         ModestGtkhtmlMsgView *self = MODEST_GTKHTML_MSG_VIEW (widget);
 732         ModestGtkhtmlMsgViewPrivate *priv = MODEST_GTKHTML_MSG_VIEW_GET_PRIVATE (self);
 733
 734         gdk_window_set_user_data (priv->view_window, NULL);
 735         gdk_window_destroy (priv->view_window);
 736         priv->view_window = NULL;
 737
 738         gdk_window_set_user_data (priv->headers_window, NULL);
 739         gdk_window_destroy (priv->headers_window);
 740         priv->headers_window = NULL;
 741
 742         gdk_window_set_user_data (priv->html_window, NULL);
 743         gdk_window_destroy (priv->html_window);
 744         priv->html_window = NULL;
 745
 746         if (GTK_WIDGET_CLASS (parent_class)->unrealize)
 747                 ( * GTK_WIDGET_CLASS (parent_class)->unrealize) (widget);
 748
 749 }
 750
 751 static gint
 752 expose (GtkWidget *widget,
 753         GdkEventExpose *event)
 754 {
 755         ModestGtkhtmlMsgView *self;
 756         ModestGtkhtmlMsgViewPrivate *priv;
 757
 758         if (GTK_WIDGET_DRAWABLE (widget)) {
 759                 self = MODEST_GTKHTML_MSG_VIEW (widget);
 760                 priv = MODEST_GTKHTML_MSG_VIEW_GET_PRIVATE (self);
 761                 if (event->window == widget->window) {
 762                         gtk_paint_shadow (widget->style, widget->window,
 763                                           GTK_STATE_NORMAL, priv->shadow_type,
 764                                           &event->area, widget, "msgview",
 765                                           0,0,-1,-1);
 766                 } else if (event->window == priv->headers_window) {
 767                         gtk_paint_flat_box(widget->style, priv->headers_window, GTK_STATE_NORMAL,
 768                                            GTK_SHADOW_NONE,
 769                                            &event->area, widget, "msgviewheaders",
 770                                            0,0,-1,-1);
 771                 } else if (event->window == priv->html_window) {
 772                         gtk_paint_flat_box(widget->style, priv->html_window, GTK_STATE_NORMAL,
 773                                            GTK_SHADOW_NONE,
 774                                            &event->area, widget, "msgviewcontents",
 775                                            0,0,-1,-1);
 776                 }
 777                 if (priv->headers_box)
 778                         gtk_container_propagate_expose (GTK_CONTAINER (self), priv->headers_box, event);
 779                 if (priv->html_scroll)
 780                         gtk_container_propagate_expose (GTK_CONTAINER (self), priv->html_scroll, event);
 781                 (* GTK_WIDGET_CLASS (parent_class)->expose_event) (widget, event);
 782         }
 783
 784         return FALSE;
 785 }
 786
 787 static void
 788 forall (GtkContainer *container,
 789         gboolean include_internals,
 790         GtkCallback callback,
 791         gpointer userdata)
 792 {
 793         ModestGtkhtmlMsgViewPrivate *priv = MODEST_GTKHTML_MSG_VIEW_GET_PRIVATE (container);
 794         g_return_if_fail (callback != NULL);
 795
 796         if (priv->headers_box)
 797                 (*callback) (priv->headers_box, userdata);
 798         if (priv->html_scroll)
 799                 (*callback) (priv->html_scroll, userdata);
 800 }
 801
 802 static void
 803 container_remove (GtkContainer *container,
 804                   GtkWidget *widget)
 805 {
 806         gboolean was_visible = FALSE;
 807         ModestGtkhtmlMsgViewPrivate *priv = MODEST_GTKHTML_MSG_VIEW_GET_PRIVATE (container);
 808         was_visible = GTK_WIDGET_VISIBLE (widget);
 809         if (widget == priv->headers_box) {
 810                 gtk_widget_unparent (priv->headers_box);
 811                 priv->headers_box = NULL;
 812         } else if (widget == priv->html_scroll) {
 813                 gtk_widget_unparent (priv->html_scroll);
 814                 priv->html_scroll = NULL;
 815         } else {
 816                 return;
 817         }
 818         if (was_visible)
 819                 gtk_widget_queue_resize (GTK_WIDGET(container));
 820
 821 }
 822
 823 static void
 824 size_request (GtkWidget *widget,
 825               GtkRequisition *req)
 826 {
 827         ModestGtkhtmlMsgViewPrivate *priv = MODEST_GTKHTML_MSG_VIEW_GET_PRIVATE (widget);
 828         GtkRequisition child_req;
 829
 830         req->width = 0;
 831         req->height = 0;
 832
 833         gtk_widget_size_request (priv->headers_box, &child_req);
 834         req->width = child_req.width;
 835         req->height += child_req.height;
 836         gtk_widget_size_request (priv->html_scroll, &child_req);
 837         req->width = MAX (child_req.width, req->width);
 838         req->height += child_req.height;
 839
 840 }
 841
 842 static void
 843 size_allocate (GtkWidget *widget,
 844                GtkAllocation *allocation)
 845 {
 846         ModestGtkhtmlMsgView *self = MODEST_GTKHTML_MSG_VIEW (widget);
 847         ModestGtkhtmlMsgViewPrivate *priv = MODEST_GTKHTML_MSG_VIEW_GET_PRIVATE (self);
 848         gboolean hadj_value_changed, vadj_value_changed;
 849         GtkAllocation headers_allocation, html_allocation, view_allocation;
 850         GtkAdjustment *html_vadj;
 851
 852         if (GTK_WIDGET_MAPPED (widget) &&
 853             priv->shadow_type != GTK_SHADOW_NONE &&
 854             (allocation->width != widget->allocation.width ||
 855              allocation->height != widget->allocation.height))
 856                 gdk_window_invalidate_rect (widget->window, NULL, FALSE);
 857
 858         widget->allocation = *allocation;
 859         set_hadjustment_values (self, &hadj_value_changed);
 860         set_vadjustment_values (self, &vadj_value_changed);
 861
 862         get_view_allocation (self, &view_allocation);
 863
 864         headers_allocation.x = 0;
 865         headers_allocation.y = 0;
 866         headers_allocation.width = view_allocation.width;
 867         if (priv->headers_box)
 868                 headers_allocation.height = GTK_WIDGET (priv->headers_box)->requisition.height;
 869         else
 870                 headers_allocation.height = 0;
 871
 872         html_vadj = gtk_scrolled_window_get_vadjustment (GTK_SCROLLED_WINDOW (priv->html_scroll));
 873
 874         html_allocation.x = 0;
 875         html_allocation.y = headers_allocation.height;
 876         html_allocation.width = view_allocation.width;
 877         html_allocation.height = MAX ((gint) html_vadj->upper, (gint)(priv->vadj->upper - headers_allocation.height));
 878
 879         if (GTK_WIDGET_REALIZED (widget)) {
 880                 gdk_window_move_resize (widget->window,
 881                                         allocation->x,
 882                                         allocation->y,
 883                                         allocation->width,
 884                                         allocation->height);
 885
 886                 gdk_window_move_resize (priv->view_window,
 887                                         view_allocation.x,
 888                                         view_allocation.y,
 889                                         view_allocation.width,
 890                                         view_allocation.height);
 891                 gdk_window_move_resize (priv->headers_window,
 892                                         0,
 893                                         (gint) (- priv->vadj->value),
 894                                         allocation->width,
 895                                         headers_allocation.height);
 896                 gdk_window_move_resize (priv->html_window,
 897                                         (gint) (- priv->hadj->value),
 898                                         (gint) (html_allocation.y - priv->vadj->value),
 899                                         (gint) priv->hadj->upper,
 900                                         html_allocation.height);
 901         }
 902
 903         if (priv->headers_box && GTK_WIDGET_VISIBLE (priv->headers_box)) {
 904                 gtk_widget_size_allocate (priv->headers_box, &headers_allocation);
 905         }
 906         if (priv->html_scroll && GTK_WIDGET_VISIBLE (priv->html_scroll)) {
 907                 html_allocation.x = 0;
 908                 html_allocation.y = 0;
 909                 html_allocation.width = (gint) priv->hadj->upper;
 910                 html_allocation.height = (gint) priv->vadj->upper - headers_allocation.height;
 911                 gtk_widget_size_allocate (priv->html_scroll, &html_allocation);
 912         }
 913         gtk_adjustment_changed (priv->hadj);
 914         gtk_adjustment_changed (priv->vadj);
 915
 916         if (hadj_value_changed)
 917                 gtk_adjustment_value_changed (priv->hadj);
 918         if (vadj_value_changed)
 919                 gtk_adjustment_value_changed (priv->vadj);
 920
 921 }
 922
 923 static void
 924 adjustment_value_changed (GtkAdjustment *adj, gpointer data)
 925 {
 926         ModestGtkhtmlMsgView *self = NULL;
 927         ModestGtkhtmlMsgViewPrivate *priv = NULL;
 928
 929         g_return_if_fail (GTK_IS_ADJUSTMENT (adj));
 930         g_return_if_fail (MODEST_IS_GTKHTML_MSG_VIEW (data));
 931
 932         self = MODEST_GTKHTML_MSG_VIEW (data);
 933         priv = MODEST_GTKHTML_MSG_VIEW_GET_PRIVATE (self);
 934
 935         if (GTK_WIDGET_REALIZED (self)) {
 936                 GtkAdjustment *hadj = get_hadjustment (self);
 937                 GtkAdjustment *vadj = get_vadjustment (self);
 938                 gint headers_offset = 0;
 939
 940                 gtk_widget_queue_resize (priv->html_scroll);
 941
 942                 if (priv->headers_box && GTK_WIDGET_VISIBLE (priv->headers_box)) {
 943                         gint old_x, old_y;
 944                         gint new_x, new_y;
 945                         gdk_window_get_position (priv->headers_window, &old_x, &old_y);
 946                         new_x = 0;
 947                         new_y = -vadj->value;
 948
 949                         headers_offset = GTK_WIDGET(priv->headers_box)->allocation.height;
 950
 951                         if (new_x != old_x || new_y != old_y) {
 952                                 gdk_window_move (priv->headers_window, new_x, new_y);
 953                                 gdk_window_process_updates (priv->headers_window, TRUE);
 954                         }
 955                 }
 956
 957                 if (priv->html_scroll && GTK_WIDGET_VISIBLE (priv->html_scroll)) {
 958                         gint old_x, old_y;
 959                         gint new_x, new_y;
 960                         gdk_window_get_position (priv->html_window, &old_x, &old_y);
 961                         new_x = -hadj->value;
 962                         new_y = headers_offset - vadj->value;
 963
 964                         if (new_x != old_x || new_y != old_y) {
 965                                 gdk_window_move (priv->html_window, new_x, new_y);
 966                                 gdk_window_process_updates (priv->html_window, TRUE);
 967                         }
 968                 }
 969
 970         }
 971 }
 972
 973 static void
 974 html_adjustment_changed (GtkAdjustment *adj,
 975                          gpointer userdata)
 976 {
 977         ModestGtkhtmlMsgView *self = MODEST_GTKHTML_MSG_VIEW (userdata);
 978         ModestGtkhtmlMsgViewPrivate *priv = MODEST_GTKHTML_MSG_VIEW_GET_PRIVATE (self);
 979         GtkAdjustment *html_vadj = gtk_scrolled_window_get_vadjustment (GTK_SCROLLED_WINDOW(priv->html_scroll));
 980         gboolean vadj_changed;
 981         gint new_height;
 982
 983         g_signal_stop_emission_by_name (G_OBJECT (adj), "changed");
 984
 985         priv->html_scroll->requisition.height = html_vadj->upper;
 986         if (html_vadj->upper == priv->html_scroll->allocation.height)
 987                 return;
 988         priv->html_scroll->allocation.height = html_vadj->upper;
 989
 990         set_vadjustment_values (self, &vadj_changed);
 991
 992         new_height = MAX ((gint) html_vadj->upper, (gint) (priv->vadj->upper - priv->headers_box->allocation.height));
 993
 994         gtk_adjustment_changed (priv->vadj);
 995         if (GTK_WIDGET_DRAWABLE (priv->html_scroll)) {
 996                 gdk_window_resize (priv->html_window, (gint) priv->hadj->upper, (gint) new_height);
 997                 gdk_window_process_updates (priv->view_window, TRUE);
 998                 gtk_container_resize_children (GTK_CONTAINER (self));
 999         }
1000
1001 }
1002
1003 gboolean
1004 idle_readjust_scroll (ModestGtkhtmlMsgView *self)
1005 {
1006
1007         /* We're out the main lock */
1008         gdk_threads_enter ();
1009
1010         if (GTK_WIDGET_DRAWABLE (self)) {
1011                 ModestGtkhtmlMsgViewPrivate *priv = MODEST_GTKHTML_MSG_VIEW_GET_PRIVATE (self);
1012                 GtkAdjustment *html_vadj;
1013                 html_vadj = gtk_scrolled_window_get_vadjustment (GTK_SCROLLED_WINDOW (priv->html_scroll));
1014                 html_vadj->page_size = html_vadj->upper;
1015                 gtk_adjustment_changed (html_vadj);
1016                 gtk_widget_queue_resize (GTK_WIDGET (self));
1017                 gtk_widget_queue_draw (GTK_WIDGET (self));
1018
1019                 /* Just another hack for making readjust really work. This forces an update
1020                  * of the scroll, and then, make the scroll really update properly the
1021                  * the size and not corrupt scrollable area */
1022                 gtk_adjustment_set_value (priv->vadj, 1.0);
1023                 gtk_adjustment_set_value (priv->vadj, 0.0);
1024         }
1025         g_object_unref (G_OBJECT (self));
1026
1027         gdk_threads_leave ();
1028
1029         return FALSE;
1030 }
1031
1032 static void
1033 modest_gtkhtml_msg_view_init (ModestGtkhtmlMsgView *obj)
1034 {
1035         ModestGtkhtmlMsgViewPrivate *priv;
1036         GtkAdjustment *html_vadj;
1037         GtkWidget *separator;
1038
1039         GTK_WIDGET_UNSET_FLAGS (obj, GTK_NO_WINDOW);
1040         gtk_widget_set_redraw_on_allocate (GTK_WIDGET (obj), TRUE);
1041         gtk_container_set_reallocate_redraws (GTK_CONTAINER (obj), TRUE);
1042         gtk_container_set_resize_mode (GTK_CONTAINER (obj), GTK_RESIZE_QUEUE);
1043
1044         priv = MODEST_GTKHTML_MSG_VIEW_GET_PRIVATE(obj);
1045
1046         priv->current_zoom = 1.0;
1047
1048         priv->hadj = NULL;
1049         priv->vadj = NULL;
1050         priv->shadow_type = GTK_SHADOW_IN;
1051         priv->view_window = NULL;
1052         priv->headers_window = NULL;
1053         priv->html_window = NULL;
1054
1055         priv->idle_motion_id = 0;
1056
1057         gtk_widget_push_composite_child ();
1058         priv->html_scroll = gtk_scrolled_window_new (NULL, NULL);
1059         gtk_widget_set_composite_name (priv->html_scroll, "contents");
1060         gtk_widget_pop_composite_child ();
1061         gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (priv->html_scroll), GTK_POLICY_NEVER, GTK_POLICY_NEVER);
1062
1063         priv->msg                     = NULL;
1064
1065         priv->body_view                 = GTK_WIDGET (g_object_new (MODEST_TYPE_GTKHTML_MIME_PART_VIEW, NULL));
1066 #ifdef MODEST_TOOLKIT_HILDON2
1067         priv->mail_header_view        = GTK_WIDGET(modest_compact_mail_header_view_new ());
1068 #else
1069         priv->mail_header_view        = GTK_WIDGET(modest_expander_mail_header_view_new (TRUE));
1070 #endif
1071         priv->view_images_button = gtk_button_new_with_label (_("mail_bd_external_images"));
1072         gtk_widget_set_no_show_all (priv->mail_header_view, TRUE);
1073         gtk_widget_set_no_show_all (priv->view_images_button, TRUE);
1074         priv->attachments_view        = GTK_WIDGET(modest_attachments_view_new (NULL));
1075
1076         g_signal_connect (G_OBJECT(priv->body_view), "activate_link",
1077                                        G_CALLBACK(on_activate_link), obj);
1078         g_signal_connect (G_OBJECT(priv->body_view), "fetch_url",
1079                                        G_CALLBACK(on_fetch_url), obj);
1080         g_signal_connect (G_OBJECT(priv->body_view), "link_hover",
1081                                        G_CALLBACK(on_link_hover), obj);
1082 #ifdef MAEMO_CHANGES
1083         g_signal_connect (G_OBJECT(priv->body_view), "motion-notify-event",
1084                           G_CALLBACK (motion_notify_event), obj);
1085 #endif
1086         g_signal_connect (G_OBJECT (priv->body_view), "button-press-event",
1087                           G_CALLBACK (button_press_event), obj);
1088         g_signal_connect (G_OBJECT (priv->body_view), "button-release-event",
1089                           G_CALLBACK (button_release_event), obj);
1090
1091         g_signal_connect (G_OBJECT (priv->mail_header_view), "recpt-activated",
1092                           G_CALLBACK (on_recpt_activated), obj);
1093         g_signal_connect (G_OBJECT (priv->mail_header_view), "show-details",
1094                           G_CALLBACK (on_show_details), obj);
1095
1096         g_signal_connect (G_OBJECT (priv->attachments_view), "activate",
1097                           G_CALLBACK (on_attachment_activated), obj);
1098
1099         g_signal_connect (G_OBJECT (priv->view_images_button), "clicked",
1100                           G_CALLBACK (on_view_images_clicked), obj);
1101
1102         html_vadj = gtk_scrolled_window_get_vadjustment (GTK_SCROLLED_WINDOW(priv->html_scroll));
1103
1104         g_signal_connect (G_OBJECT (html_vadj), "changed",
1105                           G_CALLBACK (html_adjustment_changed), obj);
1106
1107         gtk_widget_push_composite_child ();
1108         priv->headers_box = gtk_vbox_new (FALSE, MODEST_MARGIN_DEFAULT);
1109         gtk_widget_set_composite_name (priv->headers_box, "headers");
1110         gtk_widget_pop_composite_child ();
1111
1112         if (priv->mail_header_view)
1113                 gtk_box_pack_start (GTK_BOX(priv->headers_box), priv->mail_header_view, FALSE, FALSE, 0);
1114         if (priv->view_images_button) {
1115                 GtkWidget *hbuttonbox;
1116
1117                 hbuttonbox = gtk_hbutton_box_new ();
1118                 gtk_container_add (GTK_CONTAINER (hbuttonbox), priv->view_images_button);
1119                 gtk_box_pack_start (GTK_BOX (priv->headers_box), hbuttonbox, FALSE, FALSE, 0);
1120                 gtk_widget_hide (priv->view_images_button);
1121         }
1122
1123         if (priv->attachments_view) {
1124                 gchar *att_label = g_strconcat (_("mcen_me_viewer_attachments"), ":", NULL);
1125
1126                 priv->attachments_box = (GtkWidget *)
1127                         modest_mail_header_view_add_custom_header (MODEST_MAIL_HEADER_VIEW (priv->mail_header_view),
1128                                                                    att_label,
1129                                                                    priv->attachments_view,
1130                                                                    FALSE, FALSE);
1131                 gtk_widget_hide_all (priv->attachments_box);
1132                 g_free (att_label);
1133         }
1134
1135         separator = gtk_hseparator_new ();
1136         gtk_box_pack_start (GTK_BOX(priv->headers_box), separator, FALSE, FALSE, 0);
1137
1138         gtk_widget_set_parent (priv->headers_box, GTK_WIDGET (obj));
1139
1140         if (priv->body_view) {
1141                 gtk_container_add (GTK_CONTAINER (priv->html_scroll), priv->body_view);
1142                 gtk_widget_set_parent (priv->html_scroll, GTK_WIDGET(obj));
1143 #ifdef MAEMO_CHANGES
1144                 gtk_widget_tap_and_hold_setup (GTK_WIDGET (priv->body_view), NULL, NULL, 0);
1145                 g_signal_connect (G_OBJECT (priv->body_view), "tap-and-hold", G_CALLBACK (on_tap_and_hold), obj);
1146                 g_signal_connect (G_OBJECT (priv->body_view), "tap-and-hold-query", G_CALLBACK (on_tap_and_hold_query), obj);
1147 #endif
1148         }
1149
1150 }
1151
1152
1153 static void
1154 modest_gtkhtml_msg_view_finalize (GObject *obj)
1155 {
1156         ModestGtkhtmlMsgViewPrivate *priv;
1157         priv = MODEST_GTKHTML_MSG_VIEW_GET_PRIVATE (obj);
1158
1159         if (priv->msg) {
1160                 g_object_unref (G_OBJECT(priv->msg));
1161                 priv->msg = NULL;
1162         }
1163
1164         if (priv->idle_motion_id > 0) {
1165                 g_source_remove (priv->idle_motion_id);
1166                 priv->idle_motion_id = 0;
1167         }
1168
1169         /* we cannot disconnect sigs, because priv->body_view is
1170          * already dead */
1171
1172         disconnect_vadjustment (MODEST_GTKHTML_MSG_VIEW(obj));
1173         disconnect_hadjustment (MODEST_GTKHTML_MSG_VIEW(obj));
1174
1175         priv->body_view = NULL;
1176         priv->attachments_view = NULL;
1177
1178         G_OBJECT_CLASS(parent_class)->finalize (obj);
1179 }
1180
1181 static void
1182 modest_gtkhtml_msg_view_destroy (GtkObject *obj)
1183 {
1184         disconnect_vadjustment (MODEST_GTKHTML_MSG_VIEW(obj));
1185         disconnect_hadjustment (MODEST_GTKHTML_MSG_VIEW(obj));
1186
1187         GTK_OBJECT_CLASS(parent_class)->destroy (obj);
1188 }
1189
1190 /* INTERNAL METHODS */
1191
1192 #ifdef MAEMO_CHANGES
1193 static gboolean
1194 motion_notify_event (GtkWidget *widget,
1195                      GdkEventMotion *event,
1196                      gpointer userdata)
1197 {
1198         ModestGtkhtmlMsgViewPrivate *priv = MODEST_GTKHTML_MSG_VIEW_GET_PRIVATE (userdata);
1199
1200         /* Use panning information in gtkhtml widget to support also vertical panning */
1201
1202         if (GTK_HTML (widget)->panning) {
1203                 gint y, dy;
1204                 gdouble value;
1205
1206                 gdk_window_get_pointer (GTK_LAYOUT (widget)->bin_window, NULL, &y, NULL);
1207                 dy = y - GTK_HTML (widget)->lasty;
1208                 value = priv->vadj->value - (gdouble) dy;
1209
1210                 if (value < priv->vadj->lower)
1211                         value = priv->vadj->lower;
1212                 else if (value > priv->vadj->upper - priv->vadj->page_size)
1213                         value = priv->vadj->upper - priv->vadj->page_size;
1214                 gtk_adjustment_set_value (priv->vadj, value);
1215
1216         }
1217         return FALSE;
1218 }
1219 #endif
1220
1221 static gboolean
1222 idle_motion (gpointer userdata)
1223 {
1224         ModestGtkhtmlMsgViewPrivate *priv = MODEST_GTKHTML_MSG_VIEW_GET_PRIVATE (userdata);
1225         if (GTK_HTML (priv->body_view)->in_selection_drag) {
1226                 gdouble offset;
1227                 GtkAdjustment *adj;
1228                 gint gdk_y;
1229                 gdk_window_get_pointer (gtk_widget_get_parent_window (priv->body_view), NULL, &gdk_y, NULL);
1230                 offset= (gdouble) (priv->headers_box->requisition.height + gdk_y);
1231                 adj = GTK_ADJUSTMENT (priv->vadj);
1232                 if (offset < adj->value + adj->step_increment) {
1233                         gtk_adjustment_set_value (adj, MAX (offset + adj->page_increment - adj->page_size, 0.0));
1234                 } else if (offset > adj->value + adj->page_increment) {
1235                         gtk_adjustment_set_value (adj, MIN (offset - adj->page_increment, adj->upper - adj->page_size));
1236                 }
1237                 gtk_widget_queue_resize (userdata);
1238         }
1239         return TRUE;
1240 }
1241
1242 static gboolean
1243 button_press_event (GtkWidget *widget,
1244                     GdkEventButton *event,
1245                     gpointer userdata)
1246 {
1247         ModestGtkhtmlMsgViewPrivate *priv = MODEST_GTKHTML_MSG_VIEW_GET_PRIVATE (userdata);
1248
1249         if (priv->idle_motion_id == 0) {
1250                 priv->idle_motion_id = g_timeout_add (200, idle_motion, userdata);
1251         }
1252         return FALSE;
1253 }
1254
1255 static gboolean
1256 button_release_event (GtkWidget *widget,
1257                       GdkEventButton *event,
1258                       gpointer userdata)
1259 {
1260         ModestGtkhtmlMsgViewPrivate *priv = MODEST_GTKHTML_MSG_VIEW_GET_PRIVATE (userdata);
1261
1262         if (priv->idle_motion_id > 0) {
1263                 gint gdk_y;
1264                 g_source_remove (priv->idle_motion_id);
1265
1266                 priv->idle_motion_id = 0;;
1267                 gdk_window_get_pointer (gtk_widget_get_parent_window (priv->body_view), NULL, &gdk_y, NULL);
1268                 event->y = (gdouble) gdk_y;
1269         }
1270         return FALSE;
1271 }
1272
1273 static GtkAdjustment *
1274 get_vadjustment (ModestGtkhtmlMsgView *self)
1275 {
1276         ModestGtkhtmlMsgViewPrivate *priv = MODEST_GTKHTML_MSG_VIEW_GET_PRIVATE (self);
1277
1278         if (!priv->vadj)
1279                 set_vadjustment (self, NULL);
1280
1281         return priv->vadj;
1282
1283 }
1284
1285 static GtkAdjustment *
1286 get_hadjustment (ModestGtkhtmlMsgView *self)
1287 {
1288         ModestGtkhtmlMsgViewPrivate *priv = MODEST_GTKHTML_MSG_VIEW_GET_PRIVATE (self);
1289
1290         if (!priv->hadj)
1291                 set_hadjustment (self, NULL);
1292
1293         return priv->hadj;
1294
1295 }
1296
1297 static void
1298 set_hadjustment (ModestGtkhtmlMsgView *self, GtkAdjustment *hadj)
1299 {
1300         ModestGtkhtmlMsgViewPrivate *priv = MODEST_GTKHTML_MSG_VIEW_GET_PRIVATE (self);
1301         gboolean value_changed;
1302
1303         if (hadj && hadj == priv->hadj)
1304                 return;
1305
1306         if (!hadj)
1307                 hadj = GTK_ADJUSTMENT (gtk_adjustment_new (0.0,0.0,0.0,0.0,0.0,0.0));
1308         disconnect_hadjustment (self);
1309         g_object_ref (G_OBJECT (hadj));
1310         gtk_object_sink (GTK_OBJECT (hadj));
1311         priv->hadj = hadj;
1312         set_hadjustment_values (self, &value_changed);
1313
1314         g_signal_connect (hadj, "value_changed", G_CALLBACK (adjustment_value_changed),
1315                           self);
1316
1317         gtk_adjustment_changed (hadj);
1318         if (value_changed)
1319                 gtk_adjustment_value_changed (hadj);
1320         else
1321                 adjustment_value_changed (hadj, self);
1322
1323         g_object_notify (G_OBJECT (self), "hadjustment");
1324 }
1325
1326 static void
1327 set_vadjustment (ModestGtkhtmlMsgView *self, GtkAdjustment *vadj)
1328 {
1329         ModestGtkhtmlMsgViewPrivate *priv = MODEST_GTKHTML_MSG_VIEW_GET_PRIVATE (self);
1330         gboolean value_changed;
1331
1332         if (vadj && vadj == priv->vadj)
1333                 return;
1334
1335         if (!vadj)
1336                 vadj = (GtkAdjustment *) gtk_adjustment_new (0.0,0.0,0.0,0.0,0.0,0.0);
1337         disconnect_vadjustment (self);
1338         g_object_ref (G_OBJECT (vadj));
1339         gtk_object_sink (GTK_OBJECT (vadj));
1340         priv->vadj = vadj;
1341         set_vadjustment_values (self, &value_changed);
1342
1343         g_signal_connect (vadj, "value_changed", G_CALLBACK (adjustment_value_changed),
1344                           self);
1345
1346         gtk_adjustment_changed (vadj);
1347         if (value_changed)
1348                 gtk_adjustment_value_changed (vadj);
1349         else
1350                 adjustment_value_changed (vadj, self);
1351
1352         g_object_notify (G_OBJECT (self), "vadjustment");
1353 }
1354
1355 static void
1356 set_shadow_type (ModestGtkhtmlMsgView *self,
1357                  GtkShadowType shadow_type)
1358 {
1359         ModestGtkhtmlMsgViewPrivate *priv;
1360         g_return_if_fail (MODEST_IS_GTKHTML_MSG_VIEW (self));
1361
1362         priv = MODEST_GTKHTML_MSG_VIEW_GET_PRIVATE (self);
1363
1364         if (priv->shadow_type != shadow_type) {
1365                 priv->shadow_type = shadow_type;
1366
1367                 if (GTK_WIDGET_VISIBLE (self)) {
1368                         gtk_widget_size_allocate (GTK_WIDGET (self), &(GTK_WIDGET (self)->allocation));
1369                         gtk_widget_queue_draw (GTK_WIDGET (self));
1370                 }
1371                 g_object_notify (G_OBJECT (self), "shadow-type");
1372         }
1373 }
1374
1375 static GtkShadowType
1376 get_shadow_type (ModestGtkhtmlMsgView *self)
1377 {
1378         ModestGtkhtmlMsgViewPrivate *priv;
1379         g_return_val_if_fail (MODEST_IS_GTKHTML_MSG_VIEW (self), GTK_SHADOW_NONE);
1380         priv = MODEST_GTKHTML_MSG_VIEW_GET_PRIVATE (self);
1381
1382         return priv->shadow_type;
1383 }
1384
1385 GtkWidget*
1386 modest_msg_view_new (TnyMsg *msg)
1387 {
1388         GObject *obj;
1389         ModestGtkhtmlMsgView* self;
1390
1391         obj  = G_OBJECT(g_object_new(MODEST_TYPE_GTKHTML_MSG_VIEW, NULL));
1392         self = MODEST_GTKHTML_MSG_VIEW(obj);
1393         tny_msg_view_set_msg (TNY_MSG_VIEW (self), msg);
1394
1395         return GTK_WIDGET(self);
1396 }
1397
1398 #ifdef MAEMO_CHANGES
1399 static void
1400 on_tap_and_hold (GtkWidget *widget,
1401                  gpointer data)
1402 {
1403         ModestGtkhtmlMsgView *self = (ModestGtkhtmlMsgView *) data;
1404         ModestGtkhtmlMsgViewPrivate *priv = MODEST_GTKHTML_MSG_VIEW_GET_PRIVATE (self);
1405
1406         g_signal_emit_by_name (G_OBJECT (self), "link-contextual", priv->last_url);
1407 }
1408
1409 static gboolean
1410 on_tap_and_hold_query (GtkWidget *widget,
1411                        GdkEvent *event,
1412                        gpointer data)
1413 {
1414         ModestGtkhtmlMsgView *self = (ModestGtkhtmlMsgView *) data;
1415         ModestGtkhtmlMsgViewPrivate *priv = MODEST_GTKHTML_MSG_VIEW_GET_PRIVATE (self);
1416
1417         /* Don't show the tap and hold animation if no url below */
1418         return (priv->last_url == NULL);
1419 }
1420 #endif
1421
1422 static void
1423 on_recpt_activated (ModestMailHeaderView *header_view,
1424                     const gchar *address,
1425                     ModestGtkhtmlMsgView *self)
1426 {
1427         g_signal_emit_by_name (G_OBJECT (self), "recpt-activated", address);
1428 }
1429
1430 static void
1431 on_show_details (ModestMailHeaderView *header_view,
1432                  ModestGtkhtmlMsgView *self)
1433 {
1434         g_signal_emit_by_name (G_OBJECT (self), "show-details");
1435 }
1436
1437 static void
1438 on_attachment_activated (ModestAttachmentsView * att_view, TnyMimePart *mime_part, gpointer self)
1439 {
1440
1441         g_signal_emit_by_name (G_OBJECT(self), "attachment_clicked", mime_part);
1442 }
1443
1444 static void
1445 on_view_images_clicked (GtkButton * button, gpointer self)
1446 {
1447         ModestGtkhtmlMsgViewPrivate *priv = MODEST_GTKHTML_MSG_VIEW_GET_PRIVATE (self);
1448         TnyMimePart *part;
1449
1450         modest_mime_part_view_set_view_images (MODEST_MIME_PART_VIEW (priv->body_view), TRUE);
1451         gtk_widget_hide (priv->view_images_button);
1452         part = tny_mime_part_view_get_part (TNY_MIME_PART_VIEW (priv->body_view));
1453         tny_mime_part_view_set_part (TNY_MIME_PART_VIEW (priv->body_view), part);
1454         tny_msg_set_allow_external_images (TNY_MSG (priv->msg), TRUE);
1455         g_object_unref (part);
1456
1457
1458 }
1459
1460 static gboolean
1461 on_activate_link (GtkWidget *widget, const gchar *uri, ModestGtkhtmlMsgView *self)
1462 {
1463         gboolean result;
1464         g_return_val_if_fail (self, FALSE);
1465
1466         g_signal_emit_by_name (G_OBJECT(self), "activate-link", uri, &result);
1467
1468         return result;
1469 }
1470
1471
1472 static gboolean
1473 on_link_hover (GtkWidget *widget, const gchar *uri, ModestGtkhtmlMsgView *self)
1474 {
1475         ModestGtkhtmlMsgViewPrivate *priv = MODEST_GTKHTML_MSG_VIEW_GET_PRIVATE (self);
1476         gboolean result;
1477
1478         g_free (priv->last_url);
1479         priv->last_url = g_strdup (uri);
1480
1481         g_signal_emit_by_name (G_OBJECT(self), "link-hover", uri, &result);
1482
1483         return result;
1484 }
1485
1486
1487
1488 static TnyMimePart *
1489 find_cid_image (TnyMsg *msg, const gchar *cid)
1490 {
1491         TnyMimePart *part = NULL;
1492         TnyList *parts;
1493         TnyIterator *iter;
1494
1495         g_return_val_if_fail (msg, NULL);
1496         g_return_val_if_fail (cid, NULL);
1497
1498         parts  = TNY_LIST (tny_simple_list_new());
1499
1500         tny_mime_part_get_parts (TNY_MIME_PART (msg), parts);
1501         iter   = tny_list_create_iterator (parts);
1502
1503         while (!tny_iterator_is_done(iter)) {
1504                 const gchar *part_cid;
1505
1506                 part = TNY_MIME_PART(tny_iterator_get_current(iter));
1507                 part_cid = tny_mime_part_get_content_id (part);
1508
1509                 /* if there is no content id, try the content location;
1510                  * this is what Outlook seems to use when it converts
1511                  * it's internal richtext to html
1512                  */
1513                 if (!part_cid)
1514                         part_cid = tny_mime_part_get_content_location (part);
1515
1516                 if (part_cid && strcmp (cid, part_cid) == 0)
1517                         break;
1518
1519                 if (tny_mime_part_content_type_is (part, "multipart/related")) {
1520                         TnyList *related_parts = TNY_LIST (tny_simple_list_new ());
1521                         TnyIterator *related_iter = NULL;
1522                         TnyMimePart *related_part = NULL;
1523
1524                         tny_mime_part_get_parts (part, related_parts);
1525                         related_iter = tny_list_create_iterator (related_parts);
1526
1527                         while (!tny_iterator_is_done (related_iter)) {
1528                                 related_part = TNY_MIME_PART (tny_iterator_get_current (related_iter));
1529                                 part_cid = tny_mime_part_get_content_id (related_part);
1530                                 if (part_cid && strcmp (cid, part_cid) == 0) {
1531                                         break;
1532                                 }
1533                                 g_object_unref (related_part);
1534                                 related_part = NULL;
1535                                 tny_iterator_next (related_iter);
1536                         }
1537
1538                         g_object_unref (related_iter);
1539                         g_object_unref (related_parts);
1540                         if (related_part != NULL) {
1541                                 g_object_unref (part);
1542                                 part = related_part;
1543                                 break;
1544                         }
1545                 }
1546
1547                 g_object_unref (G_OBJECT(part));
1548
1549                 part = NULL;
1550                 tny_iterator_next (iter);
1551         }
1552
1553         g_object_unref (G_OBJECT(iter));
1554         g_object_unref (G_OBJECT(parts));
1555
1556         return part;
1557 }
1558
1559
1560 static gboolean
1561 on_fetch_url (GtkWidget *widget, const gchar *uri,
1562               TnyStream *stream, ModestGtkhtmlMsgView *self)
1563 {
1564         ModestGtkhtmlMsgViewPrivate *priv;
1565         const gchar* my_uri;
1566         TnyMimePart *part = NULL;
1567
1568
1569
1570         priv = MODEST_GTKHTML_MSG_VIEW_GET_PRIVATE (self);
1571
1572         if (modest_mime_part_view_has_external_images (MODEST_MIME_PART_VIEW (priv->body_view)))
1573                 gtk_widget_show (priv->view_images_button);
1574         /*
1575          * we search for either something starting with cid:, or something
1576          * with no prefix at all; this latter case occurs when sending mails
1577          * with MS Outlook in rich-text mode, and 'attach-as-object
1578          */
1579         if (g_str_has_prefix (uri, "cid:"))
1580                 my_uri = uri + 4;  /* +4 ==> skip "cid:" */
1581         else
1582                 my_uri = uri;
1583
1584         /* now try to find the embedded image */
1585         part = find_cid_image (priv->msg, my_uri);
1586
1587         if (!part) {
1588                 if (g_str_has_prefix (uri, "http:")) {
1589                         if (modest_mime_part_view_get_view_images (MODEST_MIME_PART_VIEW (priv->body_view))) {
1590                                 gboolean result = FALSE;
1591                                 g_signal_emit_by_name (self, "fetch-image", uri, stream, &result);
1592                                 return result;
1593                         } else {
1594                                 /* we return immediately to get a "image not found" icon */
1595                                 tny_stream_close (stream);
1596                                 return TRUE;
1597                         }
1598                 } else {
1599                         return FALSE;
1600                 }
1601         }
1602
1603         tny_mime_part_decode_to_stream ((TnyMimePart*)part, stream, NULL);
1604         tny_stream_close (stream);
1605         g_object_unref (G_OBJECT(part));
1606         return TRUE;
1607 }
1608
1609 static void
1610 set_message (ModestGtkhtmlMsgView *self, TnyMsg *msg)
1611 {
1612         TnyMimePart *body;
1613         ModestGtkhtmlMsgViewPrivate *priv;
1614         TnyHeader *header;
1615         GtkAdjustment *html_vadj;
1616
1617         g_return_if_fail (self);
1618
1619         priv = MODEST_GTKHTML_MSG_VIEW_GET_PRIVATE(self);
1620         gtk_widget_set_no_show_all (priv->mail_header_view, FALSE);
1621         modest_mime_part_view_set_view_images (MODEST_MIME_PART_VIEW (priv->body_view), FALSE);
1622
1623         html_vadj = gtk_scrolled_window_get_vadjustment (GTK_SCROLLED_WINDOW (priv->html_scroll));
1624         html_vadj->upper = 0;
1625         html_vadj->page_size = 0;
1626         g_signal_emit_by_name (G_OBJECT (html_vadj), "changed");
1627
1628
1629         if (msg != priv->msg) {
1630                 if (priv->msg)
1631                         g_object_unref (G_OBJECT(priv->msg));
1632                 if (msg)
1633                         g_object_ref   (G_OBJECT(msg));
1634                 priv->msg = msg;
1635         }
1636
1637         if (!msg) {
1638                 tny_header_view_clear (TNY_HEADER_VIEW (priv->mail_header_view));
1639                 modest_attachments_view_set_message (MODEST_ATTACHMENTS_VIEW (priv->attachments_view), NULL);
1640                 gtk_widget_hide_all (priv->mail_header_view);
1641                 gtk_widget_hide_all (priv->attachments_box);
1642                 gtk_widget_set_no_show_all (priv->mail_header_view, TRUE);
1643                 tny_mime_part_view_clear (TNY_MIME_PART_VIEW (priv->body_view));
1644                 gtk_widget_queue_resize (GTK_WIDGET(self));
1645                 gtk_widget_queue_draw (GTK_WIDGET(self));
1646                 return;
1647         }
1648
1649         header = tny_msg_get_header (msg);
1650         tny_header_view_set_header (TNY_HEADER_VIEW (priv->mail_header_view), header);
1651         g_object_unref (header);
1652
1653         modest_attachments_view_set_message (MODEST_ATTACHMENTS_VIEW(priv->attachments_view),
1654                                              msg);
1655
1656         modest_mime_part_view_set_view_images (MODEST_MIME_PART_VIEW (priv->body_view), tny_msg_get_allow_external_images (msg));
1657
1658         body = modest_tny_msg_find_body_part (msg, TRUE);
1659         if (body) {
1660                 tny_mime_part_view_set_part (TNY_MIME_PART_VIEW (priv->body_view), body);
1661                 g_object_unref (body);
1662
1663                 if(modest_attachments_view_has_attachments (MODEST_ATTACHMENTS_VIEW (priv->attachments_view))) {
1664                         gtk_widget_show_all (priv->attachments_box);
1665                 } else {
1666                         gtk_widget_hide_all (priv->attachments_box);
1667                 }
1668
1669         } else
1670                 tny_mime_part_view_clear (TNY_MIME_PART_VIEW (priv->body_view));
1671
1672         if (modest_mime_part_view_has_external_images (MODEST_MIME_PART_VIEW (priv->body_view)) &&
1673             !modest_mime_part_view_get_view_images (MODEST_MIME_PART_VIEW (priv->body_view))) {
1674                 gtk_widget_show (priv->view_images_button);
1675         } else {
1676                 gtk_widget_hide (priv->view_images_button);
1677         }
1678
1679         gtk_widget_show (priv->body_view);
1680         gtk_widget_set_no_show_all (priv->attachments_box, TRUE);
1681         gtk_widget_show_all (priv->mail_header_view);
1682         gtk_widget_set_no_show_all (priv->attachments_box, FALSE);
1683         gtk_widget_set_no_show_all (priv->mail_header_view, TRUE);
1684         gtk_widget_queue_resize (GTK_WIDGET(self));
1685         gtk_widget_queue_draw (GTK_WIDGET(self));
1686
1687         if (priv->hadj != NULL)
1688                 priv->hadj->value = 0.0;
1689         if (priv->vadj != NULL)
1690                 priv->vadj->value = 0.0;
1691
1692         g_signal_emit_by_name (G_OBJECT (html_vadj), "changed");
1693
1694         /* This is a hack to force reallocation of scroll after drawing all the stuff. This
1695          * makes the html view get the proper and expected size and prevent being able to scroll
1696          * the buffer when it shouldn't be scrollable */
1697         g_object_ref (self);
1698         g_timeout_add (250, (GSourceFunc) idle_readjust_scroll, self);
1699 }
1700
1701
1702 static TnyMsg*
1703 get_message (ModestGtkhtmlMsgView *self)
1704 {
1705         TnyMsg *msg;
1706
1707         g_return_val_if_fail (MODEST_IS_GTKHTML_MSG_VIEW (self), NULL);
1708
1709         msg = MODEST_GTKHTML_MSG_VIEW_GET_PRIVATE(self)->msg;
1710
1711         if (msg)
1712                 g_object_ref (msg);
1713
1714         return msg;
1715 }
1716
1717 static gboolean
1718 is_empty (ModestGtkhtmlMsgView *self)
1719 {
1720         ModestGtkhtmlMsgViewPrivate *priv = MODEST_GTKHTML_MSG_VIEW_GET_PRIVATE (self);
1721
1722         return modest_mime_part_view_is_empty (MODEST_MIME_PART_VIEW (priv->body_view));
1723 }
1724
1725 static void
1726 set_zoom (ModestGtkhtmlMsgView *self, gdouble zoom)
1727 {
1728         ModestGtkhtmlMsgViewPrivate *priv;
1729
1730         g_return_if_fail (MODEST_IS_GTKHTML_MSG_VIEW (self));
1731         priv = MODEST_GTKHTML_MSG_VIEW_GET_PRIVATE (self);
1732
1733         modest_zoomable_set_zoom (MODEST_ZOOMABLE(priv->body_view), zoom);
1734
1735         gtk_widget_queue_resize (priv->body_view);
1736 }
1737
1738 static gdouble
1739 get_zoom (ModestGtkhtmlMsgView *self)
1740 {
1741         ModestGtkhtmlMsgViewPrivate *priv;
1742
1743         g_return_val_if_fail (MODEST_IS_GTKHTML_MSG_VIEW (self), 1.0);
1744         priv = MODEST_GTKHTML_MSG_VIEW_GET_PRIVATE (self);
1745
1746         return modest_zoomable_get_zoom (MODEST_ZOOMABLE (priv->body_view));
1747 }
1748
1749 static TnyHeaderFlags
1750 get_priority (ModestGtkhtmlMsgView *self)
1751 {
1752         ModestGtkhtmlMsgViewPrivate *priv;
1753
1754         g_return_val_if_fail (MODEST_IS_GTKHTML_MSG_VIEW (self), 0);
1755
1756         priv = MODEST_GTKHTML_MSG_VIEW_GET_PRIVATE (self);
1757
1758         return modest_mail_header_view_get_priority (MODEST_MAIL_HEADER_VIEW (priv->mail_header_view));
1759 }
1760
1761 static void
1762 set_priority (ModestGtkhtmlMsgView *self, TnyHeaderFlags flags)
1763 {
1764         ModestGtkhtmlMsgViewPrivate *priv;
1765
1766         g_return_if_fail (MODEST_IS_GTKHTML_MSG_VIEW (self));
1767         priv = MODEST_GTKHTML_MSG_VIEW_GET_PRIVATE (self);
1768
1769         modest_mail_header_view_set_priority (MODEST_MAIL_HEADER_VIEW (priv->mail_header_view), flags);
1770 }
1771
1772 /* INCREMENTAL SEARCH IMPLEMENTATION */
1773
1774 static gboolean
1775 search (ModestGtkhtmlMsgView *self, const gchar *search)
1776 {
1777         ModestGtkhtmlMsgViewPrivate *priv;
1778         gboolean result;
1779         GtkAdjustment *vadj, *tmp_vadj;
1780         gdouble y_offset;
1781
1782         g_return_val_if_fail (MODEST_IS_GTKHTML_MSG_VIEW (self), FALSE);
1783
1784         priv = MODEST_GTKHTML_MSG_VIEW_GET_PRIVATE (self);
1785         vadj = gtk_layout_get_vadjustment (GTK_LAYOUT (priv->body_view));
1786         g_object_ref (vadj);
1787         tmp_vadj = GTK_ADJUSTMENT (gtk_adjustment_new (0.0, vadj->lower, vadj->upper, vadj->step_increment, 32.0, 32.0));
1788         gtk_layout_set_vadjustment (GTK_LAYOUT (priv->body_view), tmp_vadj);
1789         result = modest_isearch_view_search (MODEST_ISEARCH_VIEW (priv->body_view),
1790                                              search);
1791
1792         if (result) {
1793                 gint x, y, w, h;
1794                 gdouble offset_top, offset_bottom;
1795                 GtkAdjustment *adj;
1796                 if (modest_isearch_view_get_selection_area (MODEST_ISEARCH_VIEW (priv->body_view), &x, &y, &w, &h)) {
1797                         offset_top = (gdouble) (priv->headers_box->requisition.height + y);
1798                         offset_bottom = (gdouble) (priv->headers_box->requisition.height + y + h);
1799                         adj = GTK_ADJUSTMENT (priv->vadj);
1800                         if (offset_top < adj->value)
1801                                 gtk_adjustment_set_value (adj, offset_top + adj->page_increment - adj->page_size);
1802                         else if (offset_bottom > adj->value + adj->page_increment)
1803                                 gtk_adjustment_set_value (adj, offset_bottom - adj->page_increment);
1804                 }
1805         }
1806
1807         y_offset = tmp_vadj->value;
1808         gtk_layout_set_vadjustment (GTK_LAYOUT (priv->body_view), vadj);
1809         g_object_unref (vadj);
1810
1811         return result;
1812 }
1813
1814 static gboolean
1815 search_next (ModestGtkhtmlMsgView *self)
1816 {
1817         ModestGtkhtmlMsgViewPrivate *priv;
1818         gboolean result;
1819
1820         g_return_val_if_fail (MODEST_IS_GTKHTML_MSG_VIEW (self), FALSE);
1821
1822         priv = MODEST_GTKHTML_MSG_VIEW_GET_PRIVATE (self);
1823         result = modest_isearch_view_search_next (MODEST_ISEARCH_VIEW (priv->body_view));
1824
1825         if (result) {
1826                 gint x, y, w, h;
1827                 gdouble offset_top, offset_bottom;
1828                 GtkAdjustment *adj;
1829
1830                 if (modest_isearch_view_get_selection_area (MODEST_ISEARCH_VIEW (priv->body_view), &x, &y, &w, &h)) {
1831                         offset_top = (gdouble) (priv->headers_box->requisition.height + y);
1832                         offset_bottom = (gdouble) (priv->headers_box->requisition.height + y + h);
1833                         adj = GTK_ADJUSTMENT (priv->vadj);
1834                         if (offset_top < adj->value)
1835                                 gtk_adjustment_set_value (adj, offset_top + adj->page_increment - adj->page_size);
1836                         else if (offset_bottom > adj->value + adj->page_increment)
1837                                 gtk_adjustment_set_value (adj, offset_bottom - adj->page_increment);
1838                 }
1839         }
1840         return result;
1841 }
1842
1843 static TnyList *
1844 get_selected_attachments (ModestGtkhtmlMsgView *self)
1845 {
1846         ModestGtkhtmlMsgViewPrivate *priv;
1847
1848         g_return_val_if_fail (MODEST_IS_GTKHTML_MSG_VIEW (self), NULL);
1849         priv = MODEST_GTKHTML_MSG_VIEW_GET_PRIVATE (self);
1850
1851         return modest_attachments_view_get_selection (MODEST_ATTACHMENTS_VIEW (priv->attachments_view));
1852
1853 }
1854
1855 static TnyList *
1856 get_attachments (ModestGtkhtmlMsgView *self)
1857 {
1858         ModestGtkhtmlMsgViewPrivate *priv;
1859
1860         g_return_val_if_fail (MODEST_IS_GTKHTML_MSG_VIEW (self), NULL);
1861         priv = MODEST_GTKHTML_MSG_VIEW_GET_PRIVATE (self);
1862
1863         return modest_attachments_view_get_attachments (MODEST_ATTACHMENTS_VIEW (priv->attachments_view));
1864
1865 }
1866
1867 static void
1868 grab_focus (ModestGtkhtmlMsgView *self)
1869 {
1870         ModestGtkhtmlMsgViewPrivate *priv = NULL;
1871
1872         g_return_if_fail (MODEST_IS_GTKHTML_MSG_VIEW (self));
1873         priv = MODEST_GTKHTML_MSG_VIEW_GET_PRIVATE (self);
1874
1875         gtk_widget_grab_focus (priv->body_view);
1876 }
1877
1878 static void
1879 remove_attachment (ModestGtkhtmlMsgView *self, TnyMimePart *attachment)
1880 {
1881         ModestGtkhtmlMsgViewPrivate *priv;
1882
1883         g_return_if_fail (MODEST_IS_GTKHTML_MSG_VIEW (self));
1884         g_return_if_fail (TNY_IS_MIME_PART (attachment));
1885         priv = MODEST_GTKHTML_MSG_VIEW_GET_PRIVATE (self);
1886
1887         modest_attachments_view_remove_attachment (MODEST_ATTACHMENTS_VIEW (priv->attachments_view),
1888                                                    attachment);
1889
1890 }
1891
1892 /* TNY MSG IMPLEMENTATION */
1893
1894 static void
1895 tny_msg_view_init (gpointer g, gpointer iface_data)
1896 {
1897         TnyMsgViewIface *klass = (TnyMsgViewIface *)g;
1898
1899         klass->get_msg = modest_msg_view_get_msg;
1900         klass->set_msg = modest_msg_view_set_msg;
1901         klass->set_unavailable = modest_msg_view_set_unavailable;
1902         klass->clear = modest_msg_view_clear;
1903         klass->create_mime_part_view_for = modest_msg_view_create_mime_part_view_for;
1904         klass->create_new_inline_viewer = modest_msg_view_create_new_inline_viewer;
1905
1906         return;
1907 }
1908
1909 static TnyMsg *
1910 modest_msg_view_get_msg (TnyMsgView *self)
1911 {
1912         return MODEST_GTKHTML_MSG_VIEW_GET_CLASS (self)->get_msg_func (self);
1913 }
1914
1915 static TnyMsg *
1916 modest_msg_view_get_msg_default (TnyMsgView *self)
1917 {
1918         return TNY_MSG (tny_mime_part_view_get_part (TNY_MIME_PART_VIEW (self)));
1919 }
1920
1921 static void
1922 modest_msg_view_set_msg (TnyMsgView *self, TnyMsg *msg)
1923 {
1924         MODEST_GTKHTML_MSG_VIEW_GET_CLASS (self)->set_msg_func (self, msg);
1925 }
1926
1927 static void
1928 modest_msg_view_set_msg_default (TnyMsgView *self, TnyMsg *msg)
1929 {
1930
1931         tny_mime_part_view_set_part (TNY_MIME_PART_VIEW (self), TNY_MIME_PART (msg));
1932
1933         return;
1934 }
1935
1936 static void
1937 modest_msg_view_set_unavailable (TnyMsgView *self)
1938 {
1939         MODEST_GTKHTML_MSG_VIEW_GET_CLASS (self)->set_unavailable_func (self);
1940 }
1941
1942 static void
1943 modest_msg_view_set_unavailable_default (TnyMsgView *self)
1944 {
1945         tny_msg_view_clear (self);
1946
1947         return;
1948 }
1949
1950 static void
1951 modest_msg_view_clear (TnyMsgView *self)
1952 {
1953         MODEST_GTKHTML_MSG_VIEW_GET_CLASS (self)->clear_func (self);
1954 }
1955
1956 static void
1957 modest_msg_view_clear_default (TnyMsgView *self)
1958 {
1959         set_message (MODEST_GTKHTML_MSG_VIEW (self), NULL);
1960 }
1961
1962 static TnyMimePartView*
1963 modest_msg_view_create_mime_part_view_for (TnyMsgView *self, TnyMimePart *part)
1964 {
1965         return MODEST_GTKHTML_MSG_VIEW_GET_CLASS (self)->create_mime_part_view_for_func (self, part);
1966 }
1967
1968 static TnyMimePartView*
1969 modest_msg_view_create_mime_part_view_for_default (TnyMsgView *self, TnyMimePart *part)
1970 {
1971         g_warning ("modest_msg_view_create_mime_part_view_for_default is not implemented");
1972         return NULL;
1973 }
1974
1975 static TnyMsgView*
1976 modest_msg_view_create_new_inline_viewer (TnyMsgView *self)
1977 {
1978         return MODEST_GTKHTML_MSG_VIEW_GET_CLASS (self)->create_new_inline_viewer_func (self);
1979 }
1980
1981 static TnyMsgView*
1982 modest_msg_view_create_new_inline_viewer_default (TnyMsgView *self)
1983 {
1984         g_warning ("modest_msg_view_create_new_inline_viewer_default is not implemented");
1985
1986         return NULL;
1987 }
1988
1989 /* TNY MIME PART IMPLEMENTATION */
1990
1991 static void
1992 tny_mime_part_view_init (gpointer g, gpointer iface_data)
1993 {
1994         TnyMimePartViewIface *klass = (TnyMimePartViewIface *)g;
1995
1996         klass->get_part = modest_msg_view_mp_get_part;
1997         klass->set_part = modest_msg_view_mp_set_part;
1998         klass->clear = modest_msg_view_mp_clear;
1999
2000         return;
2001 }
2002
2003 static TnyMimePart*
2004 modest_msg_view_mp_get_part (TnyMimePartView *self)
2005 {
2006         return MODEST_GTKHTML_MSG_VIEW_GET_CLASS (self)->get_part_func (self);
2007 }
2008
2009
2010 static TnyMimePart*
2011 modest_msg_view_mp_get_part_default (TnyMimePartView *self)
2012 {
2013         return TNY_MIME_PART (get_message (MODEST_GTKHTML_MSG_VIEW (self)));
2014 }
2015
2016 static void
2017 modest_msg_view_mp_set_part (TnyMimePartView *self,
2018                              TnyMimePart *part)
2019 {
2020         MODEST_GTKHTML_MSG_VIEW_GET_CLASS (self)->set_part_func (self, part);
2021 }
2022
2023 static void
2024 modest_msg_view_mp_set_part_default (TnyMimePartView *self,
2025                                      TnyMimePart *part)
2026 {
2027         g_return_if_fail ((part == NULL) || TNY_IS_MSG (part));
2028
2029         set_message (MODEST_GTKHTML_MSG_VIEW (self), TNY_MSG (part));
2030 }
2031
2032 static void
2033 modest_msg_view_mp_clear (TnyMimePartView *self)
2034 {
2035         tny_msg_view_clear (TNY_MSG_VIEW (self));
2036 }
2037
2038 /* MODEST MIME PART VIEW IMPLEMENTATION */
2039
2040 static void
2041 modest_mime_part_view_init (gpointer g, gpointer iface_data)
2042 {
2043         ModestMimePartViewIface *klass = (ModestMimePartViewIface *)g;
2044
2045         klass->is_empty_func = modest_msg_view_mp_is_empty;
2046
2047         return;
2048 }
2049
2050 static gboolean
2051 modest_msg_view_mp_is_empty (ModestMimePartView *self)
2052 {
2053         return MODEST_GTKHTML_MSG_VIEW_GET_CLASS (self)->is_empty_func (self);
2054 }
2055
2056 static gboolean
2057 modest_msg_view_mp_is_empty_default (ModestMimePartView *self)
2058 {
2059         return is_empty (MODEST_GTKHTML_MSG_VIEW (self));
2060 }
2061
2062 /* MODEST ZOOMABLE IMPLEMENTATION */
2063 static void
2064 modest_zoomable_init (gpointer g, gpointer iface_data)
2065 {
2066         ModestZoomableIface *klass = (ModestZoomableIface *)g;
2067
2068         klass->get_zoom_func = modest_msg_view_get_zoom;
2069         klass->set_zoom_func = modest_msg_view_set_zoom;
2070         klass->zoom_minus_func = modest_msg_view_zoom_minus;
2071         klass->zoom_plus_func = modest_msg_view_zoom_plus;
2072
2073         return;
2074 }
2075
2076 static gdouble
2077 modest_msg_view_get_zoom (ModestZoomable *self)
2078 {
2079         return MODEST_GTKHTML_MSG_VIEW_GET_CLASS (self)->get_zoom_func (self);
2080 }
2081
2082 static gdouble
2083 modest_msg_view_get_zoom_default (ModestZoomable *self)
2084 {
2085         return get_zoom (MODEST_GTKHTML_MSG_VIEW (self));
2086 }
2087
2088 static void
2089 modest_msg_view_set_zoom (ModestZoomable *self, gdouble value)
2090 {
2091         MODEST_GTKHTML_MSG_VIEW_GET_CLASS (self)->set_zoom_func (self, value);
2092 }
2093
2094 static void
2095 modest_msg_view_set_zoom_default (ModestZoomable *self, gdouble value)
2096 {
2097         set_zoom (MODEST_GTKHTML_MSG_VIEW (self), value);
2098 }
2099
2100 static gboolean
2101 modest_msg_view_zoom_minus (ModestZoomable *self)
2102 {
2103         return MODEST_GTKHTML_MSG_VIEW_GET_CLASS (self)->zoom_minus_func (self);
2104 }
2105
2106 static gboolean
2107 modest_msg_view_zoom_minus_default (ModestZoomable *self)
2108 {
2109         /* operation not supported in ModestMsgView */
2110         return FALSE;
2111 }
2112
2113 static gboolean
2114 modest_msg_view_zoom_plus (ModestZoomable *self)
2115 {
2116         return MODEST_GTKHTML_MSG_VIEW_GET_CLASS (self)->zoom_plus_func (self);
2117 }
2118
2119 static gboolean
2120 modest_msg_view_zoom_plus_default (ModestZoomable *self)
2121 {
2122         /* operation not supported in ModestMsgView */
2123         return FALSE;
2124 }
2125
2126 /* MODEST ISEARCH VIEW IMPLEMENTATION */
2127 static void
2128 modest_isearch_view_init (gpointer g, gpointer iface_data)
2129 {
2130         ModestISearchViewIface *klass = (ModestISearchViewIface *)g;
2131
2132         klass->search_func = modest_msg_view_search;
2133         klass->search_next_func = modest_msg_view_search_next;
2134
2135         return;
2136 }
2137
2138 static gboolean
2139 modest_msg_view_search (ModestISearchView *self, const gchar *string)
2140 {
2141         return MODEST_GTKHTML_MSG_VIEW_GET_CLASS (self)->search_func (self, string);
2142 }
2143
2144 static gboolean
2145 modest_msg_view_search_default (ModestISearchView *self, const gchar *string)
2146 {
2147         return search (MODEST_GTKHTML_MSG_VIEW (self), string);
2148 }
2149
2150 static gboolean
2151 modest_msg_view_search_next (ModestISearchView *self)
2152 {
2153         return MODEST_GTKHTML_MSG_VIEW_GET_CLASS (self)->search_next_func (self);
2154 }
2155
2156 static gboolean
2157 modest_msg_view_search_next_default (ModestISearchView *self)
2158 {
2159         return search_next (MODEST_GTKHTML_MSG_VIEW (self));
2160 }
2161
2162 /* MODEST MSG VIEW IMPLEMENTATION */
2163 static void
2164 modest_msg_view_init (gpointer g, gpointer iface_data)
2165 {
2166         ModestMsgViewIface *klass = (ModestMsgViewIface *)g;
2167
2168         klass->get_vadjustment_func = modest_gtkhtml_msg_view_get_vadjustment;
2169         klass->get_hadjustment_func = modest_gtkhtml_msg_view_get_hadjustment;
2170         klass->set_vadjustment_func = modest_gtkhtml_msg_view_set_vadjustment;
2171         klass->set_hadjustment_func = modest_gtkhtml_msg_view_set_hadjustment;
2172         klass->set_shadow_type_func = modest_gtkhtml_msg_view_set_shadow_type;
2173         klass->get_shadow_type_func = modest_gtkhtml_msg_view_get_shadow_type;
2174         klass->get_priority_func = modest_gtkhtml_msg_view_get_priority;
2175         klass->set_priority_func = modest_gtkhtml_msg_view_set_priority;
2176         klass->get_selected_attachments_func = modest_gtkhtml_msg_view_get_selected_attachments;
2177         klass->get_attachments_func = modest_gtkhtml_msg_view_get_attachments;
2178         klass->grab_focus_func = modest_gtkhtml_msg_view_grab_focus;
2179         klass->remove_attachment_func = modest_gtkhtml_msg_view_remove_attachment;
2180
2181         return;
2182 }
2183
2184 static GtkAdjustment*
2185 modest_gtkhtml_msg_view_get_vadjustment (ModestMsgView *self)
2186 {
2187         return MODEST_GTKHTML_MSG_VIEW_GET_CLASS (self)->get_vadjustment_func (self);
2188 }
2189
2190 static GtkAdjustment*
2191 modest_gtkhtml_msg_view_get_vadjustment_default (ModestMsgView *self)
2192 {
2193         return get_vadjustment (MODEST_GTKHTML_MSG_VIEW (self));
2194 }
2195
2196 static GtkAdjustment*
2197 modest_gtkhtml_msg_view_get_hadjustment (ModestMsgView *self)
2198 {
2199         return MODEST_GTKHTML_MSG_VIEW_GET_CLASS (self)->get_hadjustment_func (self);
2200 }
2201
2202 static GtkAdjustment*
2203 modest_gtkhtml_msg_view_get_hadjustment_default (ModestMsgView *self)
2204 {
2205         return get_hadjustment (MODEST_GTKHTML_MSG_VIEW (self));
2206 }
2207
2208 static void
2209 modest_gtkhtml_msg_view_set_vadjustment (ModestMsgView *self, GtkAdjustment *adj)
2210 {
2211         MODEST_GTKHTML_MSG_VIEW_GET_CLASS (self)->set_vadjustment_func (self, adj);
2212 }
2213
2214 static void
2215 modest_gtkhtml_msg_view_set_vadjustment_default (ModestMsgView *self, GtkAdjustment *adj)
2216 {
2217         set_vadjustment (MODEST_GTKHTML_MSG_VIEW (self), adj);
2218 }
2219
2220 static void
2221 modest_gtkhtml_msg_view_set_hadjustment (ModestMsgView *self, GtkAdjustment *adj)
2222 {
2223         MODEST_GTKHTML_MSG_VIEW_GET_CLASS (self)->set_hadjustment_func (self, adj);
2224 }
2225
2226 static void
2227 modest_gtkhtml_msg_view_set_hadjustment_default (ModestMsgView *self, GtkAdjustment *adj)
2228 {
2229         set_hadjustment (MODEST_GTKHTML_MSG_VIEW (self), adj);
2230 }
2231
2232 static void
2233 modest_gtkhtml_msg_view_set_shadow_type (ModestMsgView *self, GtkShadowType type)
2234 {
2235         MODEST_GTKHTML_MSG_VIEW_GET_CLASS (self)->set_shadow_type_func (self, type);
2236 }
2237
2238 static void
2239 modest_gtkhtml_msg_view_set_shadow_type_default (ModestMsgView *self, GtkShadowType type)
2240 {
2241         set_shadow_type (MODEST_GTKHTML_MSG_VIEW (self), type);
2242 }
2243
2244 static GtkShadowType
2245 modest_gtkhtml_msg_view_get_shadow_type (ModestMsgView *self)
2246 {
2247         return MODEST_GTKHTML_MSG_VIEW_GET_CLASS (self)->get_shadow_type_func (self);
2248 }
2249
2250 static GtkShadowType
2251 modest_gtkhtml_msg_view_get_shadow_type_default (ModestMsgView *self)
2252 {
2253         return get_shadow_type (MODEST_GTKHTML_MSG_VIEW (self));
2254 }
2255
2256 static void
2257 modest_gtkhtml_msg_view_set_priority (ModestMsgView *self, TnyHeaderFlags flags)
2258 {
2259         MODEST_GTKHTML_MSG_VIEW_GET_CLASS (self)->set_priority_func (self, flags);
2260 }
2261
2262 static void
2263 modest_gtkhtml_msg_view_set_priority_default (ModestMsgView *self, TnyHeaderFlags flags)
2264 {
2265         set_priority (MODEST_GTKHTML_MSG_VIEW (self), flags);
2266 }
2267
2268 static TnyHeaderFlags
2269 modest_gtkhtml_msg_view_get_priority (ModestMsgView *self)
2270 {
2271         return MODEST_GTKHTML_MSG_VIEW_GET_CLASS (self)->get_priority_func (self);
2272 }
2273
2274 static TnyHeaderFlags
2275 modest_gtkhtml_msg_view_get_priority_default (ModestMsgView *self)
2276 {
2277         return get_priority (MODEST_GTKHTML_MSG_VIEW (self));
2278 }
2279
2280 static TnyList*
2281 modest_gtkhtml_msg_view_get_selected_attachments (ModestMsgView *self)
2282 {
2283         return MODEST_GTKHTML_MSG_VIEW_GET_CLASS (self)->get_selected_attachments_func (self);
2284 }
2285
2286 static TnyList*
2287 modest_gtkhtml_msg_view_get_selected_attachments_default (ModestMsgView *self)
2288 {
2289         return get_selected_attachments (MODEST_GTKHTML_MSG_VIEW (self));
2290 }
2291
2292 static TnyList*
2293 modest_gtkhtml_msg_view_get_attachments (ModestMsgView *self)
2294 {
2295         return MODEST_GTKHTML_MSG_VIEW_GET_CLASS (self)->get_attachments_func (self);
2296 }
2297
2298 static TnyList*
2299 modest_gtkhtml_msg_view_get_attachments_default (ModestMsgView *self)
2300 {
2301         return get_attachments (MODEST_GTKHTML_MSG_VIEW (self));
2302 }
2303
2304 static void
2305 modest_gtkhtml_msg_view_grab_focus (ModestMsgView *self)
2306 {
2307         MODEST_GTKHTML_MSG_VIEW_GET_CLASS (self)->grab_focus_func (self);
2308 }
2309
2310 static void
2311 modest_gtkhtml_msg_view_grab_focus_default (ModestMsgView *self)
2312 {
2313         grab_focus (MODEST_GTKHTML_MSG_VIEW (self));
2314 }
2315
2316 static void
2317 modest_gtkhtml_msg_view_remove_attachment (ModestMsgView *self, TnyMimePart *attachment)
2318 {
2319         MODEST_GTKHTML_MSG_VIEW_GET_CLASS (self)->remove_attachment_func (self, attachment);
2320 }
2321
2322 static void
2323 modest_gtkhtml_msg_view_remove_attachment_default (ModestMsgView *self, TnyMimePart *attachment)
2324 {
2325         remove_attachment (MODEST_GTKHTML_MSG_VIEW (self), attachment);
2326 }