Annot.h

Go to the documentation of this file.

//---------------------------------------------------------------------------------------
// Copyright (c) 2001-2012 by PDFTron Systems Inc. All Rights Reserved.
// Consult legal.txt regarding legal and license information.
//---------------------------------------------------------------------------------------

#ifndef PDFTRON_H_CPPPDFAnnot
#define PDFTRON_H_CPPPDFAnnot

#include <SDF/Obj.h>
#include <PDF/Date.h>
#include <SDF/SDFDoc.h>
#include <PDF/Rect.h>
#include <PDF/ColorSpace.h>
#include <PDF/FileSpec.h>
#include <C/PDF/TRN_Annot.h>
#include <vector>

namespace pdftron { 
        namespace PDF {

class Annot
{
public: 

        enum Type
        {
                e_Text,           
                e_Link,           
                e_FreeText,       
                e_Line,           
                e_Square,         
                e_Circle,         
                e_Polygon,        
                e_Polyline,       
                e_Highlight,      
                e_Underline,      
                e_Squiggly,       
                e_StrikeOut,      
                e_Stamp,          
                e_Caret,          
                e_Ink,            
                e_Popup,          
                e_FileAttachment, 
                e_Sound,          
                e_Movie,          
                e_Widget,         
                e_Screen,         
                e_PrinterMark,    
                e_TrapNet,        
                e_Watermark,      
                e_3D,             
                e_Redact,         
                e_Projection,     
                e_RichMedia,      
                e_Unknown         
        };

        static Annot Create(SDF::SDFDoc& doc, Type type, const Rect& pos);

        Annot (SDF::Obj d = 0);

        Annot (const Annot& d);

        Annot& operator=(const Annot& d);

        bool operator==(const Annot& d);

        bool IsValid() const;

        SDF::Obj GetSDFObj () const;    

        Type GetType() const;

        Rect GetRect() const;

        bool IsMarkup() const;

        void SetRect(const Rect& p);

        Page GetPage() const;

        void SetPage(const Page& page);

        SDF::Obj GetUniqueID() const;

        void SetUniqueID(const char* id, int id_buf_sz = 0);

        Date GetDate() const;

        void SetDate(const Date& date);

        enum Flag
        {
                e_invisible,         // PDF 1.2
                e_hidden,            // PDF 1.2
                e_print,             // PDF 1.2
                e_no_zoom,           // PDF 1.3
                e_no_rotate,         // PDF 1.3
                e_no_view,           // PDF 1.3
                e_read_only,         // PDF 1.3
                e_locked,            // PDF 1.4
                e_toggle_no_view,     // PDF 1.5
                e_locked_contents    // PDF 1.7
        };


        bool GetFlag(Flag flag) const;

        void SetFlag(Flag flag, bool value);

        class BorderStyle
        {
        public: 
                enum Style {
                        e_solid,   
                        e_dashed,  
                        e_beveled, 
                        e_inset,   
                        e_underline  
                };

                BorderStyle(Style s, double b_width, double b_hr =0, double b_vr =0);
                BorderStyle(Style s, double b_width, double b_hr, double b_vr, const std::vector<double>& b_dash);
                BorderStyle(const BorderStyle&);
                ~BorderStyle();

                void Destroy();

                BorderStyle& operator=(const BorderStyle&);
                friend inline bool operator==( const BorderStyle& a, const BorderStyle& b );
                friend inline bool operator!=( const BorderStyle& a, const BorderStyle& b ) { return !( a == b ); }

                Style GetStyle() const;

                void SetStyle(Style style);

                double GetHR() const;   

                void SetHR(double hr);

                double GetVR() const;

                void SetVR(double vr);  

                double GetWidth() const;

                void SetWidth(double width);

                std::vector<double> GetDash() const;

                void SetDash( const std::vector<double>& dash);  

                BorderStyle(TRN_AnnotBorderStyle impl);
                BorderStyle() : mp_bs(0) {}
        private: 
                friend class PDF::Annot;
                TRN_AnnotBorderStyle mp_bs;
        };

        BorderStyle GetBorderStyle() const;

        void SetBorderStyle( const BorderStyle& bs, bool oldStyleOnly = false );

        enum AnnotationState
        {
                e_normal,
                e_rollover,
                e_down
        };

        SDF::Obj GetAppearance(AnnotationState annot_state = e_normal, const char* app_state = 0);

        void SetAppearance(SDF::Obj app_stream, AnnotationState annot_state = e_normal, const char* app_state = 0);

        void RemoveAppearance(AnnotationState annot_state = e_normal, const char* app_state = 0);

        void Flatten(class Page page);

        const char* GetActiveAppearanceState() const;

        void SetActiveAppearanceState(const char* astate);


        ColorPt GetColorAsRGB() const;

        ColorPt GetColorAsCMYK() const;

        ColorPt GetColorAsGray() const;

        int GetColorCompNum() const;


        void SetColor(const ColorPt& c, int comp_num=3);


        int GetStructParent() const;

        void SetStructParent(const int keyval);//The value can be set, should be limited. 


        SDF::Obj GetOptionalContent() const;

        void SetOptionalContent(SDF::Obj oc);

        void SetContents(const UString& contents);

        UString GetContents() const;


        void RefreshAppearance();

        void Resize(const Rect& newrect);

        #ifndef SWIGHIDDEN
        Annot(TRN_Annot annot);
        TRN_Annot mp_annot;
        #endif

}; //Class Annot


        } //namespace PDF
} //namespace pdftron

#include <Impl/Page.inl>
#endif

---

© 2002-2012 PDFTron Systems Inc.