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., 59 Temple Place, Suite 330, Boston, MA 02111-1307, USA.
  19  */
  20
  21 #include <config.h>
  22
  23 #include "ev-jobs.h"
  24 #include "ev-document-thumbnails.h"
  25 #include "ev-document-links.h"
  26 #include "ev-document-images.h"
  27 #include "ev-document-forms.h"
  28 #include "ev-file-exporter.h"
  29 #include "ev-document-factory.h"
  30 #include "ev-document-misc.h"
  31 #include "ev-file-helpers.h"
  32 #include "ev-document-fonts.h"
  33 #include "ev-document-security.h"
  34 #include "ev-document-find.h"
  35 #include "ev-document-layers.h"
  36 #include "ev-document-annotations.h"
  37 #include "ev-debug.h"
  38
  39 #include <errno.h>
  40 #include <glib/gstdio.h>
  41 #include <glib/gi18n-lib.h>
  42 #include <unistd.h>
  43
  44 static void ev_job_init                   (EvJob                 *job);
  45 static void ev_job_class_init             (EvJobClass            *class);
  46 static void ev_job_links_init             (EvJobLinks            *job);
  47 static void ev_job_links_class_init       (EvJobLinksClass       *class);
  48 static void ev_job_attachments_init       (EvJobAttachments      *job);
  49 static void ev_job_attachments_class_init (EvJobAttachmentsClass *class);
  50 static void ev_job_render_init            (EvJobRender           *job);
  51 static void ev_job_render_class_init      (EvJobRenderClass      *class);
  52 static void ev_job_thumbnail_init         (EvJobThumbnail        *job);
  53 static void ev_job_thumbnail_class_init   (EvJobThumbnailClass   *class);
  54 static void ev_job_load_init              (EvJobLoad             *job);
  55 static void ev_job_load_class_init        (EvJobLoadClass        *class);
  56 static void ev_job_save_init              (EvJobSave             *job);
  57 static void ev_job_save_class_init        (EvJobSaveClass        *class);
  58 static void ev_job_find_init              (EvJobFind             *job);
  59 static void ev_job_find_class_init        (EvJobFindClass        *class);
  60 static void ev_job_layers_init            (EvJobLayers           *job);
  61 static void ev_job_layers_class_init      (EvJobLayersClass      *class);
  62 static void ev_job_export_init            (EvJobExport           *job);
  63 static void ev_job_export_class_init      (EvJobExportClass      *class);
  64
  65 enum {
  66         CANCELLED,
  67         FINISHED,
  68         LAST_SIGNAL
  69 };
  70
  71 enum {
  72         PAGE_READY,
  73         RENDER_LAST_SIGNAL
  74 };
  75
  76 enum {
  77         FONTS_UPDATED,
  78         FONTS_LAST_SIGNAL
  79 };
  80
  81 enum {
  82         FIND_UPDATED,
  83         FIND_LAST_SIGNAL
  84 };
  85
  86 static guint job_signals[LAST_SIGNAL] = { 0 };
  87 static guint job_render_signals[RENDER_LAST_SIGNAL] = { 0 };
  88 static guint job_fonts_signals[FONTS_LAST_SIGNAL] = { 0 };
  89 static guint job_find_signals[FIND_LAST_SIGNAL] = { 0 };
  90
  91 G_DEFINE_ABSTRACT_TYPE (EvJob, ev_job, G_TYPE_OBJECT)
  92 G_DEFINE_TYPE (EvJobLinks, ev_job_links, EV_TYPE_JOB)
  93 G_DEFINE_TYPE (EvJobAttachments, ev_job_attachments, EV_TYPE_JOB)
  94 G_DEFINE_TYPE (EvJobRender, ev_job_render, EV_TYPE_JOB)
  95 G_DEFINE_TYPE (EvJobThumbnail, ev_job_thumbnail, EV_TYPE_JOB)
  96 G_DEFINE_TYPE (EvJobFonts, ev_job_fonts, EV_TYPE_JOB)
  97 G_DEFINE_TYPE (EvJobLoad, ev_job_load, EV_TYPE_JOB)
  98 G_DEFINE_TYPE (EvJobSave, ev_job_save, EV_TYPE_JOB)
  99 G_DEFINE_TYPE (EvJobFind, ev_job_find, EV_TYPE_JOB)
 100 G_DEFINE_TYPE (EvJobLayers, ev_job_layers, EV_TYPE_JOB)
 101 G_DEFINE_TYPE (EvJobExport, ev_job_export, EV_TYPE_JOB)
 102
 103 /* EvJob */
 104 static void
 105 ev_job_init (EvJob *job)
 106 {
 107         job->cancellable = g_cancellable_new ();
 108 }
 109
 110 static void
 111 ev_job_dispose (GObject *object)
 112 {
 113         EvJob *job;
 114
 115         job = EV_JOB (object);
 116
 117         if (job->document) {
 118                 g_object_unref (job->document);
 119                 job->document = NULL;
 120         }
 121
 122         if (job->cancellable) {
 123                 g_object_unref (job->cancellable);
 124                 job->cancellable = NULL;
 125         }
 126
 127         if (job->error) {
 128                 g_error_free (job->error);
 129                 job->error = NULL;
 130         }
 131
 132         (* G_OBJECT_CLASS (ev_job_parent_class)->dispose) (object);
 133 }
 134
 135 static void
 136 ev_job_class_init (EvJobClass *class)
 137 {
 138         GObjectClass *oclass;
 139
 140         oclass = G_OBJECT_CLASS (class);
 141
 142         oclass->dispose = ev_job_dispose;
 143
 144         job_signals[CANCELLED] =
 145                 g_signal_new ("cancelled",
 146                               EV_TYPE_JOB,
 147                               G_SIGNAL_RUN_LAST,
 148                               G_STRUCT_OFFSET (EvJobClass, cancelled),
 149                               NULL, NULL,
 150                               g_cclosure_marshal_VOID__VOID,
 151                               G_TYPE_NONE, 0);
 152         job_signals [FINISHED] =
 153                 g_signal_new ("finished",
 154                               EV_TYPE_JOB,
 155                               G_SIGNAL_RUN_FIRST,
 156                               G_STRUCT_OFFSET (EvJobClass, finished),
 157                               NULL, NULL,
 158                               g_cclosure_marshal_VOID__VOID,
 159                               G_TYPE_NONE, 0);
 160 }
 161
 162 static gboolean
 163 emit_finished (EvJob *job)
 164 {
 165         ev_debug_message (DEBUG_JOBS, "%s (%p)", EV_GET_TYPE_NAME (job), job);
 166
 167         job->idle_finished_id = 0;
 168
 169         if (job->cancelled) {
 170                 ev_debug_message (DEBUG_JOBS, "%s (%p) job was cancelled, do not emit finished", EV_GET_TYPE_NAME (job), job);
 171         } else {
 172                 ev_profiler_stop (EV_PROFILE_JOBS, "%s (%p)", EV_GET_TYPE_NAME (job), job);
 173                 g_signal_emit (job, job_signals[FINISHED], 0);
 174         }
 175
 176         return FALSE;
 177 }
 178
 179 static void
 180 ev_job_emit_finished (EvJob *job)
 181 {
 182         ev_debug_message (DEBUG_JOBS, "%s (%p)", EV_GET_TYPE_NAME (job), job);
 183
 184         if (g_cancellable_is_cancelled (job->cancellable)) {
 185                 ev_debug_message (DEBUG_JOBS, "%s (%p) job was cancelled, returning", EV_GET_TYPE_NAME (job), job);
 186                 return;
 187         }
 188
 189         job->finished = TRUE;
 190
 191         if (job->run_mode == EV_JOB_RUN_THREAD) {
 192                 job->idle_finished_id =
 193                         g_idle_add_full (G_PRIORITY_DEFAULT_IDLE,
 194                                          (GSourceFunc)emit_finished,
 195                                          g_object_ref (job),
 196                                          (GDestroyNotify)g_object_unref);
 197         } else {
 198                 ev_profiler_stop (EV_PROFILE_JOBS, "%s (%p)", EV_GET_TYPE_NAME (job), job);
 199                 g_signal_emit (job, job_signals[FINISHED], 0);
 200         }
 201 }
 202
 203 gboolean
 204 ev_job_run (EvJob *job)
 205 {
 206         EvJobClass *class = EV_JOB_GET_CLASS (job);
 207
 208         return class->run (job);
 209 }
 210
 211 void
 212 ev_job_cancel (EvJob *job)
 213 {
 214         if (job->cancelled || (job->finished && job->idle_finished_id == 0))
 215                 return;
 216
 217         ev_debug_message (DEBUG_JOBS, "job %s (%p) cancelled", EV_GET_TYPE_NAME (job), job);
 218         ev_profiler_stop (EV_PROFILE_JOBS, "%s (%p)", EV_GET_TYPE_NAME (job), job);
 219
 220         /* This should never be called from a thread */
 221         job->cancelled = TRUE;
 222         g_cancellable_cancel (job->cancellable);
 223         g_signal_emit (job, job_signals[CANCELLED], 0);
 224 }
 225
 226 void
 227 ev_job_failed (EvJob       *job,
 228                GQuark       domain,
 229                gint         code,
 230                const gchar *format,
 231                ...)
 232 {
 233         va_list args;
 234         gchar  *message;
 235
 236         if (job->failed || job->finished)
 237                 return;
 238
 239         ev_debug_message (DEBUG_JOBS, "job %s (%p) failed", EV_GET_TYPE_NAME (job), job);
 240
 241         job->failed = TRUE;
 242
 243         va_start (args, format);
 244         message = g_strdup_vprintf (format, args);
 245         va_end (args);
 246
 247         job->error = g_error_new_literal (domain, code, message);
 248         g_free (message);
 249
 250         ev_job_emit_finished (job);
 251 }
 252
 253 void
 254 ev_job_failed_from_error (EvJob  *job,
 255                           GError *error)
 256 {
 257         if (job->failed || job->finished)
 258                 return;
 259
 260         ev_debug_message (DEBUG_JOBS, "job %s (%p) failed", EV_GET_TYPE_NAME (job), job);
 261
 262         job->failed = TRUE;
 263         job->error = g_error_copy (error);
 264
 265         ev_job_emit_finished (job);
 266 }
 267
 268 void
 269 ev_job_succeeded (EvJob *job)
 270 {
 271         if (job->finished)
 272                 return;
 273
 274         ev_debug_message (DEBUG_JOBS, "job %s (%p) succeeded", EV_GET_TYPE_NAME (job), job);
 275
 276         job->failed = FALSE;
 277         ev_job_emit_finished (job);
 278 }
 279
 280 gboolean
 281 ev_job_is_finished (EvJob *job)
 282 {
 283         return job->finished;
 284 }
 285
 286 gboolean
 287 ev_job_is_failed (EvJob *job)
 288 {
 289         return job->failed;
 290 }
 291
 292 EvJobRunMode
 293 ev_job_get_run_mode (EvJob *job)
 294 {
 295         return job->run_mode;
 296 }
 297
 298 void
 299 ev_job_set_run_mode (EvJob       *job,
 300                      EvJobRunMode run_mode)
 301 {
 302         job->run_mode = run_mode;
 303 }
 304
 305 /* EvJobLinks */
 306 static void
 307 ev_job_links_init (EvJobLinks *job)
 308 {
 309         EV_JOB (job)->run_mode = EV_JOB_RUN_THREAD;
 310 }
 311
 312 static void
 313 ev_job_links_dispose (GObject *object)
 314 {
 315         EvJobLinks *job;
 316
 317         ev_debug_message (DEBUG_JOBS, NULL);
 318
 319         job = EV_JOB_LINKS (object);
 320
 321         if (job->model) {
 322                 g_object_unref (job->model);
 323                 job->model = NULL;
 324         }
 325
 326         (* G_OBJECT_CLASS (ev_job_links_parent_class)->dispose) (object);
 327 }
 328
 329 static gboolean
 330 ev_job_links_run (EvJob *job)
 331 {
 332         EvJobLinks *job_links = EV_JOB_LINKS (job);
 333
 334         ev_debug_message (DEBUG_JOBS, NULL);
 335         ev_profiler_start (EV_PROFILE_JOBS, "%s (%p)", EV_GET_TYPE_NAME (job), job);
 336
 337         ev_document_doc_mutex_lock ();
 338         job_links->model = ev_document_links_get_links_model (EV_DOCUMENT_LINKS (job->document));
 339         ev_document_doc_mutex_unlock ();
 340
 341         ev_job_succeeded (job);
 342
 343         return FALSE;
 344 }
 345
 346 static void
 347 ev_job_links_class_init (EvJobLinksClass *class)
 348 {
 349         GObjectClass *oclass = G_OBJECT_CLASS (class);
 350         EvJobClass   *job_class = EV_JOB_CLASS (class);
 351
 352         oclass->dispose = ev_job_links_dispose;
 353         job_class->run = ev_job_links_run;
 354 }
 355
 356 EvJob *
 357 ev_job_links_new (EvDocument *document)
 358 {
 359         EvJob *job;
 360
 361         ev_debug_message (DEBUG_JOBS, NULL);
 362
 363         job = g_object_new (EV_TYPE_JOB_LINKS, NULL);
 364         job->document = g_object_ref (document);
 365
 366         return job;
 367 }
 368
 369 /* EvJobAttachments */
 370 static void
 371 ev_job_attachments_init (EvJobAttachments *job)
 372 {
 373         EV_JOB (job)->run_mode = EV_JOB_RUN_THREAD;
 374 }
 375
 376 static void
 377 ev_job_attachments_dispose (GObject *object)
 378 {
 379         EvJobAttachments *job;
 380
 381         ev_debug_message (DEBUG_JOBS, NULL);
 382
 383         job = EV_JOB_ATTACHMENTS (object);
 384
 385         if (job->attachments) {
 386                 g_list_foreach (job->attachments, (GFunc)g_object_unref, NULL);
 387                 g_list_free (job->attachments);
 388                 job->attachments = NULL;
 389         }
 390
 391         (* G_OBJECT_CLASS (ev_job_attachments_parent_class)->dispose) (object);
 392 }
 393
 394 static gboolean
 395 ev_job_attachments_run (EvJob *job)
 396 {
 397         EvJobAttachments *job_attachments = EV_JOB_ATTACHMENTS (job);
 398
 399         ev_debug_message (DEBUG_JOBS, NULL);
 400         ev_profiler_start (EV_PROFILE_JOBS, "%s (%p)", EV_GET_TYPE_NAME (job), job);
 401
 402         ev_document_doc_mutex_lock ();
 403         job_attachments->attachments = ev_document_get_attachments (job->document);
 404         ev_document_doc_mutex_unlock ();
 405
 406         ev_job_succeeded (job);
 407
 408         return FALSE;
 409 }
 410
 411 static void
 412 ev_job_attachments_class_init (EvJobAttachmentsClass *class)
 413 {
 414         GObjectClass *oclass = G_OBJECT_CLASS (class);
 415         EvJobClass   *job_class = EV_JOB_CLASS (class);
 416
 417         oclass->dispose = ev_job_attachments_dispose;
 418         job_class->run = ev_job_attachments_run;
 419 }
 420
 421 EvJob *
 422 ev_job_attachments_new (EvDocument *document)
 423 {
 424         EvJob *job;
 425
 426         ev_debug_message (DEBUG_JOBS, NULL);
 427
 428         job = g_object_new (EV_TYPE_JOB_ATTACHMENTS, NULL);
 429         job->document = g_object_ref (document);
 430
 431         return job;
 432 }
 433
 434 /* EvJobRender */
 435 static void
 436 ev_job_render_init (EvJobRender *job)
 437 {
 438         EV_JOB (job)->run_mode = EV_JOB_RUN_THREAD;
 439 }
 440
 441 static void
 442 ev_job_render_dispose (GObject *object)
 443 {
 444         EvJobRender *job;
 445
 446         job = EV_JOB_RENDER (object);
 447
 448         if (job->ev_page) {
 449                 ev_debug_message (DEBUG_JOBS, "page: %d (%p)", job->ev_page->index, job);
 450                 g_object_unref (job->ev_page);
 451                 job->ev_page = NULL;
 452         }
 453
 454         if (job->surface) {
 455                 cairo_surface_destroy (job->surface);
 456                 job->surface = NULL;
 457         }
 458
 459         if (job->selection) {
 460                 cairo_surface_destroy (job->selection);
 461                 job->selection = NULL;
 462         }
 463
 464         if (job->selection_region) {
 465                 gdk_region_destroy (job->selection_region);
 466                 job->selection_region = NULL;
 467         }
 468
 469         (* G_OBJECT_CLASS (ev_job_render_parent_class)->dispose) (object);
 470 }
 471
 472 static gboolean
 473 notify_page_ready (EvJobRender *job)
 474 {
 475         ev_debug_message (DEBUG_JOBS, "%d (%p)", job->ev_page->index, job);
 476         ev_profiler_stop (EV_PROFILE_JOBS, "Rendering page %d", job->ev_page->index);
 477
 478         if (EV_JOB (job)->cancelled) {
 479                 ev_debug_message (DEBUG_JOBS, "%s (%p) job was cancelled, do not emit page_ready", EV_GET_TYPE_NAME (job), job);
 480         } else {
 481                 g_signal_emit (job, job_render_signals[PAGE_READY], 0);
 482         }
 483
 484         return FALSE;
 485 }
 486
 487 static void
 488 ev_job_render_page_ready (EvJobRender *job)
 489 {
 490         ev_debug_message (DEBUG_JOBS, "%d (%p)", job->ev_page->index, job);
 491
 492         job->page_ready = TRUE;
 493         g_idle_add_full (G_PRIORITY_HIGH_IDLE,
 494                          (GSourceFunc)notify_page_ready,
 495                          g_object_ref (job),
 496                          (GDestroyNotify)g_object_unref);
 497 }
 498
 499 static gboolean
 500 ev_job_render_run (EvJob *job)
 501 {
 502         EvJobRender     *job_render = EV_JOB_RENDER (job);
 503         EvRenderContext *rc;
 504
 505         ev_debug_message (DEBUG_JOBS, "page: %d (%p)", job_render->page, job);
 506         ev_profiler_start (EV_PROFILE_JOBS, "%s (%p)", EV_GET_TYPE_NAME (job), job);
 507
 508         ev_document_doc_mutex_lock ();
 509
 510         ev_profiler_start (EV_PROFILE_JOBS, "Rendering page %d", job_render->page);
 511
 512         ev_document_fc_mutex_lock ();
 513
 514         job_render->ev_page = ev_document_get_page (job->document, job_render->page);
 515         rc = ev_render_context_new (job_render->ev_page, job_render->rotation, job_render->scale);
 516
 517         job_render->surface = ev_document_render (job->document, rc);
 518         /* If job was cancelled during the page rendering,
 519          * we return now, so that the thread is finished ASAP
 520          */
 521         if (g_cancellable_is_cancelled (job->cancellable)) {
 522                 ev_document_fc_mutex_unlock ();
 523                 ev_document_doc_mutex_unlock ();
 524                 g_object_unref (rc);
 525
 526                 return FALSE;
 527         }
 528
 529         if ((job_render->flags & EV_RENDER_INCLUDE_SELECTION) && EV_IS_SELECTION (job->document)) {
 530                 ev_selection_render_selection (EV_SELECTION (job->document),
 531                                                rc,
 532                                                &(job_render->selection),
 533                                                &(job_render->selection_points),
 534                                                NULL,
 535                                                job_render->selection_style,
 536                                                &(job_render->text), &(job_render->base));
 537                 job_render->selection_region =
 538                         ev_selection_get_selection_region (EV_SELECTION (job->document),
 539                                                            rc,
 540                                                            job_render->selection_style,
 541                                                            &(job_render->selection_points));
 542         }
 543
 544         ev_job_render_page_ready (job_render);
 545
 546         ev_document_fc_mutex_unlock ();
 547
 548         if ((job_render->flags & EV_RENDER_INCLUDE_TEXT) && EV_IS_SELECTION (job->document))
 549                 job_render->text_mapping =
 550                         ev_selection_get_selection_map (EV_SELECTION (job->document), rc);
 551         if ((job_render->flags & EV_RENDER_INCLUDE_LINKS) && EV_IS_DOCUMENT_LINKS (job->document))
 552                 job_render->link_mapping =
 553                         ev_document_links_get_links (EV_DOCUMENT_LINKS (job->document), job_render->page);
 554         if ((job_render->flags & EV_RENDER_INCLUDE_FORMS) && EV_IS_DOCUMENT_FORMS (job->document))
 555                 job_render->form_field_mapping =
 556                         ev_document_forms_get_form_fields (EV_DOCUMENT_FORMS (job->document),
 557                                                            job_render->ev_page);
 558         if ((job_render->flags & EV_RENDER_INCLUDE_IMAGES) && EV_IS_DOCUMENT_IMAGES (job->document))
 559                 job_render->image_mapping =
 560                         ev_document_images_get_image_mapping (EV_DOCUMENT_IMAGES (job->document),
 561                                                               job_render->page);
 562         if ((job_render->flags & EV_RENDER_INCLUDE_ANNOTS) && EV_IS_DOCUMENT_ANNOTATIONS (job->document))
 563                 job_render->annots_mapping =
 564                         ev_document_annotations_get_annotations (EV_DOCUMENT_ANNOTATIONS (job->document),
 565                                                                  job_render->ev_page);
 566         g_object_unref (rc);
 567         ev_document_doc_mutex_unlock ();
 568
 569         ev_job_succeeded (job);
 570
 571         return FALSE;
 572 }
 573
 574 static void
 575 ev_job_render_class_init (EvJobRenderClass *class)
 576 {
 577         GObjectClass *oclass = G_OBJECT_CLASS (class);
 578         EvJobClass   *job_class = EV_JOB_CLASS (class);
 579
 580         job_render_signals [PAGE_READY] =
 581                 g_signal_new ("page-ready",
 582                               EV_TYPE_JOB_RENDER,
 583                               G_SIGNAL_RUN_LAST,
 584                               G_STRUCT_OFFSET (EvJobRenderClass, page_ready),
 585                               NULL, NULL,
 586                               g_cclosure_marshal_VOID__VOID,
 587                               G_TYPE_NONE, 0);
 588
 589         oclass->dispose = ev_job_render_dispose;
 590         job_class->run = ev_job_render_run;
 591 }
 592
 593 EvJob *
 594 ev_job_render_new (EvDocument   *document,
 595                    gint          page,
 596                    gint          rotation,
 597                    gdouble       scale,
 598                    gint          width,
 599                    gint          height,
 600                    EvRenderFlags flags)
 601 {
 602         EvJobRender *job;
 603
 604         ev_debug_message (DEBUG_JOBS, "page: %d", page);
 605
 606         job = g_object_new (EV_TYPE_JOB_RENDER, NULL);
 607
 608         EV_JOB (job)->document = g_object_ref (document);
 609         job->page = page;
 610         job->rotation = rotation;
 611         job->scale = scale;
 612         job->target_width = width;
 613         job->target_height = height;
 614         job->flags = flags;
 615
 616         return EV_JOB (job);
 617 }
 618
 619 void
 620 ev_job_render_set_selection_info (EvJobRender     *job,
 621                                   EvRectangle     *selection_points,
 622                                   EvSelectionStyle selection_style,
 623                                   GdkColor        *text,
 624                                   GdkColor        *base)
 625 {
 626         job->flags |= EV_RENDER_INCLUDE_SELECTION;
 627
 628         job->selection_points = *selection_points;
 629         job->selection_style = selection_style;
 630         job->text = *text;
 631         job->base = *base;
 632 }
 633
 634 /* EvJobThumbnail */
 635 static void
 636 ev_job_thumbnail_init (EvJobThumbnail *job)
 637 {
 638         EV_JOB (job)->run_mode = EV_JOB_RUN_THREAD;
 639 }
 640
 641 static void
 642 ev_job_thumbnail_dispose (GObject *object)
 643 {
 644         EvJobThumbnail *job;
 645
 646         job = EV_JOB_THUMBNAIL (object);
 647
 648         ev_debug_message (DEBUG_JOBS, "%d (%p)", job->page, job);
 649
 650         if (job->thumbnail) {
 651                 g_object_unref (job->thumbnail);
 652                 job->thumbnail = NULL;
 653         }
 654
 655         (* G_OBJECT_CLASS (ev_job_thumbnail_parent_class)->dispose) (object);
 656 }
 657
 658 static gboolean
 659 ev_job_thumbnail_run (EvJob *job)
 660 {
 661         EvJobThumbnail  *job_thumb = EV_JOB_THUMBNAIL (job);
 662         EvRenderContext *rc;
 663         EvPage          *page;
 664
 665         ev_debug_message (DEBUG_JOBS, "%d (%p)", job_thumb->page, job);
 666         ev_profiler_start (EV_PROFILE_JOBS, "%s (%p)", EV_GET_TYPE_NAME (job), job);
 667
 668         ev_document_doc_mutex_lock ();
 669
 670         page = ev_document_get_page (job->document, job_thumb->page);
 671         rc = ev_render_context_new (page, job_thumb->rotation, job_thumb->scale);
 672         g_object_unref (page);
 673
 674         job_thumb->thumbnail = ev_document_thumbnails_get_thumbnail (EV_DOCUMENT_THUMBNAILS (job->document),
 675                                                                      rc, TRUE);
 676         g_object_unref (rc);
 677         ev_document_doc_mutex_unlock ();
 678
 679         ev_job_succeeded (job);
 680
 681         return FALSE;
 682 }
 683
 684 static void
 685 ev_job_thumbnail_class_init (EvJobThumbnailClass *class)
 686 {
 687         GObjectClass *oclass = G_OBJECT_CLASS (class);
 688         EvJobClass   *job_class = EV_JOB_CLASS (class);
 689
 690         oclass->dispose = ev_job_thumbnail_dispose;
 691         job_class->run = ev_job_thumbnail_run;
 692 }
 693
 694 EvJob *
 695 ev_job_thumbnail_new (EvDocument *document,
 696                       gint        page,
 697                       gint        rotation,
 698                       gdouble     scale)
 699 {
 700         EvJobThumbnail *job;
 701
 702         ev_debug_message (DEBUG_JOBS, "%d", page);
 703
 704         job = g_object_new (EV_TYPE_JOB_THUMBNAIL, NULL);
 705
 706         EV_JOB (job)->document = g_object_ref (document);
 707         job->page = page;
 708         job->rotation = rotation;
 709         job->scale = scale;
 710
 711         return EV_JOB (job);
 712 }
 713
 714 /* EvJobFonts */
 715 static void
 716 ev_job_fonts_init (EvJobFonts *job)
 717 {
 718         EV_JOB (job)->run_mode = EV_JOB_RUN_MAIN_LOOP;
 719 }
 720
 721 static gboolean
 722 ev_job_fonts_run (EvJob *job)
 723 {
 724         EvJobFonts      *job_fonts = EV_JOB_FONTS (job);
 725         EvDocumentFonts *fonts = EV_DOCUMENT_FONTS (job->document);
 726
 727         ev_debug_message (DEBUG_JOBS, NULL);
 728
 729         /* Do not block the main loop */
 730         if (!ev_document_doc_mutex_trylock ())
 731                 return TRUE;
 732
 733         if (!ev_document_fc_mutex_trylock ())
 734                 return TRUE;
 735
 736 #ifdef EV_ENABLE_DEBUG
 737         /* We use the #ifdef in this case because of the if */
 738         if (ev_document_fonts_get_progress (fonts) == 0)
 739                 ev_profiler_start (EV_PROFILE_JOBS, "%s (%p)", EV_GET_TYPE_NAME (job), job);
 740 #endif
 741
 742         job_fonts->scan_completed = !ev_document_fonts_scan (fonts, 20);
 743         g_signal_emit (job_fonts, job_fonts_signals[FONTS_UPDATED], 0,
 744                        ev_document_fonts_get_progress (fonts));
 745
 746         ev_document_fc_mutex_unlock ();
 747         ev_document_doc_mutex_unlock ();
 748
 749         if (job_fonts->scan_completed)
 750                 ev_job_succeeded (job);
 751
 752         return !job_fonts->scan_completed;
 753 }
 754
 755 static void
 756 ev_job_fonts_class_init (EvJobFontsClass *class)
 757 {
 758         EvJobClass *job_class = EV_JOB_CLASS (class);
 759
 760         job_class->run = ev_job_fonts_run;
 761
 762         job_fonts_signals[FONTS_UPDATED] =
 763                 g_signal_new ("updated",
 764                               EV_TYPE_JOB_FONTS,
 765                               G_SIGNAL_RUN_LAST,
 766                               G_STRUCT_OFFSET (EvJobFontsClass, updated),
 767                               NULL, NULL,
 768                               g_cclosure_marshal_VOID__DOUBLE,
 769                               G_TYPE_NONE,
 770                               1, G_TYPE_DOUBLE);
 771 }
 772
 773 EvJob *
 774 ev_job_fonts_new (EvDocument *document)
 775 {
 776         EvJobFonts *job;
 777
 778         ev_debug_message (DEBUG_JOBS, NULL);
 779
 780         job = g_object_new (EV_TYPE_JOB_FONTS, NULL);
 781
 782         EV_JOB (job)->document = g_object_ref (document);
 783
 784         return EV_JOB (job);
 785 }
 786
 787 /* EvJobLoad */
 788 static void
 789 ev_job_load_init (EvJobLoad *job)
 790 {
 791         EV_JOB (job)->run_mode = EV_JOB_RUN_THREAD;
 792 }
 793
 794 static void
 795 ev_job_load_dispose (GObject *object)
 796 {
 797         EvJobLoad *job = EV_JOB_LOAD (object);
 798
 799         ev_debug_message (DEBUG_JOBS, "%s", job->uri);
 800
 801         if (job->uri) {
 802                 g_free (job->uri);
 803                 job->uri = NULL;
 804         }
 805
 806         if (job->password) {
 807                 g_free (job->password);
 808                 job->password = NULL;
 809         }
 810
 811         (* G_OBJECT_CLASS (ev_job_load_parent_class)->dispose) (object);
 812 }
 813
 814 static gboolean
 815 ev_job_load_run (EvJob *job)
 816 {
 817         EvJobLoad *job_load = EV_JOB_LOAD (job);
 818         GError    *error = NULL;
 819
 820         ev_debug_message (DEBUG_JOBS, "%s", job_load->uri);
 821         ev_profiler_start (EV_PROFILE_JOBS, "%s (%p)", EV_GET_TYPE_NAME (job), job);
 822
 823         ev_document_fc_mutex_lock ();
 824
 825         /* This job may already have a document even if the job didn't complete
 826            because, e.g., a password is required - if so, just reload rather than
 827            creating a new instance */
 828         if (job->document) {
 829                 if (job_load->password) {
 830                         ev_document_security_set_password (EV_DOCUMENT_SECURITY (job->document),
 831                                                            job_load->password);
 832                 }
 833
 834                 job->failed = FALSE;
 835                 job->finished = FALSE;
 836                 g_clear_error (&job->error);
 837
 838                 ev_document_load (job->document,
 839                                   job_load->uri,
 840                                   &error);
 841         } else {
 842                 job->document = ev_document_factory_get_document (job_load->uri,
 843                                                                   &error);
 844         }
 845
 846         ev_document_fc_mutex_unlock ();
 847
 848         if (error) {
 849                 ev_job_failed_from_error (job, error);
 850                 g_error_free (error);
 851         } else {
 852                 ev_job_succeeded (job);
 853         }
 854
 855         return FALSE;
 856 }
 857
 858 static void
 859 ev_job_load_class_init (EvJobLoadClass *class)
 860 {
 861         GObjectClass *oclass = G_OBJECT_CLASS (class);
 862         EvJobClass   *job_class = EV_JOB_CLASS (class);
 863
 864         oclass->dispose = ev_job_load_dispose;
 865         job_class->run = ev_job_load_run;
 866 }
 867
 868 EvJob *
 869 ev_job_load_new (const gchar *uri)
 870 {
 871         EvJobLoad *job;
 872
 873         ev_debug_message (DEBUG_JOBS, "%s", uri);
 874
 875         job = g_object_new (EV_TYPE_JOB_LOAD, NULL);
 876         job->uri = g_strdup (uri);
 877
 878         return EV_JOB (job);
 879 }
 880
 881 void
 882 ev_job_load_set_uri (EvJobLoad *job, const gchar *uri)
 883 {
 884         ev_debug_message (DEBUG_JOBS, "%s", uri);
 885
 886         if (job->uri)
 887                 g_free (job->uri);
 888         job->uri = g_strdup (uri);
 889 }
 890
 891 void
 892 ev_job_load_set_password (EvJobLoad *job, const gchar *password)
 893 {
 894         ev_debug_message (DEBUG_JOBS, NULL);
 895
 896         if (job->password)
 897                 g_free (job->password);
 898         job->password = password ? g_strdup (password) : NULL;
 899 }
 900
 901 /* EvJobSave */
 902 static void
 903 ev_job_save_init (EvJobSave *job)
 904 {
 905         EV_JOB (job)->run_mode = EV_JOB_RUN_THREAD;
 906 }
 907
 908 static void
 909 ev_job_save_dispose (GObject *object)
 910 {
 911         EvJobSave *job = EV_JOB_SAVE (object);
 912
 913         ev_debug_message (DEBUG_JOBS, "%s", job->uri);
 914
 915         if (job->uri) {
 916                 g_free (job->uri);
 917                 job->uri = NULL;
 918         }
 919
 920         if (job->document_uri) {
 921                 g_free (job->document_uri);
 922                 job->document_uri = NULL;
 923         }
 924
 925         (* G_OBJECT_CLASS (ev_job_save_parent_class)->dispose) (object);
 926 }
 927
 928 static gboolean
 929 ev_job_save_run (EvJob *job)
 930 {
 931         EvJobSave *job_save = EV_JOB_SAVE (job);
 932         gint       fd;
 933         gchar     *filename;
 934         gchar     *tmp_filename;
 935         gchar     *local_uri;
 936         GError    *error = NULL;
 937
 938         ev_debug_message (DEBUG_JOBS, "uri: %s, document_uri: %s", job_save->uri, job_save->document_uri);
 939         ev_profiler_start (EV_PROFILE_JOBS, "%s (%p)", EV_GET_TYPE_NAME (job), job);
 940
 941         filename = ev_tmp_filename ("saveacopy");
 942         tmp_filename = g_strdup_printf ("%s.XXXXXX", filename);
 943         g_free (filename);
 944
 945         fd = g_mkstemp (tmp_filename);
 946         if (fd == -1) {
 947                 gchar *display_name;
 948                 gint   save_errno = errno;
 949
 950                 display_name = g_filename_display_name (tmp_filename);
 951                 ev_job_failed (job,
 952                                G_FILE_ERROR,
 953                                g_file_error_from_errno (save_errno),
 954                                _("Failed to create file “%s”: %s"),
 955                                display_name, g_strerror (save_errno));
 956                 g_free (display_name);
 957                 g_free (tmp_filename);
 958
 959                 return FALSE;
 960         }
 961
 962         ev_document_doc_mutex_lock ();
 963
 964         /* Save document to temp filename */
 965         local_uri = g_filename_to_uri (tmp_filename, NULL, NULL);
 966         ev_document_save (job->document, local_uri, &error);
 967         close (fd);
 968
 969         ev_document_doc_mutex_unlock ();
 970
 971         if (error) {
 972                 g_free (local_uri);
 973                 ev_job_failed_from_error (job, error);
 974                 g_error_free (error);
 975
 976                 return FALSE;
 977         }
 978
 979         /* If original document was compressed,
 980          * compress it again before saving
 981          */
 982         if (g_object_get_data (G_OBJECT (job->document), "uri-uncompressed")) {
 983                 EvCompressionType ctype = EV_COMPRESSION_NONE;
 984                 const gchar      *ext;
 985                 gchar            *uri_comp;
 986
 987                 ext = g_strrstr (job_save->document_uri, ".gz");
 988                 if (ext && g_ascii_strcasecmp (ext, ".gz") == 0)
 989                         ctype = EV_COMPRESSION_GZIP;
 990
 991                 ext = g_strrstr (job_save->document_uri, ".bz2");
 992                 if (ext && g_ascii_strcasecmp (ext, ".bz2") == 0)
 993                         ctype = EV_COMPRESSION_BZIP2;
 994
 995                 uri_comp = ev_file_compress (local_uri, ctype, &error);
 996                 g_free (local_uri);
 997                 ev_tmp_filename_unlink (tmp_filename);
 998
 999                 if (!uri_comp || error) {
1000                         local_uri = NULL;
1001                 } else {
1002                         local_uri = uri_comp;
1003                 }
1004         }
1005
1006         g_free (tmp_filename);
1007
1008         if (error) {
1009                 g_free (local_uri);
1010                 ev_job_failed_from_error (job, error);
1011                 g_error_free (error);
1012
1013                 return FALSE;
1014         }
1015
1016         if (!local_uri)
1017                 return FALSE;
1018
1019         ev_xfer_uri_simple (local_uri, job_save->uri, &error);
1020         ev_tmp_uri_unlink (local_uri);
1021
1022         if (error) {
1023                 ev_job_failed_from_error (job, error);
1024                 g_error_free (error);
1025         } else {
1026                 ev_job_succeeded (job);
1027         }
1028
1029         return FALSE;
1030 }
1031
1032 static void
1033 ev_job_save_class_init (EvJobSaveClass *class)
1034 {
1035         GObjectClass *oclass = G_OBJECT_CLASS (class);
1036         EvJobClass   *job_class = EV_JOB_CLASS (class);
1037
1038         oclass->dispose = ev_job_save_dispose;
1039         job_class->run = ev_job_save_run;
1040 }
1041
1042 EvJob *
1043 ev_job_save_new (EvDocument  *document,
1044                  const gchar *uri,
1045                  const gchar *document_uri)
1046 {
1047         EvJobSave *job;
1048
1049         ev_debug_message (DEBUG_JOBS, "uri: %s, document_uri: %s", uri, document_uri);
1050
1051         job = g_object_new (EV_TYPE_JOB_SAVE, NULL);
1052
1053         EV_JOB (job)->document = g_object_ref (document);
1054         job->uri = g_strdup (uri);
1055         job->document_uri = g_strdup (document_uri);
1056
1057         return EV_JOB (job);
1058 }
1059
1060 /* EvJobFind */
1061 static void
1062 ev_job_find_init (EvJobFind *job)
1063 {
1064         EV_JOB (job)->run_mode = EV_JOB_RUN_MAIN_LOOP;
1065 }
1066
1067 static void
1068 ev_job_find_dispose (GObject *object)
1069 {
1070         EvJobFind *job = EV_JOB_FIND (object);
1071
1072         ev_debug_message (DEBUG_JOBS, NULL);
1073
1074         if (job->text) {
1075                 g_free (job->text);
1076                 job->text = NULL;
1077         }
1078
1079         if (job->pages) {
1080                 gint i;
1081
1082                 for (i = 0; i < job->n_pages; i++) {
1083                         g_list_foreach (job->pages[i], (GFunc)g_free, NULL);
1084                         g_list_free (job->pages[i]);
1085                 }
1086
1087                 g_free (job->pages);
1088                 job->pages = NULL;
1089         }
1090
1091         (* G_OBJECT_CLASS (ev_job_find_parent_class)->dispose) (object);
1092 }
1093
1094 static gboolean
1095 ev_job_find_run (EvJob *job)
1096 {
1097         EvJobFind      *job_find = EV_JOB_FIND (job);
1098         EvDocumentFind *find = EV_DOCUMENT_FIND (job->document);
1099         EvPage         *ev_page;
1100         GList          *matches;
1101
1102         ev_debug_message (DEBUG_JOBS, NULL);
1103
1104         /* Do not block the main loop */
1105         if (!ev_document_doc_mutex_trylock ())
1106                 return TRUE;
1107
1108 #ifdef EV_ENABLE_DEBUG
1109         /* We use the #ifdef in this case because of the if */
1110         if (job_find->current_page == job_find->start_page)
1111                 ev_profiler_start (EV_PROFILE_JOBS, "%s (%p)", EV_GET_TYPE_NAME (job), job);
1112 #endif
1113
1114         ev_page = ev_document_get_page (job->document, job_find->current_page);
1115         matches = ev_document_find_find_text (find, ev_page, job_find->text,
1116                                               job_find->case_sensitive);
1117         g_object_unref (ev_page);
1118
1119         ev_document_doc_mutex_unlock ();
1120
1121         if (!job_find->has_results)
1122                 job_find->has_results = (matches != NULL);
1123
1124         job_find->pages[job_find->current_page] = matches;
1125         g_signal_emit (job_find, job_find_signals[FIND_UPDATED], 0, job_find->current_page);
1126
1127         job_find->current_page = (job_find->current_page + 1) % job_find->n_pages;
1128         if (job_find->current_page == job_find->start_page) {
1129                 ev_job_succeeded (job);
1130
1131                 return FALSE;
1132         }
1133
1134         return TRUE;
1135 }
1136
1137 static void
1138 ev_job_find_class_init (EvJobFindClass *class)
1139 {
1140         EvJobClass   *job_class = EV_JOB_CLASS (class);
1141         GObjectClass *gobject_class = G_OBJECT_CLASS (class);
1142
1143         job_class->run = ev_job_find_run;
1144         gobject_class->dispose = ev_job_find_dispose;
1145
1146         job_find_signals[FIND_UPDATED] =
1147                 g_signal_new ("updated",
1148                               EV_TYPE_JOB_FIND,
1149                               G_SIGNAL_RUN_LAST,
1150                               G_STRUCT_OFFSET (EvJobFindClass, updated),
1151                               NULL, NULL,
1152                               g_cclosure_marshal_VOID__INT,
1153                               G_TYPE_NONE,
1154                               1, G_TYPE_INT);
1155 }
1156
1157 EvJob *
1158 ev_job_find_new (EvDocument  *document,
1159                  gint         start_page,
1160                  gint         n_pages,
1161                  const gchar *text,
1162                  gboolean     case_sensitive)
1163 {
1164         EvJobFind *job;
1165
1166         ev_debug_message (DEBUG_JOBS, NULL);
1167
1168         job = g_object_new (EV_TYPE_JOB_FIND, NULL);
1169
1170         EV_JOB (job)->document = g_object_ref (document);
1171         job->start_page = start_page;
1172         job->current_page = start_page;
1173         job->n_pages = n_pages;
1174         job->pages = g_new0 (GList *, n_pages);
1175         job->text = g_strdup (text);
1176         job->case_sensitive = case_sensitive;
1177         job->has_results = FALSE;
1178
1179         return EV_JOB (job);
1180 }
1181
1182 gint
1183 ev_job_find_get_n_results (EvJobFind *job,
1184                            gint       page)
1185 {
1186         return g_list_length (job->pages[page]);
1187 }
1188
1189 gdouble
1190 ev_job_find_get_progress (EvJobFind *job)
1191 {
1192         gint pages_done;
1193
1194         if (ev_job_is_finished (EV_JOB (job)))
1195                 return 1.0;
1196
1197         if (job->current_page > job->start_page) {
1198                 pages_done = job->current_page - job->start_page + 1;
1199         } else if (job->current_page == job->start_page) {
1200                 pages_done = job->n_pages;
1201         } else {
1202                 pages_done = job->n_pages - job->start_page + job->current_page;
1203         }
1204
1205         return pages_done / (gdouble) job->n_pages;
1206 }
1207
1208 gboolean
1209 ev_job_find_has_results (EvJobFind *job)
1210 {
1211         return job->has_results;
1212 }
1213
1214 GList **
1215 ev_job_find_get_results (EvJobFind *job)
1216 {
1217         return job->pages;
1218 }
1219
1220 /* EvJobLayers */
1221 static void
1222 ev_job_layers_init (EvJobLayers *job)
1223 {
1224         EV_JOB (job)->run_mode = EV_JOB_RUN_THREAD;
1225 }
1226
1227 static void
1228 ev_job_layers_dispose (GObject *object)
1229 {
1230         EvJobLayers *job;
1231
1232         ev_debug_message (DEBUG_JOBS, NULL);
1233
1234         job = EV_JOB_LAYERS (object);
1235
1236         if (job->model) {
1237                 g_object_unref (job->model);
1238                 job->model = NULL;
1239         }
1240
1241         (* G_OBJECT_CLASS (ev_job_layers_parent_class)->dispose) (object);
1242 }
1243
1244 static gboolean
1245 ev_job_layers_run (EvJob *job)
1246 {
1247         EvJobLayers *job_layers = EV_JOB_LAYERS (job);
1248
1249         ev_debug_message (DEBUG_JOBS, NULL);
1250         ev_profiler_start (EV_PROFILE_JOBS, "%s (%p)", EV_GET_TYPE_NAME (job), job);
1251
1252         ev_document_doc_mutex_lock ();
1253         job_layers->model = ev_document_layers_get_layers (EV_DOCUMENT_LAYERS (job->document));
1254         ev_document_doc_mutex_unlock ();
1255
1256         ev_job_succeeded (job);
1257
1258         return FALSE;
1259 }
1260
1261 static void
1262 ev_job_layers_class_init (EvJobLayersClass *class)
1263 {
1264         GObjectClass *oclass = G_OBJECT_CLASS (class);
1265         EvJobClass   *job_class = EV_JOB_CLASS (class);
1266
1267         oclass->dispose = ev_job_layers_dispose;
1268         job_class->run = ev_job_layers_run;
1269 }
1270
1271 EvJob *
1272 ev_job_layers_new (EvDocument *document)
1273 {
1274         EvJob *job;
1275
1276         ev_debug_message (DEBUG_JOBS, NULL);
1277
1278         job = g_object_new (EV_TYPE_JOB_LAYERS, NULL);
1279         job->document = g_object_ref (document);
1280
1281         return job;
1282 }
1283
1284 /* EvJobExport */
1285 static void
1286 ev_job_export_init (EvJobExport *job)
1287 {
1288         EV_JOB (job)->run_mode = EV_JOB_RUN_THREAD;
1289         job->page = -1;
1290 }
1291
1292 static void
1293 ev_job_export_dispose (GObject *object)
1294 {
1295         EvJobExport *job;
1296
1297         ev_debug_message (DEBUG_JOBS, NULL);
1298
1299         job = EV_JOB_EXPORT (object);
1300
1301         if (job->rc) {
1302                 g_object_unref (job->rc);
1303                 job->rc = NULL;
1304         }
1305
1306         (* G_OBJECT_CLASS (ev_job_export_parent_class)->dispose) (object);
1307 }
1308
1309 static gboolean
1310 ev_job_export_run (EvJob *job)
1311 {
1312         EvJobExport *job_export = EV_JOB_EXPORT (job);
1313         EvPage      *ev_page;
1314
1315         g_assert (job_export->page != -1);
1316
1317         ev_debug_message (DEBUG_JOBS, NULL);
1318         ev_profiler_start (EV_PROFILE_JOBS, "%s (%p)", EV_GET_TYPE_NAME (job), job);
1319
1320         ev_document_doc_mutex_lock ();
1321
1322         ev_page = ev_document_get_page (job->document, job_export->page);
1323         if (job_export->rc) {
1324                 job->failed = FALSE;
1325                 job->finished = FALSE;
1326                 g_clear_error (&job->error);
1327
1328                 ev_render_context_set_page (job_export->rc, ev_page);
1329         } else {
1330                 job_export->rc = ev_render_context_new (ev_page, 0, 1.0);
1331         }
1332         g_object_unref (ev_page);
1333
1334         ev_file_exporter_do_page (EV_FILE_EXPORTER (job->document), job_export->rc);
1335
1336         ev_document_doc_mutex_unlock ();
1337
1338         ev_job_succeeded (job);
1339
1340         return FALSE;
1341 }
1342
1343 static void
1344 ev_job_export_class_init (EvJobExportClass *class)
1345 {
1346         GObjectClass *oclass = G_OBJECT_CLASS (class);
1347         EvJobClass   *job_class = EV_JOB_CLASS (class);
1348
1349         oclass->dispose = ev_job_export_dispose;
1350         job_class->run = ev_job_export_run;
1351 }
1352
1353 EvJob *
1354 ev_job_export_new (EvDocument *document)
1355 {
1356         EvJob *job;
1357
1358         ev_debug_message (DEBUG_JOBS, NULL);
1359
1360         job = g_object_new (EV_TYPE_JOB_EXPORT, NULL);
1361         job->document = g_object_ref (document);
1362
1363         return job;
1364 }
1365
1366 void
1367 ev_job_export_set_page (EvJobExport *job,
1368                         gint         page)
1369 {
1370         job->page = page;
1371 }