stamper.h

// Copyright (c) 2009-2026 Avanquest Software. All rights reserved.
 
#ifndef PDFSDK_CXX_STAMPER_H_INCLUDED_
#define PDFSDK_CXX_STAMPER_H_INCLUDED_
 
#include <filesystem>
#include <string>
#include <vector>
 
#include <pdfsdk/cxx/document.h>
#include <pdfsdk/cxx/graphics.h>
#include <pdfsdk/cxx/wrapper_base.h>
#include <pdfsdk/stamper.h>
 
namespace PDF {

class Stamper : public detail::RefCountedHandle<PDFStamper> {
public:
    static Stamper Create(PDFStampSizeMode sizeMode, float a, float b);

    void SetSize(PDFStampSizeMode sizeMode, float a, float b);

    void SetPosition(float horizontalDistance, float verticalDistance, bool usePercentage = false);

    void SetAlignment(PDFStampHAlign hAlign, PDFStampVAlign vAlign);

    void SetRotation(float degrees);

    void SetOpacity(float opacity);

    void SetAsBackground(bool background);

    void SetAsAnnotation(bool annotation);

    void ShowsOnScreen(bool onScreen);

    void ShowsOnPrint(bool onPrint);

    void ShowsInLayersPanel(bool inLayersPanel);

    void SetName(const std::wstring& name);

    void SetFont(const PDFontInfo& fontInfo);

    void SetFontColor(PDColorValue color);

    void SetTextOutline(PDColorValue strokeColor, float strokeWidth);

    void SetTextAlignment(PDFStampTextAlign textAlign);

    void StampText(const Document& destDoc, const std::wstring& text, const std::vector<size_t>& destPages = {});

    void StampImage(const Document& destDoc, const Graphics::Bitmap& bitmap, const std::vector<size_t>& destPages = {});

    void StampImageFromFile(const Document& destDoc, const std::filesystem::path& imagePath, const std::vector<size_t>& destPages = {});

    void StampPage(const Document& destDoc, const Document& srcDoc, size_t srcPageIndex, const std::vector<size_t>& destPages = {});

    static bool HasStamps(const Document& doc, const std::vector<size_t>& pages = {});

    static void DeleteStamps(const Document& doc, const std::vector<size_t>& pages = {});
 
    PDF_CXX_CORE_WRAPPER_DEFINE_MEMBERS_(Stamper, PDFStamper)
};
 
namespace detail {
 
inline PDPageRange MakePageRange(const std::vector<size_t>& pages) {
    return {pages.data(), pages.size()};
}
 
}  // namespace detail
 
inline Stamper Stamper::Create(PDFStampSizeMode sizeMode, float a, float b) {
    Stamper stamper;
    PDF_CHECK_SUCCESS_X(PDFStamperCreate(sizeMode, a, b, &stamper));
    return stamper;
}
 
inline void Stamper::SetSize(PDFStampSizeMode sizeMode, float a, float b) {
    PDF_CHECK_SUCCESS_X(PDFStamperSetSize(m_handle, sizeMode, a, b));
}
 
inline void Stamper::SetPosition(float horizontalDistance, float verticalDistance, bool usePercentage) {
    PDF_CHECK_SUCCESS_X(PDFStamperSetPosition(m_handle, horizontalDistance, verticalDistance, usePercentage));
}
 
inline void Stamper::SetAlignment(PDFStampHAlign hAlign, PDFStampVAlign vAlign) {
    PDF_CHECK_SUCCESS_X(PDFStamperSetAlignment(m_handle, hAlign, vAlign));
}
 
inline void Stamper::SetRotation(float degrees) {
    PDF_CHECK_SUCCESS_X(PDFStamperSetRotation(m_handle, degrees));
}
 
inline void Stamper::SetOpacity(float opacity) {
    PDF_CHECK_SUCCESS_X(PDFStamperSetOpacity(m_handle, opacity));
}
 
inline void Stamper::SetAsBackground(bool background) {
    PDF_CHECK_SUCCESS_X(PDFStamperSetAsBackground(m_handle, background));
}
 
inline void Stamper::SetAsAnnotation(bool annotation) {
    PDF_CHECK_SUCCESS_X(PDFStamperSetAsAnnotation(m_handle, annotation));
}
 
inline void Stamper::ShowsOnScreen(bool onScreen) {
    PDF_CHECK_SUCCESS_X(PDFStamperShowsOnScreen(m_handle, onScreen));
}
 
inline void Stamper::ShowsOnPrint(bool onPrint) {
    PDF_CHECK_SUCCESS_X(PDFStamperShowsOnPrint(m_handle, onPrint));
}
 
inline void Stamper::ShowsInLayersPanel(bool inLayersPanel) {
    PDF_CHECK_SUCCESS_X(PDFStamperShowsInLayersPanel(m_handle, inLayersPanel));
}
 
inline void Stamper::SetName(const std::wstring& name) {
    PDF_CHECK_SUCCESS_X(PDFStamperSetName(m_handle, name.c_str()));
}
 
inline void Stamper::SetFont(const PDFontInfo& fontInfo) {
    PDF_CHECK_SUCCESS_X(PDFStamperSetFont(m_handle, &fontInfo));
}
 
inline void Stamper::SetFontColor(PDColorValue color) {
    PDF_CHECK_SUCCESS_X(PDFStamperSetFontColor(m_handle, color));
}
 
inline void Stamper::SetTextOutline(PDColorValue strokeColor, float strokeWidth) {
    PDF_CHECK_SUCCESS_X(PDFStamperSetTextOutline(m_handle, strokeColor, strokeWidth));
}
 
inline void Stamper::SetTextAlignment(PDFStampTextAlign textAlign) {
    PDF_CHECK_SUCCESS_X(PDFStamperSetTextAlignment(m_handle, textAlign));
}
 
inline void Stamper::StampText(const Document& destDoc, const std::wstring& text, const std::vector<size_t>& destPages) {
    PDPageRange range = detail::MakePageRange(destPages);
    const PDPageRange* rangePtr = destPages.empty() ? nullptr : &range;
    PDF_CHECK_SUCCESS_X(PDFStamperStampText(m_handle, destDoc.get(), text.c_str(), rangePtr));
}
 
inline void Stamper::StampImage(const Document& destDoc, const Graphics::Bitmap& bitmap, const std::vector<size_t>& destPages) {
    PDPageRange range = detail::MakePageRange(destPages);
    const PDPageRange* rangePtr = destPages.empty() ? nullptr : &range;
    PDF_CHECK_SUCCESS_X(PDFStamperStampImage(m_handle, destDoc.get(), bitmap.get(), rangePtr));
}
 
inline void Stamper::StampImageFromFile(const Document& destDoc, const std::filesystem::path& imagePath, const std::vector<size_t>& destPages) {
    PDPageRange range = detail::MakePageRange(destPages);
    const PDPageRange* rangePtr = destPages.empty() ? nullptr : &range;
    PDF_CHECK_SUCCESS_X(PDFStamperStampImageFromFile(m_handle, destDoc.get(), imagePath.wstring().c_str(), rangePtr));
}
 
inline void Stamper::StampPage(const Document& destDoc, const Document& srcDoc, size_t srcPageIndex, const std::vector<size_t>& destPages) {
    PDPageRange range = detail::MakePageRange(destPages);
    const PDPageRange* rangePtr = destPages.empty() ? nullptr : &range;
    PDF_CHECK_SUCCESS_X(PDFStamperStampPage(m_handle, destDoc.get(), srcDoc.get(), srcPageIndex, rangePtr));
}
 
inline bool Stamper::HasStamps(const Document& doc, const std::vector<size_t>& pages) {
    PDPageRange range = detail::MakePageRange(pages);
    const PDPageRange* rangePtr = pages.empty() ? nullptr : &range;
    bool hasStamps = false;
    PDF_CHECK_SUCCESS_X(PDFStamperHasStamps(doc.get(), rangePtr, &hasStamps));
    return hasStamps;
}
 
inline void Stamper::DeleteStamps(const Document& doc, const std::vector<size_t>& pages) {
    PDPageRange range = detail::MakePageRange(pages);
    const PDPageRange* rangePtr = pages.empty() ? nullptr : &range;
    PDF_CHECK_SUCCESS_X(PDFStamperDeleteStamps(doc.get(), rangePtr));
}
 
}  // namespace PDF
 
#endif  // PDFSDK_CXX_STAMPER_H_INCLUDED_