src/plugins/litehtml_viewer/lh_widget.cpp

   1 /*
   2  * Claws Mail -- A GTK based, lightweight, and fast e-mail client
   3  * Copyright(C) 2019 the Claws Mail Team
   4  *
   5  * This program is free software; you can redistribute it and/or modify
   6  * it under the terms of the GNU General Public License as published by
   7  * the Free Software Foundation; either version 3 of the License, or
   8  * (at your option) any later version.
   9  * This program is distributed in the hope that it will be useful,
  10  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  11  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
  12  * GNU General Public License for more details.
  13  * You should have received a copy of the GNU General Public License
  14  * along with this program; if not, write tothe Free Software
  15  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
  16  */
  17
  18 #ifdef HAVE_CONFIG_H
  19 #include "config.h"
  20 #include "claws-features.h"
  21 #endif
  22
  23 #include <glib.h>
  24 #include <glib/gi18n.h>
  25 #include <glib/gstdio.h>
  26 #include <fcntl.h>
  27 #include <sys/types.h>
  28 #include <sys/stat.h>
  29 #include <curl/curl.h>
  30 #include <gdk/gdk.h>
  31
  32 #include "utils.h"
  33
  34 #include "litehtml/litehtml.h"
  35
  36 #include "lh_prefs.h"
  37 #include "lh_widget.h"
  38 #include "lh_widget_wrapped.h"
  39
  40 extern "C" {
  41 const gchar *prefs_common_get_uri_cmd(void);
  42 }
  43
  44 static gboolean draw_cb(GtkWidget *widget, cairo_t *cr,
  45                 gpointer user_data);
  46 static gboolean button_press_event(GtkWidget *widget, GdkEventButton *event,
  47                 gpointer user_data);
  48 static gboolean motion_notify_event(GtkWidget *widget, GdkEventButton *event,
  49         gpointer user_data);
  50 static gboolean button_release_event(GtkWidget *widget, GdkEventButton *event,
  51         gpointer user_data);
  52 static void open_link_cb(GtkMenuItem *item, gpointer user_data);
  53 static void copy_link_cb(GtkMenuItem *item, gpointer user_data);
  54
  55 lh_widget::lh_widget()
  56 {
  57         GtkWidget *item;
  58
  59         m_force_render = false;
  60         m_blank = false;
  61
  62         /* scrolled window */
  63         m_scrolled_window = gtk_scrolled_window_new(NULL, NULL);
  64         gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(m_scrolled_window),
  65                         GTK_POLICY_AUTOMATIC, GTK_POLICY_ALWAYS);
  66
  67         /* viewport */
  68         GtkScrolledWindow *scw = GTK_SCROLLED_WINDOW(m_scrolled_window);
  69         m_viewport = gtk_viewport_new(
  70                         gtk_scrolled_window_get_hadjustment(scw),
  71                         gtk_scrolled_window_get_vadjustment(scw));
  72         gtk_container_add(GTK_CONTAINER(m_scrolled_window), m_viewport);
  73
  74         /* drawing area */
  75         m_drawing_area = gtk_drawing_area_new();
  76         gtk_container_add(GTK_CONTAINER(m_viewport), m_drawing_area);
  77         g_signal_connect(m_drawing_area, "draw",
  78                         G_CALLBACK(draw_cb), this);
  79         g_signal_connect(m_drawing_area, "motion_notify_event",
  80                         G_CALLBACK(motion_notify_event), this);
  81         g_signal_connect(m_drawing_area, "button_press_event",
  82                         G_CALLBACK(button_press_event), this);
  83         g_signal_connect(m_drawing_area, "button_release_event",
  84                         G_CALLBACK(button_release_event), this);
  85
  86         gtk_widget_show_all(m_scrolled_window);
  87
  88         /* context menu */
  89         m_context_menu = gtk_menu_new();
  90
  91         item = gtk_menu_item_new_with_label(_("Open Link"));
  92         g_signal_connect(G_OBJECT(item), "activate", G_CALLBACK(open_link_cb), this);
  93         gtk_menu_shell_append(GTK_MENU_SHELL(m_context_menu), item);
  94
  95         item = gtk_menu_item_new_with_label(_("Copy Link Location"));
  96         g_signal_connect(G_OBJECT(item), "activate", G_CALLBACK(copy_link_cb), this);
  97         gtk_menu_shell_append(GTK_MENU_SHELL(m_context_menu), item);
  98
  99         m_html = NULL;
 100         m_rendered_width = 0;
 101
 102         m_font_name = NULL;
 103         m_font_size = 0;
 104
 105         m_partinfo = NULL;
 106
 107         m_showing_url = FALSE;
 108
 109         m_cairo_context = NULL;
 110
 111         gtk_widget_set_events(m_drawing_area,
 112                                 GDK_BUTTON_RELEASE_MASK
 113                               | GDK_BUTTON_PRESS_MASK
 114                               | GDK_POINTER_MOTION_MASK);
 115 }
 116
 117 lh_widget::~lh_widget()
 118 {
 119         g_object_unref(m_drawing_area);
 120         m_drawing_area = NULL;
 121         g_object_unref(m_scrolled_window);
 122         m_scrolled_window = NULL;
 123         m_html = NULL;
 124         g_free(m_font_name);
 125 }
 126
 127 GtkWidget *lh_widget::get_widget() const
 128 {
 129         return m_scrolled_window;
 130 }
 131
 132 void lh_widget::set_caption(const char *caption)
 133 {
 134         debug_print("lh_widget set_caption\n");
 135         return;
 136 }
 137
 138 void lh_widget::set_base_url(const char *base_url)
 139 {
 140         debug_print("lh_widget set_base_url '%s'\n",
 141                         (base_url ? base_url : "(null)"));
 142         if (base_url)
 143                 m_base_url = base_url;
 144         else
 145                 m_base_url.clear();
 146
 147         return;
 148 }
 149
 150 void lh_widget::on_anchor_click(const char *url, const litehtml::element::ptr& el)
 151 {
 152         debug_print("lh_widget on_anchor_click. url -> %s\n", url);
 153
 154         m_clicked_url = fullurl(url);
 155         return;
 156 }
 157
 158 void lh_widget::import_css(litehtml::string& text, const litehtml::string& url, litehtml::string& baseurl)
 159 {
 160         debug_print("lh_widget import_css. url=\"%s\" baseurl=\"%s\"\n", url.c_str(), baseurl.c_str());
 161 }
 162
 163 void lh_widget::get_client_rect(litehtml::position& client) const
 164 {
 165         if (m_drawing_area == NULL)
 166                 return;
 167
 168         client.width = m_rendered_width;
 169         client.height = m_height;
 170         client.x = 0;
 171         client.y = 0;
 172
 173 //      debug_print("lh_widget::get_client_rect: %dx%d\n",
 174 //                      client.width, client.height);
 175 }
 176
 177 void lh_widget::open_html(const gchar *contents)
 178 {
 179         gint num = clear_images(lh_prefs_get()->image_cache_size * 1024 * 1000);
 180         GtkAdjustment *adj;
 181
 182         debug_print("LH: cleared %d images from image cache\n", num);
 183
 184         update_font();
 185
 186         lh_widget_statusbar_push("Loading HTML part ...");
 187         m_html = litehtml::document::createFromString(contents, this);
 188         m_rendered_width = 0;
 189         if (m_html != NULL) {
 190                 debug_print("lh_widget::open_html created document\n");
 191                 adj = gtk_scrolled_window_get_hadjustment(
 192                                 GTK_SCROLLED_WINDOW(m_scrolled_window));
 193                 gtk_adjustment_set_value(adj, 0.0);
 194                 adj = gtk_scrolled_window_get_vadjustment(
 195                                 GTK_SCROLLED_WINDOW(m_scrolled_window));
 196                 gtk_adjustment_set_value(adj, 0.0);
 197                 m_blank = false;
 198         }
 199         lh_widget_statusbar_pop();
 200 }
 201
 202 void lh_widget::rerender()
 203 {
 204         m_force_render = true;
 205         gtk_widget_queue_draw(m_drawing_area);
 206 }
 207
 208 void lh_widget::draw(cairo_t *cr)
 209 {
 210         double x1, x2, y1, y2;
 211         double width, height;
 212
 213         if (m_html == NULL)
 214                 return;
 215
 216         cairo_clip_extents(cr, &x1, &y1, &x2, &y2);
 217
 218         width = x2 - x1;
 219         height = y2 - y1;
 220
 221         litehtml::position pos;
 222         pos.width = (int)width;
 223         pos.height = (int)height;
 224         pos.x = (int)x1;
 225         pos.y = (int)y1;
 226
 227         m_html->draw((litehtml::uint_ptr)cr, 0, 0, &pos);
 228 }
 229
 230 void lh_widget::redraw()
 231 {
 232         GtkAllocation rect;
 233         gint width;
 234         GdkWindow *gdkwin;
 235         cairo_t *cr;
 236         cairo_region_t *creg;
 237         GdkDrawingContext *gdkctx;
 238         gboolean destroy = FALSE;
 239
 240         if (m_html == NULL)
 241                 return;
 242
 243         /* Get width of the viewport. */
 244         gtk_widget_get_allocation(GTK_WIDGET(m_viewport), &rect);
 245         width = rect.width;
 246         m_height = rect.height;
 247
 248         /* If the available width has changed, rerender the HTML content. */
 249         if (m_rendered_width != width || std::atomic_exchange(&m_force_render, false)) {
 250                 debug_print("lh_widget::redraw: width changed: %d != %d\n",
 251                                 m_rendered_width, width);
 252
 253                 /* Update our internally stored width, mainly so that
 254                  * lh_widget::get_client_rect() gives correct width during the
 255                  * render. */
 256                 m_rendered_width = width;
 257
 258                 /* Re-render HTML for this width. */
 259                 m_html->media_changed();
 260                 m_html->render(m_rendered_width);
 261                 debug_print("render is %dx%d\n", m_html->width(), m_html->height());
 262
 263                 /* Change drawing area's size to match what was rendered. */
 264                 gtk_widget_set_size_request(m_drawing_area,
 265                                 m_html->width(), m_html->height());
 266         }
 267
 268         /* Use provided cairo context, if any. Otherwise create our own. */
 269         if (m_cairo_context != NULL) {
 270                 cr = m_cairo_context;
 271         } else {
 272                 gdkwin = gtk_widget_get_window(m_drawing_area);
 273                 if (gdkwin == NULL) {
 274                         g_warning("lh_widget::redraw: No GdkWindow to draw on!");
 275                         return;
 276                 }
 277                 creg = cairo_region_create_rectangle(&rect);
 278                 gdkctx = gdk_window_begin_draw_frame(gdkwin, creg);
 279                 cr = gdk_drawing_context_get_cairo_context(gdkctx);
 280                 destroy = TRUE;
 281         }
 282
 283         if(!std::atomic_exchange(&m_blank, false)) {
 284                 draw(cr);
 285         } else {
 286                 cairo_rectangle(cr, rect.x, rect.y, rect.width, rect.height);
 287                 cairo_set_source_rgb(cr, 255, 255, 255);
 288                 cairo_fill(cr);
 289         }
 290
 291         /* Only destroy the used cairo context if we created it earlier. */
 292         if (destroy) {
 293                 gdk_window_end_draw_frame(gdkwin, gdkctx);
 294                 cairo_region_destroy(creg);
 295         }
 296 }
 297
 298 void lh_widget::clear()
 299 {
 300         m_html = nullptr;
 301         m_blank = true;
 302         m_rendered_width = 0;
 303         m_base_url.clear();
 304         m_clicked_url.clear();
 305 }
 306
 307 void lh_widget::set_cursor(const char *cursor)
 308 {
 309         litehtml::element::const_ptr over_el = m_html->get_over_element();
 310
 311         if (m_showing_url &&
 312                         (over_el == NULL || over_el != m_over_element)) {
 313                 lh_widget_statusbar_pop();
 314                 m_showing_url = FALSE;
 315         }
 316
 317         if (over_el != m_over_element) {
 318                 m_over_element = over_el;
 319                 update_cursor(cursor);
 320         }
 321 }
 322
 323 void lh_widget::update_cursor(const char *cursor)
 324 {
 325         GdkCursorType cursType = GDK_ARROW;
 326         const char *href = get_href_at(m_over_element);
 327
 328         /* If there is a href, and litehtml is okay with showing a pointer
 329          * cursor ("pointer" or "auto"), set it, otherwise keep the
 330          * default arrow cursor */
 331         if ((!strcmp(cursor, "pointer") || !strcmp(cursor, "auto")) &&
 332                         href != NULL) {
 333                 cursType = GDK_HAND2;
 334         }
 335
 336         if (cursType == GDK_ARROW) {
 337                 gdk_window_set_cursor(gtk_widget_get_window(m_drawing_area), NULL);
 338         } else {
 339                 gdk_window_set_cursor(gtk_widget_get_window(m_drawing_area),
 340                                 gdk_cursor_new_for_display(gtk_widget_get_display(m_drawing_area),
 341                                         cursType));
 342         }
 343
 344         /* If there is a href, show it in statusbar */
 345         if (href != NULL) {
 346                 lh_widget_statusbar_push(fullurl(href).c_str());
 347                 m_showing_url = TRUE;
 348         }
 349 }
 350
 351 const char *lh_widget::get_href_at(litehtml::element::const_ptr element)
 352 {
 353         litehtml::element::const_ptr el;
 354
 355         if (element == NULL)
 356                 return NULL;
 357
 358         /* If it's not an anchor, check if it has a parent anchor
 359          * (e.g. it's an image within an anchor) and grab a pointer
 360          * to that. */
 361         if (strcmp(element->get_tagName(), "a") && element->parent()) {
 362                 el = element->parent();
 363                 while (el && el != m_html->root() && strcmp(el->get_tagName(), "a")) {
 364                         el = el->parent();
 365                 }
 366
 367                 if (!el || el == m_html->root())
 368                         return NULL;
 369         } else {
 370                 el = element;
 371         }
 372
 373         /* At this point, over_el is pointing at an anchor tag, so let's
 374          * grab its href attribute. */
 375         return el->get_attr("href");
 376 }
 377
 378 void lh_widget::print()
 379 {
 380     debug_print("lh_widget print\n");
 381     gtk_widget_realize(GTK_WIDGET(m_drawing_area));
 382 }
 383
 384 void lh_widget::popup_context_menu(const char *url,
 385                 GdkEventButton *event)
 386 {
 387         cm_return_if_fail(url != NULL);
 388         cm_return_if_fail(event != NULL);
 389
 390         debug_print("lh_widget showing context menu for '%s'\n", url);
 391
 392         m_clicked_url = url;
 393         gtk_widget_show_all(m_context_menu);
 394         gtk_menu_popup_at_pointer(GTK_MENU(m_context_menu), (GdkEvent *)event);
 395 }
 396
 397 void lh_widget::update_font()
 398 {
 399         PangoFontDescription *pd =
 400                 pango_font_description_from_string(lh_prefs_get()->default_font);
 401         gboolean absolute = pango_font_description_get_size_is_absolute(pd);
 402
 403         g_free(m_font_name);
 404         m_font_name = g_strdup(pango_font_description_get_family(pd));
 405         m_font_size = pango_font_description_get_size(pd);
 406
 407         pango_font_description_free(pd);
 408
 409         if (!absolute)
 410                 m_font_size /= PANGO_SCALE;
 411
 412         debug_print("Font set to '%s', size %d\n", m_font_name, m_font_size);
 413 }
 414
 415 const litehtml::string lh_widget::fullurl(const char *url) const
 416 {
 417         if (*url == '#' && !m_base_url.empty())
 418                 return m_base_url + url;
 419
 420         return url;
 421 }
 422
 423 void lh_widget::set_partinfo(MimeInfo *partinfo)
 424 {
 425         m_partinfo = partinfo;
 426 }
 427
 428 GdkPixbuf *lh_widget::get_local_image(const litehtml::string url) const
 429 {
 430         GdkPixbuf *pixbuf;
 431         const gchar *name;
 432         MimeInfo *p = m_partinfo;
 433
 434         if (strncmp(url.c_str(), "cid:", 4) != 0) {
 435                 debug_print("lh_widget::get_local_image: '%s' is not a local URI, ignoring\n", url.c_str());
 436                 return NULL;
 437         }
 438
 439         name = url.c_str() + 4;
 440         debug_print("getting message part '%s'\n", name);
 441
 442         while ((p = procmime_mimeinfo_next(p)) != NULL) {
 443                 size_t len = strlen(name);
 444
 445                 /* p->id is in format "<partname>" */
 446                 if (p->id != NULL &&
 447                                 strlen(p->id) >= len + 2 &&
 448                                 !strncasecmp(name, p->id + 1, len) &&
 449                                 *(p->id + len + 1) == '>') {
 450                         GError *error = NULL;
 451
 452                         pixbuf = procmime_get_part_as_pixbuf(p, &error);
 453                         if (error != NULL) {
 454                                 g_warning("couldn't load image: %s", error->message);
 455                                 g_error_free(error);
 456                                 return NULL;
 457                         }
 458
 459                         return pixbuf;
 460                 }
 461         }
 462
 463         /* MIME part with requested name was not found */
 464         return NULL;
 465 }
 466
 467 void lh_widget::set_cairo_context(cairo_t *cr)
 468 {
 469         m_cairo_context = cr;
 470 }
 471
 472
 473 ////////////////////////////////////////////////
 474 static gboolean draw_cb(GtkWidget *widget, cairo_t *cr,
 475                 gpointer user_data)
 476 {
 477         lh_widget *w = (lh_widget *)user_data;
 478         w->set_cairo_context(cr);
 479         w->redraw();
 480         w->set_cairo_context(NULL);
 481         return FALSE;
 482 }
 483
 484 static gboolean button_press_event(GtkWidget *widget, GdkEventButton *event,
 485                 gpointer user_data)
 486 {
 487         litehtml::position::vector redraw_boxes;
 488         lh_widget *w = (lh_widget *)user_data;
 489
 490         if (w->m_html == NULL)
 491                 return FALSE;
 492
 493         //debug_print("lh_widget on_button_press_event\n");
 494
 495         if (event->type == GDK_2BUTTON_PRESS ||
 496                         event->type == GDK_3BUTTON_PRESS)
 497                 return TRUE;
 498
 499         /* Right-click */
 500         if (event->button == 3) {
 501                 const char *url = w->get_href_at(w->m_html->get_over_element());
 502
 503                 if (url != NULL)
 504                         w->popup_context_menu(url, event);
 505
 506                 return TRUE;
 507         }
 508
 509         if(w->m_html->on_lbutton_down((int) event->x, (int) event->y,
 510                                 (int) event->x, (int) event->y, redraw_boxes)) {
 511                 for(auto& pos : redraw_boxes) {
 512                         debug_print("x: %d y:%d w: %d h: %d\n", pos.x, pos.y, pos.width, pos.height);
 513                         gtk_widget_queue_draw_area(widget, pos.x, pos.y, pos.width, pos.height);
 514                 }
 515         }
 516
 517         return TRUE;
 518 }
 519
 520 static gboolean motion_notify_event(GtkWidget *widget, GdkEventButton *event,
 521         gpointer user_data)
 522 {
 523     litehtml::position::vector redraw_boxes;
 524     lh_widget *w = (lh_widget *)user_data;
 525
 526     //debug_print("lh_widget on_motion_notify_event\n");
 527
 528     if(w->m_html)
 529     {
 530         if(w->m_html->on_mouse_over((int) event->x, (int) event->y, (int) event->x, (int) event->y, redraw_boxes))
 531         {
 532             for (auto& pos : redraw_boxes)
 533             {
 534                 debug_print("x: %d y:%d w: %d h: %d\n", pos.x, pos.y, pos.width, pos.height);
 535                 gtk_widget_queue_draw_area(widget, pos.x, pos.y, pos.width, pos.height);
 536             }
 537         }
 538         }
 539
 540         return TRUE;
 541 }
 542
 543 static gboolean button_release_event(GtkWidget *widget, GdkEventButton *event,
 544         gpointer user_data)
 545 {
 546     litehtml::position::vector redraw_boxes;
 547     lh_widget *w = (lh_widget *)user_data;
 548
 549         if (w->m_html == NULL)
 550                 return FALSE;
 551
 552         //debug_print("lh_widget on_button_release_event\n");
 553
 554         if (event->type == GDK_2BUTTON_PRESS ||
 555                         event->type == GDK_3BUTTON_PRESS)
 556                 return TRUE;
 557
 558         /* Right-click */
 559         if (event->button == 3)
 560                 return TRUE;
 561
 562         w->m_clicked_url.clear();
 563
 564     if(w->m_html->on_lbutton_up((int) event->x, (int) event->y, (int) event->x, (int) event->y, redraw_boxes))
 565     {
 566         for (auto& pos : redraw_boxes)
 567         {
 568             debug_print("x: %d y:%d w: %d h: %d\n", pos.x, pos.y, pos.width, pos.height);
 569             gtk_widget_queue_draw_area(widget, pos.x, pos.y, pos.width, pos.height);
 570         }
 571     }
 572
 573     if (!w->m_clicked_url.empty())
 574     {
 575             debug_print("Open in browser: %s\n", w->m_clicked_url.c_str());
 576             open_uri(w->m_clicked_url.c_str(), prefs_common_get_uri_cmd());
 577     }
 578
 579         return TRUE;
 580 }
 581
 582 static void open_link_cb(GtkMenuItem *item, gpointer user_data)
 583 {
 584         lh_widget_wrapped *w = (lh_widget_wrapped *)user_data;
 585
 586         open_uri(w->m_clicked_url.c_str(), prefs_common_get_uri_cmd());
 587 }
 588
 589 static void copy_link_cb(GtkMenuItem *item, gpointer user_data)
 590 {
 591         lh_widget_wrapped *w = (lh_widget_wrapped *)user_data;
 592
 593         gtk_clipboard_set_text(gtk_clipboard_get(GDK_SELECTION_PRIMARY),
 594                         w->m_clicked_url.c_str(), -1);
 595         gtk_clipboard_set_text(gtk_clipboard_get(GDK_SELECTION_CLIPBOARD),
 596                         w->m_clicked_url.c_str(), -1);
 597 }
 598
 599 ///////////////////////////////////////////////////////////
 600 extern "C" {
 601
 602 lh_widget_wrapped *lh_widget_new()
 603 {
 604         return new lh_widget;
 605 }
 606
 607 GtkWidget *lh_widget_get_widget(lh_widget_wrapped *w)
 608 {
 609         return w->get_widget();
 610 }
 611
 612 void lh_widget_open_html(lh_widget_wrapped *w, const gchar *path)
 613 {
 614         w->open_html(path);
 615 }
 616
 617 void lh_widget_clear(lh_widget_wrapped *w)
 618 {
 619         w->clear();
 620 }
 621
 622 void lh_widget_destroy(lh_widget_wrapped *w)
 623 {
 624         delete w;
 625 }
 626
 627 void lh_widget_print(lh_widget_wrapped *w) {
 628         w->print();
 629 }
 630
 631 void lh_widget_set_partinfo(lh_widget_wrapped *w, MimeInfo *partinfo)
 632 {
 633         w->set_partinfo(partinfo);
 634 }
 635
 636 } /* extern "C" */