source: trunk/poppler/mypoppler/poppler/Annot.h @ 277

Last change on this file since 277 was 277, checked in by rbri, 11 years ago

PDF plugin: Poppler library updated to version 0.12.3

File size: 38.8 KB
Line 
1//========================================================================
2//
3// Annot.h
4//
5// Copyright 2000-2003 Glyph & Cog, LLC
6//
7//========================================================================
8
9//========================================================================
10//
11// Modified under the Poppler project - http://poppler.freedesktop.org
12//
13// All changes made under the Poppler project to this file are licensed
14// under GPL version 2 or later
15//
16// Copyright (C) 2006 Scott Turner <scotty1024@mac.com>
17// Copyright (C) 2007, 2008 Julien Rebetez <julienr@svn.gnome.org>
18// Copyright (C) 2007-2009 Carlos Garcia Campos <carlosgc@gnome.org>
19// Copyright (C) 2007, 2008 Iñigo Martínez <inigomartinez@gmail.com>
20// Copyright (C) 2008 Michael Vrable <mvrable@cs.ucsd.edu>
21// Copyright (C) 2008 Hugo Mercier <hmercier31@gmail.com>
22// Copyright (C) 2008 Pino Toscano <pino@kde.org>
23// Copyright (C) 2008 Tomas Are Haavet <tomasare@gmail.com>
24// Copyright (C) 2009 Albert Astals Cid <aacid@kde.org>
25//
26// To see a description of the changes please see the Changelog file that
27// came with your tarball or type make ChangeLog if you are building from git
28//
29//========================================================================
30
31#ifndef ANNOT_H
32#define ANNOT_H
33
34#ifdef USE_GCC_PRAGMAS
35#pragma interface
36#endif
37
38class XRef;
39class Gfx;
40class Catalog;
41class CharCodeToUnicode;
42class GfxFont;
43class GfxFontDict;
44class Form;
45class FormWidget;
46class PDFRectangle;
47class Movie;
48class OCGs;
49class Sound;
50
51enum AnnotLineEndingStyle {
52  annotLineEndingSquare,        // Square
53  annotLineEndingCircle,        // Circle
54  annotLineEndingDiamond,       // Diamond
55  annotLineEndingOpenArrow,     // OpenArrow
56  annotLineEndingClosedArrow,   // ClosedArrow
57  annotLineEndingNone,          // None
58  annotLineEndingButt,          // Butt
59  annotLineEndingROpenArrow,    // ROpenArrow
60  annotLineEndingRClosedArrow,  // RClosedArrow
61  annotLineEndingSlash          // Slash
62};
63
64enum AnnotExternalDataType {
65  annotExternalDataMarkupUnknown,
66  annotExternalDataMarkup3D       // Markup3D
67};
68
69//------------------------------------------------------------------------
70// AnnotCoord
71//------------------------------------------------------------------------
72
73class AnnotCoord {
74public:
75
76  AnnotCoord() : x(0), y(0) { }
77  AnnotCoord(double _x, double _y) : x(_x), y(_y) { }
78
79  double getX() const { return x; }
80  double getY() const { return y; }
81 
82protected:
83
84  double x, y;
85};
86
87//------------------------------------------------------------------------
88// AnnotPath
89//------------------------------------------------------------------------
90
91class AnnotPath {
92public:
93  AnnotPath();
94  AnnotPath(Array *array);
95  AnnotPath(AnnotCoord **coords, int coordLength);
96  ~AnnotPath();
97
98  double getX(int coord) const;
99  double getY(int coord) const;
100  AnnotCoord *getCoord(int coord) const;
101  int getCoordsLength() const { return coordsLength; }
102protected:
103  AnnotCoord **coords;
104  int coordsLength;
105
106  void parsePathArray(Array *array);
107};
108 
109//------------------------------------------------------------------------
110// AnnotCalloutLine
111//------------------------------------------------------------------------
112
113class AnnotCalloutLine {
114public:
115
116  AnnotCalloutLine(double x1, double y1, double x2, double y2);
117  virtual ~AnnotCalloutLine() { }
118
119  double getX1() const { return coord1.getX(); }
120  double getY1() const { return coord1.getY(); }
121  double getX2() const { return coord2.getX(); }
122  double getY2() const { return coord2.getY(); }
123 
124protected:
125
126  AnnotCoord coord1, coord2;
127};
128
129//------------------------------------------------------------------------
130// AnnotCalloutMultiLine
131//------------------------------------------------------------------------
132
133class AnnotCalloutMultiLine: public AnnotCalloutLine {
134public:
135
136  AnnotCalloutMultiLine(double x1, double y1, double x2, double y2,
137    double x3, double y3);
138
139  double getX3() const { return coord3.getX(); }
140  double getY3() const { return coord3.getY(); }
141
142protected:
143
144  AnnotCoord coord3;
145};
146
147//------------------------------------------------------------------------
148// AnnotBorderEffect
149//------------------------------------------------------------------------
150
151class AnnotBorderEffect {
152public:
153
154  enum AnnotBorderEffectType {
155    borderEffectNoEffect, // S
156    borderEffectCloudy    // C
157  };
158
159  AnnotBorderEffect(Dict *dict);
160
161  AnnotBorderEffectType getEffectType() const { return effectType; }
162  double getIntensity() const { return intensity; }
163
164private:
165
166  AnnotBorderEffectType effectType; // S  (Default S)
167  double intensity;                 // I  (Default 0)
168};
169
170//------------------------------------------------------------------------
171// AnnotQuadrilateral
172//------------------------------------------------------------------------
173
174class AnnotQuadrilaterals {
175  class AnnotQuadrilateral {
176  public:
177    AnnotQuadrilateral(double x1, double y1, double x2, double y2, double x3,
178      double y3, double x4, double y4);
179
180    AnnotCoord coord1, coord2, coord3, coord4;
181  };
182
183public:
184
185  AnnotQuadrilaterals(Array *array, PDFRectangle *rect);
186  ~AnnotQuadrilaterals();
187
188  double getX1(int quadrilateral);
189  double getY1(int quadrilateral);
190  double getX2(int quadrilateral);
191  double getY2(int quadrilateral);
192  double getX3(int quadrilateral);
193  double getY3(int quadrilateral);
194  double getX4(int quadrilateral);
195  double getY4(int quadrilateral);
196  int getQuadrilateralsLength() const { return quadrilateralsLength; }
197protected:
198
199  AnnotQuadrilateral** quadrilaterals;
200  int quadrilateralsLength;
201};
202
203//------------------------------------------------------------------------
204// AnnotBorder
205//------------------------------------------------------------------------
206
207class AnnotBorder {
208public:
209  enum AnnotBorderType {
210    typeUnknown,
211    typeArray,
212    typeBS
213  };
214
215  enum AnnotBorderStyle {
216    borderSolid,      // Solid
217    borderDashed,     // Dashed
218    borderBeveled,    // Beveled
219    borderInset,      // Inset
220    borderUnderlined  // Underlined
221  };
222
223  AnnotBorder();
224  virtual ~AnnotBorder();
225
226  virtual AnnotBorderType getType() const { return type; }
227  virtual double getWidth() const { return width; }
228  virtual int getDashLength() const { return dashLength; }
229  virtual double *getDash() const { return dash; }
230  virtual AnnotBorderStyle getStyle() const { return style; }
231
232protected:
233  AnnotBorderType type;
234  double width;
235  int dashLength;
236  double *dash;
237  AnnotBorderStyle style;
238};
239
240//------------------------------------------------------------------------
241// AnnotBorderArray
242//------------------------------------------------------------------------
243
244class AnnotBorderArray: public AnnotBorder {
245public:
246  AnnotBorderArray();
247  AnnotBorderArray(Array *array);
248
249  double getHorizontalCorner() const { return horizontalCorner; }
250  double getVerticalCorner() const { return verticalCorner; }
251
252protected:
253  static const int DASH_LIMIT = 10; // implementation note 82 in Appendix H.
254  double horizontalCorner;          // (Default 0)
255  double verticalCorner;            // (Default 0)
256  // double width;                  // (Default 1)  (inherited from AnnotBorder)
257};
258
259//------------------------------------------------------------------------
260// AnnotBorderBS
261//------------------------------------------------------------------------
262
263class AnnotBorderBS: public AnnotBorder {
264public:
265
266  AnnotBorderBS();
267  AnnotBorderBS(Dict *dict);
268
269private:
270  // double width;           // W  (Default 1)   (inherited from AnnotBorder)
271  // AnnotBorderStyle style; // S  (Default S)   (inherited from AnnotBorder)
272  // double *dash;           // D  (Default [3]) (inherited from AnnotBorder)
273};
274
275//------------------------------------------------------------------------
276// AnnotColor
277//------------------------------------------------------------------------
278
279class AnnotColor {
280public:
281
282  enum AnnotColorSpace {
283    colorTransparent = 0,
284    colorGray        = 1,
285    colorRGB         = 3,
286    colorCMYK        = 4
287  };
288
289  AnnotColor();
290  AnnotColor(double gray);
291  AnnotColor(double r, double g, double b);
292  AnnotColor(double c, double m, double y, double k);
293  AnnotColor(Array *array);
294  ~AnnotColor();
295
296  AnnotColorSpace getSpace() const { return (AnnotColorSpace) length; }
297  double *getValues() const { return values; }
298
299private:
300
301  double *values;
302  int length;
303};
304
305//------------------------------------------------------------------------
306// AnnotBorderStyle
307//------------------------------------------------------------------------
308
309enum AnnotBorderType {
310  annotBorderSolid,
311  annotBorderDashed,
312  annotBorderBeveled,
313  annotBorderInset,
314  annotBorderUnderlined
315};
316
317class AnnotBorderStyle {
318public:
319
320  AnnotBorderStyle(AnnotBorderType typeA, double widthA,
321                   double *dashA, int dashLengthA,
322                   double rA, double gA, double bA);
323  ~AnnotBorderStyle();
324
325  AnnotBorderType getType() { return type; }
326  double getWidth() { return width; }
327  void getDash(double **dashA, int *dashLengthA)
328    { *dashA = dash; *dashLengthA = dashLength; }
329  void getColor(double *rA, double *gA, double *bA)
330    { *rA = r; *gA = g; *bA = b; }
331
332private:
333
334  AnnotBorderType type;
335  double width;
336  double *dash;
337  int dashLength;
338  double r, g, b;
339};
340
341//------------------------------------------------------------------------
342// AnnotIconFit
343//------------------------------------------------------------------------
344
345class AnnotIconFit {
346public:
347
348  enum AnnotIconFitScaleWhen {
349    scaleAlways,  // A
350    scaleBigger,  // B
351    scaleSmaller, // S
352    scaleNever    // N
353  };
354
355  enum AnnotIconFitScale {
356    scaleAnamorphic,  // A
357    scaleProportional // P
358  };
359
360  AnnotIconFit(Dict *dict);
361
362  AnnotIconFitScaleWhen getScaleWhen() { return scaleWhen; }
363  AnnotIconFitScale getScale() { return scale; }
364  double getLeft() { return left; }
365  double getBottom() { return bottom; }
366  bool getFullyBounds() { return fullyBounds; }
367
368protected:
369
370  AnnotIconFitScaleWhen scaleWhen;  // SW (Default A)
371  AnnotIconFitScale scale;          // S  (Default P)
372  double left;                      // A  (Default [0.5 0.5]
373  double bottom;                    // Only if scale is P
374  bool fullyBounds;                 // FB (Default false)
375};
376
377//------------------------------------------------------------------------
378// AnnotAppearance
379//------------------------------------------------------------------------
380
381class AnnotAppearance {
382public:
383
384  enum AnnotAppearanceType {
385    appearNormal,
386    appearRollover,
387    appearDown
388  };
389
390  AnnotAppearance(Dict *dict);
391};
392
393//------------------------------------------------------------------------
394// AnnotAppearanceCharacs
395//------------------------------------------------------------------------
396
397class AnnotAppearanceCharacs {
398public:
399
400  enum AnnotAppearanceCharacsTextPos {
401    captionNoIcon,    // 0
402    captionNoCaption, // 1
403    captionBelow,     // 2
404    captionAbove,     // 3
405    captionRight,     // 4
406    captionLeft,      // 5
407    captionOverlaid   // 6
408  };
409
410  AnnotAppearanceCharacs(Dict *dict);
411  ~AnnotAppearanceCharacs();
412
413  int getRotation() { return rotation; }
414  AnnotColor *getBorderColor() { return borderColor; }
415  AnnotColor *getBackColor() { return backColor; }
416  GooString *getNormalCaption() { return normalCaption; }
417  GooString *getRolloverCaption() { return rolloverCaption; }
418  GooString *getAlternateCaption() { return alternateCaption; }
419  AnnotIconFit *getIconFit() { return iconFit; }
420  AnnotAppearanceCharacsTextPos getPosition() { return position; }
421
422protected:
423
424  int rotation;                           // R  (Default 0)
425  AnnotColor *borderColor;                // BC
426  AnnotColor *backColor;                  // BG
427  GooString *normalCaption;               // CA
428  GooString *rolloverCaption;             // RC
429  GooString *alternateCaption;            // AC
430  // I
431  // RI
432  // IX
433  AnnotIconFit *iconFit;                  // IF
434  AnnotAppearanceCharacsTextPos position; // TP (Default 0)
435};
436
437//------------------------------------------------------------------------
438// Annot
439//------------------------------------------------------------------------
440
441class Annot {
442public:
443  enum AnnotFlag {
444    flagUnknown        = 0x0000,
445    flagInvisible      = 0x0001,
446    flagHidden         = 0x0002,
447    flagPrint          = 0x0004,
448    flagNoZoom         = 0x0008,
449    flagNoRotate       = 0x0010,
450    flagNoView         = 0x0020,
451    flagReadOnly       = 0x0040,
452    flagLocked         = 0x0080,
453    flagToggleNoView   = 0x0100,
454    flagLockedContents = 0x0200
455  };
456
457  enum AnnotSubtype {
458    typeUnknown,        //                 0
459    typeText,           // Text            1
460    typeLink,           // Link            2
461    typeFreeText,       // FreeText        3
462    typeLine,           // Line            4
463    typeSquare,         // Square          5
464    typeCircle,         // Circle          6
465    typePolygon,        // Polygon         7
466    typePolyLine,       // PolyLine        8
467    typeHighlight,      // Highlight       9
468    typeUnderline,      // Underline      10
469    typeSquiggly,       // Squiggly       11
470    typeStrikeOut,      // StrikeOut      12
471    typeStamp,          // Stamp          13
472    typeCaret,          // Caret          14
473    typeInk,            // Ink            15
474    typePopup,          // Popup          16
475    typeFileAttachment, // FileAttachment 17
476    typeSound,          // Sound          18
477    typeMovie,          // Movie          19
478    typeWidget,         // Widget         20
479    typeScreen,         // Screen         21
480    typePrinterMark,    // PrinterMark    22
481    typeTrapNet,        // TrapNet        23
482    typeWatermark,      // Watermark      24
483    type3D              // 3D             25
484  };
485
486  Annot(XRef *xrefA, PDFRectangle *rectA, Catalog *catalog);
487  Annot(XRef *xrefA, Dict *dict, Catalog *catalog);
488  Annot(XRef *xrefA, Dict *dict, Catalog *catalog, Object *obj);
489  virtual ~Annot();
490  GBool isOk() { return ok; }
491
492  virtual void draw(Gfx *gfx, GBool printing);
493  // Get appearance object.
494  Object *getAppearance(Object *obj) { return appearance.fetch(xref, obj); }
495
496  GBool match(Ref *refA)
497    { return ref.num == refA->num && ref.gen == refA->gen; }
498
499  double getXMin();
500  double getYMin();
501
502  double getFontSize() { return fontSize; }
503
504  // Sets the annot contents to new_content
505  // new_content should never be NULL
506  void setContents(GooString *new_content);
507
508  // The annotation takes the ownership of
509  // new_color.
510  void setColor(AnnotColor *new_color);
511
512  // getters
513  Ref getRef() const { return ref; }
514  AnnotSubtype getType() const { return type; }
515  PDFRectangle *getRect() const { return rect; }
516  GooString *getContents() const { return contents; }
517  Dict *getPageDict() const { return pageDict; }
518  GooString *getName() const { return name; }
519  GooString *getModified() const { return modified; }
520  Guint getFlags() const { return flags; }
521  /*Dict *getAppearDict() const { return appearDict; }*/
522  GooString *getAppearState() const { return appearState; }
523  AnnotBorder *getBorder() const { return border; }
524  AnnotColor *getColor() const { return color; }
525  int getTreeKey() const { return treeKey; }
526
527  int getId() { return ref.num; }
528
529private:
530  void readArrayNum(Object *pdfArray, int key, double *value);
531  // write vStr[i:j[ in appearBuf
532
533  void initialize (XRef *xrefA, Dict *dict, Catalog *catalog);
534
535
536protected:
537  void setColor(Array *a, GBool fill, int adjust);
538  void drawCircle(double cx, double cy, double r, GBool fill);
539  void drawCircleTopLeft(double cx, double cy, double r);
540  void drawCircleBottomRight(double cx, double cy, double r);
541
542  // Updates the field key of the annotation dictionary
543  // and sets M to the current time
544  void update(const char *key, Object *value);
545
546  Object annotObj;
547 
548  // required data
549  AnnotSubtype type;                // Annotation type
550  PDFRectangle *rect;               // Rect
551
552  // optional data
553  GooString *contents;              // Contents
554  Dict *pageDict;                   // P
555  GooString *name;                  // NM
556  GooString *modified;              // M
557  Guint flags;                      // F (must be a 32 bit unsigned int)
558  //Dict *appearDict;                 // AP (should be correctly parsed)
559  Ref appRef;                       //the reference to the indirect appearance object in XRef
560  Object appearance;     // a reference to the Form XObject stream
561                         //   for the normal appearance
562  GooString *appearState;           // AS
563  int treeKey;                      // Struct Parent;
564  OCGs *optContentConfig;           // Optional content config
565  Object oc;                        // OC
566
567  XRef *xref;                   // the xref table for this PDF file
568  Ref ref;                      // object ref identifying this annotation
569  GooString *appearBuf;
570  AnnotBorder *border;          // Border, BS
571  AnnotColor *color;            // C
572  double fontSize; 
573  GBool ok;
574
575  bool hasRef;
576};
577
578//------------------------------------------------------------------------
579// AnnotPopup
580//------------------------------------------------------------------------
581
582class AnnotPopup: public Annot {
583public:
584  AnnotPopup(XRef *xrefA, PDFRectangle *rect, Catalog *catalog);
585  AnnotPopup(XRef *xrefA, Dict *dict, Catalog *catalog, Object *obj);
586  ~AnnotPopup();
587
588  Object *getParent(Object *obj) { return parent.fetch (xref, obj); }
589  Object *getParentNF(Object *obj) { return &parent; }
590  void setParent(Object *parentA);
591  void setParent(Annot *parentA);
592  GBool getOpen() const { return open; }
593  void setOpen(GBool openA);
594
595protected:
596  void initialize(XRef *xrefA, Dict *dict, Catalog *catalog);
597
598  Object parent; // Parent
599  GBool open;   // Open
600};
601
602//------------------------------------------------------------------------
603// AnnotMarkup
604//------------------------------------------------------------------------
605
606class AnnotMarkup: public Annot {
607public:
608  enum  AnnotMarkupReplyType {
609    replyTypeR,     // R
610    replyTypeGroup  // Group
611  };
612
613  AnnotMarkup(XRef *xrefA, PDFRectangle *rect, Catalog *catalog);
614  AnnotMarkup(XRef *xrefA, Dict *dict, Catalog *catalog, Object *obj);
615  virtual ~AnnotMarkup();
616
617  // getters
618  GooString *getLabel() const { return label; }
619  AnnotPopup *getPopup() const { return popup; }
620  double getOpacity() const { return opacity; }
621  // getRC
622  GooString *getDate() const { return date; }
623  int getInReplyToID() const { return inReplyTo.num; }
624  GooString *getSubject() const { return subject; }
625  AnnotMarkupReplyType getReplyTo() const { return replyTo; }
626  AnnotExternalDataType getExData() const { return exData; }
627
628  // The annotation takes the ownership of new_popup
629  void setPopup(AnnotPopup *new_popup);
630  void setLabel(GooString *new_label);
631
632protected:
633  GooString *label;             // T            (Default autor)
634  AnnotPopup *popup;            // Popup
635  double opacity;               // CA           (Default 1.0)
636  // RC
637  GooString *date;              // CreationDate
638  Ref inReplyTo;                // IRT
639  GooString *subject;           // Subj
640  AnnotMarkupReplyType replyTo; // RT           (Default R)
641  // this object is overrided by the custom intent fields defined in some
642  // annotation types.
643  //GooString *intent;          // IT
644  AnnotExternalDataType exData; // ExData
645
646private:
647  void initialize(XRef *xrefA, Dict *dict, Catalog *catalog, Object *obj);
648};
649
650//------------------------------------------------------------------------
651// AnnotText
652//------------------------------------------------------------------------
653
654class AnnotText: public AnnotMarkup {
655public:
656  enum AnnotTextState {
657    stateUnknown,
658    // Marked state model
659    stateMarked,    // Marked
660    stateUnmarked,  // Unmarked
661    // Review state model
662    stateAccepted,  // Accepted
663    stateRejected,  // Rejected
664    stateCancelled, // Cancelled
665    stateCompleted, // Completed
666    stateNone       // None
667  };
668
669  AnnotText(XRef *xrefA, PDFRectangle *rect, Catalog *catalog);
670  AnnotText(XRef *xrefA, Dict *dict, Catalog *catalog, Object *obj);
671  ~AnnotText();
672
673  // getters
674  GBool getOpen() const { return open; }
675  GooString *getIcon() const { return icon; }
676  AnnotTextState getState() const { return state; }
677
678  void setOpen(GBool openA);
679  void setIcon(GooString *new_icon);
680
681private:
682
683  void initialize(XRef *xrefA, Catalog *catalog, Dict *dict);
684
685  GBool open;                       // Open       (Default false)
686  GooString *icon;                  // Name       (Default Note)
687  AnnotTextState state;             // State      (Default Umarked if
688                                    //             StateModel Marked
689                                    //             None if StareModel Review)
690};
691
692//------------------------------------------------------------------------
693// AnnotMovie
694//------------------------------------------------------------------------
695
696
697
698class AnnotMovie: public Annot {
699 public:
700  enum PosterType {
701    posterTypeNone,
702    posterTypeStream,
703    posterTypeFromMovie
704  };
705
706  enum RepeatMode {
707    repeatModeOnce,
708    repeatModeOpen,
709    repeatModeRepeat,
710    repeatModePalindrome
711  };
712
713  struct Time {
714    Time() { units_per_second = 0; }
715    Gulong units;
716    int units_per_second; // 0 : defined by movie
717  };
718
719  AnnotMovie(XRef *xrefA, PDFRectangle *rect, Movie *movieA, Catalog *catalog);
720  AnnotMovie(XRef *xrefA, Dict *dict, Catalog *catalog, Object *obj);
721  ~AnnotMovie();
722
723  GooString* getTitle() { return title; }
724  GooString* getFileName() { return fileName; }
725  int getRotationAngle() { return rotationAngle; }
726
727  PosterType getPosterType() { return posterType; }
728  Stream* getPosterStream() { return posterStream; }
729
730  Time getStart() { return start; }
731  Time getDuration() { return duration; }
732  double getRate() { return rate; }
733  double getVolume() { return volume; }
734
735  GBool getShowControls() { return showControls; }
736  RepeatMode getRepeatMode() { return repeatMode; }
737  GBool getSynchronousPlay() { return synchronousPlay; }
738
739  GBool needFloatingWindow() { return hasFloatingWindow; }
740  GBool needFullscreen() { return isFullscreen; }
741 
742 
743  void getMovieSize(int& width, int& height);
744  void getZoomFactor(int& num, int& denum);
745  void getWindowPosition(double& x, double& y) { x = FWPosX; y = FWPosY; }
746
747  Movie* getMovie() { return movie; }
748
749 private:
750  void initialize(XRef *xrefA, Catalog *catalog, Dict *dict);
751
752  GooString* title;      // T
753  GooString* fileName;   // Movie/F
754
755  int width;             // Movie/Aspect
756  int height;            // Movie/Aspect
757  int rotationAngle;     // Movie/Rotate
758
759  PosterType posterType; // Movie/Poster
760  Stream* posterStream;
761
762  Time start;            // A/Start
763  Time duration;         // A/Duration
764  double rate;           // A/Rate
765  double volume;         // A/Volume
766 
767  GBool showControls;    // A/ShowControls
768 
769  RepeatMode repeatMode; // A/Mode
770 
771  GBool synchronousPlay; // A/Synchronous
772
773  // floating window
774  GBool hasFloatingWindow; 
775  unsigned short FWScaleNum; // A/FWScale
776  unsigned short FWScaleDenum;
777  GBool isFullscreen;
778
779  double FWPosX;         // A/FWPosition
780  double FWPosY; 
781
782  Movie* movie;
783};
784
785
786//------------------------------------------------------------------------
787// AnnotScreen
788//------------------------------------------------------------------------
789
790class AnnotScreen: public Annot {
791 public:
792
793  AnnotScreen(XRef *xrefA, PDFRectangle *rect, Catalog *catalog);
794  AnnotScreen(XRef *xrefA, Dict *dict, Catalog *catalog, Object *obj);
795  ~AnnotScreen();
796
797  GooString* getTitle() { return title; }
798
799  AnnotAppearanceCharacs *getAppearCharacs() { return appearCharacs; }
800  Object* getAction() { return &action; }
801  Object* getAdditionActions() { return &additionAction; }
802
803 private:
804  void initialize(XRef *xrefA, Catalog *catalog, Dict *dict);
805
806
807  GooString* title;                      // T
808
809  AnnotAppearanceCharacs* appearCharacs; // MK
810
811  Object action;                         // A
812  Object additionAction;                 // AA
813};
814
815//------------------------------------------------------------------------
816// AnnotLink
817//------------------------------------------------------------------------
818
819class AnnotLink: public Annot {
820public:
821
822  enum AnnotLinkEffect {
823    effectNone,     // N
824    effectInvert,   // I
825    effectOutline,  // O
826    effectPush      // P
827  };
828
829  AnnotLink(XRef *xrefA, PDFRectangle *rect, Catalog *catalog);
830  AnnotLink(XRef *xrefA, Dict *dict, Catalog *catalog, Object *obj);
831  virtual ~AnnotLink();
832
833  virtual void draw(Gfx *gfx, GBool printing);
834
835  // getters
836  Dict *getActionDict() const { return actionDict; }
837  Object *getDest() { return &dest; }
838  AnnotLinkEffect getLinkEffect() const { return linkEffect; }
839  Dict *getUriAction() const { return uriAction; }
840  AnnotQuadrilaterals *getQuadrilaterals() const { return quadrilaterals; }
841
842protected:
843
844  void initialize(XRef *xrefA, Catalog *catalog, Dict *dict);
845
846  Dict *actionDict;                    // A
847  Object dest;                         // Dest
848  AnnotLinkEffect linkEffect;          // H          (Default I)
849  Dict *uriAction;                     // PA
850
851  AnnotQuadrilaterals *quadrilaterals; // QuadPoints
852};
853
854//------------------------------------------------------------------------
855// AnnotFreeText
856//------------------------------------------------------------------------
857
858class AnnotFreeText: public AnnotMarkup {
859public:
860
861  enum AnnotFreeTextQuadding {
862    quaddingLeftJustified,  // 0
863    quaddingCentered,       // 1
864    quaddingRightJustified  // 2
865  };
866
867  enum AnnotFreeTextIntent {
868    intentFreeText,           // FreeText
869    intentFreeTextCallout,    // FreeTextCallout
870    intentFreeTextTypeWriter  // FreeTextTypeWriter
871  };
872
873  AnnotFreeText(XRef *xrefA, PDFRectangle *rect, GooString *da, Catalog *catalog);
874  AnnotFreeText(XRef *xrefA, Dict *dict, Catalog *catalog, Object *obj);
875  ~AnnotFreeText();
876
877  // getters
878  GooString *getAppearanceString() const { return appearanceString; }
879  AnnotFreeTextQuadding getQuadding() const { return quadding; }
880  // return rc
881  GooString *getStyleString() const { return styleString; }
882  AnnotCalloutLine *getCalloutLine() const {  return calloutLine; }
883  AnnotFreeTextIntent getIntent() const { return intent; }
884  AnnotBorderEffect *getBorderEffect() const { return borderEffect; }
885  PDFRectangle *getRectangle() const { return rectangle; }
886  AnnotLineEndingStyle getEndStyle() const { return endStyle; }
887
888protected:
889
890  void initialize(XRef *xrefA, Catalog *catalog, Dict *dict);
891
892  // required
893  GooString *appearanceString;      // DA
894
895  // optional
896  AnnotFreeTextQuadding quadding;   // Q  (Default 0)
897  // RC
898  GooString *styleString;           // DS
899  AnnotCalloutLine *calloutLine;    // CL
900  AnnotFreeTextIntent intent;       // IT
901  AnnotBorderEffect *borderEffect;  // BE
902  PDFRectangle *rectangle;          // RD
903  // inherited  from Annot
904  // AnnotBorderBS border;          // BS
905  AnnotLineEndingStyle endStyle;    // LE (Default None)
906};
907
908//------------------------------------------------------------------------
909// AnnotLine
910//------------------------------------------------------------------------
911
912class AnnotLine: public AnnotMarkup {
913public:
914
915  enum AnnotLineIntent {
916    intentLineArrow,    // LineArrow
917    intentLineDimension // LineDimension
918  };
919
920  enum AnnotLineCaptionPos {
921    captionPosInline, // Inline
922    captionPosTop     // Top
923  };
924
925  AnnotLine(XRef *xrefA, PDFRectangle *rect, PDFRectangle *lRect, Catalog *catalog);
926  AnnotLine(XRef *xrefA, Dict *dict, Catalog *catalog, Object *obj);
927  ~AnnotLine();
928
929  // getters
930  AnnotLineEndingStyle getStartStyle() const { return startStyle; }
931  AnnotLineEndingStyle getEndStyle() const { return endStyle; }
932  AnnotColor *getInteriorColor() const { return interiorColor; }
933  double getLeaderLineLength() const { return leaderLineLength; }
934  double getLeaderLineExtension() const { return leaderLineExtension; }
935  bool getCaption() const { return caption; }
936  AnnotLineIntent getIntent() const { return intent; }
937  double  getLeaderLineOffset() const { return leaderLineOffset; }
938  AnnotLineCaptionPos getCaptionPos() const { return captionPos; }
939  Dict *getMeasure() const { return measure; }
940  double getCaptionTextHorizontal() const { return captionTextHorizontal; }
941  double getCaptionTextVertical() const { return captionTextVertical; }
942  double getX1() const { return coord1->getX(); }
943  double getY1() const { return coord1->getY(); }
944  double getX2() const { return coord2->getX(); }
945  double getY2() const { return coord2->getY(); }
946
947protected:
948
949  void initialize(XRef *xrefA, Catalog *catalog, Dict *dict);
950
951  // required
952  AnnotCoord *coord1, *coord2;
953 
954  // optional
955  // inherited  from Annot
956  // AnnotBorderBS border;          // BS
957  AnnotLineEndingStyle startStyle;  // LE       (Default [/None /None])
958  AnnotLineEndingStyle endStyle;    //
959  AnnotColor *interiorColor;        // IC
960  double leaderLineLength;          // LL       (Default 0)
961  double leaderLineExtension;       // LLE      (Default 0)
962  bool caption;                     // Cap      (Default false)
963  AnnotLineIntent intent;           // IT
964  double leaderLineOffset;          // LLO
965  AnnotLineCaptionPos captionPos;   // CP       (Default Inline)
966  Dict *measure;                    // Measure
967  double captionTextHorizontal;     // CO       (Default [0, 0])
968  double captionTextVertical;       //
969};
970
971//------------------------------------------------------------------------
972// AnnotTextMarkup
973//------------------------------------------------------------------------
974
975class AnnotTextMarkup: public AnnotMarkup {
976public:
977
978  AnnotTextMarkup(XRef *xrefA, PDFRectangle *rect, AnnotSubtype subType,
979                  AnnotQuadrilaterals *quadPoints, Catalog *catalog);
980  AnnotTextMarkup(XRef *xrefA, Dict *dict, Catalog *catalog, Object *obj);
981  virtual ~AnnotTextMarkup();
982
983  AnnotQuadrilaterals *getQuadrilaterals() const { return quadrilaterals; }
984
985protected:
986
987  void initialize(XRef *xrefA, Catalog *catalog, Dict *dict);
988 
989  AnnotQuadrilaterals *quadrilaterals; // QuadPoints
990};
991
992//------------------------------------------------------------------------
993// AnnotStamp
994//------------------------------------------------------------------------
995
996class AnnotStamp: public AnnotMarkup {
997public:
998
999  AnnotStamp(XRef *xrefA, PDFRectangle *rect, Catalog *catalog);
1000  AnnotStamp(XRef *xrefA, Dict *dict, Catalog *catalog, Object *obj);
1001  ~AnnotStamp();
1002
1003  // getters
1004  GooString *getIcon() const { return icon; }
1005
1006private:
1007
1008  void initialize(XRef *xrefA, Catalog *catalog, Dict *dict);
1009
1010  GooString *icon;                  // Name       (Default Draft)
1011};
1012
1013//------------------------------------------------------------------------
1014// AnnotGeometry
1015//------------------------------------------------------------------------
1016
1017class AnnotGeometry: public AnnotMarkup {
1018public:
1019
1020  AnnotGeometry(XRef *xrefA, PDFRectangle *rect, AnnotSubtype subType, Catalog *catalog);
1021  AnnotGeometry(XRef *xrefA, Dict *dict, Catalog *catalog, Object *obj);
1022  ~AnnotGeometry();
1023
1024  // getters
1025  AnnotColor *getInteriorColor() const { return interiorColor; }
1026  AnnotBorderEffect *getBorderEffect() const { return borderEffect; }
1027  PDFRectangle *getGeometryRect() const { return geometryRect; }
1028
1029private:
1030
1031  void initialize(XRef *xrefA, Catalog *catalog, Dict *dict);
1032
1033  AnnotColor *interiorColor;        // IC
1034  AnnotBorderEffect *borderEffect;  // BE
1035  PDFRectangle *geometryRect;       // RD (combined with Rect)
1036};
1037
1038//------------------------------------------------------------------------
1039// AnnotPolygon
1040//------------------------------------------------------------------------
1041
1042class AnnotPolygon: public AnnotMarkup {
1043public:
1044
1045  enum AnnotPolygonIntent {
1046    polygonCloud,      // PolygonCloud
1047    polylineDimension, // PolyLineDimension
1048    polygonDimension   // PolygonDimension
1049  };
1050
1051  AnnotPolygon(XRef *xrefA, PDFRectangle *rect, AnnotSubtype subType,
1052               AnnotPath *path, Catalog *catalog);
1053  AnnotPolygon(XRef *xrefA, Dict *dict, Catalog *catalog, Object *obj);
1054  ~AnnotPolygon();
1055
1056  // getters
1057  AnnotPath *getVertices() const { return vertices; }
1058  AnnotLineEndingStyle getStartStyle() const { return startStyle; }
1059  AnnotLineEndingStyle getEndStyle() const { return endStyle; }
1060  AnnotColor *getInteriorColor() const { return interiorColor; }
1061  AnnotBorderEffect *getBorderEffect() const { return borderEffect; }
1062  AnnotPolygonIntent getIntent() const { return intent; }
1063
1064private:
1065
1066  void initialize(XRef *xrefA, Catalog *catalog, Dict *dict);
1067
1068  // required
1069  AnnotPath *vertices;              // Vertices
1070
1071  // optional
1072  AnnotLineEndingStyle startStyle;  // LE       (Default [/None /None])
1073  AnnotLineEndingStyle endStyle;    //
1074  // inherited  from Annot
1075  // AnnotBorderBS border;          // BS
1076  AnnotColor *interiorColor;        // IC
1077  AnnotBorderEffect *borderEffect;  // BE
1078  AnnotPolygonIntent intent;        // IT
1079  // Measure
1080};
1081
1082//------------------------------------------------------------------------
1083// AnnotCaret
1084//------------------------------------------------------------------------
1085
1086class AnnotCaret: public AnnotMarkup {
1087public:
1088
1089  enum AnnotCaretSymbol {
1090    symbolNone,     // None
1091    symbolP         // P
1092  };
1093
1094  AnnotCaret(XRef *xrefA, PDFRectangle *rect, Catalog *catalog);
1095  AnnotCaret(XRef *xrefA, Dict *dict, Catalog *catalog, Object *obj);
1096  ~AnnotCaret();
1097
1098  // getters
1099  AnnotCaretSymbol getSymbol() const { return symbol; }
1100  PDFRectangle *getCaretRect() const { return caretRect; }
1101
1102private:
1103
1104  void initialize(XRef *xrefA, Catalog *catalog, Dict *dict);
1105
1106  AnnotCaretSymbol symbol;       // Sy         (Default None)
1107  PDFRectangle *caretRect;       // RD (combined with Rect)
1108};
1109
1110//------------------------------------------------------------------------
1111// AnnotInk
1112//------------------------------------------------------------------------
1113
1114class AnnotInk: public AnnotMarkup {
1115public:
1116
1117  AnnotInk(XRef *xrefA, PDFRectangle *rect, AnnotPath **paths, int n_paths, Catalog *catalog);
1118  AnnotInk(XRef *xrefA, Dict *dict, Catalog *catalog, Object *obj);
1119  ~AnnotInk();
1120
1121  // getters
1122  AnnotPath **getInkList() const { return inkList; }
1123  int getInkListLength() const { return inkListLength; }
1124
1125private:
1126
1127  void initialize(XRef *xrefA, Catalog *catalog, Dict *dict);
1128
1129  // required
1130  AnnotPath **inkList;       // InkList
1131  int inkListLength;
1132
1133  // optional
1134  // inherited from Annot
1135  // AnnotBorderBS border;  // BS
1136};
1137
1138//------------------------------------------------------------------------
1139// AnnotFileAttachment
1140//------------------------------------------------------------------------
1141
1142class AnnotFileAttachment: public AnnotMarkup {
1143public:
1144
1145  AnnotFileAttachment(XRef *xrefA, PDFRectangle *rect, GooString *filename, Catalog *catalog);
1146  AnnotFileAttachment(XRef *xrefA, Dict *dict, Catalog *catalog, Object *obj);
1147  ~AnnotFileAttachment();
1148
1149  // getters
1150  Object *getFile() { return &file; }
1151  GooString *getName() const { return name; }
1152
1153private:
1154
1155  void initialize(XRef *xrefA, Catalog *catalog, Dict *dict);
1156
1157  // required
1158  Object file;      // FS
1159
1160  // optional
1161  GooString *name;  // Name
1162};
1163
1164//------------------------------------------------------------------------
1165// AnnotSound
1166//------------------------------------------------------------------------
1167
1168class AnnotSound: public AnnotMarkup {
1169public:
1170
1171  AnnotSound(XRef *xrefA, PDFRectangle *rect, Sound *soundA, Catalog *catalog);
1172  AnnotSound(XRef *xrefA, Dict *dict, Catalog *catalog, Object *obj);
1173  ~AnnotSound();
1174
1175  // getters
1176  Sound *getSound() { return sound; }
1177  GooString *getName() const { return name; }
1178
1179private:
1180
1181  void initialize(XRef *xrefA, Catalog *catalog, Dict *dict);
1182
1183  // required
1184  Sound *sound;                  // Sound
1185
1186  // optional
1187  GooString *name;               // Name
1188};
1189
1190//------------------------------------------------------------------------
1191// AnnotWidget
1192//------------------------------------------------------------------------
1193
1194class AnnotWidget: public Annot {
1195public:
1196
1197  enum AnnotWidgetHighlightMode {
1198    highlightModeNone,    // N
1199    highlightModeInvert,  // I
1200    highlightModeOutline, // O
1201    highlightModePush     // P,T
1202  };
1203
1204  AnnotWidget(XRef *xrefA, Dict *dict, Catalog *catalog, Object *obj);
1205  virtual ~AnnotWidget();
1206
1207  virtual void draw(Gfx *gfx, GBool printing);
1208
1209  void generateFieldAppearance ();
1210
1211  AnnotWidgetHighlightMode getMode() { return mode; }
1212  AnnotAppearanceCharacs *getAppearCharacs() { return appearCharacs; }
1213  Dict *getAction() { return action; }
1214  Dict *getAdditionActions() { return additionActions; }
1215  Dict *getParent() { return parent; }
1216
1217private:
1218
1219  void initialize(XRef *xrefA, Catalog *catalog, Dict *dict);
1220
1221  void drawText(GooString *text, GooString *da, GfxFontDict *fontDict,
1222                GBool multiline, int comb, int quadding,
1223                GBool txField, GBool forceZapfDingbats,
1224                GBool password=false);
1225  void drawListBox(GooString **text, GBool *selection,
1226                   int nOptions, int topIdx,
1227                   GooString *da, GfxFontDict *fontDict, GBool quadding);
1228  void layoutText(GooString *text, GooString *outBuf, int *i, GfxFont *font,
1229                  double *width, double widthLimit, int *charCount,
1230                  GBool noReencode);
1231  void writeString(GooString *str, GooString *appearBuf);
1232
1233  Form *form;
1234  FormWidget *widget;                     // FormWidget object for this annotation
1235  AnnotWidgetHighlightMode mode;          // H  (Default I)
1236  AnnotAppearanceCharacs *appearCharacs;  // MK
1237  Dict *action;                           // A
1238  Dict *additionActions;                  // AA
1239  // inherited  from Annot
1240  // AnnotBorderBS border;                // BS
1241  Dict *parent;                           // Parent
1242  GBool regen;
1243  GBool addDingbatsResource;
1244};
1245
1246//------------------------------------------------------------------------
1247// Annot3D
1248//------------------------------------------------------------------------
1249
1250class Annot3D: public Annot {
1251  class Activation {
1252  public:
1253    enum ActivationATrigger {
1254      aTriggerUnknown,
1255      aTriggerPageOpened,  // PO
1256      aTriggerPageVisible, // PV
1257      aTriggerUserAction   // XA
1258    };
1259
1260    enum ActivationAState {
1261      aStateUnknown,
1262      aStateEnabled, // I
1263      aStateDisabled // L
1264    };
1265
1266    enum ActivationDTrigger {
1267      dTriggerUnknown,
1268      dTriggerPageClosed,    // PC
1269      dTriggerPageInvisible, // PI
1270      dTriggerUserAction     // XD
1271    };
1272
1273    enum ActivationDState {
1274      dStateUnknown,
1275      dStateUninstantiaded, // U
1276      dStateInstantiated,   // I
1277      dStateLive            // L
1278    };
1279
1280    Activation(Dict *dict);
1281  private:
1282   
1283    ActivationATrigger aTrigger;  // A   (Default XA)
1284    ActivationAState aState;      // AIS (Default L)
1285    ActivationDTrigger dTrigger;  // D   (Default PI)
1286    ActivationDState dState;      // DIS (Default U)
1287    GBool displayToolbar;         // TB  (Default true)
1288    GBool displayNavigation;      // NP  (Default false);
1289  };
1290public:
1291
1292  Annot3D(XRef *xrefA, PDFRectangle *rect, Catalog *catalog);
1293  Annot3D(XRef *xrefA, Dict *dict, Catalog *catalog, Object *obj);
1294  ~Annot3D();
1295
1296  // getters
1297
1298private:
1299
1300  void initialize(XRef *xrefA, Catalog *catalog, Dict *dict);
1301
1302  Activation *activation;  // 3DA
1303};
1304
1305//------------------------------------------------------------------------
1306// Annots
1307//------------------------------------------------------------------------
1308
1309class Annots {
1310public:
1311
1312  // Build a list of Annot objects.
1313  Annots(XRef *xref, Catalog *catalog, Object *annotsObj);
1314
1315  ~Annots();
1316
1317  // Iterate through list of annotations.
1318  int getNumAnnots() { return nAnnots; }
1319  Annot *getAnnot(int i) { return annots[i]; }
1320
1321private:
1322  Annot* createAnnot(XRef *xref, Dict* dict, Catalog *catalog, Object *obj);
1323  Annot *findAnnot(Ref *ref);
1324
1325  Annot **annots;
1326  int nAnnots;
1327};
1328
1329#endif
Note: See TracBrowser for help on using the repository browser.