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

Last change on this file since 461 was 461, checked in by Silvan Scherrer, 11 years ago

poppler update to 0.14.2

File size: 37.6 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-2010 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 LinkAction;
49class OCGs;
50class Sound;
51
52enum AnnotLineEndingStyle {
53  annotLineEndingSquare,        // Square
54  annotLineEndingCircle,        // Circle
55  annotLineEndingDiamond,       // Diamond
56  annotLineEndingOpenArrow,     // OpenArrow
57  annotLineEndingClosedArrow,   // ClosedArrow
58  annotLineEndingNone,          // None
59  annotLineEndingButt,          // Butt
60  annotLineEndingROpenArrow,    // ROpenArrow
61  annotLineEndingRClosedArrow,  // RClosedArrow
62  annotLineEndingSlash          // Slash
63};
64
65enum AnnotExternalDataType {
66  annotExternalDataMarkupUnknown,
67  annotExternalDataMarkup3D       // Markup3D
68};
69
70//------------------------------------------------------------------------
71// AnnotCoord
72//------------------------------------------------------------------------
73
74class AnnotCoord {
75public:
76
77  AnnotCoord() : x(0), y(0) { }
78  AnnotCoord(double _x, double _y) : x(_x), y(_y) { }
79
80  double getX() const { return x; }
81  double getY() const { return y; }
82 
83protected:
84
85  double x, y;
86};
87
88//------------------------------------------------------------------------
89// AnnotPath
90//------------------------------------------------------------------------
91
92class AnnotPath {
93public:
94  AnnotPath();
95  AnnotPath(Array *array);
96  AnnotPath(AnnotCoord **coords, int coordLength);
97  ~AnnotPath();
98
99  double getX(int coord) const;
100  double getY(int coord) const;
101  AnnotCoord *getCoord(int coord) const;
102  int getCoordsLength() const { return coordsLength; }
103protected:
104  AnnotCoord **coords;
105  int coordsLength;
106
107  void parsePathArray(Array *array);
108};
109 
110//------------------------------------------------------------------------
111// AnnotCalloutLine
112//------------------------------------------------------------------------
113
114class AnnotCalloutLine {
115public:
116
117  AnnotCalloutLine(double x1, double y1, double x2, double y2);
118  virtual ~AnnotCalloutLine() { }
119
120  double getX1() const { return coord1.getX(); }
121  double getY1() const { return coord1.getY(); }
122  double getX2() const { return coord2.getX(); }
123  double getY2() const { return coord2.getY(); }
124 
125protected:
126
127  AnnotCoord coord1, coord2;
128};
129
130//------------------------------------------------------------------------
131// AnnotCalloutMultiLine
132//------------------------------------------------------------------------
133
134class AnnotCalloutMultiLine: public AnnotCalloutLine {
135public:
136
137  AnnotCalloutMultiLine(double x1, double y1, double x2, double y2,
138    double x3, double y3);
139
140  double getX3() const { return coord3.getX(); }
141  double getY3() const { return coord3.getY(); }
142
143protected:
144
145  AnnotCoord coord3;
146};
147
148//------------------------------------------------------------------------
149// AnnotBorderEffect
150//------------------------------------------------------------------------
151
152class AnnotBorderEffect {
153public:
154
155  enum AnnotBorderEffectType {
156    borderEffectNoEffect, // S
157    borderEffectCloudy    // C
158  };
159
160  AnnotBorderEffect(Dict *dict);
161
162  AnnotBorderEffectType getEffectType() const { return effectType; }
163  double getIntensity() const { return intensity; }
164
165private:
166
167  AnnotBorderEffectType effectType; // S  (Default S)
168  double intensity;                 // I  (Default 0)
169};
170
171//------------------------------------------------------------------------
172// AnnotQuadrilateral
173//------------------------------------------------------------------------
174
175class AnnotQuadrilaterals {
176  class AnnotQuadrilateral {
177  public:
178    AnnotQuadrilateral(double x1, double y1, double x2, double y2, double x3,
179      double y3, double x4, double y4);
180
181    AnnotCoord coord1, coord2, coord3, coord4;
182  };
183
184public:
185
186  AnnotQuadrilaterals(Array *array, PDFRectangle *rect);
187  ~AnnotQuadrilaterals();
188
189  double getX1(int quadrilateral);
190  double getY1(int quadrilateral);
191  double getX2(int quadrilateral);
192  double getY2(int quadrilateral);
193  double getX3(int quadrilateral);
194  double getY3(int quadrilateral);
195  double getX4(int quadrilateral);
196  double getY4(int quadrilateral);
197  int getQuadrilateralsLength() const { return quadrilateralsLength; }
198protected:
199
200  AnnotQuadrilateral** quadrilaterals;
201  int quadrilateralsLength;
202};
203
204//------------------------------------------------------------------------
205// AnnotBorder
206//------------------------------------------------------------------------
207
208class AnnotBorder {
209public:
210  enum AnnotBorderType {
211    typeUnknown,
212    typeArray,
213    typeBS
214  };
215
216  enum AnnotBorderStyle {
217    borderSolid,      // Solid
218    borderDashed,     // Dashed
219    borderBeveled,    // Beveled
220    borderInset,      // Inset
221    borderUnderlined  // Underlined
222  };
223
224  AnnotBorder();
225  virtual ~AnnotBorder();
226
227  virtual AnnotBorderType getType() const { return type; }
228  virtual double getWidth() const { return width; }
229  virtual int getDashLength() const { return dashLength; }
230  virtual double *getDash() const { return dash; }
231  virtual AnnotBorderStyle getStyle() const { return style; }
232
233protected:
234  AnnotBorderType type;
235  double width;
236  int dashLength;
237  double *dash;
238  AnnotBorderStyle style;
239};
240
241//------------------------------------------------------------------------
242// AnnotBorderArray
243//------------------------------------------------------------------------
244
245class AnnotBorderArray: public AnnotBorder {
246public:
247  AnnotBorderArray();
248  AnnotBorderArray(Array *array);
249
250  double getHorizontalCorner() const { return horizontalCorner; }
251  double getVerticalCorner() const { return verticalCorner; }
252
253protected:
254  static const int DASH_LIMIT = 10; // implementation note 82 in Appendix H.
255  double horizontalCorner;          // (Default 0)
256  double verticalCorner;            // (Default 0)
257  // double width;                  // (Default 1)  (inherited from AnnotBorder)
258};
259
260//------------------------------------------------------------------------
261// AnnotBorderBS
262//------------------------------------------------------------------------
263
264class AnnotBorderBS: public AnnotBorder {
265public:
266
267  AnnotBorderBS();
268  AnnotBorderBS(Dict *dict);
269
270private:
271  // double width;           // W  (Default 1)   (inherited from AnnotBorder)
272  // AnnotBorderStyle style; // S  (Default S)   (inherited from AnnotBorder)
273  // double *dash;           // D  (Default [3]) (inherited from AnnotBorder)
274};
275
276//------------------------------------------------------------------------
277// AnnotColor
278//------------------------------------------------------------------------
279
280class AnnotColor {
281public:
282
283  enum AnnotColorSpace {
284    colorTransparent = 0,
285    colorGray        = 1,
286    colorRGB         = 3,
287    colorCMYK        = 4
288  };
289
290  AnnotColor();
291  AnnotColor(double gray);
292  AnnotColor(double r, double g, double b);
293  AnnotColor(double c, double m, double y, double k);
294  AnnotColor(Array *array, int adjust = 0);
295
296  AnnotColorSpace getSpace() const { return (AnnotColorSpace) length; }
297  const double *getValues() const { return values; }
298
299private:
300
301  double values[4];
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  int getPageNum() const { return page; }
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(AnnotColor *color, GBool fill);
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  void createForm(double *bbox, GBool transparencyGroup, Object *resDict, Object *aStream);
542  void createResourcesDict(char *formName, Object *formStream, char *stateName,
543                           double opacity, char *blendMode, Object *resDict);
544  GBool isVisible(GBool printing);
545
546  // Updates the field key of the annotation dictionary
547  // and sets M to the current time
548  void update(const char *key, Object *value);
549
550  Object annotObj;
551 
552  // required data
553  AnnotSubtype type;                // Annotation type
554  PDFRectangle *rect;               // Rect
555
556  // optional data
557  GooString *contents;              // Contents
558  int       page;                   // P
559  GooString *name;                  // NM
560  GooString *modified;              // M
561  Guint flags;                      // F (must be a 32 bit unsigned int)
562  //Dict *appearDict;                 // AP (should be correctly parsed)
563  Ref appRef;                       //the reference to the indirect appearance object in XRef
564  Object appearance;     // a reference to the Form XObject stream
565                         //   for the normal appearance
566  GooString *appearState;           // AS
567  int treeKey;                      // Struct Parent;
568  OCGs *optContentConfig;           // Optional content config
569  Object oc;                        // OC
570
571  XRef *xref;                   // the xref table for this PDF file
572  Ref ref;                      // object ref identifying this annotation
573  GooString *appearBuf;
574  AnnotBorder *border;          // Border, BS
575  AnnotColor *color;            // C
576  double fontSize; 
577  GBool ok;
578
579  bool hasRef;
580};
581
582//------------------------------------------------------------------------
583// AnnotPopup
584//------------------------------------------------------------------------
585
586class AnnotPopup: public Annot {
587public:
588  AnnotPopup(XRef *xrefA, PDFRectangle *rect, Catalog *catalog);
589  AnnotPopup(XRef *xrefA, Dict *dict, Catalog *catalog, Object *obj);
590  ~AnnotPopup();
591
592  Object *getParent(Object *obj) { return parent.fetch (xref, obj); }
593  Object *getParentNF(Object *obj) { return &parent; }
594  void setParent(Object *parentA);
595  void setParent(Annot *parentA);
596  GBool getOpen() const { return open; }
597  void setOpen(GBool openA);
598
599protected:
600  void initialize(XRef *xrefA, Dict *dict, Catalog *catalog);
601
602  Object parent; // Parent
603  GBool open;   // Open
604};
605
606//------------------------------------------------------------------------
607// AnnotMarkup
608//------------------------------------------------------------------------
609
610class AnnotMarkup: public Annot {
611public:
612  enum  AnnotMarkupReplyType {
613    replyTypeR,     // R
614    replyTypeGroup  // Group
615  };
616
617  AnnotMarkup(XRef *xrefA, PDFRectangle *rect, Catalog *catalog);
618  AnnotMarkup(XRef *xrefA, Dict *dict, Catalog *catalog, Object *obj);
619  virtual ~AnnotMarkup();
620
621  // getters
622  GooString *getLabel() const { return label; }
623  AnnotPopup *getPopup() const { return popup; }
624  double getOpacity() const { return opacity; }
625  // getRC
626  GooString *getDate() const { return date; }
627  int getInReplyToID() const { return inReplyTo.num; }
628  GooString *getSubject() const { return subject; }
629  AnnotMarkupReplyType getReplyTo() const { return replyTo; }
630  AnnotExternalDataType getExData() const { return exData; }
631
632  // The annotation takes the ownership of new_popup
633  void setPopup(AnnotPopup *new_popup);
634  void setLabel(GooString *new_label);
635
636protected:
637  GooString *label;             // T            (Default autor)
638  AnnotPopup *popup;            // Popup
639  double opacity;               // CA           (Default 1.0)
640  // RC
641  GooString *date;              // CreationDate
642  Ref inReplyTo;                // IRT
643  GooString *subject;           // Subj
644  AnnotMarkupReplyType replyTo; // RT           (Default R)
645  // this object is overrided by the custom intent fields defined in some
646  // annotation types.
647  //GooString *intent;          // IT
648  AnnotExternalDataType exData; // ExData
649
650private:
651  void initialize(XRef *xrefA, Dict *dict, Catalog *catalog, Object *obj);
652};
653
654//------------------------------------------------------------------------
655// AnnotText
656//------------------------------------------------------------------------
657
658class AnnotText: public AnnotMarkup {
659public:
660  enum AnnotTextState {
661    stateUnknown,
662    // Marked state model
663    stateMarked,    // Marked
664    stateUnmarked,  // Unmarked
665    // Review state model
666    stateAccepted,  // Accepted
667    stateRejected,  // Rejected
668    stateCancelled, // Cancelled
669    stateCompleted, // Completed
670    stateNone       // None
671  };
672
673  AnnotText(XRef *xrefA, PDFRectangle *rect, Catalog *catalog);
674  AnnotText(XRef *xrefA, Dict *dict, Catalog *catalog, Object *obj);
675  ~AnnotText();
676
677  virtual void draw(Gfx *gfx, GBool printing);
678
679  // getters
680  GBool getOpen() const { return open; }
681  GooString *getIcon() const { return icon; }
682  AnnotTextState getState() const { return state; }
683
684  void setOpen(GBool openA);
685  void setIcon(GooString *new_icon);
686
687private:
688
689  void initialize(XRef *xrefA, Catalog *catalog, Dict *dict);
690
691  GBool open;                       // Open       (Default false)
692  GooString *icon;                  // Name       (Default Note)
693  AnnotTextState state;             // State      (Default Umarked if
694                                    //             StateModel Marked
695                                    //             None if StareModel Review)
696};
697
698//------------------------------------------------------------------------
699// AnnotMovie
700//------------------------------------------------------------------------
701
702
703
704class AnnotMovie: public Annot {
705 public:
706  AnnotMovie(XRef *xrefA, PDFRectangle *rect, Movie *movieA, Catalog *catalog);
707  AnnotMovie(XRef *xrefA, Dict *dict, Catalog *catalog, Object *obj);
708  ~AnnotMovie();
709
710  virtual void draw(Gfx *gfx, GBool printing);
711
712  GooString* getTitle() { return title; }
713  Movie* getMovie() { return movie; }
714
715 private:
716  void initialize(XRef *xrefA, Catalog *catalog, Dict *dict);
717
718  GooString* title;      // T
719  Movie* movie;          // Movie + A
720};
721
722
723//------------------------------------------------------------------------
724// AnnotScreen
725//------------------------------------------------------------------------
726
727class AnnotScreen: public Annot {
728 public:
729
730  AnnotScreen(XRef *xrefA, PDFRectangle *rect, Catalog *catalog);
731  AnnotScreen(XRef *xrefA, Dict *dict, Catalog *catalog, Object *obj);
732  ~AnnotScreen();
733
734  GooString* getTitle() { return title; }
735
736  AnnotAppearanceCharacs *getAppearCharacs() { return appearCharacs; }
737  LinkAction* getAction() { return action; }
738  Object* getAdditionActions() { return &additionAction; }
739
740 private:
741  void initialize(XRef *xrefA, Catalog *catalog, Dict *dict);
742
743
744  GooString* title;                      // T
745
746  AnnotAppearanceCharacs* appearCharacs; // MK
747
748  LinkAction *action;                    // A
749  Object additionAction;                 // AA
750};
751
752//------------------------------------------------------------------------
753// AnnotLink
754//------------------------------------------------------------------------
755
756class AnnotLink: public Annot {
757public:
758
759  enum AnnotLinkEffect {
760    effectNone,     // N
761    effectInvert,   // I
762    effectOutline,  // O
763    effectPush      // P
764  };
765
766  AnnotLink(XRef *xrefA, PDFRectangle *rect, Catalog *catalog);
767  AnnotLink(XRef *xrefA, Dict *dict, Catalog *catalog, Object *obj);
768  virtual ~AnnotLink();
769
770  virtual void draw(Gfx *gfx, GBool printing);
771
772  // getters
773  Dict *getActionDict() const { return actionDict; }
774  Object *getDest() { return &dest; }
775  AnnotLinkEffect getLinkEffect() const { return linkEffect; }
776  Dict *getUriAction() const { return uriAction; }
777  AnnotQuadrilaterals *getQuadrilaterals() const { return quadrilaterals; }
778
779protected:
780
781  void initialize(XRef *xrefA, Catalog *catalog, Dict *dict);
782
783  Dict *actionDict;                    // A
784  Object dest;                         // Dest
785  AnnotLinkEffect linkEffect;          // H          (Default I)
786  Dict *uriAction;                     // PA
787
788  AnnotQuadrilaterals *quadrilaterals; // QuadPoints
789};
790
791//------------------------------------------------------------------------
792// AnnotFreeText
793//------------------------------------------------------------------------
794
795class AnnotFreeText: public AnnotMarkup {
796public:
797
798  enum AnnotFreeTextQuadding {
799    quaddingLeftJustified,  // 0
800    quaddingCentered,       // 1
801    quaddingRightJustified  // 2
802  };
803
804  enum AnnotFreeTextIntent {
805    intentFreeText,           // FreeText
806    intentFreeTextCallout,    // FreeTextCallout
807    intentFreeTextTypeWriter  // FreeTextTypeWriter
808  };
809
810  AnnotFreeText(XRef *xrefA, PDFRectangle *rect, GooString *da, Catalog *catalog);
811  AnnotFreeText(XRef *xrefA, Dict *dict, Catalog *catalog, Object *obj);
812  ~AnnotFreeText();
813
814  // getters
815  GooString *getAppearanceString() const { return appearanceString; }
816  AnnotFreeTextQuadding getQuadding() const { return quadding; }
817  // return rc
818  GooString *getStyleString() const { return styleString; }
819  AnnotCalloutLine *getCalloutLine() const {  return calloutLine; }
820  AnnotFreeTextIntent getIntent() const { return intent; }
821  AnnotBorderEffect *getBorderEffect() const { return borderEffect; }
822  PDFRectangle *getRectangle() const { return rectangle; }
823  AnnotLineEndingStyle getEndStyle() const { return endStyle; }
824
825protected:
826
827  void initialize(XRef *xrefA, Catalog *catalog, Dict *dict);
828
829  // required
830  GooString *appearanceString;      // DA
831
832  // optional
833  AnnotFreeTextQuadding quadding;   // Q  (Default 0)
834  // RC
835  GooString *styleString;           // DS
836  AnnotCalloutLine *calloutLine;    // CL
837  AnnotFreeTextIntent intent;       // IT
838  AnnotBorderEffect *borderEffect;  // BE
839  PDFRectangle *rectangle;          // RD
840  // inherited  from Annot
841  // AnnotBorderBS border;          // BS
842  AnnotLineEndingStyle endStyle;    // LE (Default None)
843};
844
845//------------------------------------------------------------------------
846// AnnotLine
847//------------------------------------------------------------------------
848
849class AnnotLine: public AnnotMarkup {
850public:
851
852  enum AnnotLineIntent {
853    intentLineArrow,    // LineArrow
854    intentLineDimension // LineDimension
855  };
856
857  enum AnnotLineCaptionPos {
858    captionPosInline, // Inline
859    captionPosTop     // Top
860  };
861
862  AnnotLine(XRef *xrefA, PDFRectangle *rect, PDFRectangle *lRect, Catalog *catalog);
863  AnnotLine(XRef *xrefA, Dict *dict, Catalog *catalog, Object *obj);
864  ~AnnotLine();
865
866  virtual void draw(Gfx *gfx, GBool printing);
867
868  // getters
869  AnnotLineEndingStyle getStartStyle() const { return startStyle; }
870  AnnotLineEndingStyle getEndStyle() const { return endStyle; }
871  AnnotColor *getInteriorColor() const { return interiorColor; }
872  double getLeaderLineLength() const { return leaderLineLength; }
873  double getLeaderLineExtension() const { return leaderLineExtension; }
874  bool getCaption() const { return caption; }
875  AnnotLineIntent getIntent() const { return intent; }
876  double  getLeaderLineOffset() const { return leaderLineOffset; }
877  AnnotLineCaptionPos getCaptionPos() const { return captionPos; }
878  Dict *getMeasure() const { return measure; }
879  double getCaptionTextHorizontal() const { return captionTextHorizontal; }
880  double getCaptionTextVertical() const { return captionTextVertical; }
881  double getX1() const { return coord1->getX(); }
882  double getY1() const { return coord1->getY(); }
883  double getX2() const { return coord2->getX(); }
884  double getY2() const { return coord2->getY(); }
885
886protected:
887
888  void initialize(XRef *xrefA, Catalog *catalog, Dict *dict);
889
890  // required
891  AnnotCoord *coord1, *coord2;
892 
893  // optional
894  // inherited  from Annot
895  // AnnotBorderBS border;          // BS
896  AnnotLineEndingStyle startStyle;  // LE       (Default [/None /None])
897  AnnotLineEndingStyle endStyle;    //
898  AnnotColor *interiorColor;        // IC
899  double leaderLineLength;          // LL       (Default 0)
900  double leaderLineExtension;       // LLE      (Default 0)
901  bool caption;                     // Cap      (Default false)
902  AnnotLineIntent intent;           // IT
903  double leaderLineOffset;          // LLO
904  AnnotLineCaptionPos captionPos;   // CP       (Default Inline)
905  Dict *measure;                    // Measure
906  double captionTextHorizontal;     // CO       (Default [0, 0])
907  double captionTextVertical;       //
908};
909
910//------------------------------------------------------------------------
911// AnnotTextMarkup
912//------------------------------------------------------------------------
913
914class AnnotTextMarkup: public AnnotMarkup {
915public:
916
917  AnnotTextMarkup(XRef *xrefA, PDFRectangle *rect, AnnotSubtype subType,
918                  AnnotQuadrilaterals *quadPoints, Catalog *catalog);
919  AnnotTextMarkup(XRef *xrefA, Dict *dict, Catalog *catalog, Object *obj);
920  virtual ~AnnotTextMarkup();
921
922  virtual void draw(Gfx *gfx, GBool printing);
923
924  AnnotQuadrilaterals *getQuadrilaterals() const { return quadrilaterals; }
925
926protected:
927
928  void initialize(XRef *xrefA, Catalog *catalog, Dict *dict);
929 
930  AnnotQuadrilaterals *quadrilaterals; // QuadPoints
931};
932
933//------------------------------------------------------------------------
934// AnnotStamp
935//------------------------------------------------------------------------
936
937class AnnotStamp: public AnnotMarkup {
938public:
939
940  AnnotStamp(XRef *xrefA, PDFRectangle *rect, Catalog *catalog);
941  AnnotStamp(XRef *xrefA, Dict *dict, Catalog *catalog, Object *obj);
942  ~AnnotStamp();
943
944  // getters
945  GooString *getIcon() const { return icon; }
946
947private:
948
949  void initialize(XRef *xrefA, Catalog *catalog, Dict *dict);
950
951  GooString *icon;                  // Name       (Default Draft)
952};
953
954//------------------------------------------------------------------------
955// AnnotGeometry
956//------------------------------------------------------------------------
957
958class AnnotGeometry: public AnnotMarkup {
959public:
960
961  AnnotGeometry(XRef *xrefA, PDFRectangle *rect, AnnotSubtype subType, Catalog *catalog);
962  AnnotGeometry(XRef *xrefA, Dict *dict, Catalog *catalog, Object *obj);
963  ~AnnotGeometry();
964
965  virtual void draw(Gfx *gfx, GBool printing);
966
967  // getters
968  AnnotColor *getInteriorColor() const { return interiorColor; }
969  AnnotBorderEffect *getBorderEffect() const { return borderEffect; }
970  PDFRectangle *getGeometryRect() const { return geometryRect; }
971
972private:
973
974  void initialize(XRef *xrefA, Catalog *catalog, Dict *dict);
975
976  AnnotColor *interiorColor;        // IC
977  AnnotBorderEffect *borderEffect;  // BE
978  PDFRectangle *geometryRect;       // RD (combined with Rect)
979};
980
981//------------------------------------------------------------------------
982// AnnotPolygon
983//------------------------------------------------------------------------
984
985class AnnotPolygon: public AnnotMarkup {
986public:
987
988  enum AnnotPolygonIntent {
989    polygonCloud,      // PolygonCloud
990    polylineDimension, // PolyLineDimension
991    polygonDimension   // PolygonDimension
992  };
993
994  AnnotPolygon(XRef *xrefA, PDFRectangle *rect, AnnotSubtype subType,
995               AnnotPath *path, Catalog *catalog);
996  AnnotPolygon(XRef *xrefA, Dict *dict, Catalog *catalog, Object *obj);
997  ~AnnotPolygon();
998
999  // getters
1000  AnnotPath *getVertices() const { return vertices; }
1001  AnnotLineEndingStyle getStartStyle() const { return startStyle; }
1002  AnnotLineEndingStyle getEndStyle() const { return endStyle; }
1003  AnnotColor *getInteriorColor() const { return interiorColor; }
1004  AnnotBorderEffect *getBorderEffect() const { return borderEffect; }
1005  AnnotPolygonIntent getIntent() const { return intent; }
1006
1007private:
1008
1009  void initialize(XRef *xrefA, Catalog *catalog, Dict *dict);
1010
1011  // required
1012  AnnotPath *vertices;              // Vertices
1013
1014  // optional
1015  AnnotLineEndingStyle startStyle;  // LE       (Default [/None /None])
1016  AnnotLineEndingStyle endStyle;    //
1017  // inherited  from Annot
1018  // AnnotBorderBS border;          // BS
1019  AnnotColor *interiorColor;        // IC
1020  AnnotBorderEffect *borderEffect;  // BE
1021  AnnotPolygonIntent intent;        // IT
1022  // Measure
1023};
1024
1025//------------------------------------------------------------------------
1026// AnnotCaret
1027//------------------------------------------------------------------------
1028
1029class AnnotCaret: public AnnotMarkup {
1030public:
1031
1032  enum AnnotCaretSymbol {
1033    symbolNone,     // None
1034    symbolP         // P
1035  };
1036
1037  AnnotCaret(XRef *xrefA, PDFRectangle *rect, Catalog *catalog);
1038  AnnotCaret(XRef *xrefA, Dict *dict, Catalog *catalog, Object *obj);
1039  ~AnnotCaret();
1040
1041  // getters
1042  AnnotCaretSymbol getSymbol() const { return symbol; }
1043  PDFRectangle *getCaretRect() const { return caretRect; }
1044
1045private:
1046
1047  void initialize(XRef *xrefA, Catalog *catalog, Dict *dict);
1048
1049  AnnotCaretSymbol symbol;       // Sy         (Default None)
1050  PDFRectangle *caretRect;       // RD (combined with Rect)
1051};
1052
1053//------------------------------------------------------------------------
1054// AnnotInk
1055//------------------------------------------------------------------------
1056
1057class AnnotInk: public AnnotMarkup {
1058public:
1059
1060  AnnotInk(XRef *xrefA, PDFRectangle *rect, AnnotPath **paths, int n_paths, Catalog *catalog);
1061  AnnotInk(XRef *xrefA, Dict *dict, Catalog *catalog, Object *obj);
1062  ~AnnotInk();
1063
1064  // getters
1065  AnnotPath **getInkList() const { return inkList; }
1066  int getInkListLength() const { return inkListLength; }
1067
1068private:
1069
1070  void initialize(XRef *xrefA, Catalog *catalog, Dict *dict);
1071
1072  // required
1073  AnnotPath **inkList;       // InkList
1074  int inkListLength;
1075
1076  // optional
1077  // inherited from Annot
1078  // AnnotBorderBS border;  // BS
1079};
1080
1081//------------------------------------------------------------------------
1082// AnnotFileAttachment
1083//------------------------------------------------------------------------
1084
1085class AnnotFileAttachment: public AnnotMarkup {
1086public:
1087
1088  AnnotFileAttachment(XRef *xrefA, PDFRectangle *rect, GooString *filename, Catalog *catalog);
1089  AnnotFileAttachment(XRef *xrefA, Dict *dict, Catalog *catalog, Object *obj);
1090  ~AnnotFileAttachment();
1091
1092  virtual void draw(Gfx *gfx, GBool printing);
1093
1094  // getters
1095  Object *getFile() { return &file; }
1096  GooString *getName() const { return name; }
1097
1098private:
1099
1100  void initialize(XRef *xrefA, Catalog *catalog, Dict *dict);
1101
1102  // required
1103  Object file;      // FS
1104
1105  // optional
1106  GooString *name;  // Name
1107};
1108
1109//------------------------------------------------------------------------
1110// AnnotSound
1111//------------------------------------------------------------------------
1112
1113class AnnotSound: public AnnotMarkup {
1114public:
1115
1116  AnnotSound(XRef *xrefA, PDFRectangle *rect, Sound *soundA, Catalog *catalog);
1117  AnnotSound(XRef *xrefA, Dict *dict, Catalog *catalog, Object *obj);
1118  ~AnnotSound();
1119
1120  virtual void draw(Gfx *gfx, GBool printing);
1121
1122  // getters
1123  Sound *getSound() { return sound; }
1124  GooString *getName() const { return name; }
1125
1126private:
1127
1128  void initialize(XRef *xrefA, Catalog *catalog, Dict *dict);
1129
1130  // required
1131  Sound *sound;                  // Sound
1132
1133  // optional
1134  GooString *name;               // Name
1135};
1136
1137//------------------------------------------------------------------------
1138// AnnotWidget
1139//------------------------------------------------------------------------
1140
1141class AnnotWidget: public Annot {
1142public:
1143
1144  enum AnnotWidgetHighlightMode {
1145    highlightModeNone,    // N
1146    highlightModeInvert,  // I
1147    highlightModeOutline, // O
1148    highlightModePush     // P,T
1149  };
1150
1151  AnnotWidget(XRef *xrefA, Dict *dict, Catalog *catalog, Object *obj);
1152  virtual ~AnnotWidget();
1153
1154  virtual void draw(Gfx *gfx, GBool printing);
1155
1156  void generateFieldAppearance ();
1157
1158  AnnotWidgetHighlightMode getMode() { return mode; }
1159  AnnotAppearanceCharacs *getAppearCharacs() { return appearCharacs; }
1160  Dict *getAction() { return action; }
1161  Dict *getAdditionActions() { return additionActions; }
1162  Dict *getParent() { return parent; }
1163
1164private:
1165
1166  void initialize(XRef *xrefA, Catalog *catalog, Dict *dict);
1167
1168  void drawText(GooString *text, GooString *da, GfxFontDict *fontDict,
1169                GBool multiline, int comb, int quadding,
1170                GBool txField, GBool forceZapfDingbats,
1171                GBool password=false);
1172  void drawListBox(GooString **text, GBool *selection,
1173                   int nOptions, int topIdx,
1174                   GooString *da, GfxFontDict *fontDict, GBool quadding);
1175  void layoutText(GooString *text, GooString *outBuf, int *i, GfxFont *font,
1176                  double *width, double widthLimit, int *charCount,
1177                  GBool noReencode);
1178  void writeString(GooString *str, GooString *appearBuf);
1179
1180  Form *form;
1181  FormWidget *widget;                     // FormWidget object for this annotation
1182  AnnotWidgetHighlightMode mode;          // H  (Default I)
1183  AnnotAppearanceCharacs *appearCharacs;  // MK
1184  Dict *action;                           // A
1185  Dict *additionActions;                  // AA
1186  // inherited  from Annot
1187  // AnnotBorderBS border;                // BS
1188  Dict *parent;                           // Parent
1189  GBool regen;
1190  GBool addDingbatsResource;
1191};
1192
1193//------------------------------------------------------------------------
1194// Annot3D
1195//------------------------------------------------------------------------
1196
1197class Annot3D: public Annot {
1198  class Activation {
1199  public:
1200    enum ActivationATrigger {
1201      aTriggerUnknown,
1202      aTriggerPageOpened,  // PO
1203      aTriggerPageVisible, // PV
1204      aTriggerUserAction   // XA
1205    };
1206
1207    enum ActivationAState {
1208      aStateUnknown,
1209      aStateEnabled, // I
1210      aStateDisabled // L
1211    };
1212
1213    enum ActivationDTrigger {
1214      dTriggerUnknown,
1215      dTriggerPageClosed,    // PC
1216      dTriggerPageInvisible, // PI
1217      dTriggerUserAction     // XD
1218    };
1219
1220    enum ActivationDState {
1221      dStateUnknown,
1222      dStateUninstantiaded, // U
1223      dStateInstantiated,   // I
1224      dStateLive            // L
1225    };
1226
1227    Activation(Dict *dict);
1228  private:
1229   
1230    ActivationATrigger aTrigger;  // A   (Default XA)
1231    ActivationAState aState;      // AIS (Default L)
1232    ActivationDTrigger dTrigger;  // D   (Default PI)
1233    ActivationDState dState;      // DIS (Default U)
1234    GBool displayToolbar;         // TB  (Default true)
1235    GBool displayNavigation;      // NP  (Default false);
1236  };
1237public:
1238
1239  Annot3D(XRef *xrefA, PDFRectangle *rect, Catalog *catalog);
1240  Annot3D(XRef *xrefA, Dict *dict, Catalog *catalog, Object *obj);
1241  ~Annot3D();
1242
1243  // getters
1244
1245private:
1246
1247  void initialize(XRef *xrefA, Catalog *catalog, Dict *dict);
1248
1249  Activation *activation;  // 3DA
1250};
1251
1252//------------------------------------------------------------------------
1253// Annots
1254//------------------------------------------------------------------------
1255
1256class Annots {
1257public:
1258
1259  // Build a list of Annot objects.
1260  Annots(XRef *xref, Catalog *catalog, Object *annotsObj);
1261
1262  ~Annots();
1263
1264  // Iterate through list of annotations.
1265  int getNumAnnots() { return nAnnots; }
1266  Annot *getAnnot(int i) { return annots[i]; }
1267
1268private:
1269  Annot* createAnnot(XRef *xref, Dict* dict, Catalog *catalog, Object *obj);
1270  Annot *findAnnot(Ref *ref);
1271
1272  Annot **annots;
1273  int nAnnots;
1274};
1275
1276#endif
Note: See TracBrowser for help on using the repository browser.