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

Last change on this file since 261 was 261, checked in by Eugene Romanenko, 13 years ago

PDF plugin: Poppler library updated to version 0.10.2

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