← Back to branch summary

~ubuntu-branches/ubuntu/lucid/xpdf/lucid-updates

« back to all changes in this revision

Viewing changes to xpdf/Page.cc

  • Committer: Bazaar Package Importer
  • Author(s): Andy Price
  • Date: 2007-05-17 22:04:33 UTC
  • mfrom: (1.1.1 upstream)
  • Revision ID: james.westby@ubuntu.com-20070517220433-gzcx2lrvllkbl7mr
Tags: 3.02-1ubuntu1
https://launchpad.net/bugs/113365
* Merge from Debian unstable (LP: #113365), remaining changes:
  - Added back 09_xpdfrc_manpage.dpatch (LP #71753)
  - Set Ubuntu maintainer

Show diffs side-by-side

added added

removed removed

Lines of Context:
xpdf/Page.cc
2
2
//
3
3
// Page.cc
4
4
//
5
 
// Copyright 1996-2003 Glyph & Cog, LLC
 
5
// Copyright 1996-2007 Glyph & Cog, LLC
6
6
//
7
7
//========================================================================
8
8
 
26
26
#include "Annot.h"
27
27
#endif
28
28
#include "Error.h"
 
29
#include "Catalog.h"
29
30
#include "Page.h"
30
31
 
31
32
//------------------------------------------------------------------------
 
33
// PDFRectangle
 
34
//------------------------------------------------------------------------
 
35
 
 
36
void PDFRectangle::clipTo(PDFRectangle *rect) {
 
37
  if (x1 < rect->x1) {
 
38
    x1 = rect->x1;
 
39
  } else if (x1 > rect->x2) {
 
40
    x1 = rect->x2;
 
41
  }
 
42
  if (x2 < rect->x1) {
 
43
    x2 = rect->x1;
 
44
  } else if (x2 > rect->x2) {
 
45
    x2 = rect->x2;
 
46
  }
 
47
  if (y1 < rect->y1) {
 
48
    y1 = rect->y1;
 
49
  } else if (y1 > rect->y2) {
 
50
    y1 = rect->y2;
 
51
  }
 
52
  if (y2 < rect->y1) {
 
53
    y2 = rect->y1;
 
54
  } else if (y2 > rect->y2) {
 
55
    y2 = rect->y2;
 
56
  }
 
57
}
 
58
 
 
59
//------------------------------------------------------------------------
32
60
// PageAttrs
33
61
//------------------------------------------------------------------------
34
62
 
74
102
  artBox = cropBox;
75
103
  readBox(dict, "ArtBox", &artBox);
76
104
 
 
105
  // clip all other boxes to the media box
 
106
  cropBox.clipTo(&mediaBox);
 
107
  bleedBox.clipTo(&mediaBox);
 
108
  trimBox.clipTo(&mediaBox);
 
109
  artBox.clipTo(&mediaBox);
 
110
 
77
111
  // rotate
78
112
  dict->lookup("Rotate", &obj1);
79
113
  if (obj1.isInt()) {
213
247
  contents.free();
214
248
}
215
249
 
 
250
Links *Page::getLinks(Catalog *catalog) {
 
251
  Links *links;
 
252
  Object obj;
 
253
 
 
254
  links = new Links(getAnnots(&obj), catalog->getBaseURI());
 
255
  obj.free();
 
256
  return links;
 
257
}
 
258
 
216
259
void Page::display(OutputDev *out, double hDPI, double vDPI,
217
260
                   int rotate, GBool useMediaBox, GBool crop,
218
 
                   Links *links, Catalog *catalog,
 
261
                   GBool printing, Catalog *catalog,
219
262
                   GBool (*abortCheckCbk)(void *data),
220
263
                   void *abortCheckCbkData) {
221
264
  displaySlice(out, hDPI, vDPI, rotate, useMediaBox, crop,
222
 
               -1, -1, -1, -1, links, catalog,
 
265
               -1, -1, -1, -1, printing, catalog,
223
266
               abortCheckCbk, abortCheckCbkData);
224
267
}
225
268
 
226
269
void Page::displaySlice(OutputDev *out, double hDPI, double vDPI,
227
270
                        int rotate, GBool useMediaBox, GBool crop,
228
271
                        int sliceX, int sliceY, int sliceW, int sliceH,
229
 
                        Links *links, Catalog *catalog,
 
272
                        GBool printing, Catalog *catalog,
230
273
                        GBool (*abortCheckCbk)(void *data),
231
274
                        void *abortCheckCbkData) {
232
275
#ifndef PDF_PARSER_ONLY
233
 
  PDFRectangle *mediaBox, *cropBox, *baseBox;
 
276
  PDFRectangle *mediaBox, *cropBox;
234
277
  PDFRectangle box;
235
278
  Gfx *gfx;
236
279
  Object obj;
237
 
  Link *link;
238
280
  Annots *annotList;
239
 
  double kx, ky;
 
281
  Dict *acroForm;
240
282
  int i;
241
283
 
 
284
  if (!out->checkPageSlice(this, hDPI, vDPI, rotate, useMediaBox, crop,
 
285
                           sliceX, sliceY, sliceW, sliceH,
 
286
                           printing, catalog,
 
287
                           abortCheckCbk, abortCheckCbkData)) {
 
288
    return;
 
289
  }
 
290
 
242
291
  rotate += getRotate();
243
292
  if (rotate >= 360) {
244
293
    rotate -= 360;
246
295
    rotate += 360;
247
296
  }
248
297
 
249
 
  mediaBox = getMediaBox();
 
298
  makeBox(hDPI, vDPI, rotate, useMediaBox, out->upsideDown(),
 
299
          sliceX, sliceY, sliceW, sliceH, &box, &crop);
250
300
  cropBox = getCropBox();
251
 
  if (sliceW >= 0 && sliceH >= 0) {
252
 
    baseBox = useMediaBox ? mediaBox : cropBox;
253
 
    kx = 72.0 / hDPI;
254
 
    ky = 72.0 / vDPI;
255
 
    if (rotate == 90) {
256
 
      if (out->upsideDown()) {
257
 
        box.x1 = baseBox->x1 + ky * sliceY;
258
 
        box.x2 = baseBox->x1 + ky * (sliceY + sliceH);
259
 
      } else {
260
 
        box.x1 = baseBox->x2 - ky * (sliceY + sliceH);
261
 
        box.x2 = baseBox->x2 - ky * sliceY;
262
 
      }
263
 
      box.y1 = baseBox->y1 + kx * sliceX;
264
 
      box.y2 = baseBox->y1 + kx * (sliceX + sliceW);
265
 
    } else if (rotate == 180) {
266
 
      box.x1 = baseBox->x2 - kx * (sliceX + sliceW);
267
 
      box.x2 = baseBox->x2 - kx * sliceX;
268
 
      if (out->upsideDown()) {
269
 
        box.y1 = baseBox->y1 + ky * sliceY;
270
 
        box.y2 = baseBox->y1 + ky * (sliceY + sliceH);
271
 
      } else {
272
 
        box.y1 = baseBox->y2 - ky * (sliceY + sliceH);
273
 
        box.y2 = baseBox->y2 - ky * sliceY;
274
 
      }
275
 
    } else if (rotate == 270) {
276
 
      if (out->upsideDown()) {
277
 
        box.x1 = baseBox->x2 - ky * (sliceY + sliceH);
278
 
        box.x2 = baseBox->x2 - ky * sliceY;
279
 
      } else {
280
 
        box.x1 = baseBox->x1 + ky * sliceY;
281
 
        box.x2 = baseBox->x1 + ky * (sliceY + sliceH);
282
 
      }
283
 
      box.y1 = baseBox->y2 - kx * (sliceX + sliceW);
284
 
      box.y2 = baseBox->y2 - kx * sliceX;
285
 
    } else {
286
 
      box.x1 = baseBox->x1 + kx * sliceX;
287
 
      box.x2 = baseBox->x1 + kx * (sliceX + sliceW);
288
 
      if (out->upsideDown()) {
289
 
        box.y1 = baseBox->y2 - ky * (sliceY + sliceH);
290
 
        box.y2 = baseBox->y2 - ky * sliceY;
291
 
      } else {
292
 
        box.y1 = baseBox->y1 + ky * sliceY;
293
 
        box.y2 = baseBox->y1 + ky * (sliceY + sliceH);
294
 
      }
295
 
    }
296
 
  } else if (useMediaBox) {
297
 
    box = *mediaBox;
298
 
  } else {
299
 
    box = *cropBox;
300
 
    crop = gFalse;
301
 
  }
302
301
 
303
302
  if (globalParams->getPrintCommands()) {
 
303
    mediaBox = getMediaBox();
304
304
    printf("***** MediaBox = ll:%g,%g ur:%g,%g\n",
305
305
           mediaBox->x1, mediaBox->y1, mediaBox->x2, mediaBox->y2);
306
306
    printf("***** CropBox = ll:%g,%g ur:%g,%g\n",
319
319
  }
320
320
  obj.free();
321
321
 
322
 
  // draw links
323
 
  if (links) {
324
 
    gfx->saveState();
325
 
    for (i = 0; i < links->getNumLinks(); ++i) {
326
 
      link = links->getLink(i);
327
 
      out->drawLink(link, catalog);
 
322
  // draw annotations
 
323
  annotList = new Annots(xref, catalog, getAnnots(&obj));
 
324
  obj.free();
 
325
  acroForm = catalog->getAcroForm()->isDict() ?
 
326
               catalog->getAcroForm()->getDict() : NULL;
 
327
  if (acroForm) {
 
328
    if (acroForm->lookup("NeedAppearances", &obj)) {
 
329
      if (obj.isBool() && obj.getBool()) {
 
330
        annotList->generateAppearances(acroForm);
 
331
      }
328
332
    }
329
 
    gfx->restoreState();
330
 
    out->dump();
 
333
    obj.free();
331
334
  }
332
 
 
333
 
  // draw non-link annotations
334
 
  annotList = new Annots(xref, catalog, annots.fetch(xref, &obj));
335
 
  obj.free();
336
335
  if (annotList->getNumAnnots() > 0) {
337
336
    if (globalParams->getPrintCommands()) {
338
337
      printf("***** Annotations\n");
339
338
    }
340
339
    for (i = 0; i < annotList->getNumAnnots(); ++i) {
341
 
      annotList->getAnnot(i)->draw(gfx);
 
340
      annotList->getAnnot(i)->draw(gfx, printing);
342
341
    }
343
342
    out->dump();
344
343
  }
348
347
#endif
349
348
}
350
349
 
 
350
void Page::makeBox(double hDPI, double vDPI, int rotate,
 
351
                   GBool useMediaBox, GBool upsideDown,
 
352
                   double sliceX, double sliceY, double sliceW, double sliceH,
 
353
                   PDFRectangle *box, GBool *crop) {
 
354
  PDFRectangle *mediaBox, *cropBox, *baseBox;
 
355
  double kx, ky;
 
356
 
 
357
  mediaBox = getMediaBox();
 
358
  cropBox = getCropBox();
 
359
  if (sliceW >= 0 && sliceH >= 0) {
 
360
    baseBox = useMediaBox ? mediaBox : cropBox;
 
361
    kx = 72.0 / hDPI;
 
362
    ky = 72.0 / vDPI;
 
363
    if (rotate == 90) {
 
364
      if (upsideDown) {
 
365
        box->x1 = baseBox->x1 + ky * sliceY;
 
366
        box->x2 = baseBox->x1 + ky * (sliceY + sliceH);
 
367
      } else {
 
368
        box->x1 = baseBox->x2 - ky * (sliceY + sliceH);
 
369
        box->x2 = baseBox->x2 - ky * sliceY;
 
370
      }
 
371
      box->y1 = baseBox->y1 + kx * sliceX;
 
372
      box->y2 = baseBox->y1 + kx * (sliceX + sliceW);
 
373
    } else if (rotate == 180) {
 
374
      box->x1 = baseBox->x2 - kx * (sliceX + sliceW);
 
375
      box->x2 = baseBox->x2 - kx * sliceX;
 
376
      if (upsideDown) {
 
377
        box->y1 = baseBox->y1 + ky * sliceY;
 
378
        box->y2 = baseBox->y1 + ky * (sliceY + sliceH);
 
379
      } else {
 
380
        box->y1 = baseBox->y2 - ky * (sliceY + sliceH);
 
381
        box->y2 = baseBox->y2 - ky * sliceY;
 
382
      }
 
383
    } else if (rotate == 270) {
 
384
      if (upsideDown) {
 
385
        box->x1 = baseBox->x2 - ky * (sliceY + sliceH);
 
386
        box->x2 = baseBox->x2 - ky * sliceY;
 
387
      } else {
 
388
        box->x1 = baseBox->x1 + ky * sliceY;
 
389
        box->x2 = baseBox->x1 + ky * (sliceY + sliceH);
 
390
      }
 
391
      box->y1 = baseBox->y2 - kx * (sliceX + sliceW);
 
392
      box->y2 = baseBox->y2 - kx * sliceX;
 
393
    } else {
 
394
      box->x1 = baseBox->x1 + kx * sliceX;
 
395
      box->x2 = baseBox->x1 + kx * (sliceX + sliceW);
 
396
      if (upsideDown) {
 
397
        box->y1 = baseBox->y2 - ky * (sliceY + sliceH);
 
398
        box->y2 = baseBox->y2 - ky * sliceY;
 
399
      } else {
 
400
        box->y1 = baseBox->y1 + ky * sliceY;
 
401
        box->y2 = baseBox->y1 + ky * (sliceY + sliceH);
 
402
      }
 
403
    }
 
404
  } else if (useMediaBox) {
 
405
    *box = *mediaBox;
 
406
  } else {
 
407
    *box = *cropBox;
 
408
    *crop = gFalse;
 
409
  }
 
410
}
 
411
 
 
412
void Page::processLinks(OutputDev *out, Catalog *catalog) {
 
413
  Links *links;
 
414
  int i;
 
415
 
 
416
  links = getLinks(catalog);
 
417
  for (i = 0; i < links->getNumLinks(); ++i) {
 
418
    out->processLink(links->getLink(i), catalog);
 
419
  }
 
420
  delete links;
 
421
}
 
422
 
351
423
void Page::getDefaultCTM(double *ctm, double hDPI, double vDPI,
352
 
                         int rotate, GBool upsideDown) {
 
424
                         int rotate, GBool useMediaBox, GBool upsideDown) {
353
425
  GfxState *state;
354
426
  int i;
355
427
 
359
431
  } else if (rotate < 0) {
360
432
    rotate += 360;
361
433
  }
362
 
  state = new GfxState(hDPI, vDPI, getMediaBox(), rotate, upsideDown);
 
434
  state = new GfxState(hDPI, vDPI,
 
435
                       useMediaBox ? getMediaBox() : getCropBox(),
 
436
                       rotate, upsideDown);
363
437
  for (i = 0; i < 6; ++i) {
364
438
    ctm[i] = state->getCTM()[i];
365
439
  }