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

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