src/plugins/litehtml_viewer/lh_widget.cpp

   1 /*
   2  * Claws Mail -- A GTK+ based, lightweight, and fast e-mail client
   3  * Copyright(C) 1999-2015 the Claws Mail Team
   4  * == Fancy Plugin ==
   5  * This file Copyright (C) 2009-2015 Salvatore De Paolis
   6  * <iwkse@claws-mail.org> and the Claws Mail Team
   7  * This program is free software; you can redistribute it and/or modify
   8  * it under the terms of the GNU General Public License as published by
   9  * the Free Software Foundation; either version 3 of the License, or
  10  * (at your option) any later version.
  11  * This program is distributed in the hope that it will be useful,
  12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
  14  * GNU General Public License for more details.
  15  * You should have received a copy of the GNU General Public License
  16  * along with this program; if not, write tothe Free Software
  17  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
  18  */
  19
  20 #ifdef HAVE_CONFIG_H
  21 #include "config.h"
  22 #include "claws-features.h"
  23 #endif
  24
  25 #include <glib.h>
  26 #include <glib/gstdio.h>
  27 #include <fcntl.h>
  28 #include <sys/types.h>
  29 #include <sys/stat.h>
  30 #include <curl/curl.h>
  31 #include <gdk/gdk.h>
  32 #include "lh_widget.h"
  33 #include "lh_widget_wrapped.h"
  34 #include "http.h"
  35
  36 char master_css[] = {
  37 #include "css.inc"
  38 };
  39
  40 static gboolean expose_event_cb(GtkWidget *widget, GdkEvent *event,
  41                 gpointer user_data);
  42 static void size_allocate_cb(GtkWidget *widget, GdkRectangle *allocation,
  43                 gpointer user_data);
  44 static gboolean button_press_event(GtkWidget *widget, GdkEventButton *event,
  45                 gpointer user_data);
  46 static gboolean motion_notify_event(GtkWidget *widget, GdkEventButton *event,
  47         gpointer user_data);
  48 static gboolean button_release_event(GtkWidget *widget, GdkEventButton *event,
  49         gpointer user_data);
  50
  51 lh_widget::lh_widget()
  52 {
  53         /* scrolled window */
  54         m_scrolled_window = gtk_scrolled_window_new(NULL, NULL);
  55         gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(m_scrolled_window),
  56                         GTK_POLICY_AUTOMATIC, GTK_POLICY_ALWAYS);
  57         g_signal_connect(m_scrolled_window, "size-allocate",
  58                         G_CALLBACK(size_allocate_cb), this);
  59
  60         /* viewport */
  61         GtkScrolledWindow *scw = GTK_SCROLLED_WINDOW(m_scrolled_window);
  62         m_viewport = gtk_viewport_new(
  63                         gtk_scrolled_window_get_hadjustment(scw),
  64                         gtk_scrolled_window_get_vadjustment(scw));
  65         gtk_container_add(GTK_CONTAINER(m_scrolled_window), m_viewport);
  66
  67         /* drawing area */
  68         m_drawing_area = gtk_drawing_area_new();
  69         gtk_container_add(GTK_CONTAINER(m_viewport), m_drawing_area);
  70         g_signal_connect(m_drawing_area, "expose-event",
  71                         G_CALLBACK(expose_event_cb), this);
  72         g_signal_connect(m_drawing_area, "motion_notify_event",
  73                         G_CALLBACK(motion_notify_event), this);
  74         g_signal_connect(m_drawing_area, "button_press_event",
  75                         G_CALLBACK(button_press_event), this);
  76         g_signal_connect(m_drawing_area, "button_release_event",
  77                         G_CALLBACK(button_release_event), this);
  78
  79         gtk_widget_show_all(m_scrolled_window);
  80
  81         m_html = NULL;
  82         m_rendered_width = 0;
  83         m_context.load_master_stylesheet(master_css);
  84
  85         gtk_widget_set_events(m_drawing_area,
  86                                 GDK_BUTTON_RELEASE_MASK
  87                               | GDK_BUTTON_PRESS_MASK
  88                               | GDK_POINTER_MOTION_MASK);
  89
  90 }
  91
  92 lh_widget::~lh_widget()
  93 {
  94         g_object_unref(m_drawing_area);
  95         m_drawing_area = NULL;
  96         g_object_unref(m_scrolled_window);
  97         m_scrolled_window = NULL;
  98         m_html = NULL;
  99 }
 100
 101 GtkWidget *lh_widget::get_widget() const
 102 {
 103         return m_scrolled_window;
 104 }
 105
 106 void lh_widget::set_caption(const litehtml::tchar_t* caption)
 107 {
 108         g_log(NULL, G_LOG_LEVEL_MESSAGE, "lh_widget set_caption");
 109         return;
 110 }
 111
 112 void lh_widget::set_base_url(const litehtml::tchar_t* base_url)
 113 {
 114         g_log(NULL, G_LOG_LEVEL_MESSAGE, "lh_widget set_base_url");
 115         return;
 116 }
 117
 118 void lh_widget::on_anchor_click(const litehtml::tchar_t* url, const litehtml::element::ptr& el)
 119 {
 120         g_log(NULL, G_LOG_LEVEL_MESSAGE, "lh_widget on_anchor_click. url -> %s", url);
 121         m_clicked_url = url;
 122
 123         return;
 124 }
 125
 126 void lh_widget::set_cursor(const litehtml::tchar_t* cursor)
 127 {
 128         g_log(NULL, G_LOG_LEVEL_MESSAGE, "lh_widget set_cursor");
 129         if (cursor == NULL)
 130                 return;
 131 }
 132
 133 void lh_widget::import_css(litehtml::tstring& text, const litehtml::tstring& url, litehtml::tstring& baseurl)
 134 {
 135         g_log(NULL, G_LOG_LEVEL_MESSAGE, "lh_widget import_css");
 136         baseurl = master_css;
 137 }
 138
 139 void lh_widget::get_client_rect(litehtml::position& client) const
 140 {
 141         if (m_drawing_area == NULL)
 142                 return;
 143
 144         client.width = m_rendered_width;
 145         client.height = m_height;
 146         client.x = 0;
 147         client.y = 0;
 148
 149 //      g_log(NULL, G_LOG_LEVEL_MESSAGE, "lh_widget::get_client_rect: %dx%d",
 150 //                      client.width, client.height);
 151 }
 152
 153 GdkPixbuf *lh_widget::get_image(const litehtml::tchar_t* url, bool redraw_on_ready)
 154 {
 155         GError *error = NULL;
 156         GdkPixbuf *pixbuf = NULL;
 157
 158         g_log(NULL, G_LOG_LEVEL_MESSAGE, "Loading... %s", url);
 159
 160     http http_loader;
 161     GInputStream *image = http_loader.load_url(url, &error);
 162
 163         if (!image) return NULL;
 164
 165         pixbuf = gdk_pixbuf_new_from_stream(image, NULL, &error);
 166         if (error) {
 167             g_log(NULL, G_LOG_LEVEL_ERROR, "lh_widget::get_image: Could not create pixbuf %s", error->message);
 168             //g_object_unref(pixbuf);
 169             pixbuf = NULL;
 170             g_clear_error(&error);
 171         }
 172         g_input_stream_close(image, NULL, NULL);
 173
 174 /*      if (redraw_on_ready) {
 175                 redraw();
 176         }*/
 177
 178         return pixbuf;
 179 }
 180
 181 void lh_widget::open_html(const gchar *contents)
 182 {
 183         m_html = litehtml::document::createFromString(contents, this, &m_context);
 184         m_rendered_width = 0;
 185         if (m_html != NULL) {
 186                 g_log(NULL, G_LOG_LEVEL_MESSAGE, "lh_widget::open_html created document");
 187                 redraw();
 188         }
 189 }
 190
 191 void lh_widget::draw(cairo_t *cr)
 192 {
 193         double x1, x2, y1, y2;
 194         double width, height;
 195
 196         if (m_html == NULL)
 197                 return;
 198
 199         cairo_clip_extents(cr, &x1, &y1, &x2, &y2);
 200
 201         width = x2 - x1;
 202         height = y2 - y1;
 203
 204         litehtml::position pos;
 205         pos.width = (int)width;
 206         pos.height = (int)height;
 207         pos.x = (int)x1;
 208         pos.y = (int)y1;
 209
 210         m_html->draw((litehtml::uint_ptr)cr, 0, 0, &pos);
 211 }
 212
 213 void lh_widget::redraw()
 214 {
 215         GtkAllocation rect;
 216         gint width, height;
 217         GdkWindow *gdkwin;
 218         cairo_t *cr;
 219
 220         if (m_html == NULL) {
 221                 g_log(NULL, G_LOG_LEVEL_WARNING, "lh_widget::redraw: No document!");
 222                 return;
 223         }
 224
 225         /* Get width of the viewport. */
 226         gdkwin = gtk_viewport_get_view_window(GTK_VIEWPORT(m_viewport));
 227         gdk_drawable_get_size(gdkwin, &width, NULL);
 228
 229         /* If the available width has changed, rerender the HTML content. */
 230         if (m_rendered_width != width) {
 231                 g_log(NULL, G_LOG_LEVEL_MESSAGE,
 232                                 "lh_widget::redraw: width changed: %d != %d",
 233                                 m_rendered_width, width);
 234
 235                 /* Update our internally stored width, mainly so that
 236                  * lh_widget::get_client_rect() gives correct width during the
 237                  * render. */
 238                 m_rendered_width = width;
 239
 240                 /* Re-render HTML for this width. */
 241                 m_html->media_changed();
 242                 m_html->render(m_rendered_width);
 243                 g_log(NULL, G_LOG_LEVEL_MESSAGE, "render is %dx%d",
 244                                 m_html->width(), m_html->height());
 245
 246                 /* Change drawing area's size to match what was rendered. */
 247                 gtk_widget_set_size_request(m_drawing_area,
 248                                 m_html->width(), m_html->height());
 249         }
 250
 251         paint_white();
 252
 253         /* Paint the rendered HTML. */
 254         gdkwin = gtk_widget_get_window(m_drawing_area);
 255         if (gdkwin == NULL) {
 256                 g_log(NULL, G_LOG_LEVEL_WARNING, "lh_widget::redraw: No GdkWindow to draw on!");
 257                 return;
 258         }
 259         cr = gdk_cairo_create(GDK_DRAWABLE(gdkwin));
 260         draw(cr);
 261
 262         cairo_destroy(cr);
 263 }
 264
 265 void lh_widget::paint_white()
 266 {
 267         GdkWindow *gdkwin = gtk_widget_get_window(m_drawing_area);
 268         if (gdkwin == NULL) {
 269                 g_log(NULL, G_LOG_LEVEL_WARNING, "lh_widget::clear: No GdkWindow to draw on!");
 270                 return;
 271         }
 272         cairo_t *cr = gdk_cairo_create(GDK_DRAWABLE(gdkwin));
 273
 274         /* Paint white background. */
 275         gint width, height;
 276         gdk_drawable_get_size(gdkwin, &width, &height);
 277         cairo_rectangle(cr, 0, 0, width, height);
 278         cairo_set_source_rgb(cr, 255, 255, 255);
 279         cairo_fill(cr);
 280
 281         cairo_destroy(cr);
 282 }
 283 void lh_widget::clear()
 284 {
 285         paint_white();
 286         m_rendered_width = 0;
 287 }
 288
 289 static gboolean expose_event_cb(GtkWidget *widget, GdkEvent *event,
 290                 gpointer user_data)
 291 {
 292         lh_widget *w = (lh_widget *)user_data;
 293         w->redraw();
 294         return FALSE;
 295 }
 296
 297 static void size_allocate_cb(GtkWidget *widget, GdkRectangle *allocation,
 298                 gpointer user_data)
 299 {
 300         lh_widget *w = (lh_widget *)user_data;
 301
 302         g_log(NULL, G_LOG_LEVEL_MESSAGE, "size_allocate_cb: %dx%d",
 303                         allocation->width, allocation->height);
 304
 305         w->setHeight(allocation->height);
 306         w->redraw();
 307 }
 308
 309 static gboolean button_press_event(GtkWidget *widget, GdkEventButton *event,
 310                 gpointer user_data)
 311 {
 312     litehtml::position::vector redraw_boxes;
 313     lh_widget *w = (lh_widget *)user_data;
 314
 315     g_log(NULL, G_LOG_LEVEL_MESSAGE, "lh_widget on_button_press_event");
 316
 317     if(w->m_html)
 318     {
 319         if(w->m_html->on_lbutton_down((int) event->x, (int) event->y, (int) event->x, (int) event->y, redraw_boxes))
 320         {
 321             for(auto& pos : redraw_boxes)
 322             {
 323                 gtk_widget_queue_draw_area(widget, pos.x, pos.y, pos.width, pos.height);
 324             }
 325         }
 326         }
 327
 328         return true;
 329 }
 330
 331 static gboolean motion_notify_event(GtkWidget *widget, GdkEventButton *event,
 332         gpointer user_data)
 333 {
 334     litehtml::position::vector redraw_boxes;
 335     lh_widget *w = (lh_widget *)user_data;
 336
 337     g_log(NULL, G_LOG_LEVEL_MESSAGE, "lh_widget on_motion_notify_event");
 338
 339     if(w->m_html)
 340     {
 341         if(w->m_html->on_mouse_over((int) event->x, (int) event->y, (int) event->x, (int) event->y, redraw_boxes))
 342         {
 343             for (auto& pos : redraw_boxes)
 344             {
 345                 gtk_widget_queue_draw_area(widget, pos.x, pos.y, pos.width, pos.height);
 346             }
 347         }
 348         }
 349
 350         return true;
 351 }
 352
 353 static gboolean button_release_event(GtkWidget *widget, GdkEventButton *event,
 354         gpointer user_data)
 355 {
 356     litehtml::position::vector redraw_boxes;
 357     lh_widget *w = (lh_widget *)user_data;
 358     GError* error = NULL;
 359
 360         g_log(NULL, G_LOG_LEVEL_MESSAGE, "lh_widget on_button_release_event");
 361
 362         if(w->m_html)
 363         {
 364             w->m_clicked_url.clear();
 365         if(w->m_html->on_lbutton_up((int) event->x, (int) event->y, (int) event->x, (int) event->y, redraw_boxes))
 366         {
 367             for (auto& pos : redraw_boxes)
 368             {
 369                 gtk_widget_queue_draw_area(widget, pos.x, pos.y, pos.width, pos.height);
 370             }
 371         }
 372
 373         if (!w->m_clicked_url.empty())
 374         {
 375                 g_log(NULL, G_LOG_LEVEL_MESSAGE, "Open in browser: %s", w->m_clicked_url.c_str());
 376                 gtk_show_uri(NULL, w->m_clicked_url.c_str(), GDK_CURRENT_TIME, &error);
 377                 if (error) {
 378                     g_log(NULL, G_LOG_LEVEL_ERROR, "Failed opening url(%s): %s", w->m_clicked_url, error->message);
 379                     g_clear_error(&error);
 380                 }
 381         }
 382     }
 383
 384         return true;
 385 }
 386
 387 ///////////////////////////////////////////////////////////
 388 extern "C" {
 389
 390 lh_widget_wrapped *lh_widget_new()
 391 {
 392         return new lh_widget;
 393 }
 394
 395 GtkWidget *lh_widget_get_widget(lh_widget_wrapped *w)
 396 {
 397         return w->get_widget();
 398 }
 399
 400 void lh_widget_open_html(lh_widget_wrapped *w, const gchar *path)
 401 {
 402         w->open_html(path);
 403 }
 404
 405 void lh_widget_clear(lh_widget_wrapped *w)
 406 {
 407         w->clear();
 408 }
 409
 410 void lh_widget_destroy(lh_widget_wrapped *w)
 411 {
 412         delete w;
 413 }
 414
 415 } /* extern "C" */