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