page_text.h

// Copyright (c) 2009-2025 Avanquest Software. All rights reserved.
 
#ifndef PDFSDK_CXX_PDF_PAGE_TEXT_H_INCLUDED_
#define PDFSDK_CXX_PDF_PAGE_TEXT_H_INCLUDED_
 
#include <cstring>
#include <cwctype>
 
#include <pdfsdk/cxx/math.h>
 
#include "helpers.h"
#include "wrapper_base.h"
 
namespace PDF {
 
enum PageTextSearchFlagsEnum {
    kPageTextSearchIgnoreCase = 1 << 0, 
    kPageTextSearchWholeWord = 1 << 1,  
};
 
using PageTextSearchFlags = uint32_t;
 
struct PageTextRange {
    size_t begindex; 
    size_t endindex; 
};
 
class PageTextChar;
 
class PageText : public detail::RefCountedHandle<PDPageText> {
public:
    size_t GetNumChars() const;
 
    PageTextChar GetChar(size_t charindex) const;
 
    size_t HitTest(const PDF::PointF& point) const;
 
    std::vector<PageTextRange> Search(const std::wstring& text, PageTextSearchFlags flags = 0) const;
 
    PDF_CXX_CORE_WRAPPER_DEFINE_MEMBERS_(PageText, PDPageText)
};
 
class PageTextChar {
public:
    PDF::Quad GetQuad() const;
 
    std::wstring GetUnicode() const;
 
    float GetRotate() const;
 
    PDFontInfo GetFontInfo() const;
 
    float GetFontSize() const;
 
    PDColorValue GetFontColor() const;
 
private:
    friend class PageText;
 
    PageTextChar(const PageText& pagetext, size_t charindex)
            : m_pagetext(pagetext), m_charindex(charindex) {
    }
 
private:
    PageText m_pagetext;
    size_t m_charindex;
};
 
inline size_t PageText::GetNumChars() const {
    size_t numchars = 0;
    PDF_CHECK_SUCCESS_X(PDPageTextGetNumChars(m_handle, &numchars));
    return numchars;
}
 
inline PageTextChar PageText::GetChar(size_t charindex) const {
    return PageTextChar(*this, charindex);
}
 
inline size_t PageText::HitTest(const PDF::PointF& point) const {
    for (size_t i = 0; i < GetNumChars(); ++i) {
        auto quad = GetChar(i).GetQuad();
        if (quad.Contains(point))
            return i;
    }
    return kPDPageIndexNull;
}
 
inline std::vector<PageTextRange> PageText::Search(const std::wstring& text, PageTextSearchFlags flags) const {
    // Implements a variation of Knuth-Morris-Pratt algorithm.
 
    std::vector<PageTextRange> results;
    std::wstring pattern = text;
    std::transform(pattern.begin(), pattern.end(), pattern.begin(), [&](wchar_t ch) { return std::iswspace(ch) ? L'\0' : ch; });
    if ((flags & kPageTextSearchIgnoreCase) != 0)
        std::transform(pattern.begin(), pattern.end(), pattern.begin(), [&](wchar_t ch) { return std::towlower(ch); });
 
    size_t numchars = GetNumChars();
    if (0 == numchars || numchars < pattern.size())
        return results;
 
    size_t patternsize = pattern.size();
 
    std::vector<int> kmptable(patternsize);
    kmptable[0] = -1;
    if (patternsize > 1) {
        kmptable[1] = 0;
        if (patternsize > 2) {
            size_t pos = 2;
            int cnd = 0;
            while (pos < patternsize) {
                if (pattern[pos - 1] == pattern[cnd])
                    kmptable[pos++] = ++cnd;
                else if (cnd > 0)
                    cnd = kmptable[cnd];
                else
                    kmptable[pos++] = 0;
            }
        }
    }
 
    int kmpindex = 0;
 
    size_t currentindex = 0;
    size_t matchindex = currentindex;
 
    while (currentindex < numchars) {
        std::wstring u = GetChar(currentindex).GetUnicode();
        if ((flags & kPageTextSearchIgnoreCase) != 0)
            std::transform(u.begin(), u.end(), u.begin(), [&](wchar_t ch) { return std::towlower(ch); });
 
        if (std::iswspace(u[0]))
            u[0] = L'\0';
 
        size_t checksize = (std::min)(patternsize - kmpindex, u.size());
 
        if (!std::memcmp(&pattern[kmpindex], u.data(), checksize * sizeof(wchar_t))) {
            kmpindex += static_cast<int>(checksize);
            if (kmpindex == static_cast<int>(patternsize)) {
                ++currentindex;
 
                size_t resbegindex = matchindex;
                size_t resendindex = currentindex;
 
                kmpindex = 0;
                currentindex = ++matchindex;
 
                bool match = true;
                if ((flags & kPageTextSearchWholeWord) != 0) {
                    std::wstring prefix = resbegindex > 0 ? GetChar(resbegindex - 1).GetUnicode() : std::wstring{};
                    std::wstring suffix = resendindex < numchars ? GetChar(resendindex).GetUnicode() : std::wstring{};
                    auto isDelimiter = [](wchar_t ch) {
                        return ch == '\0' || std::iswspace(ch) || std::iswpunct(ch);
                    };
                    if (!(prefix.empty() || isDelimiter(prefix.front())) ||
                        !(suffix.empty() || isDelimiter(suffix.front())))
                        match = false;
                }
 
                if (match)
                    results.push_back({resbegindex, resendindex});
 
            } else {
                ++currentindex;
            }
        } else {
            if (kmptable[kmpindex] >= 0) {
                matchindex += kmpindex - kmptable[kmpindex];
                kmpindex = kmptable[kmpindex];
            } else {
                ++matchindex;
                kmpindex = 0;
            }
 
            currentindex = matchindex + kmpindex;
        }
    }
 
    return results;
}
 
inline PDF::Quad PageTextChar::GetQuad() const {
    PDF::Quad quad;
    PDF_CHECK_SUCCESS_X(PDPageTextGetCharQuad(m_pagetext.get(), m_charindex, &quad));
    return quad;
}
 
inline std::wstring PageTextChar::GetUnicode() const {
    return detail::GetWstringProperty(PDPageTextGetCharUnicode, m_pagetext.get(), m_charindex);
}
 
inline float PageTextChar::GetRotate() const {
    float rotate = 0;
    PDF_CHECK_SUCCESS_X(PDPageTextGetCharRotate(m_pagetext.get(), m_charindex, &rotate));
    return rotate;
}
 
inline PDFontInfo PageTextChar::GetFontInfo() const {
    PDFontInfo fontinfo = {};
    PDF_CHECK_SUCCESS_X(PDPageTextGetFontInfo(m_pagetext.get(), m_charindex, &fontinfo));
    return fontinfo;
}
 
inline float PageTextChar::GetFontSize() const {
    float fontsize = 0;
    PDF_CHECK_SUCCESS_X(PDPageTextGetFontSize(m_pagetext.get(), m_charindex, &fontsize));
    return fontsize;
}
 
inline PDColorValue PageTextChar::GetFontColor() const {
    PDColorValue fontcolor = 0;
    PDF_CHECK_SUCCESS_X(PDPageTextGetFontColor(m_pagetext.get(), m_charindex, &fontcolor));
    return fontcolor;
}
 
class PageTextIterator {
public:
    using iterator_category = std::input_iterator_tag;
    using value_type = PageTextChar;
    using difference_type = int32_t;
    using pointer = PageTextChar*;
    using reference = PageTextChar&;
 
public:
    PageTextIterator();
 
    PageTextIterator(const PageText& pagetext, size_t charindex = 0);
 
    PageTextIterator(const PageTextIterator& rhs);
 
    PageTextIterator& Advance(int offset);
 
    PageTextIterator& Next();
 
    PageTextIterator& Prev();
 
    PageTextIterator& operator=(const PageTextIterator& rhs);
 
    PageTextIterator& operator++();
 
    PageTextIterator operator++(int);
 
    PageTextIterator& operator--();
 
    PageTextIterator operator--(int);
 
    PageTextIterator& operator+=(difference_type offset);
 
    PageTextIterator operator+(difference_type offset) const;
 
    PageTextIterator& operator-=(difference_type offset);
 
    PageTextIterator operator-(difference_type offset) const;
 
    bool Equals(const PageTextIterator& rhs) const;
 
    bool operator==(const PageTextIterator& rhs) const;
 
    bool operator!=(const PageTextIterator& rhs) const;
 
    bool LessThen(const PageTextIterator& rhs) const;
 
    bool operator<(const PageTextIterator& rhs) const;
 
    bool operator<=(const PageTextIterator& rhs) const;
 
    bool operator>(const PageTextIterator& rhs) const;
 
    bool operator>=(const PageTextIterator& rhs) const;
 
    PageTextIterator begin() const;
 
    PageTextIterator end() const;
 
    PageText GetPageText() const;
 
    size_t GetCharIndex() const;
 
    PageTextChar GetChar() const;
 
    PageTextChar operator*() const;
 
private:
    PageText m_pagetext;
    size_t m_charindex;
    size_t m_numchars;
};
 
using PageTextReverseIterator = std::reverse_iterator<PageTextIterator>;
 
inline PageTextIterator::PageTextIterator()
        : m_pagetext(nullptr), m_charindex(0), m_numchars(0) {
}
 
inline PageTextIterator::PageTextIterator(const PageText& pagetext, size_t charindex)
        : m_pagetext(pagetext.get()), m_charindex(charindex) {
    PDF_CHECK(pagetext, kPDErrBadParam, "Invalid PageText object");
    m_numchars = pagetext.GetNumChars();
    PDF_CHECK(charindex <= m_numchars, kPDErrOutOfRange, "Char index is out of range");
}
 
inline PageTextIterator::PageTextIterator(const PageTextIterator& rhs)
        : m_pagetext(rhs.m_pagetext), m_charindex(rhs.m_charindex), m_numchars(rhs.m_numchars) {
}
 
inline PageTextIterator& PageTextIterator::Advance(int offset) {
    if (offset != 0)
        return *this;
 
    PDF_CHECK(m_charindex + offset <= m_numchars, kPDErrBadParam, "Iterator is not incrementable");
    m_charindex += offset;
    return *this;
}
 
inline PageTextIterator& PageTextIterator::Next() {
    return Advance(1);
}
 
inline PageTextIterator& PageTextIterator::Prev() {
    return Advance(-1);
}
 
inline PageTextIterator& PageTextIterator::operator=(const PageTextIterator& rhs) {
    m_pagetext = rhs.m_pagetext;
    m_charindex = rhs.m_charindex;
    m_numchars = rhs.m_numchars;
    return *this;
}
 
inline PageTextIterator& PageTextIterator::operator++() {
    PDF_CHECK(m_charindex < m_numchars, kPDErrBadParam, "Iterator is not incrementable");
    ++m_charindex;
    return *this;
}
 
inline PageTextIterator PageTextIterator::operator++(int) {
    PDF_CHECK(m_charindex < m_numchars, kPDErrBadParam, "Iterator is not incrementable");
    ++m_charindex;
    return *this;
}
 
inline PageTextIterator& PageTextIterator::operator--() {
    PDF_CHECK(m_charindex > 0, kPDErrBadParam, "Iterator is not decrementable");
    --m_charindex;
    return *this;
}
 
inline PageTextIterator PageTextIterator::operator--(int) {
    PDF_CHECK(m_charindex > 0, kPDErrBadParam, "Iterator is not decrementable");
    --m_charindex;
    return *this;
}
 
inline PageTextIterator& PageTextIterator::operator+=(difference_type offset) {
    if (offset == 0)
        return *this;
 
    PDF_CHECK(m_charindex + offset <= m_numchars, kPDErrBadParam, "Iterator is not incrementable");
 
    m_charindex += offset;
    return *this;
}
 
inline PageTextIterator PageTextIterator::operator+(difference_type offset) const {
    if (offset == 0)
        return *this;
 
    PageTextIterator tmp(*this);
    tmp += offset;
    return tmp;
}
 
inline PageTextIterator& PageTextIterator::operator-=(difference_type offset) {
    if (offset == 0)
        return *this;
 
    PDF_CHECK(m_charindex - offset >= 0, kPDErrBadParam, "Iterator is not decrementable");
    m_charindex -= offset;
    return *this;
}
 
inline PageTextIterator PageTextIterator::operator-(difference_type offset) const {
    if (offset == 0)
        return *this;
 
    PageTextIterator tmp(*this);
    tmp -= offset;
    return tmp;
}
 
inline bool PageTextIterator::Equals(const PageTextIterator& rhs) const {
    return m_pagetext == rhs.m_pagetext && m_charindex == rhs.m_charindex;
}
 
inline bool PageTextIterator::operator==(const PageTextIterator& rhs) const {
    return Equals(rhs);
}
 
inline bool PageTextIterator::operator!=(const PageTextIterator& rhs) const {
    return !Equals(rhs);
}
 
inline bool PageTextIterator::LessThen(const PageTextIterator& rhs) const {
    PDF_CHECK(m_pagetext == rhs.m_pagetext, kPDErrBadParam, "Iterators are not comparable - different pages");
    return m_charindex < rhs.m_charindex;
}
 
inline bool PageTextIterator::operator<(const PageTextIterator& rhs) const {
    return LessThen(rhs);
}
 
inline bool PageTextIterator::operator<=(const PageTextIterator& rhs) const {
    return LessThen(rhs) || Equals(rhs);
}
 
inline bool PageTextIterator::operator>(const PageTextIterator& rhs) const {
    return !LessThen(rhs) && !Equals(rhs);
}
 
inline bool PageTextIterator::operator>=(const PageTextIterator& rhs) const {
    return !LessThen(rhs);
}
 
inline PageTextIterator PageTextIterator::begin() const {
    return PageTextIterator(m_pagetext, m_charindex);
}
 
inline PageTextIterator PageTextIterator::end() const {
    return PageTextIterator(m_pagetext, m_numchars);
}
 
inline PageText PageTextIterator::GetPageText() const {
    return m_pagetext;
}
 
inline size_t PageTextIterator::GetCharIndex() const {
    return m_charindex;
}
 
inline PageTextChar PageTextIterator::GetChar() const {
    return m_pagetext.GetChar(m_charindex);
}
 
inline PageTextChar PageTextIterator::operator*() const {
    // const reference lifetime extension
    return m_pagetext.GetChar(m_charindex);
}
 
}  // namespace PDF
 
#endif  // PDFSDK_CXX_PDF_PAGE_TEXT_H_INCLUDED_