ev-jobs.c

   1 #include "ev-jobs.h"
   2 #include "ev-job-queue.h"
   3 #include "ev-document-thumbnails.h"
   4 #include "ev-document-links.h"
   5 #include "ev-document-images.h"
   6 #include "ev-document-factory.h"
   7 #include "ev-document-misc.h"
   8 #include "ev-file-helpers.h"
   9 #include "ev-document-fonts.h"
  10 #include "ev-selection.h"
  11 #include "ev-async-renderer.h"
  12 #include "ev-file-exporter.h"
  13 #include "ev-window.h"
  14
  15 #include <glib/gstdio.h>
  16 #include <unistd.h>
  17 #include <libgnomevfs/gnome-vfs-uri.h>
  18 #include <libgnomevfs/gnome-vfs-utils.h>
  19 #include <libgnomevfs/gnome-vfs-ops.h>
  20
  21 static void ev_job_init                 (EvJob               *job);
  22 static void ev_job_class_init           (EvJobClass          *class);
  23 static void ev_job_links_init           (EvJobLinks          *job);
  24 static void ev_job_links_class_init     (EvJobLinksClass     *class);
  25 static void ev_job_render_init          (EvJobRender         *job);
  26 static void ev_job_render_class_init    (EvJobRenderClass    *class);
  27 static void ev_job_thumbnail_init       (EvJobThumbnail      *job);
  28 static void ev_job_thumbnail_class_init (EvJobThumbnailClass *class);
  29 static void ev_job_load_init            (EvJobLoad           *job);
  30 static void ev_job_load_class_init      (EvJobLoadClass      *class);
  31 static void ev_job_print_init           (EvJobPrint          *job);
  32 static void ev_job_print_class_init     (EvJobPrintClass     *class);
  33
  34 enum
  35 {
  36         FINISHED,
  37         LAST_SIGNAL
  38 };
  39
  40 static guint job_signals[LAST_SIGNAL] = { 0 };
  41
  42 G_DEFINE_TYPE (EvJob, ev_job, G_TYPE_OBJECT)
  43 G_DEFINE_TYPE (EvJobLinks, ev_job_links, EV_TYPE_JOB)
  44 G_DEFINE_TYPE (EvJobRender, ev_job_render, EV_TYPE_JOB)
  45 G_DEFINE_TYPE (EvJobThumbnail, ev_job_thumbnail, EV_TYPE_JOB)
  46 G_DEFINE_TYPE (EvJobFonts, ev_job_fonts, EV_TYPE_JOB)
  47 G_DEFINE_TYPE (EvJobLoad, ev_job_load, EV_TYPE_JOB)
  48 G_DEFINE_TYPE (EvJobPrint, ev_job_print, EV_TYPE_JOB)
  49
  50 static void ev_job_init (EvJob *job) { /* Do Nothing */ }
  51
  52 static void
  53 ev_job_dispose (GObject *object)
  54 {
  55         EvJob *job;
  56
  57         job = EV_JOB (object);
  58
  59         if (job->document) {
  60                 g_object_unref (job->document);
  61                 job->document = NULL;
  62         }
  63
  64         (* G_OBJECT_CLASS (ev_job_parent_class)->dispose) (object);
  65 }
  66
  67 static void
  68 ev_job_class_init (EvJobClass *class)
  69 {
  70         GObjectClass *oclass;
  71
  72         oclass = G_OBJECT_CLASS (class);
  73
  74         oclass->dispose = ev_job_dispose;
  75
  76         job_signals [FINISHED] =
  77                 g_signal_new ("finished",
  78                               EV_TYPE_JOB,
  79                               G_SIGNAL_RUN_LAST,
  80                               G_STRUCT_OFFSET (EvJobClass, finished),
  81                               NULL, NULL,
  82                               g_cclosure_marshal_VOID__VOID,
  83                               G_TYPE_NONE, 0);
  84 }
  85
  86
  87 static void ev_job_links_init (EvJobLinks *job) { /* Do Nothing */ }
  88
  89 static void
  90 ev_job_links_dispose (GObject *object)
  91 {
  92         EvJobLinks *job;
  93
  94         job = EV_JOB_LINKS (object);
  95
  96         if (job->model) {
  97                 g_object_unref (job->model);
  98                 job->model = NULL;
  99         }
 100
 101         (* G_OBJECT_CLASS (ev_job_links_parent_class)->dispose) (object);
 102 }
 103
 104 static void
 105 ev_job_links_class_init (EvJobLinksClass *class)
 106 {
 107         GObjectClass *oclass;
 108
 109         oclass = G_OBJECT_CLASS (class);
 110
 111         oclass->dispose = ev_job_links_dispose;
 112 }
 113
 114
 115 static void ev_job_render_init (EvJobRender *job) { /* Do Nothing */ }
 116
 117 static void
 118 ev_job_render_dispose (GObject *object)
 119 {
 120         EvJobRender *job;
 121
 122         job = EV_JOB_RENDER (object);
 123
 124         if (job->surface) {
 125                 cairo_surface_destroy (job->surface);
 126                 job->surface = NULL;
 127         }
 128
 129         if (job->rc) {
 130                 g_object_unref (job->rc);
 131                 job->rc = NULL;
 132         }
 133
 134         if (job->selection) {
 135                 cairo_surface_destroy (job->selection);
 136                 job->selection = NULL;
 137         }
 138
 139         if (job->selection_region) {
 140                 gdk_region_destroy (job->selection_region);
 141                 job->selection_region = NULL;
 142         }
 143
 144         (* G_OBJECT_CLASS (ev_job_render_parent_class)->dispose) (object);
 145 }
 146
 147 static void
 148 ev_job_render_class_init (EvJobRenderClass *class)
 149 {
 150         GObjectClass *oclass;
 151
 152         oclass = G_OBJECT_CLASS (class);
 153
 154         oclass->dispose = ev_job_render_dispose;
 155 }
 156
 157 static void ev_job_thumbnail_init (EvJobThumbnail *job) { /* Do Nothing */ }
 158
 159 static void
 160 ev_job_thumbnail_dispose (GObject *object)
 161 {
 162         EvJobThumbnail *job;
 163
 164         job = EV_JOB_THUMBNAIL (object);
 165
 166         if (job->thumbnail) {
 167                 g_object_unref (job->thumbnail);
 168                 job->thumbnail = NULL;
 169         }
 170
 171         if (job->rc) {
 172                 g_object_unref (job->rc);
 173                 job->rc = NULL;
 174         }
 175
 176         (* G_OBJECT_CLASS (ev_job_thumbnail_parent_class)->dispose) (object);
 177 }
 178
 179 static void
 180 ev_job_thumbnail_class_init (EvJobThumbnailClass *class)
 181 {
 182         GObjectClass *oclass;
 183
 184         oclass = G_OBJECT_CLASS (class);
 185
 186         oclass->dispose = ev_job_thumbnail_dispose;
 187 }
 188
 189 static void ev_job_print_init (EvJobPrint *job) { /* Do Nothing */ }
 190
 191 static void
 192 ev_job_print_dispose (GObject *object)
 193 {
 194         EvJobPrint *job;
 195
 196         job = EV_JOB_PRINT (object);
 197
 198         if (job->temp_file) {
 199                 g_unlink (job->temp_file);
 200                 g_free (job->temp_file);
 201                 job->temp_file = NULL;
 202         }
 203
 204         if (job->error) {
 205                 g_error_free (job->error);
 206                 job->error = NULL;
 207         }
 208
 209         if (job->ranges) {
 210                 g_free (job->ranges);
 211                 job->ranges = NULL;
 212                 job->n_ranges = 0;
 213         }
 214
 215         (* G_OBJECT_CLASS (ev_job_print_parent_class)->dispose) (object);
 216 }
 217
 218 static void
 219 ev_job_print_class_init (EvJobPrintClass *class)
 220 {
 221         GObjectClass *oclass;
 222
 223         oclass = G_OBJECT_CLASS (class);
 224
 225         oclass->dispose = ev_job_print_dispose;
 226 }
 227
 228 /* Public functions */
 229 void
 230 ev_job_finished (EvJob *job)
 231 {
 232         g_return_if_fail (EV_IS_JOB (job));
 233
 234         g_signal_emit (job, job_signals[FINISHED], 0);
 235 }
 236
 237 EvJob *
 238 ev_job_links_new (EvDocument *document)
 239 {
 240         EvJob *job;
 241
 242         job = g_object_new (EV_TYPE_JOB_LINKS, NULL);
 243         job->document = g_object_ref (document);
 244
 245         return job;
 246 }
 247
 248 void
 249 ev_job_links_run (EvJobLinks *job)
 250 {
 251         g_return_if_fail (EV_IS_JOB_LINKS (job));
 252
 253         ev_document_doc_mutex_lock ();
 254         job->model = ev_document_links_get_links_model (EV_DOCUMENT_LINKS (EV_JOB (job)->document));
 255         EV_JOB (job)->finished = TRUE;
 256         ev_document_doc_mutex_unlock ();
 257 }
 258
 259
 260 EvJob *
 261 ev_job_render_new (EvDocument      *document,
 262                    EvRenderContext *rc,
 263                    gint             width,
 264                    gint             height,
 265                    EvRectangle     *selection_points,
 266                    GdkColor        *text,
 267                    GdkColor        *base,
 268                    gboolean         include_links,
 269                    gboolean         include_images,
 270                    gboolean         include_text,
 271                    gboolean         include_selection)
 272 {
 273         EvJobRender *job;
 274
 275         g_return_val_if_fail (EV_IS_RENDER_CONTEXT (rc), NULL);
 276         if (include_selection)
 277                 g_return_val_if_fail (selection_points != NULL, NULL);
 278
 279         job = g_object_new (EV_TYPE_JOB_RENDER, NULL);
 280
 281         EV_JOB (job)->document = g_object_ref (document);
 282         job->rc = g_object_ref (rc);
 283         job->target_width = width;
 284         job->target_height = height;
 285         job->text = *text;
 286         job->base = *base;
 287         job->include_links = include_links;
 288         job->include_images = include_images;
 289         job->include_text = include_text;
 290         job->include_selection = include_selection;
 291
 292         if (include_selection)
 293                 job->selection_points = *selection_points;
 294
 295         if (EV_IS_ASYNC_RENDERER (document)) {
 296                 EV_JOB (job)->async = TRUE;
 297         }
 298
 299         return EV_JOB (job);
 300 }
 301
 302 static void
 303 render_finished_cb (EvDocument      *document,
 304                     GdkPixbuf       *pixbuf,
 305                     EvJobRender     *job)
 306 {
 307         g_signal_handlers_disconnect_by_func (EV_JOB (job)->document,
 308                                               render_finished_cb, job);
 309
 310         /* FIXME: ps backend should be ported to cairo */
 311         job->surface = ev_document_misc_surface_from_pixbuf (pixbuf);
 312         EV_JOB (job)->finished = TRUE;
 313         ev_job_finished (EV_JOB (job));
 314 }
 315
 316 void
 317 ev_job_render_run (EvJobRender *job)
 318 {
 319         g_return_if_fail (EV_IS_JOB_RENDER (job));
 320
 321         ev_document_doc_mutex_lock ();
 322
 323         if (EV_JOB (job)->async) {
 324                 EvAsyncRenderer *renderer = EV_ASYNC_RENDERER (EV_JOB (job)->document);
 325                 ev_async_renderer_render_pixbuf (renderer, job->rc->page, job->rc->scale,
 326                                                  job->rc->rotation);
 327                 g_signal_connect (EV_JOB (job)->document, "render_finished",
 328                                   G_CALLBACK (render_finished_cb), job);
 329         } else {
 330                 ev_document_fc_mutex_lock ();
 331
 332                 job->surface = ev_document_render (EV_JOB (job)->document, job->rc);
 333                 if (job->include_links && EV_IS_DOCUMENT_LINKS (EV_JOB (job)->document))
 334                         job->link_mapping =
 335                                 ev_document_links_get_links (EV_DOCUMENT_LINKS (EV_JOB (job)->document),
 336                                                              job->rc->page);
 337                 if (job->include_images && EV_IS_DOCUMENT_IMAGES (EV_JOB (job)->document))
 338                         job->image_mapping =
 339                                 ev_document_images_get_images (EV_DOCUMENT_IMAGES (EV_JOB (job)->document),
 340                                                                job->rc->page);
 341                 if (job->include_text && EV_IS_SELECTION (EV_JOB (job)->document))
 342                         job->text_mapping =
 343                                 ev_selection_get_selection_map (EV_SELECTION (EV_JOB (job)->document),
 344                                                                 job->rc);
 345                 if (job->include_selection && EV_IS_SELECTION (EV_JOB (job)->document)) {
 346                         ev_selection_render_selection (EV_SELECTION (EV_JOB (job)->document),
 347                                                        job->rc,
 348                                                        &(job->selection),
 349                                                        &(job->selection_points),
 350                                                        NULL,
 351                                                        &(job->text), &(job->base));
 352                         job->selection_region =
 353                                 ev_selection_get_selection_region (EV_SELECTION (EV_JOB (job)->document),
 354                                                                    job->rc,
 355                                                                    &(job->selection_points));
 356                 }
 357
 358                 ev_document_fc_mutex_unlock ();
 359                 EV_JOB (job)->finished = TRUE;
 360         }
 361
 362         ev_document_doc_mutex_unlock ();
 363 }
 364
 365 EvJob *
 366 ev_job_thumbnail_new (EvDocument      *document,
 367                       EvRenderContext *rc)
 368 {
 369         EvJobThumbnail *job;
 370
 371         job = g_object_new (EV_TYPE_JOB_THUMBNAIL, NULL);
 372
 373         EV_JOB (job)->document = g_object_ref (document);
 374         job->rc = g_object_ref (rc);
 375
 376         return EV_JOB (job);
 377 }
 378
 379 void
 380 ev_job_thumbnail_run (EvJobThumbnail *job)
 381 {
 382         g_return_if_fail (EV_IS_JOB_THUMBNAIL (job));
 383
 384         ev_document_doc_mutex_lock ();
 385
 386         job->thumbnail =
 387                 ev_document_thumbnails_get_thumbnail (EV_DOCUMENT_THUMBNAILS (EV_JOB (job)->document),
 388                                                       job->rc, TRUE);
 389         EV_JOB (job)->finished = TRUE;
 390
 391         ev_document_doc_mutex_unlock ();
 392 }
 393
 394 static void ev_job_fonts_init (EvJobFonts *job) { /* Do Nothing */ }
 395
 396 static void ev_job_fonts_class_init (EvJobFontsClass *class) { /* Do Nothing */ }
 397
 398 EvJob *
 399 ev_job_fonts_new (EvDocument *document)
 400 {
 401         EvJobFonts *job;
 402
 403         job = g_object_new (EV_TYPE_JOB_FONTS, NULL);
 404
 405         EV_JOB (job)->document = g_object_ref (document);
 406
 407         return EV_JOB (job);
 408 }
 409
 410 void
 411 ev_job_fonts_run (EvJobFonts *job)
 412 {
 413         EvDocumentFonts *fonts;
 414
 415         g_return_if_fail (EV_IS_JOB_FONTS (job));
 416
 417         ev_document_doc_mutex_lock ();
 418
 419         fonts = EV_DOCUMENT_FONTS (EV_JOB (job)->document);
 420         ev_document_fc_mutex_lock ();
 421         job->scan_completed = !ev_document_fonts_scan (fonts, 20);
 422         ev_document_fc_mutex_unlock ();
 423
 424         EV_JOB (job)->finished = TRUE;
 425
 426         ev_document_doc_mutex_unlock ();
 427 }
 428
 429 static void ev_job_load_init (EvJobLoad *job) { /* Do Nothing */ }
 430
 431 static void
 432 ev_job_load_dispose (GObject *object)
 433 {
 434         EvJobLoad *job = EV_JOB_LOAD (object);
 435
 436         if (job->uri) {
 437                 g_free (job->uri);
 438                 job->uri = NULL;
 439         }
 440
 441         if (job->error) {
 442                 g_error_free (job->error);
 443                 job->error = NULL;
 444         }
 445
 446         if (job->dest) {
 447                 g_object_unref (job->dest);
 448                 job->dest = NULL;
 449         }
 450
 451         (* G_OBJECT_CLASS (ev_job_load_parent_class)->dispose) (object);
 452 }
 453
 454 static void
 455 ev_job_load_class_init (EvJobLoadClass *class)
 456 {
 457         GObjectClass *oclass;
 458
 459         oclass = G_OBJECT_CLASS (class);
 460
 461         oclass->dispose = ev_job_load_dispose;
 462 }
 463
 464
 465 EvJob *
 466 ev_job_load_new (const gchar *uri, EvLinkDest *dest, EvWindowRunMode mode)
 467 {
 468         EvJobLoad *job;
 469
 470         job = g_object_new (EV_TYPE_JOB_LOAD, NULL);
 471
 472         job->uri = g_strdup (uri);
 473         if (dest)
 474                 job->dest = g_object_ref (dest);
 475
 476         job->mode = mode;
 477
 478         return EV_JOB (job);
 479 }
 480
 481 void
 482 ev_job_load_set_uri (EvJobLoad *job, const gchar *uri)
 483 {
 484         if (job->uri)
 485                 g_free (job->uri);
 486         job->uri = g_strdup (uri);
 487 }
 488
 489 void
 490 ev_job_load_run (EvJobLoad *job)
 491 {
 492         g_return_if_fail (EV_IS_JOB_LOAD (job));
 493
 494         if (job->error) {
 495                 g_error_free (job->error);
 496                 job->error = NULL;
 497         }
 498
 499         ev_document_fc_mutex_lock ();
 500
 501         /* This job may already have a document even if the job didn't complete
 502            because, e.g., a password is required - if so, just reload rather than
 503            creating a new instance */
 504         if (EV_JOB (job)->document) {
 505                 ev_document_load (EV_JOB (job)->document,
 506                                   job->uri,
 507                                   &job->error);
 508         } else {
 509                 EV_JOB(job)->document =
 510                         ev_document_factory_get_document (job->uri,
 511                                                           &job->error);
 512         }
 513
 514         ev_document_fc_mutex_unlock ();
 515         EV_JOB (job)->finished = TRUE;
 516 }
 517
 518 EvJob *
 519 ev_job_print_new (EvDocument    *document,
 520                   const gchar   *format,
 521                   gdouble        width,
 522                   gdouble        height,
 523                   EvPrintRange  *ranges,
 524                   gint           n_ranges,
 525                   EvPrintPageSet page_set,
 526                   gint           copies,
 527                   gdouble        collate,
 528                   gdouble        reverse)
 529 {
 530         EvJobPrint *job;
 531
 532         job = g_object_new (EV_TYPE_JOB_PRINT, NULL);
 533
 534         EV_JOB (job)->document = g_object_ref (document);
 535
 536         job->format = format;
 537
 538         job->temp_file = NULL;
 539         job->error = NULL;
 540
 541         job->width = width;
 542         job->height = height;
 543
 544         job->ranges = ranges;
 545         job->n_ranges = n_ranges;
 546
 547         job->page_set = page_set;
 548
 549         job->copies = copies;
 550         job->collate = collate;
 551         job->reverse = reverse;
 552
 553         return EV_JOB (job);
 554 }
 555
 556 static gint
 557 ev_print_job_get_first_page (EvJobPrint *job)
 558 {
 559         gint i;
 560         gint first_page = G_MAXINT;
 561
 562         if (job->n_ranges == 0)
 563                 return 0;
 564
 565         for (i = 0; i < job->n_ranges; i++) {
 566                 if (job->ranges[i].start < first_page)
 567                         first_page = job->ranges[i].start;
 568         }
 569
 570         return MAX (0, first_page);
 571 }
 572
 573 static gint
 574 ev_print_job_get_last_page (EvJobPrint *job)
 575 {
 576         gint i;
 577         gint last_page = G_MININT;
 578         gint max_page;
 579
 580         max_page = ev_document_get_n_pages (EV_JOB (job)->document) - 1;
 581
 582         if (job->n_ranges == 0)
 583                 return max_page;
 584
 585         for (i = 0; i < job->n_ranges; i++) {
 586                 if (job->ranges[i].end > last_page)
 587                         last_page = job->ranges[i].end;
 588         }
 589
 590         return MIN (max_page, last_page);
 591 }
 592
 593 static gboolean
 594 ev_print_job_print_page_in_range (EvJobPrint *job,
 595                                   gint        page)
 596 {
 597         gint i;
 598
 599         for (i = 0; i < job->n_ranges; i++) {
 600                 if (page >= job->ranges[i].start &&
 601                     page <= job->ranges[i].end)
 602                         return TRUE;
 603         }
 604
 605         return FALSE;
 606 }
 607
 608 static gboolean
 609 ev_print_job_print_page_in_set (EvJobPrint *job,
 610                                 gint        page)
 611 {
 612         switch (job->page_set) {
 613                 case EV_PRINT_PAGE_SET_EVEN:
 614                         return page % 2 == 0;
 615                 case EV_PRINT_PAGE_SET_ODD:
 616                         return page % 2 != 0;
 617                 case EV_PRINT_PAGE_SET_ALL:
 618                         return TRUE;
 619         }
 620
 621         return FALSE;
 622 }
 623
 624 static void
 625 ev_job_print_do_page (EvJobPrint *job, gint page)
 626 {
 627         EvDocument      *document = EV_JOB (job)->document;
 628         EvRenderContext *rc;
 629
 630         rc = ev_render_context_new (0, page, 1.0);
 631         ev_file_exporter_do_page (EV_FILE_EXPORTER (document), rc);
 632         g_object_unref (rc);
 633 }
 634
 635 void
 636 ev_job_print_run (EvJobPrint *job)
 637 {
 638         EvDocument *document = EV_JOB (job)->document;
 639         gint        fd;
 640         gint        last_page;
 641         gint        first_page;
 642         gint        i;
 643         gchar      *filename;
 644
 645         g_return_if_fail (EV_IS_JOB_PRINT (job));
 646
 647         if (job->temp_file)
 648                 g_free (job->temp_file);
 649         job->temp_file = NULL;
 650
 651         if (job->error)
 652                 g_error_free (job->error);
 653         job->error = NULL;
 654
 655         filename = g_strdup_printf ("evince_print.%s.XXXXXX", job->format);
 656         fd = g_file_open_tmp (filename, &job->temp_file, &job->error);
 657         g_free (filename);
 658         if (fd <= -1) {
 659                 EV_JOB (job)->finished = TRUE;
 660                 return;
 661         }
 662
 663         first_page = ev_print_job_get_first_page (job);
 664         last_page = ev_print_job_get_last_page (job);
 665
 666         ev_document_doc_mutex_lock ();
 667         ev_file_exporter_begin (EV_FILE_EXPORTER (document),
 668                                 g_ascii_strcasecmp (job->format, "pdf") == 0 ?
 669                                 EV_FILE_FORMAT_PDF : EV_FILE_FORMAT_PS,
 670                                 job->temp_file,
 671                                 MIN (first_page, last_page),
 672                                 MAX (first_page, last_page),
 673                                 job->width, job->height, FALSE);
 674         ev_document_doc_mutex_unlock ();
 675
 676         for (i = 0; i < job->copies; i++) {
 677                 gint page, step;
 678
 679                 step = job->reverse ? -1 : 1;
 680                 page = job->reverse ? last_page : first_page;
 681
 682                 while ((job->reverse && (page >= first_page)) ||
 683                        (!job->reverse && (page <= last_page))) {
 684                         gint n_pages = 1;
 685                         gint j;
 686
 687                         if (job->n_ranges > 0 &&
 688                             !ev_print_job_print_page_in_range (job, page)) {
 689                                 page += step;
 690                                 continue;
 691                         }
 692
 693                         if (!ev_print_job_print_page_in_set (job, page + 1)) {
 694                                 page += step;
 695                                 continue;
 696                         }
 697
 698                         if (job->collate)
 699                                 n_pages = job->copies;
 700
 701                         for (j = 0; j < n_pages; j++) {
 702                                 ev_document_doc_mutex_lock ();
 703                                 ev_job_print_do_page (job, page);
 704                                 ev_document_doc_mutex_unlock ();
 705                         }
 706
 707                         page += step;
 708                 }
 709
 710                 if (job->collate)
 711                         break;
 712         }
 713
 714         ev_document_doc_mutex_lock ();
 715         ev_file_exporter_end (EV_FILE_EXPORTER (document));
 716         ev_document_doc_mutex_unlock ();
 717
 718         close (fd);
 719
 720         EV_JOB (job)->finished = TRUE;
 721 }