← Back to branch summary

~ubuntu-branches/ubuntu/oneiric/evince/oneiric-updates

« back to all changes in this revision

Viewing changes to backend/pdf/ev-poppler.cc

  • Committer: Bazaar Package Importer
  • Author(s): Josselin Mouette, Josselin Mouette, Marc 'HE' Brockschmidt
  • Date: 2008-12-31 16:41:58 UTC
  • mfrom: (1.1.36 upstream)
  • mto: (1.5.1 sid)
  • mto: This revision was merged to the branch mainline in revision 109.
  • Revision ID: james.westby@ubuntu.com-20081231164158-xnobl1sokvvc6ho8
Tags: 2.24.2-1
http://bugs.debian.org/506836
[ Josselin Mouette ]
* README.Debian: document that you need to install poppler-data.
  Closes: #506836.

[ Marc 'HE' Brockschmidt ]
* debian/control: Make the Gnome team maintainer. I'm not doing the job
   anyway.

[ Josselin Mouette ]
* New upstream release.
* Require nautilus 2.22 to build the extension for the correct 
  version.

Show diffs side-by-side

added added

removed removed

Lines of Context:
backend/pdf/ev-poppler.cc
49
49
#include "ev-attachment.h"
50
50
#include "ev-image.h"
51
51
 
52
 
#if (defined (HAVE_POPPLER_PAGE_RENDER) || defined (HAVE_POPPLER_PAGE_RENDER_FOR_PRINTING)) && (defined (HAVE_CAIRO_PDF) || defined (HAVE_CAIRO_PS))
 
52
#if (defined (HAVE_POPPLER_PAGE_RENDER)) && (defined (HAVE_CAIRO_PDF) || defined (HAVE_CAIRO_PS))
53
53
#define HAVE_CAIRO_PRINT
54
54
#endif
55
55
 
56
 
#if POPPLER_MAJOR_VERSION <= 6 || (POPPLER_MAJOR_VERSION == 7 && POPPLER_MINOR_VERSION < 2)
57
 
#define POPPLER_HAS_GDK
58
 
#else
59
 
#ifdef POPPLER_WITH_GDK
60
 
#define POPPLER_HAS_GDK
61
 
#endif
62
 
#endif
63
 
 
64
56
typedef struct {
65
57
        PdfDocument *document;
66
58
        char *text;
157
149
                         });
158
150
 
159
151
static void
160
 
set_rc_data (PdfDocument     *pdf_document,
161
 
             EvRenderContext *rc)
162
 
{
163
 
        if (rc->data == NULL) {
164
 
                rc->data = poppler_document_get_page (pdf_document->document,
165
 
                                                      rc->page);
166
 
                rc->destroy = g_object_unref;
167
 
        } else {
168
 
                g_assert (rc->page == poppler_page_get_index (POPPLER_PAGE (rc->data)));
169
 
        }
170
 
}
171
 
 
172
 
static void
173
152
pdf_document_search_free (PdfDocumentSearch   *search)
174
153
{
175
154
        PdfDocument *pdf_document = search->document;
304
283
        return poppler_document_get_n_pages (PDF_DOCUMENT (document)->document);
305
284
}
306
285
 
307
 
static void
308
 
pdf_document_get_page_size (EvDocument   *document,
309
 
                            int           page,
310
 
                            double       *width,
311
 
                            double       *height)
 
286
static EvPage *
 
287
pdf_document_get_page (EvDocument *document,
 
288
                       gint        index)
312
289
{
313
290
        PdfDocument *pdf_document = PDF_DOCUMENT (document);
314
291
        PopplerPage *poppler_page;
 
292
        EvPage      *page;
315
293
 
316
 
        poppler_page = poppler_document_get_page (pdf_document->document, page);
317
 
        poppler_page_get_size (poppler_page, width, height);
 
294
        poppler_page = poppler_document_get_page (pdf_document->document, index);
 
295
        page = ev_page_new (index);
 
296
        page->backend_page = (EvBackendPage)g_object_ref (poppler_page);
 
297
        page->backend_destroy_func = (EvBackendPageDestroyFunc)g_object_unref;
318
298
        g_object_unref (poppler_page);
 
299
 
 
300
        return page;
 
301
}
 
302
 
 
303
static void
 
304
pdf_document_get_page_size (EvDocument *document,
 
305
                            EvPage     *page,
 
306
                            double     *width,
 
307
                            double     *height)
 
308
{
 
309
        g_return_if_fail (POPPLER_IS_PAGE (page->backend_page));
 
310
        
 
311
        poppler_page_get_size (POPPLER_PAGE (page->backend_page), width, height);
319
312
}
320
313
 
321
314
static char *
322
315
pdf_document_get_page_label (EvDocument *document,
323
 
                             int         page)
 
316
                             EvPage     *page)
324
317
{
325
 
        PopplerPage *poppler_page;
326
318
        char *label = NULL;
327
319
 
328
 
        poppler_page = poppler_document_get_page (PDF_DOCUMENT (document)->document,
329
 
                                                  page);
 
320
        g_return_val_if_fail (POPPLER_IS_PAGE (page->backend_page), NULL);
330
321
 
331
 
        g_object_get (G_OBJECT (poppler_page),
 
322
        g_object_get (G_OBJECT (page->backend_page),
332
323
                      "label", &label,
333
324
                      NULL);
334
 
        g_object_unref (poppler_page);
335
 
 
336
325
        return label;
337
326
}
338
327
 
512
501
                     EvRenderContext *rc)
513
502
{
514
503
        PdfDocument *pdf_document;
 
504
        PopplerPage *poppler_page;
515
505
        double width_points, height_points;
516
506
        gint width, height;
517
507
 
518
 
        pdf_document = PDF_DOCUMENT (document);
519
 
 
520
 
        set_rc_data (pdf_document, rc);
521
 
 
522
 
        poppler_page_get_size (POPPLER_PAGE (rc->data),
 
508
        poppler_page = POPPLER_PAGE (rc->page->backend_page);
 
509
 
 
510
        poppler_page_get_size (poppler_page,
523
511
                               &width_points, &height_points);
524
512
        
525
513
        if (rc->rotation == 90 || rc->rotation == 270) {
530
518
                height = (int) ((height_points * rc->scale) + 0.5);
531
519
        }
532
520
        
533
 
        return pdf_page_render (POPPLER_PAGE (rc->data),
 
521
        return pdf_page_render (poppler_page,
534
522
                                width, height, rc);
535
523
}
536
524
 
563
551
        PopplerPageMode mode;
564
552
        PopplerViewerPreferences view_prefs;
565
553
        PopplerPermissions permissions;
 
554
        EvPage *page;
566
555
 
567
556
        info = g_new0 (EvDocumentInfo, 1);
568
557
 
601
590
                      "linearized", &(info->linearized),
602
591
                      NULL);
603
592
 
604
 
        pdf_document_get_page_size(document, 0,
605
 
                                   &(info->paper_width),
606
 
                                   &(info->paper_height));
607
 
 
608
 
        // Convert to mm.
609
 
        info->paper_width = info->paper_width / 72.0f * 25.4f;
610
 
        info->paper_height = info->paper_height / 72.0f * 25.4f;
 
593
        info->n_pages = ev_document_get_n_pages (document);
 
594
 
 
595
        if (info->n_pages > 0) {
 
596
                page = ev_document_get_page (document, 0);
 
597
                ev_document_get_page_size (document, page,
 
598
                                           &(info->paper_width),
 
599
                                           &(info->paper_height));
 
600
                g_object_unref (page);
 
601
                
 
602
 
 
603
                // Convert to mm.
 
604
                info->paper_width = info->paper_width / 72.0f * 25.4f;
 
605
                info->paper_height = info->paper_height / 72.0f * 25.4f;
 
606
        }
611
607
 
612
608
        switch (layout) {
613
609
                case POPPLER_PAGE_LAYOUT_SINGLE_PAGE:
687
683
                info->permissions |= EV_DOCUMENT_PERMISSIONS_OK_TO_ADD_NOTES;
688
684
        }
689
685
 
690
 
        info->n_pages = ev_document_get_n_pages (document);
691
 
 
692
686
        if (ev_document_security_has_document_security (EV_DOCUMENT_SECURITY (document))) {
693
687
                /* translators: this is the document security state */
694
688
                info->security = g_strdup (_("Yes"));
706
700
        iface->save = pdf_document_save;
707
701
        iface->load = pdf_document_load;
708
702
        iface->get_n_pages = pdf_document_get_n_pages;
 
703
        iface->get_page = pdf_document_get_page;
709
704
        iface->get_page_size = pdf_document_get_page_size;
710
705
        iface->get_page_label = pdf_document_get_page_label;
711
706
        iface->has_attachments = pdf_document_has_attachments;
960
955
        const char   *unimplemented_action = NULL;
961
956
 
962
957
        switch (action->type) {
 
958
                case POPPLER_ACTION_NONE:
 
959
                        break;
963
960
                case POPPLER_ACTION_GOTO_DEST: {
964
961
                        EvLinkDest *dest;
965
962
                        
1197
1194
                image_mapping = (PopplerImageMapping *)list->data;
1198
1195
 
1199
1196
                ev_image_mapping = g_new (EvImageMapping, 1);
1200
 
#ifdef HAVE_POPPLER_PAGE_GET_IMAGE
 
1197
                
1201
1198
                ev_image_mapping->image = ev_image_new (page, image_mapping->image_id);
1202
 
#elif POPPLER_HAS_CAIRO
1203
 
                ev_image_mapping->image = ev_image_new_from_pixbuf (image_mapping->image);
1204
 
#endif
1205
1199
                ev_image_mapping->x1 = image_mapping->area.x1;
1206
1200
                ev_image_mapping->x2 = image_mapping->area.x2;
1207
1201
                ev_image_mapping->y1 = image_mapping->area.y1;
1220
1214
pdf_document_images_get_image (EvDocumentImages *document_images,
1221
1215
                               EvImage          *image)
1222
1216
{
1223
 
#ifdef HAVE_POPPLER_PAGE_GET_IMAGE
1224
1217
        PdfDocument     *pdf_document;
1225
1218
        PopplerPage     *poppler_page;
1226
1219
        cairo_surface_t *surface;
1239
1232
        g_object_unref (poppler_page);
1240
1233
 
1241
1234
        return retval;
1242
 
#else
1243
 
        return GDK_PIXBUF (g_object_ref (ev_image_get_pixbuf (image)));
1244
 
#endif /* HAVE_POPPLER_PAGE_GET_IMAGE */
1245
1235
}
1246
1236
 
1247
1237
static void
1261
1251
 
1262
1252
        pdf_document_thumbnails_get_dimensions (EV_DOCUMENT_THUMBNAILS (pdf_document),
1263
1253
                                                rc, &width, &height);
1264
 
#ifdef POPPLER_HAS_GDK
 
1254
#ifdef POPPLER_WITH_GDK
1265
1255
        pixbuf = gdk_pixbuf_new (GDK_COLORSPACE_RGB, FALSE, 8,
1266
1256
                                 width, height);
1267
1257
        gdk_pixbuf_fill (pixbuf, 0xffffffff);
1280
1270
        
1281
1271
        pixbuf = ev_document_misc_pixbuf_from_surface (surface);
1282
1272
        cairo_surface_destroy (surface);
1283
 
#endif /* POPPLER_HAS_GDK */
 
1273
#endif /* POPPLER_WITH_GDK */
1284
1274
 
1285
1275
        return pixbuf;
1286
1276
}
1290
1280
                                       EvRenderContext      *rc, 
1291
1281
                                       gboolean              border)
1292
1282
{
1293
 
        PdfDocument *pdf_document;
 
1283
        PdfDocument *pdf_document = PDF_DOCUMENT (document_thumbnails);
1294
1284
        PopplerPage *poppler_page;
1295
1285
        GdkPixbuf *pixbuf = NULL;
1296
1286
        GdkPixbuf *border_pixbuf;
1297
1287
 
1298
 
        pdf_document = PDF_DOCUMENT (document_thumbnails);
1299
 
 
1300
 
        poppler_page = poppler_document_get_page (pdf_document->document, rc->page);
1301
 
        g_return_val_if_fail (poppler_page != NULL, NULL);
1302
 
 
1303
 
#if POPPLER_MAJOR_VERSION <= 6 || (POPPLER_MAJOR_VERSION == 7 && POPPLER_MINOR_VERSION < 2)
1304
 
        pixbuf = poppler_page_get_thumbnail (poppler_page);
1305
 
#else
1306
 
#ifdef POPPLER_HAS_GDK
 
1288
        poppler_page = POPPLER_PAGE (rc->page->backend_page);
 
1289
 
 
1290
#ifdef POPPLER_WITH_GDK
1307
1291
        pixbuf = poppler_page_get_thumbnail_pixbuf (poppler_page);
1308
1292
#else
1309
1293
        cairo_surface_t *surface;
1313
1297
                pixbuf = ev_document_misc_pixbuf_from_surface (surface);
1314
1298
                cairo_surface_destroy (surface);
1315
1299
        }
1316
 
#endif
1317
 
#endif
1318
 
                
 
1300
#endif /* POPPLER_WITH_GDK */
 
1301
 
1319
1302
        if (pixbuf) {
1320
1303
                /* Rotate provided thumbnail if needed */
1321
1304
                GdkPixbuf *rotated_pixbuf;
1335
1318
                pixbuf = border_pixbuf;
1336
1319
        }               
1337
1320
 
1338
 
        g_object_unref (poppler_page);
1339
 
        
1340
1321
        return pixbuf;
1341
1322
}
1342
1323
 
1346
1327
                                        gint                 *width,
1347
1328
                                        gint                 *height)
1348
1329
{
1349
 
        PdfDocument *pdf_document;
1350
1330
        PopplerPage *poppler_page;
1351
1331
        gint has_thumb;
1352
1332
        
1353
 
        pdf_document = PDF_DOCUMENT (document_thumbnails);
1354
 
        poppler_page = poppler_document_get_page (pdf_document->document, rc->page);
1355
 
 
1356
 
        g_return_if_fail (poppler_page != NULL);
 
1333
        poppler_page = POPPLER_PAGE (rc->page->backend_page);
1357
1334
 
1358
1335
        has_thumb = poppler_page_get_thumbnail_size (poppler_page, width, height);
1359
1336
 
1360
 
        if (!has_thumb) {
 
1337
        if (!has_thumb || *width <= 0 || *height <= 0) {
1361
1338
                double page_width, page_height;
1362
1339
 
1363
1340
                poppler_page_get_size (poppler_page, &page_width, &page_height);
1373
1350
                *width = *height;
1374
1351
                *height = temp;
1375
1352
        }
1376
 
        
1377
 
        g_object_unref (poppler_page);
1378
1353
}
1379
1354
 
1380
1355
static void
1385
1360
}
1386
1361
 
1387
1362
 
1388
 
static gboolean
1389
 
pdf_document_search_idle_callback (void *data)
1390
 
{
1391
 
        PdfDocumentSearch *search = (PdfDocumentSearch*) data;
1392
 
        PdfDocument *pdf_document = search->document;
1393
 
        int n_pages;
1394
 
        GList *matches;
1395
 
        PopplerPage *page;
1396
 
 
1397
 
        page = poppler_document_get_page (search->document->document,
1398
 
                                          search->search_page);
1399
 
 
1400
 
        ev_document_doc_mutex_lock ();
1401
 
        matches = poppler_page_find_text (page, search->text);
1402
 
        ev_document_doc_mutex_unlock ();
1403
 
 
1404
 
        g_object_unref (page);
1405
 
 
1406
 
        search->pages[search->search_page] = matches;
1407
 
        ev_document_find_changed (EV_DOCUMENT_FIND (pdf_document),
1408
 
                                  search->search_page);
1409
 
 
1410
 
        n_pages = pdf_document_get_n_pages (EV_DOCUMENT (search->document));
1411
 
        search->search_page += 1;
1412
 
        if (search->search_page == n_pages) {
1413
 
                /* wrap around */
1414
 
                search->search_page = 0;
1415
 
        }
1416
 
 
1417
 
        if (search->search_page != search->start_page) {
1418
 
                return TRUE;
1419
 
        }
1420
 
 
1421
 
        /* We're done. */
1422
 
        search->idle = 0; /* will return FALSE to remove */
1423
 
        return FALSE;
1424
 
}
1425
 
 
1426
 
 
1427
 
static PdfDocumentSearch *
1428
 
pdf_document_search_new (PdfDocument *pdf_document,
1429
 
                         int          start_page,
1430
 
                         const char  *text)
1431
 
{
1432
 
        PdfDocumentSearch *search;
1433
 
        int n_pages;
1434
 
        int i;
1435
 
 
1436
 
        n_pages = pdf_document_get_n_pages (EV_DOCUMENT (pdf_document));
1437
 
 
1438
 
        search = g_new0 (PdfDocumentSearch, 1);
1439
 
 
1440
 
        search->text = g_strdup (text);
1441
 
        search->pages = g_new0 (GList *, n_pages);
1442
 
        search->document = pdf_document;
1443
 
 
1444
 
        /* We add at low priority so the progress bar repaints */
1445
 
        search->idle = g_idle_add_full (G_PRIORITY_LOW,
1446
 
                                        pdf_document_search_idle_callback,
1447
 
                                        search,
1448
 
                                        NULL);
1449
 
 
1450
 
        search->start_page = start_page;
1451
 
        search->search_page = start_page;
1452
 
 
1453
 
        return search;
1454
 
}
1455
 
 
1456
 
static void
1457
 
pdf_document_find_begin (EvDocumentFind   *document,
1458
 
                         int               page,
1459
 
                         const char       *search_string,
1460
 
                         gboolean          case_sensitive)
1461
 
{
1462
 
        PdfDocument *pdf_document = PDF_DOCUMENT (document);
1463
 
 
1464
 
        /* FIXME handle case_sensitive (right now XPDF
1465
 
         * code is always case insensitive for ASCII
1466
 
         * and case sensitive for all other languaages)
1467
 
         */
1468
 
 
1469
 
        if (pdf_document->search &&
1470
 
            strcmp (search_string, pdf_document->search->text) == 0)
1471
 
                return;
1472
 
 
1473
 
        if (pdf_document->search)
1474
 
                pdf_document_search_free (pdf_document->search);
1475
 
 
1476
 
        pdf_document->search = pdf_document_search_new (pdf_document,
1477
 
                                                        page,
1478
 
                                                        search_string);
1479
 
}
1480
 
 
1481
 
static int
1482
 
pdf_document_find_get_n_results (EvDocumentFind *document_find, int page)
1483
 
{
1484
 
        PdfDocumentSearch *search = PDF_DOCUMENT (document_find)->search;
1485
 
 
1486
 
        if (search) {
1487
 
                return g_list_length (search->pages[page]);
1488
 
        } else {
1489
 
                return 0;
1490
 
        }
1491
 
}
1492
 
 
1493
 
static gboolean
1494
 
pdf_document_find_get_result (EvDocumentFind *document_find,
1495
 
                              int             page,
1496
 
                              int             n_result,
1497
 
                              EvRectangle    *rectangle)
1498
 
{
1499
 
        PdfDocument *pdf_document = PDF_DOCUMENT (document_find);
1500
 
        PdfDocumentSearch *search = pdf_document->search;
 
1363
static GList *
 
1364
pdf_document_find_find_text (EvDocumentFind *document_find,
 
1365
                             EvPage         *page,
 
1366
                             const gchar    *text,
 
1367
                             gboolean        case_sensitive)
 
1368
{
 
1369
        GList *matches, *l;
1501
1370
        PopplerPage *poppler_page;
1502
 
        PopplerRectangle *r;
1503
 
        double height;
1504
 
 
1505
 
        if (search == NULL)
1506
 
                return FALSE;
1507
 
 
1508
 
        r = (PopplerRectangle *) g_list_nth_data (search->pages[page],
1509
 
                                                  n_result);
1510
 
        if (r == NULL)
1511
 
                return FALSE;
1512
 
 
1513
 
        poppler_page = poppler_document_get_page (pdf_document->document, page);
 
1371
        gdouble height;
 
1372
        
 
1373
        g_return_val_if_fail (POPPLER_IS_PAGE (page->backend_page), NULL);
 
1374
        g_return_val_if_fail (text != NULL, NULL);
 
1375
 
 
1376
        poppler_page = POPPLER_PAGE (page->backend_page);
 
1377
        
 
1378
        matches = poppler_page_find_text (poppler_page, text);
 
1379
        if (!matches)
 
1380
                return NULL;
 
1381
 
1514
1382
        poppler_page_get_size (poppler_page, NULL, &height);
1515
 
        rectangle->x1 = r->x1;
1516
 
        rectangle->y1 = height - r->y2;
1517
 
        rectangle->x2 = r->x2;
1518
 
        rectangle->y2 = height - r->y1;
1519
 
        g_object_unref (poppler_page);
1520
 
                
1521
 
        return TRUE;
1522
 
}
1523
 
 
1524
 
static int
1525
 
pdf_document_find_page_has_results (EvDocumentFind *document_find,
1526
 
                                    int             page)
1527
 
{
1528
 
        PdfDocumentSearch *search = PDF_DOCUMENT (document_find)->search;
1529
 
 
1530
 
        return search && search->pages[page] != NULL;
1531
 
}
1532
 
 
1533
 
static double
1534
 
pdf_document_find_get_progress (EvDocumentFind *document_find)
1535
 
{
1536
 
        PdfDocumentSearch *search;
1537
 
        int n_pages, pages_done;
1538
 
 
1539
 
        search = PDF_DOCUMENT (document_find)->search;
1540
 
 
1541
 
        if (search == NULL) {
1542
 
                return 0;
1543
 
        }
1544
 
 
1545
 
        n_pages = pdf_document_get_n_pages (EV_DOCUMENT (document_find));
1546
 
        if (search->search_page > search->start_page) {
1547
 
                pages_done = search->search_page - search->start_page + 1;
1548
 
        } else if (search->search_page == search->start_page) {
1549
 
                pages_done = n_pages;
1550
 
        } else {
1551
 
                pages_done = n_pages - search->start_page + search->search_page;
1552
 
        }
1553
 
 
1554
 
        return pages_done / (double) n_pages;
1555
 
}
1556
 
 
1557
 
static void
1558
 
pdf_document_find_cancel (EvDocumentFind *document)
1559
 
{
1560
 
        PdfDocument *pdf_document = PDF_DOCUMENT (document);
1561
 
 
1562
 
        if (pdf_document->search) {
1563
 
                pdf_document_search_free (pdf_document->search);
1564
 
                pdf_document->search = NULL;
1565
 
        }
 
1383
        for (l = matches; l && l->data; l = g_list_next (l)) {
 
1384
                PopplerRectangle *rect = (PopplerRectangle *)l->data;
 
1385
                gdouble           tmp;
 
1386
 
 
1387
                tmp = rect->y1;
 
1388
                rect->y1 = height - rect->y2;
 
1389
                rect->y2 = height - tmp;
 
1390
        }
 
1391
        
 
1392
        return matches;
1566
1393
}
1567
1394
 
1568
1395
static void
1569
1396
pdf_document_find_iface_init (EvDocumentFindIface *iface)
1570
1397
{
1571
 
        iface->begin = pdf_document_find_begin;
1572
 
        iface->get_n_results = pdf_document_find_get_n_results;
1573
 
        iface->get_result = pdf_document_find_get_result;
1574
 
        iface->page_has_results = pdf_document_find_page_has_results;
1575
 
        iface->get_progress = pdf_document_find_get_progress;
1576
 
        iface->cancel = pdf_document_find_cancel;
 
1398
        iface->find_text = pdf_document_find_find_text;
1577
1399
}
1578
1400
 
1579
1401
static void
1721
1543
 
1722
1544
        g_return_if_fail (pdf_document->print_ctx != NULL);
1723
1545
 
1724
 
        poppler_page = poppler_document_get_page (pdf_document->document, rc->page);
 
1546
        poppler_page = POPPLER_PAGE (rc->page->backend_page);
1725
1547
        
1726
1548
#ifdef HAVE_CAIRO_PRINT
1727
1549
        x = (ctx->pages_printed % ctx->pages_per_sheet) % ctx->pages_x;
1798
1620
                         y * (rotate ? pwidth : pheight));
1799
1621
        cairo_scale (ctx->cr, xscale, yscale);
1800
1622
 
1801
 
#ifdef HAVE_POPPLER_PAGE_RENDER_FOR_PRINTING
1802
1623
        poppler_page_render_for_printing (poppler_page, ctx->cr);
1803
 
#else
1804
 
#ifdef HAVE_POPPLER_PAGE_RENDER
1805
 
        poppler_page_render (poppler_page, ctx->cr);
1806
 
#endif
1807
 
#endif
1808
1624
 
1809
1625
        ctx->pages_printed++;
1810
1626
                        
1813
1629
        if (ctx->format == EV_FILE_FORMAT_PS)
1814
1630
                poppler_page_render_to_ps (poppler_page, ctx->ps_file);
1815
1631
#endif /* HAVE_CAIRO_PRINT */
1816
 
        
1817
 
        g_object_unref (poppler_page);
1818
1632
}
1819
1633
 
1820
1634
static void
1885
1699
                                GdkColor         *text,
1886
1700
                                GdkColor         *base)
1887
1701
{
1888
 
        PdfDocument *pdf_document;
 
1702
        PopplerPage *poppler_page;
1889
1703
        double width_points, height_points;
1890
1704
        gint width, height;
1891
1705
 
1892
 
        pdf_document = PDF_DOCUMENT (selection);
1893
 
        set_rc_data (pdf_document, rc);
 
1706
        poppler_page = POPPLER_PAGE (rc->page->backend_page);
1894
1707
 
1895
 
        poppler_page_get_size (POPPLER_PAGE (rc->data),
 
1708
        poppler_page_get_size (poppler_page,
1896
1709
                               &width_points, &height_points);
1897
1710
        width = (int) ((width_points * rc->scale) + 0.5);
1898
1711
        height = (int) ((height_points * rc->scale) + 0.5);
1899
1712
 
1900
1713
#ifdef HAVE_POPPLER_PAGE_RENDER
1901
1714
        cairo_t *cr;
1902
 
        
1903
 
#if POPPLER_MAJOR_VERSION <= 6 || (POPPLER_MAJOR_VERSION == 7 && POPPLER_MINOR_VERSION < 2)
1904
 
        GdkColor text_color, base_color;
1905
 
 
1906
 
        text_color = *text;
1907
 
        base_color = *base;
1908
 
#else
1909
1715
        PopplerColor text_color, base_color;
1910
1716
        
1911
1717
        text_color.red = text->red;
1915
1721
        base_color.red = base->red;
1916
1722
        base_color.green = base->green;
1917
1723
        base_color.blue = base->blue;
1918
 
#endif
1919
1724
 
1920
1725
        if (*surface == NULL) {
1921
1726
                *surface = cairo_image_surface_create (CAIRO_FORMAT_ARGB32,
1929
1734
        memset (cairo_image_surface_get_data (*surface), 0x00,
1930
1735
                cairo_image_surface_get_height (*surface) *
1931
1736
                cairo_image_surface_get_stride (*surface));
1932
 
        poppler_page_render_selection (POPPLER_PAGE (rc->data),
 
1737
        poppler_page_render_selection (poppler_page,
1933
1738
                                       cr,
1934
1739
                                       (PopplerRectangle *)points,
1935
1740
                                       (PopplerRectangle *)old_points,
1944
1749
                                 TRUE, 8,
1945
1750
                                 width, height);
1946
1751
 
1947
 
        poppler_page_render_selection_to_pixbuf (POPPLER_PAGE (rc->data),
 
1752
        poppler_page_render_selection_to_pixbuf (poppler_page,
1948
1753
                                                 rc->scale, rc->rotation, pixbuf,
1949
1754
                                                 (PopplerRectangle *)points,
1950
1755
                                                 (PopplerRectangle *)old_points,
1964
1769
                                 EvSelectionStyle style,
1965
1770
                                 EvRectangle     *points)
1966
1771
{
1967
 
        PdfDocument *pdf_document = PDF_DOCUMENT (selection);
1968
1772
        PopplerPage *poppler_page;
1969
1773
        PopplerRectangle r;
1970
1774
        double height;
1971
1775
        char *retval;
1972
1776
        
1973
 
        poppler_page = poppler_document_get_page (pdf_document->document, rc->page);
1974
 
        g_return_val_if_fail (poppler_page != NULL, NULL);
 
1777
        poppler_page = POPPLER_PAGE (rc->page->backend_page);
1975
1778
 
1976
1779
        poppler_page_get_size (poppler_page, NULL, &height);
1977
1780
        r.x1 = points->x1;
1983
1786
                                        (PopplerSelectionStyle)style,
1984
1787
                                        &r);
1985
1788
 
1986
 
        g_object_unref (poppler_page);
1987
 
 
1988
1789
        return retval;
1989
1790
}
1990
1791
 
2020
1821
                                    EvSelectionStyle style,
2021
1822
                                    EvRectangle     *points)
2022
1823
{
2023
 
        PdfDocument *pdf_document;
 
1824
        PopplerPage *poppler_page;
2024
1825
        GdkRegion   *retval;
2025
 
 
2026
 
        pdf_document = PDF_DOCUMENT (selection);
2027
 
 
2028
 
        set_rc_data (pdf_document, rc);
2029
 
        
2030
 
#if POPPLER_MAJOR_VERSION <= 6 || (POPPLER_MAJOR_VERSION == 7 && POPPLER_MINOR_VERSION < 2)
2031
 
        retval = poppler_page_get_selection_region (POPPLER_PAGE (rc->data),
2032
 
                                                    rc->scale,
2033
 
                                                    (PopplerSelectionStyle)style,
2034
 
                                                    (PopplerRectangle *) points);
2035
 
#else
2036
 
        GList *region;
2037
 
        
2038
 
        region = poppler_page_get_selection_region (POPPLER_PAGE (rc->data),
 
1826
        GList       *region;
 
1827
 
 
1828
        poppler_page = POPPLER_PAGE (rc->page->backend_page);
 
1829
        
 
1830
        region = poppler_page_get_selection_region (poppler_page,
2039
1831
                                                    rc->scale,
2040
1832
                                                    (PopplerSelectionStyle)style,
2041
1833
                                                    (PopplerRectangle *) points);
2042
1834
        retval = create_gdk_region_from_poppler_region (region);
2043
1835
        g_list_free (region);
2044
 
#endif
2045
1836
        
2046
1837
        return retval;
2047
1838
}
2050
1841
pdf_selection_get_selection_map (EvSelection     *selection,
2051
1842
                                 EvRenderContext *rc)
2052
1843
{
2053
 
        PdfDocument *pdf_document;
2054
1844
        PopplerPage *poppler_page;
2055
1845
        PopplerRectangle points;
2056
1846
        GList *region;
2057
1847
        GdkRegion *retval;
2058
1848
 
2059
 
        pdf_document = PDF_DOCUMENT (selection);
2060
 
        poppler_page = poppler_document_get_page (pdf_document->document,
2061
 
                                                  rc->page);
 
1849
        poppler_page = POPPLER_PAGE (rc->page->backend_page);
2062
1850
 
2063
1851
        points.x1 = 0.0;
2064
1852
        points.y1 = 0.0;
2065
1853
        poppler_page_get_size (poppler_page, &(points.x2), &(points.y2));
2066
1854
        
2067
 
#if POPPLER_MAJOR_VERSION <= 6 || (POPPLER_MAJOR_VERSION == 7 && POPPLER_MINOR_VERSION < 2)
2068
 
        retval = poppler_page_get_selection_region (poppler_page, 1.0,
2069
 
                                                    POPPLER_SELECTION_GLYPH,
2070
 
                                                    &points);
2071
 
#else
2072
1855
        region = poppler_page_get_selection_region (poppler_page, 1.0,
2073
1856
                                                    POPPLER_SELECTION_GLYPH,
2074
1857
                                                    &points);
2075
1858
        retval = create_gdk_region_from_poppler_region (region);
2076
1859
        g_list_free (region);
2077
 
#endif
2078
 
        g_object_unref (poppler_page);
2079
1860
 
2080
1861
        return retval;
2081
1862
}
2279
2060
 
2280
2061
static GList *
2281
2062
pdf_document_forms_get_form_fields (EvDocumentForms *document, 
2282
 
                                    gint             page)
 
2063
                                    EvPage          *page)
2283
2064
{
2284
 
        PdfDocument *pdf_document;
2285
2065
        PopplerPage *poppler_page;
2286
2066
        GList *retval = NULL;
2287
2067
        GList *fields;
2288
2068
        GList *list;
2289
2069
        double height;
2290
2070
 
2291
 
        pdf_document = PDF_DOCUMENT (document);
2292
 
        poppler_page = poppler_document_get_page (pdf_document->document, page);
 
2071
        g_return_val_if_fail (POPPLER_IS_PAGE (page->backend_page), NULL);
 
2072
        
 
2073
        poppler_page = POPPLER_PAGE (page->backend_page);
2293
2074
        fields = poppler_page_get_form_field_mapping (poppler_page);
2294
2075
        poppler_page_get_size (poppler_page, NULL, &height);
2295
2076
 
2310
2091
                field_mapping->y1 = height - mapping->area.y2;
2311
2092
                field_mapping->y2 = height - mapping->area.y1;
2312
2093
                field_mapping->field = ev_field;
2313
 
                field_mapping->field->page = page;
 
2094
                field_mapping->field->page = EV_PAGE (g_object_ref (page));
 
2095
 
 
2096
                g_object_set_data_full (G_OBJECT (ev_field),
 
2097
                                        "poppler-field",
 
2098
                                        g_object_ref (mapping->field),
 
2099
                                        (GDestroyNotify) g_object_unref);
2314
2100
                
2315
2101
                retval = g_list_prepend (retval, field_mapping);
2316
2102
        }
2317
2103
        
2318
2104
        poppler_page_free_form_field_mapping (fields);
2319
 
        g_object_unref (poppler_page);
2320
2105
 
2321
2106
        return g_list_reverse (retval);
2322
2107
}
2326
2111
                                             EvFormField     *field)
2327
2112
        
2328
2113
{
2329
 
        PdfDocument *pdf_document = PDF_DOCUMENT (document);
2330
2114
        PopplerFormField *poppler_field;
2331
2115
        gchar *text;
2332
2116
 
2333
 
        poppler_field = poppler_document_get_form_field (pdf_document->document, field->id);
 
2117
        poppler_field = POPPLER_FORM_FIELD (g_object_get_data (G_OBJECT (field), "poppler-field"));
2334
2118
        if (!poppler_field)
2335
2119
                return NULL;
2336
2120
        
2337
2121
        text = poppler_form_field_text_get_text (poppler_field);
2338
 
        g_object_unref (poppler_field);
2339
2122
 
2340
2123
        return text;
2341
2124
}
2345
2128
                                             EvFormField     *field,
2346
2129
                                             const gchar     *text)
2347
2130
{
2348
 
        PdfDocument *pdf_document = PDF_DOCUMENT (document);
2349
2131
        PopplerFormField *poppler_field;
2350
2132
 
2351
 
        poppler_field = poppler_document_get_form_field (pdf_document->document, field->id);
 
2133
        poppler_field = POPPLER_FORM_FIELD (g_object_get_data (G_OBJECT (field), "poppler-field"));
2352
2134
        if (!poppler_field)
2353
2135
                return;
2354
2136
        poppler_form_field_text_set_text (poppler_field, text);
2355
 
        g_object_unref (poppler_field);
2356
2137
}
2357
2138
 
2358
2139
static void
2360
2141
                                                EvFormField     *field,
2361
2142
                                                gboolean         state)
2362
2143
{
2363
 
        PdfDocument *pdf_document = PDF_DOCUMENT (document);
2364
2144
        PopplerFormField *poppler_field;
2365
2145
 
2366
 
        poppler_field = poppler_document_get_form_field (pdf_document->document, field->id);
 
2146
        poppler_field = POPPLER_FORM_FIELD (g_object_get_data (G_OBJECT (field), "poppler-field"));
2367
2147
        if (!poppler_field)
2368
2148
                return;
2369
2149
        
2370
2150
        poppler_form_field_button_set_state (poppler_field, state);
2371
 
        g_object_unref (poppler_field);
2372
2151
}
2373
2152
 
2374
2153
static gboolean
2375
2154
pdf_document_forms_form_field_button_get_state (EvDocumentForms *document, 
2376
2155
                                                EvFormField     *field)
2377
2156
{
2378
 
        PdfDocument *pdf_document = PDF_DOCUMENT (document);
2379
2157
        PopplerFormField *poppler_field;
2380
2158
        gboolean state;
2381
2159
 
2382
 
        poppler_field = poppler_document_get_form_field (pdf_document->document, field->id);
 
2160
        poppler_field = POPPLER_FORM_FIELD (g_object_get_data (G_OBJECT (field), "poppler-field"));
2383
2161
        if (!poppler_field)
2384
2162
                return FALSE;
2385
2163
 
2386
2164
        state = poppler_form_field_button_get_state (poppler_field);
2387
 
        g_object_unref (poppler_field);
2388
2165
 
2389
2166
        return state;
2390
2167
}
2394
2171
                                               EvFormField     *field,
2395
2172
                                               gint             index)
2396
2173
{
2397
 
        PdfDocument *pdf_document = PDF_DOCUMENT (document);
2398
2174
        PopplerFormField *poppler_field;
2399
2175
        gchar *text;
2400
2176
 
2401
 
        poppler_field = poppler_document_get_form_field (pdf_document->document, field->id);
 
2177
        poppler_field = POPPLER_FORM_FIELD (g_object_get_data (G_OBJECT (field), "poppler-field"));
2402
2178
        if (!poppler_field)
2403
2179
                return NULL;
2404
2180
 
2405
2181
        text = poppler_form_field_choice_get_item (poppler_field, index);
2406
 
        g_object_unref (poppler_field);
2407
2182
 
2408
2183
        return text;
2409
2184
}
2412
2187
pdf_document_forms_form_field_choice_get_n_items (EvDocumentForms *document, 
2413
2188
                                                  EvFormField     *field)
2414
2189
{
2415
 
        PdfDocument *pdf_document = PDF_DOCUMENT (document);
2416
2190
        PopplerFormField *poppler_field;
2417
2191
        gint n_items;
2418
2192
 
2419
 
        poppler_field = poppler_document_get_form_field (pdf_document->document, field->id);
 
2193
        poppler_field = POPPLER_FORM_FIELD (g_object_get_data (G_OBJECT (field), "poppler-field"));
2420
2194
        if (!poppler_field)
2421
2195
                return -1;
2422
2196
        
2423
2197
        n_items = poppler_form_field_choice_get_n_items (poppler_field);
2424
 
        g_object_unref (poppler_field);
2425
2198
 
2426
2199
        return n_items;
2427
2200
}
2431
2204
                                                       EvFormField     *field,
2432
2205
                                                       gint             index)
2433
2206
{
2434
 
        PdfDocument *pdf_document = PDF_DOCUMENT (document);
2435
2207
        PopplerFormField *poppler_field;
2436
2208
        gboolean selected;
2437
2209
 
2438
 
        poppler_field = poppler_document_get_form_field (pdf_document->document, field->id);
 
2210
        poppler_field = POPPLER_FORM_FIELD (g_object_get_data (G_OBJECT (field), "poppler-field"));
2439
2211
        if (!poppler_field)
2440
2212
                return FALSE;
2441
2213
 
2442
2214
        selected = poppler_form_field_choice_is_item_selected (poppler_field, index);
2443
 
        g_object_unref (poppler_field);
2444
2215
 
2445
2216
        return selected;
2446
2217
}
2450
2221
                                                  EvFormField     *field,
2451
2222
                                                  gint             index)
2452
2223
{
2453
 
        PdfDocument *pdf_document = PDF_DOCUMENT (document);
2454
2224
        PopplerFormField *poppler_field;
2455
2225
 
2456
 
        poppler_field = poppler_document_get_form_field (pdf_document->document, field->id);
 
2226
        poppler_field = POPPLER_FORM_FIELD (g_object_get_data (G_OBJECT (field), "poppler-field"));
2457
2227
        if (!poppler_field)
2458
2228
                return;
2459
2229
 
2460
2230
        poppler_form_field_choice_select_item (poppler_field, index);
2461
 
        g_object_unref (poppler_field);
2462
2231
}
2463
2232
 
2464
2233
static void
2466
2235
                                                  EvFormField     *field,
2467
2236
                                                  gint             index)
2468
2237
{
2469
 
        PdfDocument *pdf_document = PDF_DOCUMENT (document);
2470
2238
        PopplerFormField *poppler_field;
2471
2239
 
2472
 
        poppler_field = poppler_document_get_form_field (pdf_document->document, field->id);
 
2240
        poppler_field = POPPLER_FORM_FIELD (g_object_get_data (G_OBJECT (field), "poppler-field"));
2473
2241
        if (!poppler_field)
2474
2242
                return;
2475
2243
 
2476
2244
        poppler_form_field_choice_toggle_item (poppler_field, index);
2477
 
        g_object_unref (poppler_field);
2478
2245
}
2479
2246
 
2480
2247
static void
2481
2248
pdf_document_forms_form_field_choice_unselect_all (EvDocumentForms *document, 
2482
2249
                                                   EvFormField     *field)
2483
2250
{
2484
 
        PdfDocument *pdf_document = PDF_DOCUMENT (document);
2485
2251
        PopplerFormField *poppler_field;
2486
2252
 
2487
 
        poppler_field = poppler_document_get_form_field (pdf_document->document, field->id);
 
2253
        poppler_field = POPPLER_FORM_FIELD (g_object_get_data (G_OBJECT (field), "poppler-field"));
2488
2254
        if (!poppler_field)
2489
2255
                return;
2490
2256
        
2491
2257
        poppler_form_field_choice_unselect_all (poppler_field);
2492
 
        g_object_unref (poppler_field);
2493
2258
}
2494
2259
 
2495
2260
static void
2497
2262
                                               EvFormField     *field,
2498
2263
                                               const gchar     *text)
2499
2264
{
2500
 
        PdfDocument *pdf_document = PDF_DOCUMENT (document);
2501
2265
        PopplerFormField *poppler_field;
2502
2266
 
2503
 
        poppler_field = poppler_document_get_form_field (pdf_document->document, field->id);
 
2267
        poppler_field = POPPLER_FORM_FIELD (g_object_get_data (G_OBJECT (field), "poppler-field"));
2504
2268
        if (!poppler_field)
2505
2269
                return;
2506
2270
        
2507
2271
        poppler_form_field_choice_set_text (poppler_field, text);
2508
 
        g_object_unref (poppler_field);
2509
2272
}
2510
2273
 
2511
2274
static gchar *
2512
2275
pdf_document_forms_form_field_choice_get_text (EvDocumentForms *document,
2513
2276
                                               EvFormField     *field)
2514
2277
{
2515
 
        PdfDocument *pdf_document = PDF_DOCUMENT (document);
2516
2278
        PopplerFormField *poppler_field;
2517
2279
        gchar *text;
2518
2280
 
2519
 
        poppler_field = poppler_document_get_form_field (pdf_document->document, field->id);
 
2281
        poppler_field = POPPLER_FORM_FIELD (g_object_get_data (G_OBJECT (field), "poppler-field"));
2520
2282
        if (!poppler_field)
2521
2283
                return NULL;
2522
2284
 
2523
2285
        text = poppler_form_field_choice_get_text (poppler_field);
2524
 
        g_object_unref (poppler_field);
2525
2286
 
2526
2287
        return text;
2527
2288
}