fs_search.h

Go to the documentation of this file.

#ifndef FS_SEARCH_H_
#define FS_SEARCH_H_

#include "common/fs_common.h"
#include "pdf/annots/fs_annot.h"
#include "pdf/fs_pdfpage.h"
#ifndef _FX_NO_XFA_
#include "addon/xfa/fs_xfa.h"
#endif  // #ifndef _FX_NO_XFA_

namespace foxit {
namespace pdf {
class SearchCancelCallback {
 public:
  virtual bool NeedToCancelNow() = 0;
};

class TextPageCharInfo FS_FINAL : public Object {
 public:
  typedef enum _TextCharFlag {
    e_Unknown = -1,
    e_Normal = 0,
    e_Generated = 1,
    e_UnUnicode = 2,
    e_Hyphen = 3,
    e_ComboWord = 4
  } TextCharFlag;
  

  TextPageCharInfo(const common::Font& font, TextCharFlag flag, float font_size, float origin_x, float origin_y,
                   const RectF& char_box, const RectF& char_outbox, const Matrix& matrix) {
    this->font = font;
    this->flag = flag;
    this->font_size = font_size;
    this->origin_x = origin_x;
    this->origin_y = origin_y;
    this->char_box = char_box;
    this->char_outbox = char_outbox;
    this->matrix = matrix;
  }

  TextPageCharInfo()
      : flag(TextPageCharInfo::e_Unknown)
      , font_size(0)
      , origin_x(0)
      , origin_y(0) {}

  TextPageCharInfo(const TextPageCharInfo& char_info) {
    this->font = char_info.font;
    this->flag = char_info.flag;
    this->font_size = char_info.font_size;
    this->origin_x = char_info.origin_x;
    this->origin_y = char_info.origin_y;
    this->char_box = char_info.char_box;
    this->char_outbox = char_info.char_outbox;
    this->matrix = char_info.matrix;
  }

  TextPageCharInfo& operator = (const TextPageCharInfo& char_info) {
    this->font = char_info.font;
    this->flag = char_info.flag;
    this->font_size = char_info.font_size;
    this->origin_x = char_info.origin_x;
    this->origin_y = char_info.origin_y;
    this->char_box = char_info.char_box;
    this->char_outbox = char_info.char_outbox;
    this->matrix = char_info.matrix;
    return *this;
  }

  bool operator == (const TextPageCharInfo& char_info) const {
    if (font != char_info.font || flag != char_info.flag || fabs(font_size - char_info.font_size) > FLT_EPSILON ||
        fabs(origin_x - char_info.origin_x) > FLT_EPSILON || fabs(origin_y - char_info.origin_y) > FLT_EPSILON ||
        char_box != char_info.char_box || char_outbox != char_info.char_outbox || matrix != char_info.matrix)
      return false;

    return true;
  }

  bool operator != (const TextPageCharInfo& char_info) const{
    if (font != char_info.font || flag != char_info.flag || fabs(font_size - char_info.font_size) > FLT_EPSILON ||
        fabs(origin_x - char_info.origin_x) > FLT_EPSILON || fabs(origin_y - char_info.origin_y) > FLT_EPSILON ||
        char_box != char_info.char_box || char_outbox != char_info.char_outbox || matrix != char_info.matrix)
      return true;

    return false;
  }

  void Set(const common::Font& font, TextCharFlag flag, float font_size, float origin_x, float origin_y,
           const RectF& char_box, const RectF& char_outbox, const Matrix& matrix) {
    this->font = font;
    this->flag = flag;
    this->font_size = font_size;
    this->origin_x = origin_x;
    this->origin_y = origin_y;
    this->char_box = char_box;
    this->char_outbox = char_outbox;
    this->matrix = matrix;
  }

  common::Font font;

  TextCharFlag flag;

  float font_size;

  float origin_x;

  float origin_y;

  RectF char_box;

  RectF char_outbox;

  Matrix matrix;
};

class TextPage FS_FINAL : public Base {
 public:
  typedef enum _TextParseFlags {
    e_ParseTextNormal = 0x0000,
    e_ParseTextOutputHyphen = 0x0001,
    e_ParseTextUseStreamOrder = 0x0002
  } TextParseFlags;
  
  typedef enum _TextOrderFlag {
    e_TextStreamOrder = 0,
    e_TextDisplayOrder = 1
  } TextOrderFlag;
  

  explicit TextPage(const PDFPage& page, int flags = foxit::pdf::TextPage::e_ParseTextNormal);

  ~TextPage();
  TextPage(const TextPage& other);
  TextPage& operator = (const TextPage& other);

  bool operator == (const TextPage& other) const;
  bool operator != (const TextPage& other) const;

  bool IsEmpty() const;

  int GetCharCount() const;

  TextPageCharInfo GetCharInfo(int char_index);

  WString GetChars(int start = 0, int count = -1) const;

  int GetIndexAtPos(float x, float y, float tolerance) const;

  WString GetTextInRect(const RectF& rect) const;

  WString GetText(TextOrderFlag flag) const;

  common::Range GetWordAtPos(float x, float y, float tolerance) const;

  int GetTextRectCount(int start = 0, int count = -1);

  RectF GetTextRect(int rect_index) const;

  common::Rotation GetBaselineRotation(int rect_index);

  RectFArray GetTextRectArrayByRect(const RectF& rect);

  common::Range GetCharRange(const RectF& rect);

  WString GetTextUnderAnnot(annots::Annot& annot) const;

  // User is strongly recommended NOT to use this method; otherwise unknown situation may occur.
  explicit TextPage(FS_HANDLE handle =  NULL);
};

class TextSearch FS_FINAL : public Base {
 public:
  typedef enum _SearchFlags {
    e_SearchNormal        = 0x00,
    e_SearchMatchCase      = 0x01,
    e_SearchMatchWholeWord    = 0x02,
    e_SearchConsecutive     = 0x04,
    e_SearchNotMatchFullWidth     = 0x20
  } SearchFlags;
  

  explicit TextSearch(const PDFDoc& document, SearchCancelCallback* cancel = NULL, int flags = foxit::pdf::TextPage::e_ParseTextNormal);

 #ifndef _FX_NO_XFA_

  explicit TextSearch(const foxit::addon::xfa::XFADoc& xfa_document, foxit::pdf::SearchCancelCallback* cancel = NULL);
#endif  // #ifndef _FX_NO_XFA_

  explicit TextSearch(const foxit::pdf::TextPage& text_page);

  explicit TextSearch(const foxit::pdf::annots::Annot& annot);

  ~TextSearch();
  TextSearch(const TextSearch& other);
  TextSearch& operator = (const TextSearch& other);

  bool operator == (const TextSearch& other) const;
  bool operator != (const TextSearch& other) const;

  bool IsEmpty() const;

  bool SetPattern(const wchar_t* key_words, bool is_regex_search = false);

  bool SetStartPage(int page_index);

  bool SetEndPage(int page_index);

  bool SetStartCharacter(int char_index);

  bool SetSearchFlags(uint32 search_flags);

  bool FindNext();

  bool FindPrev();

  RectFArray GetMatchRects() const;

  int GetMatchPageIndex() const;

  WString GetMatchSentence();

  int GetMatchSentenceStartIndex();

  int GetMatchSentenceEndIndex();

  int GetMatchStartCharIndex() const;

  int GetMatchEndCharIndex() const;

  // User is strongly recommended NOT to use this method; otherwise unknown situation may occur.
  explicit TextSearch(FS_HANDLE handle =  NULL);
};

class TextLink FS_FINAL : public Base{
 public:
  ~TextLink();
  TextLink(const TextLink& other);
  TextLink& operator = (const TextLink& other);

  bool operator == (const TextLink& other) const;
  bool operator != (const TextLink& other) const;

  bool IsEmpty() const;

  WString GetURI();

  int GetStartCharIndex();

  int GetEndCharIndex();

  RectFArray GetRects();
  // User is strongly recommended NOT to use this method; otherwise unknown situation may occur.
  explicit TextLink(FS_HANDLE handle =  NULL);

};

class PageTextLinks FS_FINAL : public Base{
 public:
  explicit PageTextLinks(const TextPage& page);
  PageTextLinks(const PageTextLinks& other);
  PageTextLinks& operator = (const PageTextLinks& other);
  bool operator == (const PageTextLinks& other) const ;
  bool operator != (const PageTextLinks& other) const ;

  bool IsEmpty() const;
  ~PageTextLinks();

  int GetTextLinkCount();

  TextLink GetTextLink(int index);

  // User is strongly recommended NOT to use this method; otherwise unknown situation may occur.
  explicit PageTextLinks(FS_HANDLE handle =  NULL);
};
}  // namespace pdf
}  // namespace foxit
#endif  // FS_SEARCH_H_