PdfAnnotation.h

// SPDX-FileCopyrightText: 2006 Dominik Seichter <domseichter@web.de>
// SPDX-FileCopyrightText: 2020 Francesco Pretto <ceztko@gmail.com>
// SPDX-License-Identifier: LGPL-2.0-or-later OR MPL-2.0
 
#ifndef PDF_ANNOTATION_H
#define PDF_ANNOTATION_H
 
#include "PdfElement.h"
#include <podofo/auxiliary/Rect.h>
#include "PdfColor.h"
 
namespace PoDoFo {
 
class PdfPage;
class PdfXObject;
class PdfAnnotationText;
class PdfAnnotationLink;
class PdfAnnotationFreeText;
class PdfAnnotationLine;
class PdfAnnotationSquare;
class PdfAnnotationCircle;
class PdfAnnotationPolygon;
class PdfAnnotationPolyLine;
class PdfAnnotationHighlight;
class PdfAnnotationUnderline;
class PdfAnnotationSquiggly;
class PdfAnnotationStrikeOut;
class PdfAnnotationStamp;
class PdfAnnotationCaret;
class PdfAnnotationInk;
class PdfAnnotationPopup;
class PdfAnnotationFileAttachment;
class PdfAnnotationSound;
class PdfAnnotationMovie;
class PdfAnnotationWidget;
class PdfAnnotationScreen;
class PdfAnnotationPrinterMark;
class PdfAnnotationTrapNet;
class PdfAnnotationWatermark;
class PdfAnnotationModel3D;
class PdfAnnotationRichMedia;
class PdfAnnotationWebMedia;
class PdfAnnotationRedact;
class PdfAnnotationProjection;
 
struct PODOFO_API PdfAppearanceStream final
{
    const PdfObject* Object = nullptr;
    PdfAppearanceType Type = PdfAppearanceType::Normal;
    PdfName State;
};
 
enum class PdfSetAppearanceFlags : uint32_t
{
    None = 0,
    Raw =               1 << 0,     
    SkipSelectedState = 1 << 1,     
    InplaceRotation =   1 << 2,     
};
 
class PODOFO_API PdfAnnotation : public PdfDictionaryElement
{
    friend class PdfAnnotationCollection;
    friend class PdfAnnotationTextMarkupBase;
    friend class PdfAnnotationPopup;
    friend class PdfAnnotationText;
    friend class PdfAnnotationCaret;
    friend class PdfAnnotationFileAttachment;
    friend class PdfAnnotationFreeText;
    friend class PdfAnnotationHighlight;
    friend class PdfAnnotationInk;
    friend class PdfAnnotationLine;
    friend class PdfAnnotationModel3D;
    friend class PdfAnnotationMovie;
    friend class PdfAnnotationPolygon;
    friend class PdfAnnotationPolyLine;
    friend class PdfAnnotationPrinterMark;
    friend class PdfAnnotationRichMedia;
    friend class PdfAnnotationScreen;
    friend class PdfAnnotationSquiggly;
    friend class PdfAnnotationStrikeOut;
    friend class PdfAnnotationSound;
    friend class PdfAnnotationSquare;
    friend class PdfAnnotationCircle;
    friend class PdfAnnotationStamp;
    friend class PdfAnnotationTrapNet;
    friend class PdfAnnotationUnderline;
    friend class PdfAnnotationWatermark;
    friend class PdfAnnotationWebMedia;
    friend class PdfAnnotationRedact;
    friend class PdfAnnotationProjection;
    friend class PdfAnnotationActionBase;
    friend class PdfToggleButton;
 
private:
    PdfAnnotation(PdfPage& page, PdfAnnotationType annotType, const Rect& rect);
    PdfAnnotation(PdfObject& obj, PdfAnnotationType annotType);
    PdfAnnotation(const PdfAnnotation&) = delete;
 
public:
    static bool TryCreateFromObject(PdfObject& obj, std::unique_ptr<PdfAnnotation>& xobj);
 
    static bool TryCreateFromObject(const PdfObject& obj, std::unique_ptr<const PdfAnnotation>& xobj);
 
    template <typename TAnnotation>
    static bool TryCreateFromObject(PdfObject& obj, std::unique_ptr<TAnnotation>& xobj);
 
    template <typename TAnnotation>
    static bool TryCreateFromObject(const PdfObject& obj, std::unique_ptr<const TAnnotation>& xobj);
 
public:
    void SetAppearanceStream(const PdfXObject& xobj, PdfSetAppearanceFlags flags = PdfSetAppearanceFlags::None,
        PdfAppearanceType appearance = PdfAppearanceType::Normal, const PdfName& state = { });
    void SetAppearanceStream(PdfXObject& xobj, PdfSetAppearanceFlags flags,
        PdfAppearanceType appearance = PdfAppearanceType::Normal, const PdfName& state = { });
    void SetAppearanceStream(const PdfXObject& xobj, PdfAppearanceType appearance, const PdfName& state = { });
 
    [[deprecated("Use the SetAppearanceStream methods with flags instead")]]
    void SetAppearanceStream(const PdfXObject& xobj, PdfAppearanceType appearance,
        const PdfName& state, bool skipSelectedState);
 
    [[deprecated("Use the SetAppearanceStream methods with flags instead")]]
    void SetAppearanceStreamRaw(const PdfXObject& xobj, PdfAppearanceType appearance = PdfAppearanceType::Normal,
        const PdfName& state = { }, bool skipSelectedState = false);
 
    void GetAppearanceStreams(std::vector<PdfAppearanceStream>& states) const;
 
    void ClearAppearances();
 
    PdfObject* GetAppearanceDictionaryObject();
    const PdfObject* GetAppearanceDictionaryObject() const;
 
    PdfObject* GetAppearanceStream(PdfAppearanceType appearance = PdfAppearanceType::Normal, const std::string_view& state = { });
    const PdfObject* GetAppearanceStream(PdfAppearanceType appearance = PdfAppearanceType::Normal, const std::string_view& state = { }) const;
 
    Rect GetRect() const;
 
    void SetRect(const Rect& rect);
 
    Corners GetRectRaw() const;
 
    void SetRectRaw(const Corners& rect);
 
    void SetFlags(PdfAnnotationFlags flags);
 
    PdfAnnotationFlags GetFlags() const;
 
    void SetBorderStyle(double hCorner, double vCorner, double width);
 
    void SetBorderStyle(double hCorner, double vCorner, double width, const PdfArray& strokeStyle);
 
    void SetTitle(nullable<const PdfString&> title);
 
    nullable<const PdfString&> GetTitle() const;
 
    void SetContents(nullable<const PdfString&> contents);
 
    nullable<const PdfString&> GetContents() const;
 
    PdfColor GetColor() const;
 
    void SetColor(nullable<const PdfColor&> color);
 
public:
    inline PdfAnnotationType GetType() const { return m_AnnotationType; }
 
    inline PdfPage* GetPage() { return m_Page; }
    inline const PdfPage* GetPage() const { return m_Page; }
    PdfPage& MustGetPage();
    const PdfPage& MustGetPage() const;
 
private:
    template <typename TAnnot>
    static constexpr PdfAnnotationType GetAnnotationType();
 
    static std::unique_ptr<PdfAnnotation> Create(PdfPage& page, PdfAnnotationType annotType, const Rect& rect);
 
    void SetPage(PdfPage& page) { m_Page = &page; }
 
private:
    void setAppearanceStream(PdfXObject& xobj, PdfSetAppearanceFlags flags, PdfAppearanceType appearance, const PdfName& state);
    static bool tryCreateFromObject(const PdfObject& obj, PdfAnnotationType targetType, PdfAnnotation*& xobj);
    static PdfAnnotationType getAnnotationType(const PdfObject& obj);
    PdfObject* getAppearanceStream(PdfAppearanceType appearance, const std::string_view& state) const;
    PdfDictionary* getAppearanceDictionary() const;
 
private:
    PdfAnnotationType m_AnnotationType;
    PdfPage* m_Page;
};
 
template<typename TAnnotation>
bool PdfAnnotation::TryCreateFromObject(PdfObject& obj, std::unique_ptr<TAnnotation>& xobj)
{
    PdfAnnotation* xobj_;
    if (!tryCreateFromObject(obj, GetAnnotationType<TAnnotation>(), xobj_))
        return false;
 
    // NOTE: A class GetAnnotationType() maps to Unknown accepts any annotation, so the class created is checked
    std::unique_ptr<PdfAnnotation> created(xobj_);
    if (dynamic_cast<TAnnotation*>(created.get()) == nullptr)
        return false;
 
    xobj.reset(static_cast<TAnnotation*>(created.release()));
    return true;
}
 
template<typename TAnnotation>
bool PdfAnnotation::TryCreateFromObject(const PdfObject& obj, std::unique_ptr<const TAnnotation>& xobj)
{
    PdfAnnotation* xobj_;
    if (!tryCreateFromObject(obj, GetAnnotationType<TAnnotation>(), xobj_))
        return false;
 
    std::unique_ptr<const PdfAnnotation> created(xobj_);
    if (dynamic_cast<const TAnnotation*>(created.get()) == nullptr)
        return false;
 
    xobj.reset(static_cast<const TAnnotation*>(created.release()));
    return true;
}
 
template<typename TAnnot>
constexpr PdfAnnotationType PdfAnnotation::GetAnnotationType()
{
    if (std::is_same_v<TAnnot, PdfAnnotationText>)
        return PdfAnnotationType::Text;
    else if (std::is_same_v<TAnnot, PdfAnnotationLink>)
        return PdfAnnotationType::Link;
    else if (std::is_same_v<TAnnot, PdfAnnotationFreeText>)
        return PdfAnnotationType::FreeText;
    else if (std::is_same_v<TAnnot, PdfAnnotationLine>)
        return PdfAnnotationType::Line;
    else if (std::is_same_v<TAnnot, PdfAnnotationSquare>)
        return PdfAnnotationType::Square;
    else if (std::is_same_v<TAnnot, PdfAnnotationCircle>)
        return PdfAnnotationType::Circle;
    else if (std::is_same_v<TAnnot, PdfAnnotationPolygon>)
        return PdfAnnotationType::Polygon;
    else if (std::is_same_v<TAnnot, PdfAnnotationPolyLine>)
        return PdfAnnotationType::PolyLine;
    else if (std::is_same_v<TAnnot, PdfAnnotationHighlight>)
        return PdfAnnotationType::Highlight;
    else if (std::is_same_v<TAnnot, PdfAnnotationUnderline>)
        return PdfAnnotationType::Underline;
    else if (std::is_same_v<TAnnot, PdfAnnotationSquiggly>)
        return PdfAnnotationType::Squiggly;
    else if (std::is_same_v<TAnnot, PdfAnnotationStrikeOut>)
        return PdfAnnotationType::StrikeOut;
    else if (std::is_same_v<TAnnot, PdfAnnotationStamp>)
        return PdfAnnotationType::Stamp;
    else if (std::is_same_v<TAnnot, PdfAnnotationCaret>)
        return PdfAnnotationType::Caret;
    else if (std::is_same_v<TAnnot, PdfAnnotationInk>)
        return PdfAnnotationType::Ink;
    else if (std::is_same_v<TAnnot, PdfAnnotationPopup>)
        return PdfAnnotationType::Popup;
    else if (std::is_same_v<TAnnot, PdfAnnotationFileAttachment>)
        return PdfAnnotationType::FileAttachement;
    else if (std::is_same_v<TAnnot, PdfAnnotationSound>)
        return PdfAnnotationType::Sound;
    else if (std::is_same_v<TAnnot, PdfAnnotationMovie>)
        return PdfAnnotationType::Movie;
    else if (std::is_same_v<TAnnot, PdfAnnotationWidget>)
        return PdfAnnotationType::Widget;
    else if (std::is_same_v<TAnnot, PdfAnnotationScreen>)
        return PdfAnnotationType::Screen;
    else if (std::is_same_v<TAnnot, PdfAnnotationPrinterMark>)
        return PdfAnnotationType::PrinterMark;
    else if (std::is_same_v<TAnnot, PdfAnnotationTrapNet>)
        return PdfAnnotationType::TrapNet;
    else if (std::is_same_v<TAnnot, PdfAnnotationWatermark>)
        return PdfAnnotationType::Watermark;
    else if (std::is_same_v<TAnnot, PdfAnnotationModel3D>)
        return PdfAnnotationType::Model3D;
    else if (std::is_same_v<TAnnot, PdfAnnotationRichMedia>)
        return PdfAnnotationType::RichMedia;
    else if (std::is_same_v<TAnnot, PdfAnnotationWebMedia>)
        return PdfAnnotationType::WebMedia;
    else if (std::is_same_v<TAnnot, PdfAnnotationRedact>)
        return PdfAnnotationType::Redact;
    else if (std::is_same_v<TAnnot, PdfAnnotationProjection>)
        return PdfAnnotationType::Projection;
    else
        return PdfAnnotationType::Unknown;
}
 
};
 
ENABLE_BITMASK_OPERATORS(PoDoFo::PdfSetAppearanceFlags);
 
#endif // PDF_ANNOTATION_H