diff options
Diffstat (limited to 'Build/source/libs/poppler/poppler-0.35.0/poppler/Annot.h')
-rw-r--r-- | Build/source/libs/poppler/poppler-0.35.0/poppler/Annot.h | 1439 |
1 files changed, 1439 insertions, 0 deletions
diff --git a/Build/source/libs/poppler/poppler-0.35.0/poppler/Annot.h b/Build/source/libs/poppler/poppler-0.35.0/poppler/Annot.h new file mode 100644 index 00000000000..1e64f59bc76 --- /dev/null +++ b/Build/source/libs/poppler/poppler-0.35.0/poppler/Annot.h @@ -0,0 +1,1439 @@ +//======================================================================== +// +// Annot.h +// +// Copyright 2000-2003 Glyph & Cog, LLC +// +//======================================================================== + +//======================================================================== +// +// Modified under the Poppler project - http://poppler.freedesktop.org +// +// All changes made under the Poppler project to this file are licensed +// under GPL version 2 or later +// +// Copyright (C) 2006 Scott Turner <scotty1024@mac.com> +// Copyright (C) 2007, 2008 Julien Rebetez <julienr@svn.gnome.org> +// Copyright (C) 2007-2011, 2013, 2015 Carlos Garcia Campos <carlosgc@gnome.org> +// Copyright (C) 2007, 2008 Iñigo Martínez <inigomartinez@gmail.com> +// Copyright (C) 2008 Michael Vrable <mvrable@cs.ucsd.edu> +// Copyright (C) 2008 Hugo Mercier <hmercier31@gmail.com> +// Copyright (C) 2008 Pino Toscano <pino@kde.org> +// Copyright (C) 2008 Tomas Are Haavet <tomasare@gmail.com> +// Copyright (C) 2009-2011, 2013 Albert Astals Cid <aacid@kde.org> +// Copyright (C) 2012, 2013 Fabio D'Urso <fabiodurso@hotmail.it> +// Copyright (C) 2012 Tobias Koenig <tokoe@kdab.com> +// Copyright (C) 2013 Thomas Freitag <Thomas.Freitag@alfa.de> +// Copyright (C) 2013 Adrian Johnson <ajohnson@redneon.com> +// +// To see a description of the changes please see the Changelog file that +// came with your tarball or type make ChangeLog if you are building from git +// +//======================================================================== + +#ifndef ANNOT_H +#define ANNOT_H + +#ifdef USE_GCC_PRAGMAS +#pragma interface +#endif + +#include "Object.h" + +class XRef; +class Gfx; +class CharCodeToUnicode; +class GfxFont; +class GfxResources; +class Page; +class PDFDoc; +class Form; +class FormWidget; +class FormField; +class FormFieldChoice; +class PDFRectangle; +class Movie; +class LinkAction; +class Sound; + +enum AnnotLineEndingStyle { + annotLineEndingSquare, // Square + annotLineEndingCircle, // Circle + annotLineEndingDiamond, // Diamond + annotLineEndingOpenArrow, // OpenArrow + annotLineEndingClosedArrow, // ClosedArrow + annotLineEndingNone, // None + annotLineEndingButt, // Butt + annotLineEndingROpenArrow, // ROpenArrow + annotLineEndingRClosedArrow, // RClosedArrow + annotLineEndingSlash // Slash +}; + +enum AnnotExternalDataType { + annotExternalDataMarkupUnknown, + annotExternalDataMarkup3D // Markup3D +}; + +//------------------------------------------------------------------------ +// AnnotCoord +//------------------------------------------------------------------------ + +class AnnotCoord { +public: + + AnnotCoord() : x(0), y(0) { } + AnnotCoord(double _x, double _y) : x(_x), y(_y) { } + + double getX() const { return x; } + double getY() const { return y; } + +protected: + + double x, y; +}; + +//------------------------------------------------------------------------ +// AnnotPath +//------------------------------------------------------------------------ + +class AnnotPath { +public: + AnnotPath(); + AnnotPath(Array *array); + AnnotPath(AnnotCoord **coords, int coordLength); + ~AnnotPath(); + + double getX(int coord) const; + double getY(int coord) const; + AnnotCoord *getCoord(int coord) const; + int getCoordsLength() const { return coordsLength; } +protected: + AnnotCoord **coords; + int coordsLength; + + void parsePathArray(Array *array); +}; + +//------------------------------------------------------------------------ +// AnnotCalloutLine +//------------------------------------------------------------------------ + +class AnnotCalloutLine { +public: + + AnnotCalloutLine(double x1, double y1, double x2, double y2); + virtual ~AnnotCalloutLine() { } + + double getX1() const { return coord1.getX(); } + double getY1() const { return coord1.getY(); } + double getX2() const { return coord2.getX(); } + double getY2() const { return coord2.getY(); } + +protected: + + AnnotCoord coord1, coord2; +}; + +//------------------------------------------------------------------------ +// AnnotCalloutMultiLine +//------------------------------------------------------------------------ + +class AnnotCalloutMultiLine: public AnnotCalloutLine { +public: + + AnnotCalloutMultiLine(double x1, double y1, double x2, double y2, + double x3, double y3); + + double getX3() const { return coord3.getX(); } + double getY3() const { return coord3.getY(); } + +protected: + + AnnotCoord coord3; +}; + +//------------------------------------------------------------------------ +// AnnotBorderEffect +//------------------------------------------------------------------------ + +class AnnotBorderEffect { +public: + + enum AnnotBorderEffectType { + borderEffectNoEffect, // S + borderEffectCloudy // C + }; + + AnnotBorderEffect(Dict *dict); + + AnnotBorderEffectType getEffectType() const { return effectType; } + double getIntensity() const { return intensity; } + +private: + + AnnotBorderEffectType effectType; // S (Default S) + double intensity; // I (Default 0) +}; + +//------------------------------------------------------------------------ +// AnnotQuadrilateral +//------------------------------------------------------------------------ + +class AnnotQuadrilaterals { +public: + class AnnotQuadrilateral { + public: + AnnotQuadrilateral(double x1, double y1, double x2, double y2, double x3, + double y3, double x4, double y4); + + AnnotCoord coord1, coord2, coord3, coord4; + }; + + AnnotQuadrilaterals(Array *array, PDFRectangle *rect); + AnnotQuadrilaterals(AnnotQuadrilateral **quads, int quadsLength); + ~AnnotQuadrilaterals(); + + double getX1(int quadrilateral); + double getY1(int quadrilateral); + double getX2(int quadrilateral); + double getY2(int quadrilateral); + double getX3(int quadrilateral); + double getY3(int quadrilateral); + double getX4(int quadrilateral); + double getY4(int quadrilateral); + int getQuadrilateralsLength() const { return quadrilateralsLength; } +protected: + + AnnotQuadrilateral** quadrilaterals; + int quadrilateralsLength; +}; + +//------------------------------------------------------------------------ +// AnnotBorder +//------------------------------------------------------------------------ + +class AnnotBorder { +public: + enum AnnotBorderType { + typeArray, + typeBS + }; + + enum AnnotBorderStyle { + borderSolid, // Solid + borderDashed, // Dashed + borderBeveled, // Beveled + borderInset, // Inset + borderUnderlined // Underlined + }; + + virtual ~AnnotBorder(); + + virtual void setWidth(double new_width) { width = new_width; } + + virtual AnnotBorderType getType() const = 0; + virtual double getWidth() const { return width; } + virtual int getDashLength() const { return dashLength; } + virtual double *getDash() const { return dash; } + virtual AnnotBorderStyle getStyle() const { return style; } + + virtual void writeToObject(XRef *xref, Object *obj1) const = 0; + +protected: + AnnotBorder(); + + GBool parseDashArray(Object *dashObj); + + AnnotBorderType type; + double width; + static const int DASH_LIMIT = 10; // implementation note 82 in Appendix H. + int dashLength; + double *dash; + AnnotBorderStyle style; +}; + +//------------------------------------------------------------------------ +// AnnotBorderArray +//------------------------------------------------------------------------ + +class AnnotBorderArray: public AnnotBorder { +public: + AnnotBorderArray(); + AnnotBorderArray(Array *array); + + void setHorizontalCorner(double hc) { horizontalCorner = hc; } + void setVerticalCorner(double vc) { verticalCorner = vc; } + + double getHorizontalCorner() const { return horizontalCorner; } + double getVerticalCorner() const { return verticalCorner; } + +private: + virtual AnnotBorderType getType() const { return typeArray; } + virtual void writeToObject(XRef *xref, Object *obj1) const; + + double horizontalCorner; // (Default 0) + double verticalCorner; // (Default 0) + // double width; // (Default 1) (inherited from AnnotBorder) +}; + +//------------------------------------------------------------------------ +// AnnotBorderBS +//------------------------------------------------------------------------ + +class AnnotBorderBS: public AnnotBorder { +public: + + AnnotBorderBS(); + AnnotBorderBS(Dict *dict); + +private: + virtual AnnotBorderType getType() const { return typeBS; } + virtual void writeToObject(XRef *xref, Object *obj1) const; + + const char *getStyleName() const; + + // double width; // W (Default 1) (inherited from AnnotBorder) + // AnnotBorderStyle style; // S (Default S) (inherited from AnnotBorder) + // double *dash; // D (Default [3]) (inherited from AnnotBorder) +}; + +//------------------------------------------------------------------------ +// AnnotColor +//------------------------------------------------------------------------ + +class AnnotColor { +public: + + enum AnnotColorSpace { + colorTransparent = 0, + colorGray = 1, + colorRGB = 3, + colorCMYK = 4 + }; + + AnnotColor(); + AnnotColor(double gray); + AnnotColor(double r, double g, double b); + AnnotColor(double c, double m, double y, double k); + AnnotColor(Array *array, int adjust = 0); + + void adjustColor(int adjust); + + AnnotColorSpace getSpace() const { return (AnnotColorSpace) length; } + const double *getValues() const { return values; } + + void writeToObject(XRef *xref, Object *dest) const; + +private: + + double values[4]; + int length; +}; + +//------------------------------------------------------------------------ +// AnnotIconFit +//------------------------------------------------------------------------ + +class AnnotIconFit { +public: + + enum AnnotIconFitScaleWhen { + scaleAlways, // A + scaleBigger, // B + scaleSmaller, // S + scaleNever // N + }; + + enum AnnotIconFitScale { + scaleAnamorphic, // A + scaleProportional // P + }; + + AnnotIconFit(Dict *dict); + + AnnotIconFitScaleWhen getScaleWhen() { return scaleWhen; } + AnnotIconFitScale getScale() { return scale; } + double getLeft() { return left; } + double getBottom() { return bottom; } + bool getFullyBounds() { return fullyBounds; } + +protected: + + AnnotIconFitScaleWhen scaleWhen; // SW (Default A) + AnnotIconFitScale scale; // S (Default P) + double left; // A (Default [0.5 0.5] + double bottom; // Only if scale is P + bool fullyBounds; // FB (Default false) +}; + +//------------------------------------------------------------------------ +// AnnotAppearance +//------------------------------------------------------------------------ + +class AnnotAppearance { +public: + + enum AnnotAppearanceType { + appearNormal, + appearRollover, + appearDown + }; + + AnnotAppearance(PDFDoc *docA, Object *dict); + ~AnnotAppearance(); + + // State is ignored if no subdictionary is present + void getAppearanceStream(AnnotAppearanceType type, const char *state, Object *dest); + + // Access keys in normal appearance subdictionary (N) + GooString * getStateKey(int i); + int getNumStates(); + + // Removes all associated streams in the xref table. Caller is required to + // reset parent annotation's AP and AS after this call. + void removeAllStreams(); + + // Test if this AnnotAppearance references the specified stream + GBool referencesStream(Ref targetStreamRef); + +private: + static GBool referencesStream(Object *stateObj, Ref targetStreamRef); + void removeStream(Ref refToStream); + void removeStateStreams(Object *state); + +protected: + PDFDoc *doc; + XRef *xref; // the xref table for this PDF file + Object appearDict; // Annotation's AP +}; + +//------------------------------------------------------------------------ +// AnnotAppearanceCharacs +//------------------------------------------------------------------------ + +class AnnotAppearanceCharacs { +public: + + enum AnnotAppearanceCharacsTextPos { + captionNoIcon, // 0 + captionNoCaption, // 1 + captionBelow, // 2 + captionAbove, // 3 + captionRight, // 4 + captionLeft, // 5 + captionOverlaid // 6 + }; + + AnnotAppearanceCharacs(Dict *dict); + ~AnnotAppearanceCharacs(); + + int getRotation() { return rotation; } + AnnotColor *getBorderColor() { return borderColor; } + AnnotColor *getBackColor() { return backColor; } + GooString *getNormalCaption() { return normalCaption; } + GooString *getRolloverCaption() { return rolloverCaption; } + GooString *getAlternateCaption() { return alternateCaption; } + AnnotIconFit *getIconFit() { return iconFit; } + AnnotAppearanceCharacsTextPos getPosition() { return position; } + +protected: + + int rotation; // R (Default 0) + AnnotColor *borderColor; // BC + AnnotColor *backColor; // BG + GooString *normalCaption; // CA + GooString *rolloverCaption; // RC + GooString *alternateCaption; // AC + // I + // RI + // IX + AnnotIconFit *iconFit; // IF + AnnotAppearanceCharacsTextPos position; // TP (Default 0) +}; + +//------------------------------------------------------------------------ +// AnnotAppearanceBBox +//------------------------------------------------------------------------ + +class AnnotAppearanceBBox +{ +public: + AnnotAppearanceBBox(PDFRectangle *init); + + void setBorderWidth(double w) { borderWidth = w; } + + // The following functions operate on coords relative to [origX origY] + void extendTo(double x, double y); + void getBBoxRect(double bbox[4]) const; + + // Get boundaries in page coordinates + double getPageXMin() const; + double getPageYMin() const; + double getPageXMax() const; + double getPageYMax() const; + +private: + double origX, origY, borderWidth; + double minX, minY, maxX, maxY; +}; + +//------------------------------------------------------------------------ +// Annot +//------------------------------------------------------------------------ + +class Annot { + friend class Annots; + friend class Page; +public: + enum AnnotFlag { + flagUnknown = 0x0000, + flagInvisible = 0x0001, + flagHidden = 0x0002, + flagPrint = 0x0004, + flagNoZoom = 0x0008, + flagNoRotate = 0x0010, + flagNoView = 0x0020, + flagReadOnly = 0x0040, + flagLocked = 0x0080, + flagToggleNoView = 0x0100, + flagLockedContents = 0x0200 + }; + + enum AnnotSubtype { + typeUnknown, // 0 + typeText, // Text 1 + typeLink, // Link 2 + typeFreeText, // FreeText 3 + typeLine, // Line 4 + typeSquare, // Square 5 + typeCircle, // Circle 6 + typePolygon, // Polygon 7 + typePolyLine, // PolyLine 8 + typeHighlight, // Highlight 9 + typeUnderline, // Underline 10 + typeSquiggly, // Squiggly 11 + typeStrikeOut, // StrikeOut 12 + typeStamp, // Stamp 13 + typeCaret, // Caret 14 + typeInk, // Ink 15 + typePopup, // Popup 16 + typeFileAttachment, // FileAttachment 17 + typeSound, // Sound 18 + typeMovie, // Movie 19 + typeWidget, // Widget 20 + typeScreen, // Screen 21 + typePrinterMark, // PrinterMark 22 + typeTrapNet, // TrapNet 23 + typeWatermark, // Watermark 24 + type3D // 3D 25 + }; + + /** + * Describes the additional actions of a screen or widget annotation. + */ + enum AdditionalActionsType { + actionCursorEntering, ///< Performed when the cursor enters the annotation's active area + actionCursorLeaving, ///< Performed when the cursor exists the annotation's active area + actionMousePressed, ///< Performed when the mouse button is pressed inside the annotation's active area + actionMouseReleased, ///< Performed when the mouse button is released inside the annotation's active area + actionFocusIn, ///< Performed when the annotation receives the input focus + actionFocusOut, ///< Performed when the annotation loses the input focus + actionPageOpening, ///< Performed when the page containing the annotation is opened + actionPageClosing, ///< Performed when the page containing the annotation is closed + actionPageVisible, ///< Performed when the page containing the annotation becomes visible + actionPageInvisible ///< Performed when the page containing the annotation becomes invisible + }; + + enum FormAdditionalActionsType { + actionFieldModified, ///< Performed when the when the user modifies the field + actionFormatField, ///< Performed before the field is formatted to display its value + actionValidateField, ///< Performed when the field value changes + actionCalculateField, ///< Performed when the field needs to be recalculated + }; + + Annot(PDFDoc *docA, PDFRectangle *rectA); + Annot(PDFDoc *docA, Dict *dict); + Annot(PDFDoc *docA, Dict *dict, Object *obj); + GBool isOk() { return ok; } + + void incRefCnt(); + void decRefCnt(); + + virtual void draw(Gfx *gfx, GBool printing); + // Get the resource dict of the appearance stream + virtual Object *getAppearanceResDict(Object *dest); + + GBool match(Ref *refA) + { return ref.num == refA->num && ref.gen == refA->gen; } + + double getXMin(); + double getYMin(); + double getXMax(); + double getYMax(); + + double getFontSize() { return fontSize; } + + void setRect(PDFRectangle *rect); + void setRect(double x1, double y1, double x2, double y2); + + // Sets the annot contents to new_content + // new_content should never be NULL + virtual void setContents(GooString *new_content); + void setName(GooString *new_name); + void setModified(GooString *new_date); + void setFlags(Guint new_flags); + + void setBorder(AnnotBorder *new_border); // Takes ownership + + // The annotation takes the ownership of + // new_color. + void setColor(AnnotColor *new_color); + + void setAppearanceState(const char *state); + + // getters + PDFDoc *getDoc() const { return doc; } + XRef *getXRef() const { return xref; } + GBool getHasRef() const { return hasRef; } + Ref getRef() const { return ref; } + AnnotSubtype getType() const { return type; } + PDFRectangle *getRect() const { return rect; } + void getRect(double *x1, double *y1, double *x2, double *y2) const; + GooString *getContents() const { return contents; } + int getPageNum() const { return page; } + GooString *getName() const { return name; } + GooString *getModified() const { return modified; } + Guint getFlags() const { return flags; } + AnnotAppearance *getAppearStreams() const { return appearStreams; } + GooString *getAppearState() const { return appearState; } + AnnotBorder *getBorder() const { return border; } + AnnotColor *getColor() const { return color; } + int getTreeKey() const { return treeKey; } + + int getId() { return ref.num; } + + // Check if point is inside the annot rectangle. + GBool inRect(double x, double y) const; + +private: + void readArrayNum(Object *pdfArray, int key, double *value); + // write vStr[i:j[ in appearBuf + + void initialize (PDFDoc *docA, Dict *dict); + void setPage (int new_page, GBool updateP); // Called by Page::addAnnot and Annots ctor + + +protected: + virtual ~Annot(); + virtual void removeReferencedObjects(); // Called by Page::removeAnnot + void setColor(AnnotColor *color, GBool fill); + void setLineStyleForBorder(AnnotBorder *border); + void drawCircle(double cx, double cy, double r, GBool fill); + void drawCircleTopLeft(double cx, double cy, double r); + void drawCircleBottomRight(double cx, double cy, double r); + void layoutText(GooString *text, GooString *outBuf, int *i, GfxFont *font, + double *width, double widthLimit, int *charCount, + GBool noReencode); + void writeString(GooString *str, GooString *appearBuf); + void createForm(double *bbox, GBool transparencyGroup, Object *resDict, Object *aStream); + void createResourcesDict(const char *formName, Object *formStream, const char *stateName, + double opacity, const char *blendMode, Object *resDict); + GBool isVisible(GBool printing); + int getRotation() const; + + // Updates the field key of the annotation dictionary + // and sets M to the current time + void update(const char *key, Object *value); + + // Delete appearance streams and reset appearance state + void invalidateAppearance(); + + int refCnt; + + Object annotObj; + + // required data + AnnotSubtype type; // Annotation type + PDFRectangle *rect; // Rect + + // optional data + GooString *contents; // Contents + int page; // P + GooString *name; // NM + GooString *modified; // M + Guint flags; // F (must be a 32 bit unsigned int) + AnnotAppearance *appearStreams; // AP + Object appearance; // a reference to the Form XObject stream + // for the normal appearance + AnnotAppearanceBBox *appearBBox; // BBox of generated appearance + GooString *appearState; // AS + int treeKey; // Struct Parent; + Object oc; // OC + + PDFDoc *doc; + XRef *xref; // the xref table for this PDF file + Ref ref; // object ref identifying this annotation + GooString *appearBuf; + AnnotBorder *border; // Border, BS + AnnotColor *color; // C + double fontSize; + GBool ok; + + bool hasRef; +#if MULTITHREADED + GooMutex mutex; +#endif +}; + +//------------------------------------------------------------------------ +// AnnotPopup +//------------------------------------------------------------------------ + +class AnnotPopup: public Annot { +public: + AnnotPopup(PDFDoc *docA, PDFRectangle *rect); + AnnotPopup(PDFDoc *docA, Dict *dict, Object *obj); + ~AnnotPopup(); + + Object *getParent(Object *obj) { return parent.fetch (xref, obj); } + Object *getParentNF() { return &parent; } + void setParent(Object *parentA); + void setParent(Annot *parentA); + GBool getOpen() const { return open; } + void setOpen(GBool openA); + +protected: + void initialize(PDFDoc *docA, Dict *dict); + + Object parent; // Parent + GBool open; // Open +}; + +//------------------------------------------------------------------------ +// AnnotMarkup +//------------------------------------------------------------------------ + +class AnnotMarkup: public Annot { +public: + enum AnnotMarkupReplyType { + replyTypeR, // R + replyTypeGroup // Group + }; + + AnnotMarkup(PDFDoc *docA, PDFRectangle *rect); + AnnotMarkup(PDFDoc *docA, Dict *dict, Object *obj); + virtual ~AnnotMarkup(); + + // getters + GooString *getLabel() const { return label; } + AnnotPopup *getPopup() const { return popup; } + double getOpacity() const { return opacity; } + // getRC + GooString *getDate() const { return date; } + int getInReplyToID() const { return inReplyTo.num; } + GooString *getSubject() const { return subject; } + AnnotMarkupReplyType getReplyTo() const { return replyTo; } + AnnotExternalDataType getExData() const { return exData; } + + // The annotation takes the ownership of new_popup + void setPopup(AnnotPopup *new_popup); + void setLabel(GooString *new_label); + void setOpacity(double opacityA); + void setDate(GooString *new_date); + +protected: + virtual void removeReferencedObjects(); + + GooString *label; // T (Default autor) + AnnotPopup *popup; // Popup + double opacity; // CA (Default 1.0) + // RC + GooString *date; // CreationDate + Ref inReplyTo; // IRT + GooString *subject; // Subj + AnnotMarkupReplyType replyTo; // RT (Default R) + // this object is overrided by the custom intent fields defined in some + // annotation types. + //GooString *intent; // IT + AnnotExternalDataType exData; // ExData + +private: + void initialize(PDFDoc *docA, Dict *dict, Object *obj); +}; + +//------------------------------------------------------------------------ +// AnnotText +//------------------------------------------------------------------------ + +class AnnotText: public AnnotMarkup { +public: + enum AnnotTextState { + stateUnknown, + // Marked state model + stateMarked, // Marked + stateUnmarked, // Unmarked + // Review state model + stateAccepted, // Accepted + stateRejected, // Rejected + stateCancelled, // Cancelled + stateCompleted, // Completed + stateNone // None + }; + + AnnotText(PDFDoc *docA, PDFRectangle *rect); + AnnotText(PDFDoc *docA, Dict *dict, Object *obj); + ~AnnotText(); + + virtual void draw(Gfx *gfx, GBool printing); + + // getters + GBool getOpen() const { return open; } + GooString *getIcon() const { return icon; } + AnnotTextState getState() const { return state; } + + void setOpen(GBool openA); + void setIcon(GooString *new_icon); + +private: + + void initialize(PDFDoc *docA, Dict *dict); + + GBool open; // Open (Default false) + GooString *icon; // Name (Default Note) + AnnotTextState state; // State (Default Umarked if + // StateModel Marked + // None if StareModel Review) +}; + +//------------------------------------------------------------------------ +// AnnotMovie +//------------------------------------------------------------------------ + + + +class AnnotMovie: public Annot { + public: + AnnotMovie(PDFDoc *docA, PDFRectangle *rect, Movie *movieA); + AnnotMovie(PDFDoc *docA, Dict *dict, Object *obj); + ~AnnotMovie(); + + virtual void draw(Gfx *gfx, GBool printing); + + GooString* getTitle() { return title; } + Movie* getMovie() { return movie; } + + private: + void initialize(PDFDoc *docA, Dict *dict); + + GooString* title; // T + Movie* movie; // Movie + A +}; + + +//------------------------------------------------------------------------ +// AnnotScreen +//------------------------------------------------------------------------ + +class AnnotScreen: public Annot { + public: + + AnnotScreen(PDFDoc *docA, PDFRectangle *rect); + AnnotScreen(PDFDoc *docA, Dict *dict, Object *obj); + ~AnnotScreen(); + + GooString* getTitle() { return title; } + + AnnotAppearanceCharacs *getAppearCharacs() { return appearCharacs; } + LinkAction* getAction() { return action; } + LinkAction *getAdditionalAction(AdditionalActionsType type); + + private: + void initialize(PDFDoc *docA, Dict *dict); + + + GooString* title; // T + + AnnotAppearanceCharacs* appearCharacs; // MK + + LinkAction *action; // A + Object additionalActions; // AA +}; + +//------------------------------------------------------------------------ +// AnnotLink +//------------------------------------------------------------------------ + +class AnnotLink: public Annot { +public: + + enum AnnotLinkEffect { + effectNone, // N + effectInvert, // I + effectOutline, // O + effectPush // P + }; + + AnnotLink(PDFDoc *docA, PDFRectangle *rect); + AnnotLink(PDFDoc *docA, Dict *dict, Object *obj); + virtual ~AnnotLink(); + + virtual void draw(Gfx *gfx, GBool printing); + + // getters + LinkAction *getAction() const { return action; } + AnnotLinkEffect getLinkEffect() const { return linkEffect; } + Dict *getUriAction() const { return uriAction; } + AnnotQuadrilaterals *getQuadrilaterals() const { return quadrilaterals; } + +protected: + + void initialize(PDFDoc *docA, Dict *dict); + + LinkAction *action; // A, Dest + AnnotLinkEffect linkEffect; // H (Default I) + Dict *uriAction; // PA + + AnnotQuadrilaterals *quadrilaterals; // QuadPoints +}; + +//------------------------------------------------------------------------ +// AnnotFreeText +//------------------------------------------------------------------------ + +class AnnotFreeText: public AnnotMarkup { +public: + + enum AnnotFreeTextQuadding { + quaddingLeftJustified, // 0 + quaddingCentered, // 1 + quaddingRightJustified // 2 + }; + + enum AnnotFreeTextIntent { + intentFreeText, // FreeText + intentFreeTextCallout, // FreeTextCallout + intentFreeTextTypeWriter // FreeTextTypeWriter + }; + + AnnotFreeText(PDFDoc *docA, PDFRectangle *rect, GooString *da); + AnnotFreeText(PDFDoc *docA, Dict *dict, Object *obj); + ~AnnotFreeText(); + + virtual void draw(Gfx *gfx, GBool printing); + virtual Object *getAppearanceResDict(Object *dest); + virtual void setContents(GooString *new_content); + + void setAppearanceString(GooString *new_string); + void setQuadding(AnnotFreeTextQuadding new_quadding); + void setStyleString(GooString *new_string); + void setCalloutLine(AnnotCalloutLine *line); + void setIntent(AnnotFreeTextIntent new_intent); + + // getters + GooString *getAppearanceString() const { return appearanceString; } + AnnotFreeTextQuadding getQuadding() const { return quadding; } + // return rc + GooString *getStyleString() const { return styleString; } + AnnotCalloutLine *getCalloutLine() const { return calloutLine; } + AnnotFreeTextIntent getIntent() const { return intent; } + AnnotBorderEffect *getBorderEffect() const { return borderEffect; } + PDFRectangle *getRectangle() const { return rectangle; } + AnnotLineEndingStyle getEndStyle() const { return endStyle; } + +protected: + + void initialize(PDFDoc *docA, Dict *dict); + static void parseAppearanceString(GooString *da, double &fontsize, AnnotColor* &fontcolor); + void generateFreeTextAppearance(); + + // required + GooString *appearanceString; // DA + + // optional + AnnotFreeTextQuadding quadding; // Q (Default 0) + // RC + GooString *styleString; // DS + AnnotCalloutLine *calloutLine; // CL + AnnotFreeTextIntent intent; // IT + AnnotBorderEffect *borderEffect; // BE + PDFRectangle *rectangle; // RD + // inherited from Annot + // AnnotBorderBS border; // BS + AnnotLineEndingStyle endStyle; // LE (Default None) +}; + +//------------------------------------------------------------------------ +// AnnotLine +//------------------------------------------------------------------------ + +class AnnotLine: public AnnotMarkup { +public: + + enum AnnotLineIntent { + intentLineArrow, // LineArrow + intentLineDimension // LineDimension + }; + + enum AnnotLineCaptionPos { + captionPosInline, // Inline + captionPosTop // Top + }; + + AnnotLine(PDFDoc *docA, PDFRectangle *rect); + AnnotLine(PDFDoc *docA, Dict *dict, Object *obj); + ~AnnotLine(); + + virtual void draw(Gfx *gfx, GBool printing); + virtual Object *getAppearanceResDict(Object *dest); + virtual void setContents(GooString *new_content); + + void setVertices(double x1, double y1, double x2, double y2); + void setStartEndStyle(AnnotLineEndingStyle start, AnnotLineEndingStyle end); + void setInteriorColor(AnnotColor *new_color); + void setLeaderLineLength(double len); + void setLeaderLineExtension(double len); + void setCaption(bool new_cap); + void setIntent(AnnotLineIntent new_intent); + + // getters + AnnotLineEndingStyle getStartStyle() const { return startStyle; } + AnnotLineEndingStyle getEndStyle() const { return endStyle; } + AnnotColor *getInteriorColor() const { return interiorColor; } + double getLeaderLineLength() const { return leaderLineLength; } + double getLeaderLineExtension() const { return leaderLineExtension; } + bool getCaption() const { return caption; } + AnnotLineIntent getIntent() const { return intent; } + double getLeaderLineOffset() const { return leaderLineOffset; } + AnnotLineCaptionPos getCaptionPos() const { return captionPos; } + Dict *getMeasure() const { return measure; } + double getCaptionTextHorizontal() const { return captionTextHorizontal; } + double getCaptionTextVertical() const { return captionTextVertical; } + double getX1() const { return coord1->getX(); } + double getY1() const { return coord1->getY(); } + double getX2() const { return coord2->getX(); } + double getY2() const { return coord2->getY(); } + +protected: + + void initialize(PDFDoc *docA, Dict *dict); + void generateLineAppearance(); + + // required + AnnotCoord *coord1, *coord2; + + // optional + // inherited from Annot + // AnnotBorderBS border; // BS + AnnotLineEndingStyle startStyle; // LE (Default [/None /None]) + AnnotLineEndingStyle endStyle; // + AnnotColor *interiorColor; // IC + double leaderLineLength; // LL (Default 0) + double leaderLineExtension; // LLE (Default 0) + bool caption; // Cap (Default false) + AnnotLineIntent intent; // IT + double leaderLineOffset; // LLO + AnnotLineCaptionPos captionPos; // CP (Default Inline) + Dict *measure; // Measure + double captionTextHorizontal; // CO (Default [0, 0]) + double captionTextVertical; // +}; + +//------------------------------------------------------------------------ +// AnnotTextMarkup +//------------------------------------------------------------------------ + +class AnnotTextMarkup: public AnnotMarkup { +public: + + AnnotTextMarkup(PDFDoc *docA, PDFRectangle *rect, AnnotSubtype subType); + AnnotTextMarkup(PDFDoc *docA, Dict *dict, Object *obj); + virtual ~AnnotTextMarkup(); + + virtual void draw(Gfx *gfx, GBool printing); + + // typeHighlight, typeUnderline, typeSquiggly or typeStrikeOut + void setType(AnnotSubtype new_type); + + void setQuadrilaterals(AnnotQuadrilaterals *quadPoints); + + AnnotQuadrilaterals *getQuadrilaterals() const { return quadrilaterals; } + +protected: + + void initialize(PDFDoc *docA, Dict *dict); + + AnnotQuadrilaterals *quadrilaterals; // QuadPoints +}; + +//------------------------------------------------------------------------ +// AnnotStamp +//------------------------------------------------------------------------ + +class AnnotStamp: public AnnotMarkup { +public: + + AnnotStamp(PDFDoc *docA, PDFRectangle *rect); + AnnotStamp(PDFDoc *docA, Dict *dict, Object *obj); + ~AnnotStamp(); + + void setIcon(GooString *new_icon); + + // getters + GooString *getIcon() const { return icon; } + +private: + + void initialize(PDFDoc *docA, Dict *dict); + + GooString *icon; // Name (Default Draft) +}; + +//------------------------------------------------------------------------ +// AnnotGeometry +//------------------------------------------------------------------------ + +class AnnotGeometry: public AnnotMarkup { +public: + + AnnotGeometry(PDFDoc *docA, PDFRectangle *rect, AnnotSubtype subType); + AnnotGeometry(PDFDoc *docA, Dict *dict, Object *obj); + ~AnnotGeometry(); + + virtual void draw(Gfx *gfx, GBool printing); + + void setType(AnnotSubtype new_type); // typeSquare or typeCircle + void setInteriorColor(AnnotColor *new_color); + + // getters + AnnotColor *getInteriorColor() const { return interiorColor; } + AnnotBorderEffect *getBorderEffect() const { return borderEffect; } + PDFRectangle *getGeometryRect() const { return geometryRect; } + +private: + + void initialize(PDFDoc *docA, Dict *dict); + + AnnotColor *interiorColor; // IC + AnnotBorderEffect *borderEffect; // BE + PDFRectangle *geometryRect; // RD (combined with Rect) +}; + +//------------------------------------------------------------------------ +// AnnotPolygon +//------------------------------------------------------------------------ + +class AnnotPolygon: public AnnotMarkup { +public: + + enum AnnotPolygonIntent { + polygonCloud, // PolygonCloud + polylineDimension, // PolyLineDimension + polygonDimension // PolygonDimension + }; + + AnnotPolygon(PDFDoc *docA, PDFRectangle *rect, AnnotSubtype subType); + AnnotPolygon(PDFDoc *docA, Dict *dict, Object *obj); + ~AnnotPolygon(); + + virtual void draw(Gfx *gfx, GBool printing); + + void setType(AnnotSubtype new_type); // typePolygon or typePolyLine + void setVertices(AnnotPath *path); + void setStartEndStyle(AnnotLineEndingStyle start, AnnotLineEndingStyle end); + void setInteriorColor(AnnotColor *new_color); + void setIntent(AnnotPolygonIntent new_intent); + + // getters + AnnotPath *getVertices() const { return vertices; } + AnnotLineEndingStyle getStartStyle() const { return startStyle; } + AnnotLineEndingStyle getEndStyle() const { return endStyle; } + AnnotColor *getInteriorColor() const { return interiorColor; } + AnnotBorderEffect *getBorderEffect() const { return borderEffect; } + AnnotPolygonIntent getIntent() const { return intent; } + +private: + + void initialize(PDFDoc *docA, Dict *dict); + + // required + AnnotPath *vertices; // Vertices + + // optional + AnnotLineEndingStyle startStyle; // LE (Default [/None /None]) + AnnotLineEndingStyle endStyle; // + // inherited from Annot + // AnnotBorderBS border; // BS + AnnotColor *interiorColor; // IC + AnnotBorderEffect *borderEffect; // BE + AnnotPolygonIntent intent; // IT + // Measure +}; + +//------------------------------------------------------------------------ +// AnnotCaret +//------------------------------------------------------------------------ + +class AnnotCaret: public AnnotMarkup { +public: + + enum AnnotCaretSymbol { + symbolNone, // None + symbolP // P + }; + + AnnotCaret(PDFDoc *docA, PDFRectangle *rect); + AnnotCaret(PDFDoc *docA, Dict *dict, Object *obj); + ~AnnotCaret(); + + void setSymbol(AnnotCaretSymbol new_symbol); + + // getters + AnnotCaretSymbol getSymbol() const { return symbol; } + PDFRectangle *getCaretRect() const { return caretRect; } + +private: + + void initialize(PDFDoc *docA, Dict *dict); + + AnnotCaretSymbol symbol; // Sy (Default None) + PDFRectangle *caretRect; // RD (combined with Rect) +}; + +//------------------------------------------------------------------------ +// AnnotInk +//------------------------------------------------------------------------ + +class AnnotInk: public AnnotMarkup { +public: + + AnnotInk(PDFDoc *docA, PDFRectangle *rect); + AnnotInk(PDFDoc *docA, Dict *dict, Object *obj); + ~AnnotInk(); + + virtual void draw(Gfx *gfx, GBool printing); + + void setInkList(AnnotPath **paths, int n_paths); + + // getters + AnnotPath **getInkList() const { return inkList; } + int getInkListLength() const { return inkListLength; } + +private: + + void initialize(PDFDoc *docA, Dict *dict); + void writeInkList(AnnotPath **paths, int n_paths, Array *dest_array); + void parseInkList(Array *src_array); + void freeInkList(); + + // required + AnnotPath **inkList; // InkList + int inkListLength; + + // optional + // inherited from Annot + // AnnotBorderBS border; // BS +}; + +//------------------------------------------------------------------------ +// AnnotFileAttachment +//------------------------------------------------------------------------ + +class AnnotFileAttachment: public AnnotMarkup { +public: + + AnnotFileAttachment(PDFDoc *docA, PDFRectangle *rect, GooString *filename); + AnnotFileAttachment(PDFDoc *docA, Dict *dict, Object *obj); + ~AnnotFileAttachment(); + + virtual void draw(Gfx *gfx, GBool printing); + + // getters + Object *getFile() { return &file; } + GooString *getName() const { return name; } + +private: + + void initialize(PDFDoc *docA, Dict *dict); + + // required + Object file; // FS + + // optional + GooString *name; // Name +}; + +//------------------------------------------------------------------------ +// AnnotSound +//------------------------------------------------------------------------ + +class AnnotSound: public AnnotMarkup { +public: + + AnnotSound(PDFDoc *docA, PDFRectangle *rect, Sound *soundA); + AnnotSound(PDFDoc *docA, Dict *dict, Object *obj); + ~AnnotSound(); + + virtual void draw(Gfx *gfx, GBool printing); + + // getters + Sound *getSound() { return sound; } + GooString *getName() const { return name; } + +private: + + void initialize(PDFDoc *docA, Dict *dict); + + // required + Sound *sound; // Sound + + // optional + GooString *name; // Name +}; + +//------------------------------------------------------------------------ +// AnnotWidget +//------------------------------------------------------------------------ + +class AnnotWidget: public Annot { +public: + + enum AnnotWidgetHighlightMode { + highlightModeNone, // N + highlightModeInvert, // I + highlightModeOutline, // O + highlightModePush // P,T + }; + + AnnotWidget(PDFDoc *docA, Dict *dict, Object *obj); + AnnotWidget(PDFDoc *docA, Dict *dict, Object *obj, FormField *fieldA); + virtual ~AnnotWidget(); + + virtual void draw(Gfx *gfx, GBool printing); + + void drawBorder(); + void drawFormFieldButton(GfxResources *resources, GooString *da); + void drawFormFieldText(GfxResources *resources, GooString *da); + void drawFormFieldChoice(GfxResources *resources, GooString *da); + void generateFieldAppearance (); + void updateAppearanceStream (); + + AnnotWidgetHighlightMode getMode() { return mode; } + AnnotAppearanceCharacs *getAppearCharacs() { return appearCharacs; } + LinkAction *getAction() { return action; } + LinkAction *getAdditionalAction(AdditionalActionsType type); + LinkAction *getFormAdditionalAction(FormAdditionalActionsType type); + Dict *getParent() { return parent; } + +private: + + void initialize(PDFDoc *docA, Dict *dict); + + void drawText(GooString *text, GooString *da, GfxResources *resources, + GBool multiline, int comb, int quadding, + GBool txField, GBool forceZapfDingbats, + GBool password=false); + void drawListBox(FormFieldChoice *fieldChoice, + GooString *da, GfxResources *resources, int quadding); + + Form *form; + FormField *field; // FormField object for this annotation + AnnotWidgetHighlightMode mode; // H (Default I) + AnnotAppearanceCharacs *appearCharacs; // MK + LinkAction *action; // A + Object additionalActions; // AA + // inherited from Annot + // AnnotBorderBS border; // BS + Dict *parent; // Parent + GBool addDingbatsResource; + Ref updatedAppearanceStream; // {-1,-1} if updateAppearanceStream has never been called +}; + +//------------------------------------------------------------------------ +// Annot3D +//------------------------------------------------------------------------ + +class Annot3D: public Annot { + class Activation { + public: + enum ActivationATrigger { + aTriggerUnknown, + aTriggerPageOpened, // PO + aTriggerPageVisible, // PV + aTriggerUserAction // XA + }; + + enum ActivationAState { + aStateUnknown, + aStateEnabled, // I + aStateDisabled // L + }; + + enum ActivationDTrigger { + dTriggerUnknown, + dTriggerPageClosed, // PC + dTriggerPageInvisible, // PI + dTriggerUserAction // XD + }; + + enum ActivationDState { + dStateUnknown, + dStateUninstantiaded, // U + dStateInstantiated, // I + dStateLive // L + }; + + Activation(Dict *dict); + private: + + ActivationATrigger aTrigger; // A (Default XA) + ActivationAState aState; // AIS (Default L) + ActivationDTrigger dTrigger; // D (Default PI) + ActivationDState dState; // DIS (Default U) + GBool displayToolbar; // TB (Default true) + GBool displayNavigation; // NP (Default false); + }; +public: + + Annot3D(PDFDoc *docA, PDFRectangle *rect); + Annot3D(PDFDoc *docA, Dict *dict, Object *obj); + ~Annot3D(); + + // getters + +private: + + void initialize(PDFDoc *docA, Dict *dict); + + Activation *activation; // 3DA +}; + +//------------------------------------------------------------------------ +// Annots +//------------------------------------------------------------------------ + +class Annots { +public: + + // Build a list of Annot objects and call setPage on them + Annots(PDFDoc *docA, int page, Object *annotsObj); + + ~Annots(); + + // Iterate through list of annotations. + int getNumAnnots() { return nAnnots; } + Annot *getAnnot(int i) { return annots[i]; } + void appendAnnot(Annot *annot); + GBool removeAnnot(Annot *annot); + +private: + Annot* createAnnot(Dict* dict, Object *obj); + Annot *findAnnot(Ref *ref); + + PDFDoc *doc; + Annot **annots; + int nAnnots; + int size; +}; + +#endif |