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

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

PDF plugin: Poppler library updated to version 0.10.3

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