src/gtk-tpdfv.c

   1 /*
   2  * tpdfview - src/gtk-tpdfv.c
   3  * Copyright (C) 2011 Sebastian 'tokkee' Harl <sh@tokkee.org>
   4  * All rights reserved.
   5  *
   6  * Redistribution and use in source and binary forms, with or without
   7  * modification, are permitted provided that the following conditions
   8  * are met:
   9  * 1. Redistributions of source code must retain the above copyright
  10  *    notice, this list of conditions and the following disclaimer.
  11  * 2. Redistributions in binary form must reproduce the above copyright
  12  *    notice, this list of conditions and the following disclaimer in the
  13  *    documentation and/or other materials provided with the distribution.
  14  *
  15  * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
  16  * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
  17  * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
  18  * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDERS OR
  19  * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
  20  * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
  21  * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS;
  22  * OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
  23  * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
  24  * OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF
  25  * ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  26  */
  27
  28 /*
  29  * This module provides a Gtk widget to display PDF files.
  30  */
  31
  32 #include "gtk-tpdfv.h"
  33
  34 #include <assert.h>
  35
  36 #include <errno.h>
  37
  38 #include <cairo.h>
  39 #include <gtk/gtk.h>
  40
  41 #include <poppler.h>
  42
  43 #include <stdlib.h>
  44 #include <string.h>
  45
  46 #include <sys/stat.h>
  47
  48 #define TPDFV_MIN(a, b) ((a) <= (b) ? (a) : (b))
  49 #define TPDFV_MAX(a, b) ((a) >= (b) ? (a) : (b))
  50
  51 typedef enum {
  52         TPDFV_ZOOM_CUSTOM = 0,
  53         TPDFV_ZOOM_WIDTH,
  54         TPDFV_ZOOM_HEIGHT,
  55         TPDFV_ZOOM_FIT,
  56 } tpdfv_zoommode_t;
  57
  58 typedef struct {
  59         char *filename;
  60
  61         time_t mtime;
  62
  63         PopplerDocument *doc;
  64         PopplerPage     *current_page;
  65
  66         int current_page_no;
  67         int total_pages;
  68
  69         tpdfv_zoommode_t zoom_mode;
  70         double zoom_factor;
  71
  72         double delta_x;
  73         double delta_y;
  74 } gtk_tpdfv_t;
  75
  76 GType gtk_tpdfv_get_type(void);
  77 G_DEFINE_TYPE(GtkTPDFV, gtk_tpdfv, GTK_TYPE_DRAWING_AREA);
  78
  79 #define GTK_TPDFV_GET_PRIVATE(obj) \
  80         (G_TYPE_INSTANCE_GET_PRIVATE ((obj), GTK_TYPE_TPDFV, gtk_tpdfv_t))
  81
  82 /*
  83  * Private helper functions.
  84  */
  85
  86 static void
  87 tpdfv_open(gtk_tpdfv_t *pdf)
  88 {
  89         GError *err = NULL;
  90
  91         struct stat statbuf;
  92
  93         if ((! pdf) || (! pdf->filename))
  94                 return;
  95
  96         memset(&statbuf, 0, sizeof(statbuf));
  97         if (stat(pdf->filename + strlen("file://"), &statbuf) != 0) {
  98                 char errbuf[1024];
  99                 strerror_r(errno, errbuf, sizeof(errbuf));
 100                 fprintf(stderr, "Failed to access PDF: %s.\n", errbuf);
 101                 return;
 102         }
 103
 104         pdf->mtime = statbuf.st_mtime;
 105
 106         pdf->doc = poppler_document_new_from_file(pdf->filename,
 107                         /* password = */ NULL, &err);
 108         if (! pdf->doc) {
 109                 fprintf(stderr, "Failed to open PDF: %s.\n", err->message);
 110                 return;
 111         }
 112
 113         pdf->total_pages = poppler_document_get_n_pages(pdf->doc);
 114         if (pdf->current_page_no >= pdf->total_pages)
 115                 pdf->current_page_no = pdf->total_pages - 1;
 116 } /* tpdfv_open */
 117
 118 static void
 119 tpdfv_close(gtk_tpdfv_t *pdf)
 120 {
 121         if (! pdf)
 122                 return;
 123
 124         g_object_unref(pdf->doc);
 125         pdf->doc = NULL;
 126         pdf->current_page = NULL;
 127 } /* tpdfv_close */
 128
 129 static gboolean
 130 tpdfv_init(gtk_tpdfv_t *pdf, const char *filename)
 131 {
 132         if (strstr(filename, "://"))
 133                 pdf->filename = strdup(filename);
 134         else {
 135                 size_t len = strlen("file://") + strlen(filename);
 136                 pdf->filename = (char *)malloc(len + 1);
 137                 if (pdf->filename) {
 138                         *pdf->filename = '\0';
 139                         strncat(pdf->filename, "file://", len);
 140                         strncat(pdf->filename, filename, len - strlen("file://"));
 141                 }
 142         }
 143
 144         /* XXX: error reporting mechanism */
 145
 146         if (! pdf->filename) {
 147                 char errbuf[1024];
 148                 strerror_r(errno, errbuf, sizeof(errbuf));
 149                 fprintf(stderr, "Failed to allocate string: %s.\n", errbuf);
 150                 return FALSE;
 151         }
 152
 153         pdf->doc = NULL;
 154         tpdfv_open(pdf);
 155
 156         pdf->current_page_no = 0;
 157         pdf->current_page = poppler_document_get_page(pdf->doc,
 158                         pdf->current_page_no);
 159         if (! pdf->current_page) {
 160                 fprintf(stderr, "Failed to open first page of the document.\n");
 161                 return FALSE;
 162         }
 163
 164         pdf->zoom_mode   = TPDFV_ZOOM_CUSTOM;
 165         pdf->zoom_factor = 1.0;
 166         pdf->delta_x = pdf->delta_y = 0.0;
 167         return TRUE;
 168 } /* tpdfv_init */
 169
 170 static void
 171 tpdfv_clean(gtk_tpdfv_t *pdf)
 172 {
 173         if (! pdf)
 174                 return;
 175
 176         tpdfv_close(pdf);
 177         pdf->current_page = NULL;
 178         free(pdf->filename);
 179         pdf->filename = NULL;
 180         return;
 181 } /* tpdfv_clean */
 182
 183 static void
 184 do_redraw(GtkWidget *widget)
 185 {
 186         GdkRegion *region;
 187         gtk_tpdfv_t *pdf;
 188
 189         pdf = GTK_TPDFV_GET_PRIVATE(widget);
 190
 191         if ((! pdf->current_page) || (poppler_page_get_index(pdf->current_page)
 192                         != pdf->current_page_no)) {
 193                 pdf->current_page = poppler_document_get_page(pdf->doc,
 194                 pdf->current_page_no);
 195
 196                 if (! pdf->current_page) {
 197                         fprintf(stderr, "Failed to open page %i of the document.\n",
 198                                         pdf->current_page_no + 1);
 199                         return;
 200                 }
 201         }
 202
 203         region = gdk_drawable_get_clip_region(widget->window);
 204         gdk_window_invalidate_region(widget->window, region, TRUE);
 205         gdk_window_process_updates(widget->window, TRUE);
 206
 207         gdk_region_destroy(region);
 208 } /* do_redraw */
 209
 210 /*
 211  * Gtk+ class definition.
 212  */
 213
 214 static gboolean
 215 gtk_tpdfv_expose(GtkWidget *tpdfv, GdkEventExpose *event)
 216 {
 217         gtk_tpdfv_t *pdf;
 218         cairo_t *cr;
 219
 220         struct stat statbuf;
 221
 222         gdouble width, height;
 223
 224         gdouble page_width  = 0.0;
 225         gdouble page_height = 0.0;
 226
 227         double zoom_factor  = 1.0;
 228         double x, y;
 229
 230         pdf = GTK_TPDFV_GET_PRIVATE(tpdfv);
 231
 232         if (! pdf)
 233                 return FALSE;
 234
 235         memset(&statbuf, 0, sizeof(statbuf));
 236         if (stat(pdf->filename + strlen("file://"), &statbuf)) {
 237                 char errbuf[1024];
 238                 strerror_r(errno, errbuf, sizeof(errbuf));
 239                 fprintf(stderr, "Failed to access PDF: %s.\n", errbuf);
 240                 return FALSE;
 241         }
 242
 243         if (statbuf.st_mtime > pdf->mtime)
 244                 gtk_tpdfv_reload(tpdfv);
 245
 246         cr = gdk_cairo_create(tpdfv->window);
 247         cairo_rectangle(cr, event->area.x, event->area.y,
 248                         event->area.width, event->area.height);
 249         cairo_clip(cr);
 250
 251         poppler_page_get_size(pdf->current_page, &page_width, &page_height);
 252         width  = (gdouble)tpdfv->allocation.width;
 253         height = (gdouble)tpdfv->allocation.height;
 254
 255         /* zoom */
 256         if (pdf->zoom_mode == TPDFV_ZOOM_CUSTOM) {
 257                 zoom_factor = pdf->zoom_factor;
 258         }
 259         else {
 260                 if (pdf->zoom_mode == TPDFV_ZOOM_WIDTH) {
 261                         zoom_factor = (double)(width / page_width);
 262                 }
 263                 else if (pdf->zoom_mode == TPDFV_ZOOM_HEIGHT) {
 264                         zoom_factor = (double)(height / page_height);
 265                 }
 266                 else if (pdf->zoom_mode == TPDFV_ZOOM_FIT) {
 267                         zoom_factor = (double)TPDFV_MIN(width / page_width,
 268                                         height / page_height);
 269                 }
 270                 else {
 271                         assert(0);
 272                 }
 273         }
 274         cairo_scale(cr, zoom_factor, zoom_factor);
 275
 276         /* centered position / scrolling */
 277         x = (double)(width - page_width * zoom_factor) / 2.0 / zoom_factor;
 278         y = (double)(height - page_height * zoom_factor) / 2.0 / zoom_factor;
 279
 280         cairo_translate(cr, x + pdf->delta_x, y + pdf->delta_y);
 281
 282         /* draw empty white page */
 283         cairo_save(cr);
 284
 285         cairo_set_source_rgba(cr, 1.0, 1.0, 1.0, 1.0);
 286         cairo_rectangle(cr, 0.0, 0.0, page_width, page_height);
 287         cairo_fill(cr);
 288
 289         cairo_restore(cr);
 290
 291         poppler_page_render(pdf->current_page, cr);
 292
 293         cairo_destroy(cr);
 294         return FALSE;
 295 } /* gtk_tpdfv_expose */
 296
 297 static void
 298 gtk_tpdfv_destroy(GtkObject *obj)
 299 {
 300         GtkTPDFV    *tpdfv = GTK_TPDFV(obj);
 301         gtk_tpdfv_t *pdf;
 302
 303         pdf = GTK_TPDFV_GET_PRIVATE(tpdfv);
 304         tpdfv_clean(pdf);
 305
 306         GTK_OBJECT_CLASS(gtk_tpdfv_parent_class)->destroy(obj);
 307 } /* gtk_tpdfv_destroy */
 308
 309 static void
 310 gtk_tpdfv_class_init(GtkTPDFVClass *class)
 311 {
 312         GObjectClass   *goclass;
 313         GtkObjectClass *oclass;
 314         GtkWidgetClass *wclass;
 315
 316         goclass = G_OBJECT_CLASS(class);
 317         g_type_class_add_private(goclass, sizeof(gtk_tpdfv_t));
 318
 319         oclass = GTK_OBJECT_CLASS(class);
 320         oclass->destroy = gtk_tpdfv_destroy;
 321
 322         wclass = GTK_WIDGET_CLASS(class);
 323         wclass->expose_event = gtk_tpdfv_expose;
 324 } /* gtk_tpdfv_class_init */
 325
 326 static void
 327 gtk_tpdfv_init(GtkTPDFV __attribute__((unused)) *tpdfv)
 328 {
 329         /* nothing to do for now */
 330 } /* gtk_tpdfv_init */
 331
 332 /*
 333  * Public API.
 334  */
 335
 336 GtkWidget *
 337 gtk_tpdfv_new(const char *filename)
 338 {
 339         GtkTPDFV    *tpdfv;
 340         gtk_tpdfv_t *pdf;
 341
 342         tpdfv = g_object_new(GTK_TYPE_TPDFV, NULL);
 343         pdf   = GTK_TPDFV_GET_PRIVATE(tpdfv);
 344
 345         if (TRUE != tpdfv_init(pdf, filename))
 346                 return NULL;
 347         return GTK_WIDGET(tpdfv);
 348 } /* gtk_tpdfv_new */
 349
 350 void
 351 gtk_tpdfv_reload(GtkWidget *widget)
 352 {
 353         gtk_tpdfv_t *pdf;
 354
 355         pdf = GTK_TPDFV_GET_PRIVATE(widget);
 356         tpdfv_close(pdf);
 357         tpdfv_open(pdf);
 358         do_redraw(widget);
 359 } /* gtk_tpdfv_reload */
 360
 361 void
 362 gtk_tpdfv_page_up(GtkWidget *widget)
 363 {
 364         gtk_tpdfv_t *pdf;
 365
 366         pdf = GTK_TPDFV_GET_PRIVATE(widget);
 367
 368         if (pdf->current_page_no)
 369                 --pdf->current_page_no;
 370         do_redraw(widget);
 371 } /* gtk_tpdfv_page_up */
 372
 373 void
 374 gtk_tpdfv_page_down(GtkWidget *widget)
 375 {
 376         gtk_tpdfv_t *pdf;
 377
 378         pdf = GTK_TPDFV_GET_PRIVATE(widget);
 379
 380         if (pdf->current_page_no < pdf->total_pages - 1)
 381                 ++pdf->current_page_no;
 382         do_redraw(widget);
 383 } /* gtk_tpdfv_page_down */
 384
 385 void
 386 gtk_tpdfv_first_page(GtkWidget *widget)
 387 {
 388         gtk_tpdfv_t *pdf;
 389
 390         pdf = GTK_TPDFV_GET_PRIVATE(widget);
 391         pdf->current_page_no = 0;
 392         do_redraw(widget);
 393 } /* gtk_tpdfv_first_page */
 394
 395 void
 396 gtk_tpdfv_last_page(GtkWidget *widget)
 397 {
 398         gtk_tpdfv_t *pdf;
 399
 400         pdf = GTK_TPDFV_GET_PRIVATE(widget);
 401         pdf->current_page_no = pdf->total_pages - 1;
 402         do_redraw(widget);
 403 } /* gtk_tpdfv_last_page */
 404
 405 void
 406 gtk_tpdfv_zoom_in(GtkWidget *widget)
 407 {
 408         gtk_tpdfv_t *pdf;
 409
 410         pdf = GTK_TPDFV_GET_PRIVATE(widget);
 411         pdf->zoom_factor *= 1.2;
 412         pdf->zoom_mode    = TPDFV_ZOOM_CUSTOM;
 413         do_redraw(widget);
 414 } /* gtk_tpdfv_zoom_in */
 415
 416 void
 417 gtk_tpdfv_zoom_out(GtkWidget *widget)
 418 {
 419         gtk_tpdfv_t *pdf;
 420
 421         pdf = GTK_TPDFV_GET_PRIVATE(widget);
 422
 423         if (pdf->zoom_factor > DBL_EPSILON * 2.0) {
 424                 pdf->zoom_factor /= 1.2;
 425                 pdf->zoom_mode    = TPDFV_ZOOM_CUSTOM;
 426                 do_redraw(widget);
 427         }
 428 } /* gtk_tpdfv_zoom_out */
 429
 430 void
 431 gtk_tpdfv_zoom_1(GtkWidget *widget)
 432 {
 433         gtk_tpdfv_t *pdf;
 434
 435         pdf = GTK_TPDFV_GET_PRIVATE(widget);
 436         pdf->zoom_factor = 1.0;
 437         pdf->zoom_mode   = TPDFV_ZOOM_CUSTOM;
 438         do_redraw(widget);
 439 } /* gtk_tpdfv_zoom_1 */
 440
 441 void
 442 gtk_tpdfv_zoom_width(GtkWidget *widget)
 443 {
 444         gtk_tpdfv_t *pdf;
 445
 446         pdf = GTK_TPDFV_GET_PRIVATE(widget);
 447         pdf->zoom_mode = TPDFV_ZOOM_WIDTH;
 448         do_redraw(widget);
 449 } /* gtk_tpdfv_zoom_width */
 450
 451 void
 452 gtk_tpdfv_zoom_height(GtkWidget *widget)
 453 {
 454         gtk_tpdfv_t *pdf;
 455
 456         pdf = GTK_TPDFV_GET_PRIVATE(widget);
 457         pdf->zoom_mode = TPDFV_ZOOM_HEIGHT;
 458         do_redraw(widget);
 459 } /* gtk_tpdfv_zoom_width */
 460
 461 void
 462 gtk_tpdfv_zoom_fit(GtkWidget *widget)
 463 {
 464         gtk_tpdfv_t *pdf;
 465
 466         pdf = GTK_TPDFV_GET_PRIVATE(widget);
 467         pdf->zoom_mode = TPDFV_ZOOM_FIT;
 468         do_redraw(widget);
 469 } /* gtk_tpdfv_zoom_width */
 470
 471 void
 472 gtk_tpdfv_scroll_up(GtkWidget *widget)
 473 {
 474         gtk_tpdfv_t *pdf;
 475
 476         pdf = GTK_TPDFV_GET_PRIVATE(widget);
 477         pdf->delta_y += 10.0;
 478         do_redraw(widget);
 479 } /* gtk_tpdfv_scroll_up */
 480
 481 void
 482 gtk_tpdfv_scroll_down(GtkWidget *widget)
 483 {
 484         gtk_tpdfv_t *pdf;
 485
 486         pdf = GTK_TPDFV_GET_PRIVATE(widget);
 487         pdf->delta_y -= 10.0;
 488         do_redraw(widget);
 489 } /* gtk_tpdfv_scroll_down */
 490
 491 void
 492 gtk_tpdfv_scroll_left(GtkWidget *widget)
 493 {
 494         gtk_tpdfv_t *pdf;
 495
 496         pdf = GTK_TPDFV_GET_PRIVATE(widget);
 497         pdf->delta_x += 10.0;
 498         do_redraw(widget);
 499 } /* gtk_tpdfv_scroll_left */
 500
 501 void
 502 gtk_tpdfv_scroll_right(GtkWidget *widget)
 503 {
 504         gtk_tpdfv_t *pdf;
 505
 506         pdf = GTK_TPDFV_GET_PRIVATE(widget);
 507         pdf->delta_x -= 10.0;
 508         do_redraw(widget);
 509 } /* gtk_tpdfv_scroll_right */
 510
 511 /* vim: set tw=78 sw=4 ts=4 noexpandtab : */
 512