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