fs_headerfooter.h

浏览该文件的文档.

#ifndef FS_HEADERFOOTER_H_
#define FS_HEADERFOOTER_H_

#include "common/fs_common.h"

namespace foxit {
namespace pdf {
class PageNumberRange FS_FINAL : public Object {
 public:
  explicit PageNumberRange(int32 start_number, int32 end_number, foxit::common::Range::Filter filter)
      : start_number(start_number)
      , end_number(end_number)
      , filter(filter) {}

  PageNumberRange()
      : start_number(-1)
      , end_number(-1)
      , filter(foxit::common::Range::e_All) {}

  PageNumberRange(const PageNumberRange& page_range)
      : start_number(page_range.start_number)
      , end_number(page_range.end_number)
      , filter(page_range.filter) {}

  PageNumberRange& operator=(const PageNumberRange& page_range) {
    start_number = page_range.start_number;
    end_number = page_range.end_number;
    filter = page_range.filter;
    return *this;
  }

  void Set(int32 start_number, int32 end_number, foxit::common::Range::Filter filter) {
    this->start_number = start_number;
    this->end_number = end_number;
    this->filter = filter;
  }

  int32 start_number;
  int32 end_number;
  foxit::common::Range::Filter filter;
};

class HeaderFooterContent FS_FINAL : public Object {
 public:
  explicit HeaderFooterContent(const WString& header_left_content, const WString& header_center_content,
                               const WString& header_right_content, const WString& footer_left_content,
                               const WString& footer_center_content, const WString& footer_right_content)
      : header_left_content(header_left_content)
      , header_center_content(header_center_content) 
      , header_right_content(header_right_content)
      , footer_left_content(footer_left_content)
      , footer_center_content(footer_center_content)
      , footer_right_content(footer_right_content) {}

  HeaderFooterContent() {}

  HeaderFooterContent(const HeaderFooterContent& other)
      : header_left_content(other.header_left_content)
      , header_center_content(other.header_center_content)
      , header_right_content(other.header_right_content)
      , footer_left_content(other.footer_left_content)
      , footer_center_content(other.footer_center_content)
      , footer_right_content(other.footer_right_content) {}

  HeaderFooterContent& operator=(const HeaderFooterContent& other) {
    header_left_content = other.header_left_content;
    header_center_content = other.header_center_content;
    header_right_content = other.header_right_content;
    footer_left_content = other.footer_left_content;
    footer_center_content = other.footer_center_content;
    footer_right_content = other.footer_right_content;
    return *this;
  }

  void Set(const WString& header_left_content, const WString& header_center_content,
           const WString& header_right_content, const WString& footer_left_content,
           const WString& footer_center_content, const WString& footer_right_content) {
    this->header_left_content = header_left_content;
    this->header_center_content = header_center_content;
    this->header_right_content = header_right_content;
    this->footer_left_content = footer_left_content;
    this->footer_center_content = footer_center_content;
    this->footer_right_content = footer_right_content;
  }

  WString header_left_content;
  WString header_center_content;
  WString header_right_content;
  WString footer_left_content;
  WString footer_center_content;
  WString footer_right_content;
};

class HeaderFooter FS_FINAL : public Object {
 public:
  explicit HeaderFooter(const common::Font& font, float text_size, RGB text_color, const PageNumberRange& page_range, RectF page_margin,
                        bool has_text_shrinked, bool has_fixedsize_for_print, int start_page_number,
                        const HeaderFooterContent& content, bool is_to_embed_font, bool is_underline)
    : font(font)
    , text_size(text_size)
    , text_color(text_color)
    , page_range(page_range)
    , page_margin(page_margin)
    , has_text_shrinked(has_text_shrinked)
    , has_fixedsize_for_print(has_fixedsize_for_print)
    , start_page_number(start_page_number)
    , content(content)
    , is_to_embed_font(is_to_embed_font)
    , is_underline(is_underline)
    , is_replace_font(true) {}

  HeaderFooter()
    : text_size(0)
    , text_color(0)
    , has_text_shrinked(false)
    , has_fixedsize_for_print(false)
    , start_page_number(0)
    , is_to_embed_font(false)
    , is_underline(false)
    , is_replace_font(true) {
    page_margin = RectF(72.0, 36.0, 72.0, 36.0);
  }
  HeaderFooter(const HeaderFooter& other)
    : font(other.font)
    , text_size(other.text_size)
    , text_color(other.text_color)
    , page_range(other.page_range)
    , page_margin(other.page_margin)
    , has_text_shrinked(other.has_text_shrinked)
    , has_fixedsize_for_print(other.has_fixedsize_for_print)
    , start_page_number(other.start_page_number)
    , content(other.content)
    , is_to_embed_font(other.is_to_embed_font)
    , is_underline(other.is_underline)
    , is_replace_font(other.is_replace_font) {}

  HeaderFooter& operator=(const HeaderFooter& other) {
    font = other.font;
    text_size = other.text_size;
    text_color = other.text_color;
    page_range = other.page_range;
    page_margin = other.page_margin;
    has_text_shrinked = other.has_text_shrinked;
    has_fixedsize_for_print = other.has_fixedsize_for_print;
    start_page_number = other.start_page_number;
    content = other.content;
    is_to_embed_font = other.is_to_embed_font;
    is_underline = other.is_underline;
    is_replace_font = other.is_replace_font;
    return *this;
  }

  void Set(const common::Font& font, float text_size, RGB text_color, const PageNumberRange& page_range, RectF page_margin,
           bool has_text_shrinked, bool has_fixedsize_for_print, int start_page_number,
           const HeaderFooterContent& content, bool is_to_embed_font, bool is_underline) {
    this->font = font;
    this->text_size = text_size;
    this->text_color = text_color;
    this->page_range = page_range;
    this->page_margin = page_margin;
    this->has_text_shrinked = has_text_shrinked;
    this->has_fixedsize_for_print = has_fixedsize_for_print;
    this->start_page_number = start_page_number;
    this->content = content;
    this->is_to_embed_font = is_to_embed_font;
    this->is_underline = is_underline;
    this->is_replace_font = true;
  }

  common::Font font;

  float text_size;

  RGB text_color;

  PageNumberRange page_range;

  RectF page_margin;

  bool has_text_shrinked;

  bool has_fixedsize_for_print;

  int start_page_number;

  HeaderFooterContent content;

  bool is_to_embed_font;

  bool is_underline;

  bool is_replace_font;
};

class HeaderFooterContentGenerator FS_FINAL : public Base {
 public:
  typedef enum _DateFormatType {
    e_DateFormatMSlashD = 0,
    e_DateFormatMSlashDSlashYY = 1,
    e_DateFormatMSlashDSlashYYYY = 2,
    e_DateFormatMMSlashDDSlashYY = 3,
    e_DateFormatMMSlashDDSlashYYYY = 4,
    e_DateFormatDSlashMSlashYY = 5,
    e_DateFormatDSlashMSlashYYYY = 6,
    e_DateFormatDDSlashMMSlashYY = 7,
    e_DateFormatDDSlashMMSlashYYYY = 8,
    e_DateFormatMMSlashYY = 9,
    e_DateFormatMMSlashYYYY = 10,
    e_DateFormatMDotDDotYY = 11,
    e_DateFormatMDotDDotYYYY = 12,
    e_DateFormatMMDotDDDotYY = 13,
    e_DateFormatMMDotDDDotYYYY = 14,
    e_DateFormatMMDotYY = 15,
    e_DateFormatDDotMDotYYYY = 16,
    e_DateFormatDDDotMMDotYY = 17,
    e_DateFormatDDDotMMDotYYYY = 18,
    e_DateFormatYYHyphenMMHyphenDD = 19,
    e_DateFormatYYYYHyphenMMHyphenDD = 20
  } DateFormatType;
  
  typedef enum _PageNumberFormat {
    e_PageNumberFormatDefault = 0,
    e_PageNumberFormatNumberOfCount = 1,
    e_PageNumberFormatNumberSlashCount = 2,
    e_PageNumberFormatPageNumber = 3,
    e_PageNumberFormatPageNumberOfCount = 4
  } PageNumberFormat;
  

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

  HeaderFooterContentGenerator();

  ~HeaderFooterContentGenerator();

  HeaderFooterContentGenerator(const HeaderFooterContentGenerator& other);

  HeaderFooterContentGenerator& operator=(const HeaderFooterContentGenerator& other);

  bool operator==(const HeaderFooterContentGenerator& other) const;

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

  bool IsEmpty() const;

  void AddDate(DateFormatType format_type);

  void AddPageNumber(PageNumberFormat format_type);

  void AddString(const WString& new_string);

  void Clear();

  WString GenerateContent();
};
#endif