libview/ev-jobs.c

   1 /* this file is part of evince, a gnome document viewer
   2  *
   3  *  Copyright (C) 2008 Carlos Garcia Campos <carlosgc@gnome.org>
   4  *  Copyright (C) 2005 Red Hat, Inc
   5  *
   6  * Evince is free software; you can redistribute it and/or modify it
   7  * under the terms of the GNU General Public License as published by
   8  * the Free Software Foundation; either version 2 of the License, or
   9  * (at your option) any later version.
  10  *
  11  * Evince is distributed in the hope that it will be useful, but
  12  * WITHOUT ANY WARRANTY; without even the implied warranty of
  13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  14  * General Public License for more details.
  15  *
  16  * You should have received a copy of the GNU General Public License
  17  * along with this program; if not, write to the Free Software
  18  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
  19  */
  20
  21 #include <config.h>
  22
  23 #include "ev-jobs.h"
  24 #include "ev-document-links.h"
  25 #include "ev-document-images.h"
  26 #include "ev-document-forms.h"
  27 #include "ev-file-exporter.h"
  28 #include "ev-document-factory.h"
  29 #include "ev-document-misc.h"
  30 #include "ev-file-helpers.h"
  31 #include "ev-document-fonts.h"
  32 #include "ev-document-security.h"
  33 #include "ev-document-find.h"
  34 #include "ev-document-layers.h"
  35 #include "ev-document-print.h"
  36 #include "ev-document-annotations.h"
  37 #include "ev-document-attachments.h"
  38 #include "ev-document-text.h"
  39 #include "ev-debug.h"
  40
  41 #include <errno.h>
  42 #include <glib/gstdio.h>
  43 #include <glib/gi18n-lib.h>
  44 #include <unistd.h>
  45
  46 static void ev_job_init                   (EvJob                 *job);
  47 static void ev_job_class_init             (EvJobClass            *class);
  48 static void ev_job_links_init             (EvJobLinks            *job);
  49 static void ev_job_links_class_init       (EvJobLinksClass       *class);
  50 static void ev_job_attachments_init       (EvJobAttachments      *job);
  51 static void ev_job_attachments_class_init (EvJobAttachmentsClass *class);
  52 static void ev_job_annots_init            (EvJobAnnots           *job);
  53 static void ev_job_annots_class_init      (EvJobAnnotsClass      *class);
  54 static void ev_job_render_init            (EvJobRender           *job);
  55 static void ev_job_render_class_init      (EvJobRenderClass      *class);
  56 static void ev_job_page_data_init         (EvJobPageData         *job);
  57 static void ev_job_page_data_class_init   (EvJobPageDataClass    *class);
  58 static void ev_job_thumbnail_init         (EvJobThumbnail        *job);
  59 static void ev_job_thumbnail_class_init   (EvJobThumbnailClass   *class);
  60 static void ev_job_load_init              (EvJobLoad             *job);
  61 static void ev_job_load_class_init        (EvJobLoadClass        *class);
  62 static void ev_job_save_init              (EvJobSave             *job);
  63 static void ev_job_save_class_init        (EvJobSaveClass        *class);
  64 static void ev_job_find_init              (EvJobFind             *job);
  65 static void ev_job_find_class_init        (EvJobFindClass        *class);
  66 static void ev_job_layers_init            (EvJobLayers           *job);
  67 static void ev_job_layers_class_init      (EvJobLayersClass      *class);
  68 static void ev_job_export_init            (EvJobExport           *job);
  69 static void ev_job_export_class_init      (EvJobExportClass      *class);
  70 static void ev_job_print_init             (EvJobPrint            *job);
  71 static void ev_job_print_class_init       (EvJobPrintClass       *class);
  72
  73 enum {
  74         CANCELLED,
  75         FINISHED,
  76         LAST_SIGNAL
  77 };
  78
  79 enum {
  80         FONTS_UPDATED,
  81         FONTS_LAST_SIGNAL
  82 };
  83
  84 enum {
  85         FIND_UPDATED,
  86         FIND_LAST_SIGNAL
  87 };
  88
  89 static guint job_signals[LAST_SIGNAL] = { 0 };
  90 static guint job_fonts_signals[FONTS_LAST_SIGNAL] = { 0 };
  91 static guint job_find_signals[FIND_LAST_SIGNAL] = { 0 };
  92
  93 G_DEFINE_ABSTRACT_TYPE (EvJob, ev_job, G_TYPE_OBJECT)
  94 G_DEFINE_TYPE (EvJobLinks, ev_job_links, EV_TYPE_JOB)
  95 G_DEFINE_TYPE (EvJobAttachments, ev_job_attachments, EV_TYPE_JOB)
  96 G_DEFINE_TYPE (EvJobAnnots, ev_job_annots, EV_TYPE_JOB)
  97 G_DEFINE_TYPE (EvJobRender, ev_job_render, EV_TYPE_JOB)
  98 G_DEFINE_TYPE (EvJobPageData, ev_job_page_data, EV_TYPE_JOB)
  99 G_DEFINE_TYPE (EvJobThumbnail, ev_job_thumbnail, EV_TYPE_JOB)
 100 G_DEFINE_TYPE (EvJobFonts, ev_job_fonts, EV_TYPE_JOB)
 101 G_DEFINE_TYPE (EvJobLoad, ev_job_load, EV_TYPE_JOB)
 102 G_DEFINE_TYPE (EvJobSave, ev_job_save, EV_TYPE_JOB)
 103 G_DEFINE_TYPE (EvJobFind, ev_job_find, EV_TYPE_JOB)
 104 G_DEFINE_TYPE (EvJobLayers, ev_job_layers, EV_TYPE_JOB)
 105 G_DEFINE_TYPE (EvJobExport, ev_job_export, EV_TYPE_JOB)
 106 G_DEFINE_TYPE (EvJobPrint, ev_job_print, EV_TYPE_JOB)
 107
 108 /* EvJob */
 109 static void
 110 ev_job_init (EvJob *job)
 111 {
 112         job->cancellable = g_cancellable_new ();
 113 }
 114
 115 static void
 116 ev_job_dispose (GObject *object)
 117 {
 118         EvJob *job;
 119
 120         job = EV_JOB (object);
 121
 122         if (job->document) {
 123                 g_object_unref (job->document);
 124                 job->document = NULL;
 125         }
 126
 127         if (job->cancellable) {
 128                 g_object_unref (job->cancellable);
 129                 job->cancellable = NULL;
 130         }
 131
 132         if (job->error) {
 133                 g_error_free (job->error);
 134                 job->error = NULL;
 135         }
 136
 137         (* G_OBJECT_CLASS (ev_job_parent_class)->dispose) (object);
 138 }
 139
 140 static void
 141 ev_job_class_init (EvJobClass *class)
 142 {
 143         GObjectClass *oclass;
 144
 145         oclass = G_OBJECT_CLASS (class);
 146
 147         oclass->dispose = ev_job_dispose;
 148
 149         job_signals[CANCELLED] =
 150                 g_signal_new ("cancelled",
 151                               EV_TYPE_JOB,
 152                               G_SIGNAL_RUN_LAST,
 153                               G_STRUCT_OFFSET (EvJobClass, cancelled),
 154                               NULL, NULL,
 155                               g_cclosure_marshal_VOID__VOID,
 156                               G_TYPE_NONE, 0);
 157         job_signals [FINISHED] =
 158                 g_signal_new ("finished",
 159                               EV_TYPE_JOB,
 160                               G_SIGNAL_RUN_FIRST,
 161                               G_STRUCT_OFFSET (EvJobClass, finished),
 162                               NULL, NULL,
 163                               g_cclosure_marshal_VOID__VOID,
 164                               G_TYPE_NONE, 0);
 165 }
 166
 167 static gboolean
 168 emit_finished (EvJob *job)
 169 {
 170         ev_debug_message (DEBUG_JOBS, "%s (%p)", EV_GET_TYPE_NAME (job), job);
 171
 172         job->idle_finished_id = 0;
 173
 174         if (job->cancelled) {
 175                 ev_debug_message (DEBUG_JOBS, "%s (%p) job was cancelled, do not emit finished", EV_GET_TYPE_NAME (job), job);
 176         } else {
 177                 ev_profiler_stop (EV_PROFILE_JOBS, "%s (%p)", EV_GET_TYPE_NAME (job), job);
 178                 g_signal_emit (job, job_signals[FINISHED], 0);
 179         }
 180
 181         return FALSE;
 182 }
 183
 184 static void
 185 ev_job_emit_finished (EvJob *job)
 186 {
 187         ev_debug_message (DEBUG_JOBS, "%s (%p)", EV_GET_TYPE_NAME (job), job);
 188
 189         if (g_cancellable_is_cancelled (job->cancellable)) {
 190                 ev_debug_message (DEBUG_JOBS, "%s (%p) job was cancelled, returning", EV_GET_TYPE_NAME (job), job);
 191                 return;
 192         }
 193
 194         job->finished = TRUE;
 195
 196         if (job->run_mode == EV_JOB_RUN_THREAD) {
 197                 job->idle_finished_id =
 198                         g_idle_add_full (G_PRIORITY_DEFAULT_IDLE,
 199                                          (GSourceFunc)emit_finished,
 200                                          g_object_ref (job),
 201                                          (GDestroyNotify)g_object_unref);
 202         } else {
 203                 ev_profiler_stop (EV_PROFILE_JOBS, "%s (%p)", EV_GET_TYPE_NAME (job), job);
 204                 g_signal_emit (job, job_signals[FINISHED], 0);
 205         }
 206 }
 207
 208 gboolean
 209 ev_job_run (EvJob *job)
 210 {
 211         EvJobClass *class = EV_JOB_GET_CLASS (job);
 212
 213         return class->run (job);
 214 }
 215
 216 void
 217 ev_job_cancel (EvJob *job)
 218 {
 219         if (job->cancelled)
 220                 return;
 221
 222         ev_debug_message (DEBUG_JOBS, "job %s (%p) cancelled", EV_GET_TYPE_NAME (job), job);
 223         ev_profiler_stop (EV_PROFILE_JOBS, "%s (%p)", EV_GET_TYPE_NAME (job), job);
 224
 225         /* This should never be called from a thread */
 226         job->cancelled = TRUE;
 227         g_cancellable_cancel (job->cancellable);
 228
 229         if (job->finished && job->idle_finished_id == 0)
 230                 return;
 231
 232         g_signal_emit (job, job_signals[CANCELLED], 0);
 233 }
 234
 235 void
 236 ev_job_failed (EvJob       *job,
 237                GQuark       domain,
 238                gint         code,
 239                const gchar *format,
 240                ...)
 241 {
 242         va_list args;
 243         gchar  *message;
 244
 245         if (job->failed || job->finished)
 246                 return;
 247
 248         ev_debug_message (DEBUG_JOBS, "job %s (%p) failed", EV_GET_TYPE_NAME (job), job);
 249
 250         job->failed = TRUE;
 251
 252         va_start (args, format);
 253         message = g_strdup_vprintf (format, args);
 254         va_end (args);
 255
 256         job->error = g_error_new_literal (domain, code, message);
 257         g_free (message);
 258
 259         ev_job_emit_finished (job);
 260 }
 261
 262 void
 263 ev_job_failed_from_error (EvJob  *job,
 264                           GError *error)
 265 {
 266         if (job->failed || job->finished)
 267                 return;
 268
 269         ev_debug_message (DEBUG_JOBS, "job %s (%p) failed", EV_GET_TYPE_NAME (job), job);
 270
 271         job->failed = TRUE;
 272         job->error = g_error_copy (error);
 273
 274         ev_job_emit_finished (job);
 275 }
 276
 277 void
 278 ev_job_succeeded (EvJob *job)
 279 {
 280         if (job->finished)
 281                 return;
 282
 283         ev_debug_message (DEBUG_JOBS, "job %s (%p) succeeded", EV_GET_TYPE_NAME (job), job);
 284
 285         job->failed = FALSE;
 286         ev_job_emit_finished (job);
 287 }
 288
 289 gboolean
 290 ev_job_is_finished (EvJob *job)
 291 {
 292         return job->finished;
 293 }
 294
 295 gboolean
 296 ev_job_is_failed (EvJob *job)
 297 {
 298         return job->failed;
 299 }
 300
 301 EvJobRunMode
 302 ev_job_get_run_mode (EvJob *job)
 303 {
 304         return job->run_mode;
 305 }
 306
 307 void
 308 ev_job_set_run_mode (EvJob       *job,
 309                      EvJobRunMode run_mode)
 310 {
 311         job->run_mode = run_mode;
 312 }
 313
 314 /* EvJobLinks */
 315 static void
 316 ev_job_links_init (EvJobLinks *job)
 317 {
 318         EV_JOB (job)->run_mode = EV_JOB_RUN_THREAD;
 319 }
 320
 321 static void
 322 ev_job_links_dispose (GObject *object)
 323 {
 324         EvJobLinks *job;
 325
 326         ev_debug_message (DEBUG_JOBS, NULL);
 327
 328         job = EV_JOB_LINKS (object);
 329
 330         if (job->model) {
 331                 g_object_unref (job->model);
 332                 job->model = NULL;
 333         }
 334
 335         (* G_OBJECT_CLASS (ev_job_links_parent_class)->dispose) (object);
 336 }
 337
 338 static gboolean
 339 fill_page_labels (GtkTreeModel   *tree_model,
 340                   GtkTreePath    *path,
 341                   GtkTreeIter    *iter,
 342                   EvJob          *job)
 343 {
 344         EvDocumentLinks *document_links;
 345         EvLink          *link;
 346         gchar           *page_label;
 347
 348         gtk_tree_model_get (tree_model, iter,
 349                             EV_DOCUMENT_LINKS_COLUMN_LINK, &link,
 350                             -1);
 351
 352         if (!link)
 353                 return FALSE;
 354
 355         document_links = EV_DOCUMENT_LINKS (job->document);
 356         page_label = ev_document_links_get_link_page_label (document_links, link);
 357         if (!page_label)
 358                 return FALSE;
 359
 360         gtk_tree_store_set (GTK_TREE_STORE (tree_model), iter,
 361                             EV_DOCUMENT_LINKS_COLUMN_PAGE_LABEL, page_label,
 362                             -1);
 363
 364         g_free (page_label);
 365         g_object_unref (link);
 366
 367         return FALSE;
 368 }
 369
 370 static gboolean
 371 ev_job_links_run (EvJob *job)
 372 {
 373         EvJobLinks *job_links = EV_JOB_LINKS (job);
 374
 375         ev_debug_message (DEBUG_JOBS, NULL);
 376         ev_profiler_start (EV_PROFILE_JOBS, "%s (%p)", EV_GET_TYPE_NAME (job), job);
 377
 378         ev_document_doc_mutex_lock ();
 379         job_links->model = ev_document_links_get_links_model (EV_DOCUMENT_LINKS (job->document));
 380         ev_document_doc_mutex_unlock ();
 381
 382         gtk_tree_model_foreach (job_links->model, (GtkTreeModelForeachFunc)fill_page_labels, job);
 383
 384         ev_job_succeeded (job);
 385
 386         return FALSE;
 387 }
 388
 389 static void
 390 ev_job_links_class_init (EvJobLinksClass *class)
 391 {
 392         GObjectClass *oclass = G_OBJECT_CLASS (class);
 393         EvJobClass   *job_class = EV_JOB_CLASS (class);
 394
 395         oclass->dispose = ev_job_links_dispose;
 396         job_class->run = ev_job_links_run;
 397 }
 398
 399 EvJob *
 400 ev_job_links_new (EvDocument *document)
 401 {
 402         EvJob *job;
 403
 404         ev_debug_message (DEBUG_JOBS, NULL);
 405
 406         job = g_object_new (EV_TYPE_JOB_LINKS, NULL);
 407         job->document = g_object_ref (document);
 408
 409         return job;
 410 }
 411
 412 /* EvJobAttachments */
 413 static void
 414 ev_job_attachments_init (EvJobAttachments *job)
 415 {
 416         EV_JOB (job)->run_mode = EV_JOB_RUN_THREAD;
 417 }
 418
 419 static void
 420 ev_job_attachments_dispose (GObject *object)
 421 {
 422         EvJobAttachments *job;
 423
 424         ev_debug_message (DEBUG_JOBS, NULL);
 425
 426         job = EV_JOB_ATTACHMENTS (object);
 427
 428         if (job->attachments) {
 429                 g_list_foreach (job->attachments, (GFunc)g_object_unref, NULL);
 430                 g_list_free (job->attachments);
 431                 job->attachments = NULL;
 432         }
 433
 434         (* G_OBJECT_CLASS (ev_job_attachments_parent_class)->dispose) (object);
 435 }
 436
 437 static gboolean
 438 ev_job_attachments_run (EvJob *job)
 439 {
 440         EvJobAttachments *job_attachments = EV_JOB_ATTACHMENTS (job);
 441
 442         ev_debug_message (DEBUG_JOBS, NULL);
 443         ev_profiler_start (EV_PROFILE_JOBS, "%s (%p)", EV_GET_TYPE_NAME (job), job);
 444
 445         ev_document_doc_mutex_lock ();
 446         job_attachments->attachments =
 447                 ev_document_attachments_get_attachments (EV_DOCUMENT_ATTACHMENTS (job->document));
 448         ev_document_doc_mutex_unlock ();
 449
 450         ev_job_succeeded (job);
 451
 452         return FALSE;
 453 }
 454
 455 static void
 456 ev_job_attachments_class_init (EvJobAttachmentsClass *class)
 457 {
 458         GObjectClass *oclass = G_OBJECT_CLASS (class);
 459         EvJobClass   *job_class = EV_JOB_CLASS (class);
 460
 461         oclass->dispose = ev_job_attachments_dispose;
 462         job_class->run = ev_job_attachments_run;
 463 }
 464
 465 EvJob *
 466 ev_job_attachments_new (EvDocument *document)
 467 {
 468         EvJob *job;
 469
 470         ev_debug_message (DEBUG_JOBS, NULL);
 471
 472         job = g_object_new (EV_TYPE_JOB_ATTACHMENTS, NULL);
 473         job->document = g_object_ref (document);
 474
 475         return job;
 476 }
 477
 478 /* EvJobAnnots */
 479 static void
 480 ev_job_annots_init (EvJobAnnots *job)
 481 {
 482         EV_JOB (job)->run_mode = EV_JOB_RUN_THREAD;
 483 }
 484
 485 static void
 486 ev_job_annots_dispose (GObject *object)
 487 {
 488         EvJobAnnots *job;
 489
 490         ev_debug_message (DEBUG_JOBS, NULL);
 491
 492         job = EV_JOB_ANNOTS (object);
 493
 494         if (job->annots) {
 495                 g_list_foreach (job->annots, (GFunc)ev_mapping_list_unref, NULL);
 496                 g_list_free (job->annots);
 497                 job->annots = NULL;
 498         }
 499
 500         G_OBJECT_CLASS (ev_job_annots_parent_class)->dispose (object);
 501 }
 502
 503 static gboolean
 504 ev_job_annots_run (EvJob *job)
 505 {
 506         EvJobAnnots *job_annots = EV_JOB_ANNOTS (job);
 507         gint         i;
 508
 509         ev_debug_message (DEBUG_JOBS, NULL);
 510         ev_profiler_start (EV_PROFILE_JOBS, "%s (%p)", EV_GET_TYPE_NAME (job), job);
 511
 512         ev_document_doc_mutex_lock ();
 513         for (i = 0; i < ev_document_get_n_pages (job->document); i++) {
 514                 EvMappingList *mapping_list;
 515                 EvPage        *page;
 516
 517                 page = ev_document_get_page (job->document, i);
 518                 mapping_list = ev_document_annotations_get_annotations (EV_DOCUMENT_ANNOTATIONS (job->document),
 519                                                                         page);
 520                 g_object_unref (page);
 521
 522                 if (mapping_list)
 523                         job_annots->annots = g_list_prepend (job_annots->annots, mapping_list);
 524         }
 525         ev_document_doc_mutex_unlock ();
 526
 527         job_annots->annots = g_list_reverse (job_annots->annots);
 528
 529         ev_job_succeeded (job);
 530
 531         return FALSE;
 532 }
 533
 534 static void
 535 ev_job_annots_class_init (EvJobAnnotsClass *class)
 536 {
 537         GObjectClass *oclass = G_OBJECT_CLASS (class);
 538         EvJobClass   *job_class = EV_JOB_CLASS (class);
 539
 540         oclass->dispose = ev_job_annots_dispose;
 541         job_class->run = ev_job_annots_run;
 542 }
 543
 544 EvJob *
 545 ev_job_annots_new (EvDocument *document)
 546 {
 547         EvJob *job;
 548
 549         ev_debug_message (DEBUG_JOBS, NULL);
 550
 551         job = g_object_new (EV_TYPE_JOB_ANNOTS, NULL);
 552         job->document = g_object_ref (document);
 553
 554         return job;
 555 }
 556
 557 /* EvJobRender */
 558 static void
 559 ev_job_render_init (EvJobRender *job)
 560 {
 561         EV_JOB (job)->run_mode = EV_JOB_RUN_THREAD;
 562 }
 563
 564 static void
 565 ev_job_render_dispose (GObject *object)
 566 {
 567         EvJobRender *job;
 568
 569         job = EV_JOB_RENDER (object);
 570
 571         ev_debug_message (DEBUG_JOBS, "page: %d (%p)", job->page, job);
 572
 573         if (job->surface) {
 574                 cairo_surface_destroy (job->surface);
 575                 job->surface = NULL;
 576         }
 577
 578         if (job->selection) {
 579                 cairo_surface_destroy (job->selection);
 580                 job->selection = NULL;
 581         }
 582
 583         if (job->selection_region) {
 584                 cairo_region_destroy (job->selection_region);
 585                 job->selection_region = NULL;
 586         }
 587
 588         (* G_OBJECT_CLASS (ev_job_render_parent_class)->dispose) (object);
 589 }
 590
 591 static gboolean
 592 ev_job_render_run (EvJob *job)
 593 {
 594         EvJobRender     *job_render = EV_JOB_RENDER (job);
 595         EvPage          *ev_page;
 596         EvRenderContext *rc;
 597
 598         ev_debug_message (DEBUG_JOBS, "page: %d (%p)", job_render->page, job);
 599         ev_profiler_start (EV_PROFILE_JOBS, "%s (%p)", EV_GET_TYPE_NAME (job), job);
 600
 601         ev_document_doc_mutex_lock ();
 602
 603         ev_profiler_start (EV_PROFILE_JOBS, "Rendering page %d", job_render->page);
 604
 605         ev_document_fc_mutex_lock ();
 606
 607         ev_page = ev_document_get_page (job->document, job_render->page);
 608         rc = ev_render_context_new (ev_page, job_render->rotation, job_render->scale);
 609         g_object_unref (ev_page);
 610
 611         job_render->surface = ev_document_render (job->document, rc);
 612         /* If job was cancelled during the page rendering,
 613          * we return now, so that the thread is finished ASAP
 614          */
 615         if (g_cancellable_is_cancelled (job->cancellable)) {
 616                 ev_document_fc_mutex_unlock ();
 617                 ev_document_doc_mutex_unlock ();
 618                 g_object_unref (rc);
 619
 620                 return FALSE;
 621         }
 622
 623         if (job_render->include_selection && EV_IS_SELECTION (job->document)) {
 624                 ev_selection_render_selection (EV_SELECTION (job->document),
 625                                                rc,
 626                                                &(job_render->selection),
 627                                                &(job_render->selection_points),
 628                                                NULL,
 629                                                job_render->selection_style,
 630                                                &(job_render->text), &(job_render->base));
 631                 job_render->selection_region =
 632                         ev_selection_get_selection_region (EV_SELECTION (job->document),
 633                                                            rc,
 634                                                            job_render->selection_style,
 635                                                            &(job_render->selection_points));
 636         }
 637
 638         g_object_unref (rc);
 639
 640         ev_document_fc_mutex_unlock ();
 641         ev_document_doc_mutex_unlock ();
 642
 643         ev_job_succeeded (job);
 644
 645         return FALSE;
 646 }
 647
 648 static void
 649 ev_job_render_class_init (EvJobRenderClass *class)
 650 {
 651         GObjectClass *oclass = G_OBJECT_CLASS (class);
 652         EvJobClass   *job_class = EV_JOB_CLASS (class);
 653
 654         oclass->dispose = ev_job_render_dispose;
 655         job_class->run = ev_job_render_run;
 656 }
 657
 658 EvJob *
 659 ev_job_render_new (EvDocument   *document,
 660                    gint          page,
 661                    gint          rotation,
 662                    gdouble       scale,
 663                    gint          width,
 664                    gint          height)
 665 {
 666         EvJobRender *job;
 667
 668         ev_debug_message (DEBUG_JOBS, "page: %d", page);
 669
 670         job = g_object_new (EV_TYPE_JOB_RENDER, NULL);
 671
 672         EV_JOB (job)->document = g_object_ref (document);
 673         job->page = page;
 674         job->rotation = rotation;
 675         job->scale = scale;
 676         job->target_width = width;
 677         job->target_height = height;
 678
 679         return EV_JOB (job);
 680 }
 681
 682 void
 683 ev_job_render_set_selection_info (EvJobRender     *job,
 684                                   EvRectangle     *selection_points,
 685                                   EvSelectionStyle selection_style,
 686                                   GdkColor        *text,
 687                                   GdkColor        *base)
 688 {
 689         job->include_selection = TRUE;
 690
 691         job->selection_points = *selection_points;
 692         job->selection_style = selection_style;
 693         job->text = *text;
 694         job->base = *base;
 695 }
 696
 697 /* EvJobPageData */
 698 static void
 699 ev_job_page_data_init (EvJobPageData *job)
 700 {
 701         EV_JOB (job)->run_mode = EV_JOB_RUN_THREAD;
 702 }
 703
 704 static gboolean
 705 ev_job_page_data_run (EvJob *job)
 706 {
 707         EvJobPageData *job_pd = EV_JOB_PAGE_DATA (job);
 708         EvPage        *ev_page;
 709
 710         ev_debug_message (DEBUG_JOBS, "page: %d (%p)", job_pd->page, job);
 711         ev_profiler_start (EV_PROFILE_JOBS, "%s (%p)", EV_GET_TYPE_NAME (job), job);
 712
 713         ev_document_doc_mutex_lock ();
 714         ev_page = ev_document_get_page (job->document, job_pd->page);
 715
 716         if ((job_pd->flags & EV_PAGE_DATA_INCLUDE_TEXT_MAPPING) && EV_IS_DOCUMENT_TEXT (job->document))
 717                 job_pd->text_mapping =
 718                         ev_document_text_get_text_mapping (EV_DOCUMENT_TEXT (job->document), ev_page);
 719         if ((job_pd->flags & EV_PAGE_DATA_INCLUDE_TEXT) && EV_IS_DOCUMENT_TEXT (job->document))
 720                 job_pd->text =
 721                         ev_document_text_get_text (EV_DOCUMENT_TEXT (job->document), ev_page);
 722         if ((job_pd->flags & EV_PAGE_DATA_INCLUDE_TEXT_LAYOUT) && EV_IS_DOCUMENT_TEXT (job->document))
 723                 ev_document_text_get_text_layout (EV_DOCUMENT_TEXT (job->document),
 724                                                   ev_page,
 725                                                   &(job_pd->text_layout),
 726                                                   &(job_pd->text_layout_length));
 727         if ((job_pd->flags & EV_PAGE_DATA_INCLUDE_LINKS) && EV_IS_DOCUMENT_LINKS (job->document))
 728                 job_pd->link_mapping =
 729                         ev_document_links_get_links (EV_DOCUMENT_LINKS (job->document), ev_page);
 730         if ((job_pd->flags & EV_PAGE_DATA_INCLUDE_FORMS) && EV_IS_DOCUMENT_FORMS (job->document))
 731                 job_pd->form_field_mapping =
 732                         ev_document_forms_get_form_fields (EV_DOCUMENT_FORMS (job->document),
 733                                                            ev_page);
 734         if ((job_pd->flags & EV_PAGE_DATA_INCLUDE_IMAGES) && EV_IS_DOCUMENT_IMAGES (job->document))
 735                 job_pd->image_mapping =
 736                         ev_document_images_get_image_mapping (EV_DOCUMENT_IMAGES (job->document),
 737                                                               ev_page);
 738         if ((job_pd->flags & EV_PAGE_DATA_INCLUDE_ANNOTS) && EV_IS_DOCUMENT_ANNOTATIONS (job->document))
 739                 job_pd->annot_mapping =
 740                         ev_document_annotations_get_annotations (EV_DOCUMENT_ANNOTATIONS (job->document),
 741                                                                  ev_page);
 742         g_object_unref (ev_page);
 743         ev_document_doc_mutex_unlock ();
 744
 745         ev_job_succeeded (job);
 746
 747         return FALSE;
 748 }
 749
 750 static void
 751 ev_job_page_data_class_init (EvJobPageDataClass *class)
 752 {
 753         EvJobClass *job_class = EV_JOB_CLASS (class);
 754
 755         job_class->run = ev_job_page_data_run;
 756 }
 757
 758 EvJob *
 759 ev_job_page_data_new (EvDocument        *document,
 760                       gint               page,
 761                       EvJobPageDataFlags flags)
 762 {
 763         EvJobPageData *job;
 764
 765         ev_debug_message (DEBUG_JOBS, "%d", page);
 766
 767         job = g_object_new (EV_TYPE_JOB_PAGE_DATA, NULL);
 768
 769         EV_JOB (job)->document = g_object_ref (document);
 770         job->page = page;
 771         job->flags = flags;
 772
 773         return EV_JOB (job);
 774 }
 775
 776 /* EvJobThumbnail */
 777 static void
 778 ev_job_thumbnail_init (EvJobThumbnail *job)
 779 {
 780         EV_JOB (job)->run_mode = EV_JOB_RUN_THREAD;
 781 }
 782
 783 static void
 784 ev_job_thumbnail_dispose (GObject *object)
 785 {
 786         EvJobThumbnail *job;
 787
 788         job = EV_JOB_THUMBNAIL (object);
 789
 790         ev_debug_message (DEBUG_JOBS, "%d (%p)", job->page, job);
 791
 792         if (job->thumbnail) {
 793                 g_object_unref (job->thumbnail);
 794                 job->thumbnail = NULL;
 795         }
 796
 797         (* G_OBJECT_CLASS (ev_job_thumbnail_parent_class)->dispose) (object);
 798 }
 799
 800 static gboolean
 801 ev_job_thumbnail_run (EvJob *job)
 802 {
 803         EvJobThumbnail  *job_thumb = EV_JOB_THUMBNAIL (job);
 804         EvRenderContext *rc;
 805         GdkPixbuf       *pixbuf;
 806         EvPage          *page;
 807
 808         ev_debug_message (DEBUG_JOBS, "%d (%p)", job_thumb->page, job);
 809         ev_profiler_start (EV_PROFILE_JOBS, "%s (%p)", EV_GET_TYPE_NAME (job), job);
 810
 811         ev_document_doc_mutex_lock ();
 812
 813         page = ev_document_get_page (job->document, job_thumb->page);
 814         rc = ev_render_context_new (page, job_thumb->rotation, job_thumb->scale);
 815         g_object_unref (page);
 816
 817         pixbuf = ev_document_get_thumbnail (job->document, rc);
 818         g_object_unref (rc);
 819         ev_document_doc_mutex_unlock ();
 820
 821         if (pixbuf)
 822                 job_thumb->thumbnail = ev_document_misc_get_thumbnail_frame (-1, -1, pixbuf);
 823         g_object_unref (pixbuf);
 824
 825         ev_job_succeeded (job);
 826
 827         return FALSE;
 828 }
 829
 830 static void
 831 ev_job_thumbnail_class_init (EvJobThumbnailClass *class)
 832 {
 833         GObjectClass *oclass = G_OBJECT_CLASS (class);
 834         EvJobClass   *job_class = EV_JOB_CLASS (class);
 835
 836         oclass->dispose = ev_job_thumbnail_dispose;
 837         job_class->run = ev_job_thumbnail_run;
 838 }
 839
 840 EvJob *
 841 ev_job_thumbnail_new (EvDocument *document,
 842                       gint        page,
 843                       gint        rotation,
 844                       gdouble     scale)
 845 {
 846         EvJobThumbnail *job;
 847
 848         ev_debug_message (DEBUG_JOBS, "%d", page);
 849
 850         job = g_object_new (EV_TYPE_JOB_THUMBNAIL, NULL);
 851
 852         EV_JOB (job)->document = g_object_ref (document);
 853         job->page = page;
 854         job->rotation = rotation;
 855         job->scale = scale;
 856
 857         return EV_JOB (job);
 858 }
 859
 860 /* EvJobFonts */
 861 static void
 862 ev_job_fonts_init (EvJobFonts *job)
 863 {
 864         EV_JOB (job)->run_mode = EV_JOB_RUN_MAIN_LOOP;
 865 }
 866
 867 static gboolean
 868 ev_job_fonts_run (EvJob *job)
 869 {
 870         EvJobFonts      *job_fonts = EV_JOB_FONTS (job);
 871         EvDocumentFonts *fonts = EV_DOCUMENT_FONTS (job->document);
 872
 873         ev_debug_message (DEBUG_JOBS, NULL);
 874
 875         /* Do not block the main loop */
 876         if (!ev_document_doc_mutex_trylock ())
 877                 return TRUE;
 878
 879         if (!ev_document_fc_mutex_trylock ())
 880                 return TRUE;
 881
 882 #ifdef EV_ENABLE_DEBUG
 883         /* We use the #ifdef in this case because of the if */
 884         if (ev_document_fonts_get_progress (fonts) == 0)
 885                 ev_profiler_start (EV_PROFILE_JOBS, "%s (%p)", EV_GET_TYPE_NAME (job), job);
 886 #endif
 887
 888         job_fonts->scan_completed = !ev_document_fonts_scan (fonts, 20);
 889         g_signal_emit (job_fonts, job_fonts_signals[FONTS_UPDATED], 0,
 890                        ev_document_fonts_get_progress (fonts));
 891
 892         ev_document_fc_mutex_unlock ();
 893         ev_document_doc_mutex_unlock ();
 894
 895         if (job_fonts->scan_completed)
 896                 ev_job_succeeded (job);
 897
 898         return !job_fonts->scan_completed;
 899 }
 900
 901 static void
 902 ev_job_fonts_class_init (EvJobFontsClass *class)
 903 {
 904         EvJobClass *job_class = EV_JOB_CLASS (class);
 905
 906         job_class->run = ev_job_fonts_run;
 907
 908         job_fonts_signals[FONTS_UPDATED] =
 909                 g_signal_new ("updated",
 910                               EV_TYPE_JOB_FONTS,
 911                               G_SIGNAL_RUN_LAST,
 912                               G_STRUCT_OFFSET (EvJobFontsClass, updated),
 913                               NULL, NULL,
 914                               g_cclosure_marshal_VOID__DOUBLE,
 915                               G_TYPE_NONE,
 916                               1, G_TYPE_DOUBLE);
 917 }
 918
 919 EvJob *
 920 ev_job_fonts_new (EvDocument *document)
 921 {
 922         EvJobFonts *job;
 923
 924         ev_debug_message (DEBUG_JOBS, NULL);
 925
 926         job = g_object_new (EV_TYPE_JOB_FONTS, NULL);
 927
 928         EV_JOB (job)->document = g_object_ref (document);
 929
 930         return EV_JOB (job);
 931 }
 932
 933 /* EvJobLoad */
 934 static void
 935 ev_job_load_init (EvJobLoad *job)
 936 {
 937         EV_JOB (job)->run_mode = EV_JOB_RUN_THREAD;
 938 }
 939
 940 static void
 941 ev_job_load_dispose (GObject *object)
 942 {
 943         EvJobLoad *job = EV_JOB_LOAD (object);
 944
 945         ev_debug_message (DEBUG_JOBS, "%s", job->uri);
 946
 947         if (job->uri) {
 948                 g_free (job->uri);
 949                 job->uri = NULL;
 950         }
 951
 952         if (job->password) {
 953                 g_free (job->password);
 954                 job->password = NULL;
 955         }
 956
 957         (* G_OBJECT_CLASS (ev_job_load_parent_class)->dispose) (object);
 958 }
 959
 960 static gboolean
 961 ev_job_load_run (EvJob *job)
 962 {
 963         EvJobLoad *job_load = EV_JOB_LOAD (job);
 964         GError    *error = NULL;
 965
 966         ev_debug_message (DEBUG_JOBS, "%s", job_load->uri);
 967         ev_profiler_start (EV_PROFILE_JOBS, "%s (%p)", EV_GET_TYPE_NAME (job), job);
 968
 969         ev_document_fc_mutex_lock ();
 970
 971         /* This job may already have a document even if the job didn't complete
 972            because, e.g., a password is required - if so, just reload rather than
 973            creating a new instance */
 974         if (job->document) {
 975                 const gchar *uncompressed_uri;
 976
 977                 if (job_load->password) {
 978                         ev_document_security_set_password (EV_DOCUMENT_SECURITY (job->document),
 979                                                            job_load->password);
 980                 }
 981
 982                 job->failed = FALSE;
 983                 job->finished = FALSE;
 984                 g_clear_error (&job->error);
 985
 986                 uncompressed_uri = g_object_get_data (G_OBJECT (job->document),
 987                                                       "uri-uncompressed");
 988                 ev_document_load (job->document,
 989                                   uncompressed_uri ? uncompressed_uri : job_load->uri,
 990                                   &error);
 991         } else {
 992                 job->document = ev_document_factory_get_document (job_load->uri,
 993                                                                   &error);
 994         }
 995
 996         ev_document_fc_mutex_unlock ();
 997
 998         if (error) {
 999                 ev_job_failed_from_error (job, error);
1000                 g_error_free (error);
1001         } else {
1002                 ev_job_succeeded (job);
1003         }
1004
1005         return FALSE;
1006 }
1007
1008 static void
1009 ev_job_load_class_init (EvJobLoadClass *class)
1010 {
1011         GObjectClass *oclass = G_OBJECT_CLASS (class);
1012         EvJobClass   *job_class = EV_JOB_CLASS (class);
1013
1014         oclass->dispose = ev_job_load_dispose;
1015         job_class->run = ev_job_load_run;
1016 }
1017
1018 EvJob *
1019 ev_job_load_new (const gchar *uri)
1020 {
1021         EvJobLoad *job;
1022
1023         ev_debug_message (DEBUG_JOBS, "%s", uri);
1024
1025         job = g_object_new (EV_TYPE_JOB_LOAD, NULL);
1026         job->uri = g_strdup (uri);
1027
1028         return EV_JOB (job);
1029 }
1030
1031 void
1032 ev_job_load_set_uri (EvJobLoad *job, const gchar *uri)
1033 {
1034         ev_debug_message (DEBUG_JOBS, "%s", uri);
1035
1036         if (job->uri)
1037                 g_free (job->uri);
1038         job->uri = g_strdup (uri);
1039 }
1040
1041 void
1042 ev_job_load_set_password (EvJobLoad *job, const gchar *password)
1043 {
1044         ev_debug_message (DEBUG_JOBS, NULL);
1045
1046         if (job->password)
1047                 g_free (job->password);
1048         job->password = password ? g_strdup (password) : NULL;
1049 }
1050
1051 /* EvJobSave */
1052 static void
1053 ev_job_save_init (EvJobSave *job)
1054 {
1055         EV_JOB (job)->run_mode = EV_JOB_RUN_THREAD;
1056 }
1057
1058 static void
1059 ev_job_save_dispose (GObject *object)
1060 {
1061         EvJobSave *job = EV_JOB_SAVE (object);
1062
1063         ev_debug_message (DEBUG_JOBS, "%s", job->uri);
1064
1065         if (job->uri) {
1066                 g_free (job->uri);
1067                 job->uri = NULL;
1068         }
1069
1070         if (job->document_uri) {
1071                 g_free (job->document_uri);
1072                 job->document_uri = NULL;
1073         }
1074
1075         (* G_OBJECT_CLASS (ev_job_save_parent_class)->dispose) (object);
1076 }
1077
1078 static gboolean
1079 ev_job_save_run (EvJob *job)
1080 {
1081         EvJobSave *job_save = EV_JOB_SAVE (job);
1082         gint       fd;
1083         gchar     *tmp_filename = NULL;
1084         gchar     *local_uri;
1085         GError    *error = NULL;
1086
1087         ev_debug_message (DEBUG_JOBS, "uri: %s, document_uri: %s", job_save->uri, job_save->document_uri);
1088         ev_profiler_start (EV_PROFILE_JOBS, "%s (%p)", EV_GET_TYPE_NAME (job), job);
1089
1090         fd = ev_mkstemp ("saveacopy.XXXXXX", &tmp_filename, &error);
1091         if (fd == -1) {
1092                 ev_job_failed_from_error (job, error);
1093                 g_error_free (error);
1094
1095                 return FALSE;
1096         }
1097
1098         ev_document_doc_mutex_lock ();
1099
1100         /* Save document to temp filename */
1101         local_uri = g_filename_to_uri (tmp_filename, NULL, &error);
1102         if (local_uri != NULL) {
1103                 ev_document_save (job->document, local_uri, &error);
1104         }
1105
1106         close (fd);
1107
1108         ev_document_doc_mutex_unlock ();
1109
1110         if (error) {
1111                 g_free (local_uri);
1112                 ev_job_failed_from_error (job, error);
1113                 g_error_free (error);
1114
1115                 return FALSE;
1116         }
1117
1118         /* If original document was compressed,
1119          * compress it again before saving
1120          */
1121         if (g_object_get_data (G_OBJECT (job->document), "uri-uncompressed")) {
1122                 EvCompressionType ctype = EV_COMPRESSION_NONE;
1123                 const gchar      *ext;
1124                 gchar            *uri_comp;
1125
1126                 ext = g_strrstr (job_save->document_uri, ".gz");
1127                 if (ext && g_ascii_strcasecmp (ext, ".gz") == 0)
1128                         ctype = EV_COMPRESSION_GZIP;
1129
1130                 ext = g_strrstr (job_save->document_uri, ".bz2");
1131                 if (ext && g_ascii_strcasecmp (ext, ".bz2") == 0)
1132                         ctype = EV_COMPRESSION_BZIP2;
1133
1134                 uri_comp = ev_file_compress (local_uri, ctype, &error);
1135                 g_free (local_uri);
1136                 g_unlink (tmp_filename);
1137
1138                 if (!uri_comp || error) {
1139                         local_uri = NULL;
1140                 } else {
1141                         local_uri = uri_comp;
1142                 }
1143         }
1144
1145         g_free (tmp_filename);
1146
1147         if (error) {
1148                 g_free (local_uri);
1149                 ev_job_failed_from_error (job, error);
1150                 g_error_free (error);
1151
1152                 return FALSE;
1153         }
1154
1155         if (!local_uri)
1156                 return FALSE;
1157
1158         ev_xfer_uri_simple (local_uri, job_save->uri, &error);
1159         ev_tmp_uri_unlink (local_uri);
1160
1161         if (error) {
1162                 ev_job_failed_from_error (job, error);
1163                 g_error_free (error);
1164         } else {
1165                 ev_job_succeeded (job);
1166         }
1167
1168         return FALSE;
1169 }
1170
1171 static void
1172 ev_job_save_class_init (EvJobSaveClass *class)
1173 {
1174         GObjectClass *oclass = G_OBJECT_CLASS (class);
1175         EvJobClass   *job_class = EV_JOB_CLASS (class);
1176
1177         oclass->dispose = ev_job_save_dispose;
1178         job_class->run = ev_job_save_run;
1179 }
1180
1181 EvJob *
1182 ev_job_save_new (EvDocument  *document,
1183                  const gchar *uri,
1184                  const gchar *document_uri)
1185 {
1186         EvJobSave *job;
1187
1188         ev_debug_message (DEBUG_JOBS, "uri: %s, document_uri: %s", uri, document_uri);
1189
1190         job = g_object_new (EV_TYPE_JOB_SAVE, NULL);
1191
1192         EV_JOB (job)->document = g_object_ref (document);
1193         job->uri = g_strdup (uri);
1194         job->document_uri = g_strdup (document_uri);
1195
1196         return EV_JOB (job);
1197 }
1198
1199 /* EvJobFind */
1200 static void
1201 ev_job_find_init (EvJobFind *job)
1202 {
1203         EV_JOB (job)->run_mode = EV_JOB_RUN_MAIN_LOOP;
1204 }
1205
1206 static void
1207 ev_job_find_dispose (GObject *object)
1208 {
1209         EvJobFind *job = EV_JOB_FIND (object);
1210
1211         ev_debug_message (DEBUG_JOBS, NULL);
1212
1213         if (job->text) {
1214                 g_free (job->text);
1215                 job->text = NULL;
1216         }
1217
1218         if (job->pages) {
1219                 gint i;
1220
1221                 for (i = 0; i < job->n_pages; i++) {
1222                         g_list_foreach (job->pages[i], (GFunc)ev_rectangle_free, NULL);
1223                         g_list_free (job->pages[i]);
1224                 }
1225
1226                 g_free (job->pages);
1227                 job->pages = NULL;
1228         }
1229
1230         (* G_OBJECT_CLASS (ev_job_find_parent_class)->dispose) (object);
1231 }
1232
1233 static gboolean
1234 ev_job_find_run (EvJob *job)
1235 {
1236         EvJobFind      *job_find = EV_JOB_FIND (job);
1237         EvDocumentFind *find = EV_DOCUMENT_FIND (job->document);
1238         EvPage         *ev_page;
1239         GList          *matches;
1240
1241         ev_debug_message (DEBUG_JOBS, NULL);
1242
1243         /* Do not block the main loop */
1244         if (!ev_document_doc_mutex_trylock ())
1245                 return TRUE;
1246
1247 #ifdef EV_ENABLE_DEBUG
1248         /* We use the #ifdef in this case because of the if */
1249         if (job_find->current_page == job_find->start_page)
1250                 ev_profiler_start (EV_PROFILE_JOBS, "%s (%p)", EV_GET_TYPE_NAME (job), job);
1251 #endif
1252
1253         ev_page = ev_document_get_page (job->document, job_find->current_page);
1254         matches = ev_document_find_find_text (find, ev_page, job_find->text,
1255                                               job_find->case_sensitive);
1256         g_object_unref (ev_page);
1257
1258         ev_document_doc_mutex_unlock ();
1259
1260         if (!job_find->has_results)
1261                 job_find->has_results = (matches != NULL);
1262
1263         job_find->pages[job_find->current_page] = matches;
1264         g_signal_emit (job_find, job_find_signals[FIND_UPDATED], 0, job_find->current_page);
1265
1266         job_find->current_page = (job_find->current_page + 1) % job_find->n_pages;
1267         if (job_find->current_page == job_find->start_page) {
1268                 ev_job_succeeded (job);
1269
1270                 return FALSE;
1271         }
1272
1273         return TRUE;
1274 }
1275
1276 static void
1277 ev_job_find_class_init (EvJobFindClass *class)
1278 {
1279         EvJobClass   *job_class = EV_JOB_CLASS (class);
1280         GObjectClass *gobject_class = G_OBJECT_CLASS (class);
1281
1282         job_class->run = ev_job_find_run;
1283         gobject_class->dispose = ev_job_find_dispose;
1284
1285         job_find_signals[FIND_UPDATED] =
1286                 g_signal_new ("updated",
1287                               EV_TYPE_JOB_FIND,
1288                               G_SIGNAL_RUN_LAST,
1289                               G_STRUCT_OFFSET (EvJobFindClass, updated),
1290                               NULL, NULL,
1291                               g_cclosure_marshal_VOID__INT,
1292                               G_TYPE_NONE,
1293                               1, G_TYPE_INT);
1294 }
1295
1296 EvJob *
1297 ev_job_find_new (EvDocument  *document,
1298                  gint         start_page,
1299                  gint         n_pages,
1300                  const gchar *text,
1301                  gboolean     case_sensitive)
1302 {
1303         EvJobFind *job;
1304
1305         ev_debug_message (DEBUG_JOBS, NULL);
1306
1307         job = g_object_new (EV_TYPE_JOB_FIND, NULL);
1308
1309         EV_JOB (job)->document = g_object_ref (document);
1310         job->start_page = start_page;
1311         job->current_page = start_page;
1312         job->n_pages = n_pages;
1313         job->pages = g_new0 (GList *, n_pages);
1314         job->text = g_strdup (text);
1315         job->case_sensitive = case_sensitive;
1316         job->has_results = FALSE;
1317
1318         return EV_JOB (job);
1319 }
1320
1321 gint
1322 ev_job_find_get_n_results (EvJobFind *job,
1323                            gint       page)
1324 {
1325         return g_list_length (job->pages[page]);
1326 }
1327
1328 gdouble
1329 ev_job_find_get_progress (EvJobFind *job)
1330 {
1331         gint pages_done;
1332
1333         if (ev_job_is_finished (EV_JOB (job)))
1334                 return 1.0;
1335
1336         if (job->current_page > job->start_page) {
1337                 pages_done = job->current_page - job->start_page + 1;
1338         } else if (job->current_page == job->start_page) {
1339                 pages_done = job->n_pages;
1340         } else {
1341                 pages_done = job->n_pages - job->start_page + job->current_page;
1342         }
1343
1344         return pages_done / (gdouble) job->n_pages;
1345 }
1346
1347 gboolean
1348 ev_job_find_has_results (EvJobFind *job)
1349 {
1350         return job->has_results;
1351 }
1352
1353 GList **
1354 ev_job_find_get_results (EvJobFind *job)
1355 {
1356         return job->pages;
1357 }
1358
1359 /* EvJobLayers */
1360 static void
1361 ev_job_layers_init (EvJobLayers *job)
1362 {
1363         EV_JOB (job)->run_mode = EV_JOB_RUN_THREAD;
1364 }
1365
1366 static void
1367 ev_job_layers_dispose (GObject *object)
1368 {
1369         EvJobLayers *job;
1370
1371         ev_debug_message (DEBUG_JOBS, NULL);
1372
1373         job = EV_JOB_LAYERS (object);
1374
1375         if (job->model) {
1376                 g_object_unref (job->model);
1377                 job->model = NULL;
1378         }
1379
1380         (* G_OBJECT_CLASS (ev_job_layers_parent_class)->dispose) (object);
1381 }
1382
1383 static gboolean
1384 ev_job_layers_run (EvJob *job)
1385 {
1386         EvJobLayers *job_layers = EV_JOB_LAYERS (job);
1387
1388         ev_debug_message (DEBUG_JOBS, NULL);
1389         ev_profiler_start (EV_PROFILE_JOBS, "%s (%p)", EV_GET_TYPE_NAME (job), job);
1390
1391         ev_document_doc_mutex_lock ();
1392         job_layers->model = ev_document_layers_get_layers (EV_DOCUMENT_LAYERS (job->document));
1393         ev_document_doc_mutex_unlock ();
1394
1395         ev_job_succeeded (job);
1396
1397         return FALSE;
1398 }
1399
1400 static void
1401 ev_job_layers_class_init (EvJobLayersClass *class)
1402 {
1403         GObjectClass *oclass = G_OBJECT_CLASS (class);
1404         EvJobClass   *job_class = EV_JOB_CLASS (class);
1405
1406         oclass->dispose = ev_job_layers_dispose;
1407         job_class->run = ev_job_layers_run;
1408 }
1409
1410 EvJob *
1411 ev_job_layers_new (EvDocument *document)
1412 {
1413         EvJob *job;
1414
1415         ev_debug_message (DEBUG_JOBS, NULL);
1416
1417         job = g_object_new (EV_TYPE_JOB_LAYERS, NULL);
1418         job->document = g_object_ref (document);
1419
1420         return job;
1421 }
1422
1423 /* EvJobExport */
1424 static void
1425 ev_job_export_init (EvJobExport *job)
1426 {
1427         EV_JOB (job)->run_mode = EV_JOB_RUN_THREAD;
1428         job->page = -1;
1429 }
1430
1431 static void
1432 ev_job_export_dispose (GObject *object)
1433 {
1434         EvJobExport *job;
1435
1436         ev_debug_message (DEBUG_JOBS, NULL);
1437
1438         job = EV_JOB_EXPORT (object);
1439
1440         if (job->rc) {
1441                 g_object_unref (job->rc);
1442                 job->rc = NULL;
1443         }
1444
1445         (* G_OBJECT_CLASS (ev_job_export_parent_class)->dispose) (object);
1446 }
1447
1448 static gboolean
1449 ev_job_export_run (EvJob *job)
1450 {
1451         EvJobExport *job_export = EV_JOB_EXPORT (job);
1452         EvPage      *ev_page;
1453
1454         g_assert (job_export->page != -1);
1455
1456         ev_debug_message (DEBUG_JOBS, NULL);
1457         ev_profiler_start (EV_PROFILE_JOBS, "%s (%p)", EV_GET_TYPE_NAME (job), job);
1458
1459         ev_document_doc_mutex_lock ();
1460
1461         ev_page = ev_document_get_page (job->document, job_export->page);
1462         if (job_export->rc) {
1463                 job->failed = FALSE;
1464                 job->finished = FALSE;
1465                 g_clear_error (&job->error);
1466
1467                 ev_render_context_set_page (job_export->rc, ev_page);
1468         } else {
1469                 job_export->rc = ev_render_context_new (ev_page, 0, 1.0);
1470         }
1471         g_object_unref (ev_page);
1472
1473         ev_file_exporter_do_page (EV_FILE_EXPORTER (job->document), job_export->rc);
1474
1475         ev_document_doc_mutex_unlock ();
1476
1477         ev_job_succeeded (job);
1478
1479         return FALSE;
1480 }
1481
1482 static void
1483 ev_job_export_class_init (EvJobExportClass *class)
1484 {
1485         GObjectClass *oclass = G_OBJECT_CLASS (class);
1486         EvJobClass   *job_class = EV_JOB_CLASS (class);
1487
1488         oclass->dispose = ev_job_export_dispose;
1489         job_class->run = ev_job_export_run;
1490 }
1491
1492 EvJob *
1493 ev_job_export_new (EvDocument *document)
1494 {
1495         EvJob *job;
1496
1497         ev_debug_message (DEBUG_JOBS, NULL);
1498
1499         job = g_object_new (EV_TYPE_JOB_EXPORT, NULL);
1500         job->document = g_object_ref (document);
1501
1502         return job;
1503 }
1504
1505 void
1506 ev_job_export_set_page (EvJobExport *job,
1507                         gint         page)
1508 {
1509         job->page = page;
1510 }
1511
1512 /* EvJobPrint */
1513 static void
1514 ev_job_print_init (EvJobPrint *job)
1515 {
1516         EV_JOB (job)->run_mode = EV_JOB_RUN_THREAD;
1517         job->page = -1;
1518 }
1519
1520 static void
1521 ev_job_print_dispose (GObject *object)
1522 {
1523         EvJobPrint *job;
1524
1525         ev_debug_message (DEBUG_JOBS, NULL);
1526
1527         job = EV_JOB_PRINT (object);
1528
1529         if (job->cr) {
1530                 cairo_destroy (job->cr);
1531                 job->cr = NULL;
1532         }
1533
1534         (* G_OBJECT_CLASS (ev_job_print_parent_class)->dispose) (object);
1535 }
1536
1537 static gboolean
1538 ev_job_print_run (EvJob *job)
1539 {
1540         EvJobPrint     *job_print = EV_JOB_PRINT (job);
1541         EvPage         *ev_page;
1542         cairo_status_t  cr_status;
1543
1544         g_assert (job_print->page != -1);
1545         g_assert (job_print->cr != NULL);
1546
1547         ev_debug_message (DEBUG_JOBS, NULL);
1548         ev_profiler_start (EV_PROFILE_JOBS, "%s (%p)", EV_GET_TYPE_NAME (job), job);
1549
1550         job->failed = FALSE;
1551         job->finished = FALSE;
1552         g_clear_error (&job->error);
1553
1554         ev_document_doc_mutex_lock ();
1555
1556         ev_page = ev_document_get_page (job->document, job_print->page);
1557         ev_document_print_print_page (EV_DOCUMENT_PRINT (job->document),
1558                                       ev_page, job_print->cr);
1559         g_object_unref (ev_page);
1560
1561         ev_document_doc_mutex_unlock ();
1562
1563         if (g_cancellable_is_cancelled (job->cancellable))
1564                 return FALSE;
1565
1566         cr_status = cairo_status (job_print->cr);
1567         if (cr_status == CAIRO_STATUS_SUCCESS) {
1568                 ev_job_succeeded (job);
1569         } else {
1570                 ev_job_failed (job,
1571                                GTK_PRINT_ERROR,
1572                                GTK_PRINT_ERROR_GENERAL,
1573                                _("Failed to print page %d: %s"),
1574                                job_print->page,
1575                                cairo_status_to_string (cr_status));
1576         }
1577
1578         return FALSE;
1579 }
1580
1581 static void
1582 ev_job_print_class_init (EvJobPrintClass *class)
1583 {
1584         GObjectClass *oclass = G_OBJECT_CLASS (class);
1585         EvJobClass   *job_class = EV_JOB_CLASS (class);
1586
1587         oclass->dispose = ev_job_print_dispose;
1588         job_class->run = ev_job_print_run;
1589 }
1590
1591 EvJob *
1592 ev_job_print_new (EvDocument *document)
1593 {
1594         EvJob *job;
1595
1596         ev_debug_message (DEBUG_JOBS, NULL);
1597
1598         job = g_object_new (EV_TYPE_JOB_PRINT, NULL);
1599         job->document = g_object_ref (document);
1600
1601         return job;
1602 }
1603
1604 void
1605 ev_job_print_set_page (EvJobPrint *job,
1606                        gint        page)
1607 {
1608         job->page = page;
1609 }
1610
1611 void
1612 ev_job_print_set_cairo (EvJobPrint *job,
1613                         cairo_t    *cr)
1614 {
1615         if (job->cr == cr)
1616                 return;
1617
1618         if (job->cr)
1619                 cairo_destroy (job->cr);
1620         job->cr = cr ? cairo_reference (cr) : NULL;
1621 }