fs_taggedpdf.h

#ifndef FS_TAGGEDPDF_H_
#define FS_TAGGEDPDF_H_

#include "common/fs_common.h"
#include "pdf/fs_pdfdoc.h"
#include "pdf/fs_pdfpage.h"
#include "addon/accessibility/fs_accessibility.h"

namespace foxit {
namespace addon {
namespace accessibility {
class AutoTagProviderCallback {
 public:
   typedef enum _AutoTagResultDataType {
     e_AutoTagResultDataTypeReduceConfidence = 0,
     e_AutoTagResultDataTypeTagreportPrepage = 1,
     e_AutoTagResultDataTypeTagreportNextpage = 2,
     e_AutoTagResultDataTypePage = 3,
     e_AutoTagResultDataTypeRegions = 4,
     e_AutoTagResultDataTypeArtifacts = 5,
     e_AutoTagResultDataTypeParagraphs = 6,
     e_AutoTagResultDataTypeListItem = 7,
     e_AutoTagResultDataTypeFigures = 8,
     e_AutoTagResultDataTypeTables = 9,
     e_AutoTagResultDataTypeTableRow = 10,
     e_AutoTagResultDataTypeTableHeader = 11,
     e_AutoTagResultDataTypeToc = 12,
     e_AutoTagResultDataTypeHighConfidence = 13,
     e_AutoTagResultDataTypeMediumhighConfidence = 14,
     e_AutoTagResultDataTypeMediumConfidence = 15,
     e_AutoTagResultDataTypeMediumlowConfidence = 16,
     e_AutoTagResultDataTypeLowConfidence = 17,
     e_AutoTagResultDataTypeCheckCategory = 18,
     e_AutoTagResultDataTypeFixCategory = 19,
     e_AutoTagResultDataTypeHintRegion = 20,
     e_AutoTagResultDataTypeHintArtifacts = 21,
     e_AutoTagResultDataTypeHintParagraph = 22,
     e_AutoTagResultDataTypeHintList = 23,
     e_AutoTagResultDataTypeHintFigure = 24,
     e_AutoTagResultDataTypeHintTables = 25,
     e_AutoTagResultDataTypeHintTableRow = 26,
     e_AutoTagResultDataTypeHintTableHeader = 27,
     e_AutoTagResultDataTypeHintToc = 28,
     e_AutoTagResultDataTypeHintRepair = 29,
     e_AutoTagResultDataTypeTouchupReadingOrder = 30,
     e_AutoTagResultDataTypeAlttext = 31,
     e_AutoTagResultDataTypeHintAlttext = 32,
     e_AutoTagResultDataTypeCheckerTable5 = 33,
     e_AutoTagResultDataTypeIntroduction = 34,
     e_AutoTagResultDataTypeSumReduceConfidence = 35,
     e_AutoTagResultDataTypeRibbonCategory = 36,
     e_AutoTagResultDataTypeSumAlttextFigure = 37,
     e_AutoTagResultDataTypeTagrepIntroduction = 38,
     e_AutoTagResultDataTypeMissFigure = 39,
     e_AutoTagResultDataTypeTagreportFilename = 40,
     e_AutoTagResultDataTypeBacktotop = 41
   } AutoTagResultDataType;
   
  virtual foxit::WString GetReportText(AutoTagResultDataType type) = 0;

 protected:
  ~AutoTagProviderCallback() {}
};

class TaggedPDFCallback {
 public:
  typedef enum _ReportCategory {
    e_ReportCategoryRegion = 0,
    e_ReportCategoryArtifact = 1,
    e_ReportCategoryParagraph = 2,
    e_ReportCategoryListItem = 3,
    e_ReportCategoryFigure = 4,
    e_ReportCategoryTable = 5,
    e_ReportCategoryTableRow = 6,
    e_ReportCategoryTableHeader = 7,
    e_ReportCategoryTocItem = 8
  } ReportCategory;
  
  typedef enum _ReportConfidence {
    e_ReportConfidenceHigh = 0,
    e_ReportConfidenceMediumHigh = 1,
    e_ReportConfidenceMedium = 2,
    e_ReportConfidenceMediumLow = 3,
    e_ReportConfidenceLow = 4
  } ReportConfidence;
  

  virtual void Release() = 0;

  virtual void Report(ReportCategory category, ReportConfidence confidence, int page_index, const RectF& rect) = 0;

 protected:
  ~TaggedPDFCallback() {}
};

class AlternateTextFigureData FS_FINAL : public Object {
 public:
  AlternateTextFigureData()
      : is_decorative_figure(false)
      , page_index(-1) { }

  AlternateTextFigureData(bool is_decorative_figure, const wchar_t* alternate_text, const wchar_t* alternate_text_changed, int page_index, foxit::RectF rect) {
    this->is_decorative_figure = is_decorative_figure;
    this->alternate_text = alternate_text;
    this->alternate_text_changed = alternate_text_changed;
    this->page_index = page_index;
    this->rect = rect;
  }

  AlternateTextFigureData(const AlternateTextFigureData &other) {
    this->is_decorative_figure = other.is_decorative_figure;
    this->alternate_text = other.alternate_text;
    this->alternate_text_changed = other.alternate_text_changed;
    this->page_index = other.page_index;
    this->rect = other.rect;
  }

  AlternateTextFigureData &operator=(const AlternateTextFigureData &other) {
    this->is_decorative_figure = other.is_decorative_figure;
    this->alternate_text = other.alternate_text;
    this->alternate_text_changed = other.alternate_text_changed;
    this->page_index = other.page_index;
    this->rect = other.rect;
    return (*this);
  }

  void Set(bool is_decorative_figure, const wchar_t* alternate_text, const wchar_t* alternate_text_changed,
           int page_index, foxit::RectF rect) {
    this->is_decorative_figure = is_decorative_figure;
    this->alternate_text = alternate_text;
    this->alternate_text_changed = alternate_text_changed;
    this->page_index = page_index;
    this->rect = rect;
  }

  bool is_decorative_figure;
  WString alternate_text;
  WString alternate_text_changed;
  int page_index;
  foxit::RectF rect;
};

class TaggedPDF FS_FINAL : public Base {
 public:
  TaggedPDF(const foxit::pdf::PDFDoc& doc, bool is_fix=false);

  // 强烈建议用户不要使用此方法；否则可能发生未知情况。
  explicit TaggedPDF(FS_HANDLE handle);

  ~TaggedPDF();

  TaggedPDF(const TaggedPDF& other);

  TaggedPDF& operator=(const TaggedPDF& other);

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

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

  bool IsEmpty() const;

  void SetCallback(TaggedPDFCallback* callback);

  bool CanTagDocument();

  common::Progressive StartTagDocument(common::PauseCallback* pause, foxit::common::file::StreamCallback* report_callback = NULL, AutoTagProviderCallback* callback = NULL);

  bool IsAlreadyTagged();

  void RemoveTags();

  bool CanTagFormFields();

  bool TagFormFields();

  int GetFigureCount();

  bool SetAsDecorativeFigure(int figure_index);

  void SetFigureAlternateText(int figure_index, const wchar_t*  alternate_text);

  WString GetFigureAlternateText(int figure_index);

  RectF GetFigureRect(int figure_index);

  int GetFigurePageIndex(int figure_index);

  bool HasFigures();

  int GetCurrentFigureElementIndex();

  AlternateTextFigureData GetNextFigureData();

  AlternateTextFigureData GetPrevFigureData();

  void SetCurrentFigureDataInfo(bool is_decorative, const wchar_t* alternate_text);

  bool SaveFigureData();
};

class TagTreeItemData FS_FINAL : public Object {
 public:
  typedef enum _TagImageType {
    e_TagImageTypePDF = 0,
    e_TagImageTypePageObject = 1,
    e_TagImageTypeTagParagraph = 2,
    e_TagImageTypeTagSection = 3,
    e_TagImageTypeTable = 4,
    e_TagImageTypeTableDataCell = 5,
    e_TagImageTypeTableHeaderCell = 6,
    e_TagImageTypeTableRow = 7,
    e_TagImageTypeTagNode = 8
  } TagImageType;
  
  typedef enum _TagNodeType {
    e_TagNodeTypeElement = 0,
    e_TagNodeTypeMarkedContentSeq = 1,
    e_TagNodeTypeObject = 2
  } TagNodeType;
  
  TagTreeItemData()
    : page_index(-1)
    , item_image_type(e_TagImageTypePDF)
    , item_node_type(e_TagNodeTypeElement) {}

  TagTreeItemData(const wchar_t* item_name, const char* item_id, const char* item_pos,
                                RectFArray item_rects, int page_index,
                                TagImageType item_image_type,
                                TagNodeType item_node_type)
    : item_name(item_name)
    , item_id(item_id)
    , item_pos(item_pos)
    , item_rects(item_rects)
    , page_index(page_index)
    , item_image_type(item_image_type)
    , item_node_type(item_node_type) {}

  TagTreeItemData(const TagTreeItemData& other) {
    this->item_name = other.item_name;
    this->item_id = other.item_id;
    this->item_pos = other.item_pos;
    this->item_rects = other.item_rects;
    this->page_index = other.page_index;
    this->item_image_type = other.item_image_type;
    this->item_node_type = other.item_node_type;
  }

  TagTreeItemData& operator=(const TagTreeItemData& other) {
    this->item_name = other.item_name;
    this->item_id = other.item_id;
    this->item_pos = other.item_pos;
    this->item_rects = other.item_rects;
    this->page_index = other.page_index;
    this->item_image_type = other.item_image_type;
    this->item_node_type = other.item_node_type;
    return *this;
  }

  void Set(const wchar_t* item_name, const char* item_id, const char* item_pos,
           RectFArray item_rects, int page_index,
           TagImageType item_image_type,
           TagNodeType item_node_type) {
    this->item_name = item_name;
    this->item_id = item_id;
    this->item_pos = item_pos;
    this->item_rects = item_rects;
    this->page_index = page_index;
    this->item_image_type = item_image_type;
    this->item_node_type = item_node_type;
  }

  WString item_name;
  String item_id;
  String item_pos;
  RectFArray item_rects;
  int page_index;
  TagImageType item_image_type;
  TagNodeType item_node_type;
};

FSDK_DEFINE_ARRAY(TagTreeItemDataArray, TagTreeItemData)


class AccessibilityTagTreeItem FS_FINAL : public Object {
 public:
  AccessibilityTagTreeItem() {}

  AccessibilityTagTreeItem(const TagTreeItemData& item_data,
                            const TagTreeItemDataArray& children_items_data)
    : item_data(item_data)
    , children_items_data(children_items_data) {}

  AccessibilityTagTreeItem(const AccessibilityTagTreeItem& other) {
    this->item_data = other.item_data;
    this->children_items_data = other.children_items_data;
  }

  AccessibilityTagTreeItem& operator=(const AccessibilityTagTreeItem& other) {
    this->item_data = other.item_data;
    this->children_items_data = other.children_items_data;
    return (*this);
  }

  void Set(const TagTreeItemData& item_data,
           const TagTreeItemDataArray& children_items_data) {
    this->item_data = item_data;
    this->children_items_data = children_items_data;
  }

  TagTreeItemData item_data;
  TagTreeItemDataArray children_items_data;
};

FSDK_DEFINE_ARRAY(TagTreeItemArray, AccessibilityTagTreeItem)


class TagProperty FS_FINAL : public Object {
 public:
  TagProperty() {}

  TagProperty(const wchar_t* tag_type, const wchar_t* tag_title, const wchar_t* tag_actual_text,
                           const wchar_t* tag_alternate_text, const wchar_t* tag_id, const wchar_t* tag_language)
    : tag_type(tag_type)
    , tag_title(tag_title)
    , tag_actual_text(tag_actual_text)
    , tag_alternate_text(tag_alternate_text)
    , tag_id(tag_id)
    , tag_language(tag_language) {}

  TagProperty(const TagProperty& other) {
    this->tag_type = other.tag_type;
    this->tag_title = other.tag_title;
    this->tag_actual_text = other.tag_actual_text;
    this->tag_alternate_text = other.tag_alternate_text;
    this->tag_id = other.tag_id;
    this->tag_language = other.tag_language;
  }

  TagProperty& operator=(const TagProperty& other) {
    this->tag_type = other.tag_type;
    this->tag_title = other.tag_title;
    this->tag_actual_text = other.tag_actual_text;
    this->tag_alternate_text = other.tag_alternate_text;
    this->tag_id = other.tag_id;
    this->tag_language = other.tag_language;
    return (*this);
  }

  void Set(const wchar_t* tag_type, const wchar_t* tag_title, const wchar_t* tag_actual_text,
           const wchar_t* tag_alternate_text, const wchar_t* tag_id, const wchar_t* tag_language) {
    this->tag_type = tag_type;
    this->tag_title = tag_title;
    this->tag_actual_text = tag_actual_text;
    this->tag_alternate_text = tag_alternate_text;
    this->tag_id = tag_id;
    this->tag_language = tag_language;
  }

  WString tag_type;
  WString tag_title;
  WString tag_actual_text;
  WString tag_alternate_text;
  WString tag_id;
  WString tag_language;
};

class TagTreeMenuItemData FS_FINAL : public Object {
 public:
  TagTreeMenuItemData()
    : is_enable(false)
    , is_check_item(false)
    , is_checked(false) {}

  TagTreeMenuItemData(const wchar_t* item_name, bool is_enable, bool is_check_item, bool is_checked)
    : item_name(item_name)
    , is_enable(is_enable)
    , is_check_item(is_check_item)
    , is_checked(is_checked) {}

  TagTreeMenuItemData(const TagTreeMenuItemData& other) {
    item_name = other.item_name;
    is_enable = other.is_enable;
    is_check_item = other.is_check_item;
    is_checked = other.is_checked;
  }

  TagTreeMenuItemData& operator=(const TagTreeMenuItemData& other) {
    item_name = other.item_name;
    is_enable = other.is_enable;
    is_check_item = other.is_check_item;
    is_checked = other.is_checked;
    return *this;
  }

  void Set(const wchar_t* item_name, bool is_enable, bool is_check_item, bool is_checked) {
    this->item_name = item_name;
    this->is_enable = is_enable;
    this->is_check_item = is_check_item;
    this->is_checked = is_checked;
  }

  WString item_name;
  bool is_enable;
  bool is_check_item;
  bool is_checked;
};

FSDK_DEFINE_ARRAY(TagTreeMenuItemDataArray, TagTreeMenuItemData)


class TagTreeMenuInputData FS_FINAL : public Object {
 public:
  TagTreeMenuInputData()
    : is_reflow_mode(false)
    , is_have_selected_obj(false)
    , is_selected_from_tag_finder(false)
    , is_role_map_17(false)
    , is_highlight_content(false) {}

  TagTreeMenuInputData(bool is_reflow_mode, bool is_have_selected_obj, bool is_selected_from_tag_finder,
                                    bool is_role_map_17, bool is_highlight_content,
                                    const foxit::StringArray& cut_tag_ids,
                                    const foxit::StringArray& selected_tag_ids)
    : is_reflow_mode(is_reflow_mode)
    , is_have_selected_obj(is_have_selected_obj)
    , is_selected_from_tag_finder(is_selected_from_tag_finder)
    , is_role_map_17(is_role_map_17)
    , is_highlight_content(is_highlight_content)
    , cut_tag_ids(cut_tag_ids)
    , selected_tag_ids(selected_tag_ids) {}

  TagTreeMenuInputData(const TagTreeMenuInputData& other) {
    is_reflow_mode = other.is_reflow_mode;
    is_have_selected_obj = other.is_have_selected_obj;
    is_selected_from_tag_finder = other.is_selected_from_tag_finder;
    is_role_map_17 = other.is_role_map_17;
    is_highlight_content = other.is_highlight_content;
    cut_tag_ids = other.cut_tag_ids;
    selected_tag_ids = other.selected_tag_ids;
  }

  TagTreeMenuInputData& operator=(const TagTreeMenuInputData& other) {
    is_reflow_mode = other.is_reflow_mode;
    is_have_selected_obj = other.is_have_selected_obj;
    is_selected_from_tag_finder = other.is_selected_from_tag_finder;
    is_role_map_17 = other.is_role_map_17;
    is_highlight_content = other.is_highlight_content;
    cut_tag_ids = other.cut_tag_ids;
    selected_tag_ids = other.selected_tag_ids;
    return *this;
  }

  void Set(bool is_reflow_mode, bool is_have_selected_obj, bool is_selected_from_tag_finder,
           bool is_role_map_17, bool is_highlight_content,
           const foxit::StringArray& cut_tag_ids,
           const foxit::StringArray& selected_tag_ids) {
    this->is_reflow_mode = is_reflow_mode;
    this->is_have_selected_obj = is_have_selected_obj;
    this->is_selected_from_tag_finder = is_selected_from_tag_finder;
    this->is_role_map_17 = is_role_map_17;
    this->is_highlight_content = is_highlight_content;
    this->cut_tag_ids = cut_tag_ids;
    this->selected_tag_ids = selected_tag_ids;
  }

  bool is_reflow_mode;
  bool is_have_selected_obj;
  bool is_selected_from_tag_finder;
  bool is_role_map_17;
  bool is_highlight_content;
  foxit::StringArray cut_tag_ids;
  foxit::StringArray selected_tag_ids;
};

class TagTreeEditor FS_FINAL : public Base {
 public:
  typedef enum _ArtifactType {
    e_ArtifactTypePage = 0,
    e_ArtifactTypePagination = 1,
    e_ArtifactTypeLayout = 2
  } ArtifactType;
  
  typedef enum _ArtifactAttachToSideType {
    e_ArtifactAttachToSideTypeNone = 0,
    e_ArtifactAttachToSideTypeLeft = 1,
    e_ArtifactAttachToSideTypeTop = 2,
    e_ArtifactAttachToSideTypeRight = 3,
    e_ArtifactAttachToSideTypeBottom = 4
  } ArtifactAttachToSideType;
  

  explicit TagTreeEditor(const foxit::pdf::PDFDoc& pdf_doc);

  explicit TagTreeEditor(FS_HANDLE handle);

  ~TagTreeEditor();

  TagTreeEditor(const TagTreeEditor& other);

  TagTreeEditor& operator=(const TagTreeEditor& other);

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

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

  bool IsEmpty() const;

  TagTreeItemArray GetTagTree();

  TagProperty GetTagPropertyByID(const char* item_id);

  bool SetTagPropertyType(const char* item_id, const wchar_t* type);

  bool SetTagPropertyTitle(const char* item_id, const wchar_t* title);

  bool SetTagPropertyActualText(const char* item_id, const wchar_t* actual_text);

  bool SetTagPropertyAlternateText(const char* item_id, const wchar_t* alternate_text);

  bool SetTagPropertyID(const char* item_id, const wchar_t* id);

  bool SetTagPropertyLanguage(const char* item_id, const wchar_t* language);

  TagTreeMenuItemDataArray GetTagTreeContextMenuItems(const TagTreeMenuInputData& input_data);

  TagTreeItemArray AddNewTag(const char* selected_tag_id, const wchar_t* type, const wchar_t* title);

  TagTreeItemArray DeleteTags(const foxit::StringArray& selected_tag_ids);

  TagTreeItemArray DeleteEmptyTags(const foxit::StringArray& selected_tag_ids);

  TagTreeItemArray MoveTags(const foxit::StringArray& source_tag_ids, const char* dest_tag_id,
                                          bool is_moved_as_child);

  foxit::StringArray FindTagFromSelection(const foxit::StringArray& selected_tag_ids);

  TagTreeItemArray CreateTagFromSelectionByElement(int page_index, const char* selected_tag_id);

  TagTreeItemArray CreateTagFromSelectionByText(int page_index, const RectFArray& selected_text_rects,
                                                           const char* selected_tag_id);

  TagTreeItemArray CreateTagFromSelectionByContent(const foxit::StringArray& selected_content_ids,
                                                                const char* selected_tag_id);

  TagTreeItemArray CreateTagFromSelectionByTag(const foxit::StringArray& selected_tag_ids,
                                                             const char* last_selected_tag_id);

  WString GetAllContents(const char* selected_tag_id);

  bool ChangeTagToArtifact(const StringArray& selected_tag_ids, ArtifactType artifact_type,
                            ArtifactAttachToSideType artifact_to_side);

  bool SetDocAsTaggedPDF();

  TagTreeItemArray AddTagForAnnotation(bool is_tag_annotations, const pdf::annots::Annot& annot,
                                                     int page_index, const char* selected_tag_id);

  StringArray GetContentTreeItemIDsByTagItemID(const char* selected_tag_id);
};

}
}
}
#endif