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_